stubbfel/feedcrawler
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

mv all filemethdos to file_ethods.py

Browse Source
This commit is contained in:
stubbfel
2014-08-21 00:01:18 +02:00
parent 7df02333f1
commit c7cb2ffaca
12 changed files with 271 additions and 352 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
src/feed/feed.py
View File

@@ -1,21 +1,20 @@
__author__ = 'dev'
from utilities.jsonfile import JsonFile
from utilities.feedfile import FeedFile
from config.config import Config
from utilities.podcastserializer import PodcastSerializer
import os
import feedparser
import os
import utilities.file_methods as fm
class Feed:
def __init__(self, feed_name=None, feed_type=None, link_type=None, feed_url=None):
self.config_path = None
self.feed_folder_path = None
self.feed_config = None
self.feed_file_path = None
self.serializer = None
self.feed_folder = None
self.setup_feed(feed_name, feed_type, link_type, feed_url)
def load_feed(self):
@@ -25,22 +24,20 @@ class Feed:
def load_new_feed(self):
assert (not os.path.exists(self.feed_file_path))
assert (self.serializer is not None)
feed_file = FeedFile(self.feed_file_path)
feed_file.write_feed_json_file(self.load_feed(), self.serializer)
fm.write_feed_json_file(self.feed_file_path, self.load_feed(), self.serializer)
def load_existing_feed(self):
assert (os.path.exists(self.feed_file_path))
assert (self.serializer is not None)
tmp_feed_file = FeedFile(self.feed_file_path + "tmp")
tmp_feed_file.write_feed_json_file(self.load_feed(), self.serializer)
tmp_feed_file_path = self.feed_file_path + "tmp"
fm.write_feed_json_file(tmp_feed_file_path, self.load_feed(), self.serializer)
tmp_free_json = fm.read_json_file(tmp_feed_file_path)
feed_file = FeedFile(self.feed_file_path)
if tmp_feed_file.read_feed_file() == feed_file.read_feed_file():
feed_file.write_json_file(self.feed_file_path)
tmp_feed_file.check_and_remove_file()
if tmp_free_json != fm.read_json_file(self.feed_file_path):
fm.write_json_file(self.feed_file_path, tmp_free_json)
fm.check_and_remove_file(tmp_feed_file_path)
def get_serializer(self):
return {
@@ -53,20 +50,20 @@ class Feed:
assert link_type is not None
assert feed_url is not None
self.feed_config = self.create_feed_config_file(feed_name, feed_type, link_type, feed_url)
self.feed_config = Feed.create_feed_config_file(feed_name, feed_type, link_type, feed_url)
self.config_path = self.create_feed_config_path()
if os.path.exists(self.config_path) is False:
self.write_feed_config_file()
self.feed_file_path = self.feed_folder_path+"/"+self.feed_config["FeedName"]+".json"
self.feed_file_path = self.feed_folder_path + "/" + self.feed_config["FeedName"] + ".json"
self.serializer = self.get_serializer()
def new_feed_folder(self):
if self.feed_folder_path is None:
assert self.feed_config is not None
feed_folder = Config.get("FeedStorageFolder")
assert feed_folder is not None
self.feed_folder = Config.get("FeedStorageFolder")
assert self.feed_folder is not None
feed_folder_prefix = Config.get("FeedStoragePrefix")
assert feed_folder_prefix is not None
@@ -76,17 +73,27 @@ class Feed:
tmp_value = self.feed_config.get(value)
if tmp_value is not None:
value = tmp_value
feed_folder += "/" + value
self.feed_folder += "/" + value
else:
break
self.feed_folder_path = feed_folder
self.feed_folder_path = self.feed_folder
if not os.path.exists(self.feed_folder_path):
os.mkdir(feed_folder)
os.mkdir(self.feed_folder)
return self.feed_folder_path
def create_feed_config_file(self, feed_name, feed_type, link_type, feed_url):
def create_feed_config_path(self):
if self.config_path is None:
self.config_path = self.new_feed_folder() + "/" + self.feed_config["FeedName"] + Config[
"ConfigFileSuffix"] + Config["ConfigFileExtension"]
return self.config_path
def write_feed_config_file(self):
fm.write_json_file(self.create_feed_config_path(), self.feed_config)
@staticmethod
def create_feed_config_file(feed_name, feed_type, link_type, feed_url):
assert feed_name is not None
assert feed_type is not None
assert link_type is not None
@@ -99,13 +106,4 @@ class Feed:
"FeedUrl": feed_url,
"LinkType": link_type
}
return feed_config
def create_feed_config_path(self):
if self.config_path is None:
self.config_path = self.new_feed_folder() + "/" + self.feed_config["FeedName"] + Config["ConfigFileSuffix"] + Config["ConfigFileExtension"]
return self.config_path
def write_feed_config_file(self):
file = JsonFile(self.create_feed_config_path())
file.write_json_file(self.feed_config)
return feed_config

36
src/utilities/feedfile.py
View File

@@ -1,36 +0,0 @@
__author__ = 'stubbfel'
import feedparser
from utilities.jsonfile import JsonFile
from utilities.serializer import Serializer
class FeedFile(JsonFile):
def __init__(self, filename):
"""
init class
:param filename: path to the file
"""
super(FeedFile, self).__init__(filename)
def read_feed_file(self):
"""
method read and convert the content of the file to a FeedParserDict
:return: dict - feed object
"""
feed_str = self.read_text_file()
return feedparser.parse(feed_str)
def write_feed_json_file(self, feed, serializer=None):
"""
method write a feedparpser object to a text file. It use a certain serializer or the default serializer
if type of the serializer is none
:param feed: expetc FeedparserDict
:param serializer: None or a subclass of Serializer
"""
assert isinstance(feed, feedparser.FeedParserDict)
if serializer is None:
self.write_json_file(feed)
else:
self.write_json_file(serializer.serialize(feed))

90
src/utilities/file_methods.py Normal file
View File

@@ -0,0 +1,90 @@
__author__ = 'dev'
import feedparser
import os.path
import json
def exists_file(file_path):
"""
check if this file exists or not
:return: true if the file exists, otherwise false
"""
return os.path.isfile(file_path)
def check_and_remove_file(file_path):
"""
Method remove this file, if the file don't exists the method don't call remove
"""
if exists_file(file_path):
os.remove(file_path)
def read_text_file(file_path):
"""
method return and read the content of a text file
:return: str - file content
"""
with open(file_path, newline='\n') as file:
return file.read()
def read_json_file(file_path):
"""
method read and convert the content of the file to a json object
:return: dict - json object
"""
return json.loads(read_text_file(file_path))
def read_feed_file(file_path):
"""
method read and convert the content of the file to a FeedParserDict
:return: dict - feed object
"""
feed_str = read_text_file(file_path)
return feedparser.parse(feed_str)
def write_text_file(file_path, file_content):
"""
write strings to a text file
:param file_content: strings which has to been write i a text file
:raise ValueError: will be raised, when the content is not a string
"""
assert isinstance(file_path, str)
with open(file_path, 'w', newline='\n') as file:
file.write(file_content)
file.close()
def write_json_file(file_path, json_object):
"""
write a json object to a text file
:param json_object: json object, which has to be saved. If the object is a string,
the method will be check if its a valid json object
:raise ValueError: will be raised if json_object is not a dictionary or string or the json object is not valid
"""
valid_types = (dict, str)
assert isinstance(json_object, valid_types)
if isinstance(json_object, str):
json_object = json.loads(json_object)
json_string = json.dumps(json_object, indent=4)
write_text_file(file_path, json_string)
def write_feed_json_file(file_path, feed, serializer=None):
"""
method write a feedparpser object to a text file. It use a certain serializer or the default serializer
if type of the serializer is none
:param feed: expetc FeedparserDict
:param serializer: None or a subclass of Serializer
"""
assert isinstance(feed, feedparser.FeedParserDict)
if serializer is None:
write_json_file(file_path, feed)
else:
write_json_file(file_path, serializer.serialize(feed))

36
src/utilities/jsonfile.py
View File

@@ -1,36 +0,0 @@
__author__ = 'stubbfel'
import json
from utilities.textfile import TextFile
class JsonFile(TextFile):
def __init__(self, filename):
"""
init class
:param filename: path to the file
"""
super(JsonFile, self).__init__(filename)
def write_json_file(self, json_object):
"""
write a json object to a text file
:param json_object: json object, which has to be saved. If the object is a string,
the method will be check if its a valid json object
:raise ValueError: will be raised if json_object is not a dictionary or string or the json object is not valid
"""
valid_types = (dict, str)
assert isinstance(json_object, valid_types)
if isinstance(json_object, str):
json_object = json.loads(json_object)
json_string = json.dumps(json_object, indent=4)
self.write_text_file(json_string)
def read_json_file(self):
"""
method read and convert the content of the file to a json object
:return: dict - json object
"""
return json.loads(self.read_text_file())

57
src/utilities/textfile.py
View File

@@ -1,57 +0,0 @@
__author__ = 'stubbfel'
import os.path
class TextFile:
def __init__(self, filename):
"""
init the class and set the filename
:param filename:
"""
assert isinstance(filename, str)
self._filename = filename
def write_text_file(self, file_content):
"""
write strings to a text file
:param file_content: strings which has to been write i a text file
:raise ValueError: will be raised, when the content is not a string
"""
assert isinstance(self._filename, str)
with open(self._filename, 'w', newline='\n') as file:
file.write(file_content)
file.close()
def check_and_remove_file(self):
"""
Method remove this file, if the file don't exists the method don't call remove
"""
if self.exists_file:
os.remove(self._filename)
def read_text_file(self):
"""
method return and read the content of a text file
:return: str - file content
"""
with open(self._filename, newline='\n') as file:
return file.read()
@property
def exists_file(self):
"""
check if this file exists or not
:return: true if the file exists, otherwise false
"""
return os.path.isfile(self._filename)
@property
def get_filename(self):
"""
get the file Name
:return: str
"""
assert isinstance(self._filename, str)
return self._filename

60
testenv/testfeeds/podcast/sbk/sbk.json
View File

@@ -1,150 +1,150 @@
{
"subtitle": "Vom Leben in der DDR",
"title": "Staatsb\u00fcrgerkunde",
"subtitle": "Vom Leben in der DDR",
"episodes": [
{
"subtitle": "Von Kollektivleistungen, Planstellen und dem Lohn der Arbeit",
"title": "SBK028 Arbeit",
"subtitle": "Von Kollektivleistungen, Planstellen und dem Lohn der Arbeit",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK028_Arbeit.mp3.torrent"
},
{
"subtitle": "Vom Traumberuf, Experimenten und Schulpolitik",
"title": "SBK027 Lehrerberuf",
"subtitle": "Vom Traumberuf, Experimenten und Schulpolitik",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK027_Lehrerberuf.mp3.torrent"
},
{
"subtitle": "Vom Konsum, geheimem Rotwein und Tieren ohne Lenden",
"title": "SBK026 Lebensmittel",
"subtitle": "Vom Konsum, geheimem Rotwein und Tieren ohne Lenden",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK026_Lebensmittel.mp3.torrent"
},
{
"subtitle": "Von sch\u00f6nen Plattenbauten, viel Kohle und ganz viel Eigenleistung",
"title": "SBK025 Wohnen",
"subtitle": "Von sch\u00f6nen Plattenbauten, viel Kohle und ganz viel Eigenleistung",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK025_Wohnen.mp3.torrent"
},
{
"subtitle": "Von gezogenen Registern, ungew\u00f6hnlichen Berufswegen und gro\u00dfer Musik",
"title": "SBK024 Kirchenmusik",
"subtitle": "Von gezogenen Registern, ungew\u00f6hnlichen Berufswegen und gro\u00dfer Musik",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK024_Kirchenmusik.mp3.torrent"
},
{
"subtitle": "Von Halbtags-Demonstranten, Papiertauben und Tagedieben",
"title": "SBK023 Feier- und Gedenktage",
"subtitle": "Von Halbtags-Demonstranten, Papiertauben und Tagedieben",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK023_Feier_und_Gedenktage.mp3.torrent"
},
{
"subtitle": "Vom Forscherdrang, Wechselblinkern und n\u00e4chtlichen Bastelrunden",
"title": "SBK022 Station",
"subtitle": "Vom Forscherdrang, Wechselblinkern und n\u00e4chtlichen Bastelrunden",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK022_Station.mp3.torrent"
},
{
"subtitle": "Wir sprechen \u00fcber Blockparteien, gefaltete Zettel und Wahlbeobachtungen in beide Richtungen.",
"title": "SBK021 Wahlen",
"subtitle": "Wir sprechen \u00fcber Blockparteien, gefaltete Zettel und Wahlbeobachtungen in beide Richtungen.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK021_Wahlen.mp3.torrent"
},
{
"subtitle": "Gesundheit \u2013 ist das Thema unserer heutigen Folge. Wie war es, wenn man in der DDR krank war und zum Arzt, zur \u00c4rztin oder gar ins Krankenhaus musste? Wie war man krankenversichert und warum sind Polikliniken auch heute noch modern?",
"title": "SBK020 Gesundheitssystem",
"subtitle": "Gesundheit \u2013 ist das Thema unserer heutigen Folge. Wie war es, wenn man in der DDR krank war und zum Arzt, zur \u00c4rztin oder gar ins Krankenhaus musste? Wie war man krankenversichert und warum sind Polikliniken auch heute noch modern?",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK020_Gesundheitssystem.mp3.torrent"
},
{
"subtitle": "Wir sprechen \u00fcber den Grundwehrdienst meines Vaters in der Nationalen Volksarmee und welche Erfahrungen er und wir in dieser Zeit gemacht haben.",
"title": "SBK019 NVA",
"subtitle": "Wir sprechen \u00fcber den Grundwehrdienst meines Vaters in der Nationalen Volksarmee und welche Erfahrungen er und wir in dieser Zeit gemacht haben.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK019_NVA.mp3.torrent"
},
{
"subtitle": "Die Ausreise ist genehmigt \u2013 wie ging es nun weiter? Wir sprechen in dieser Folge \u00fcber die Zeit bis zum Ausreisetag, unsere Ankunft in der BRD und die ersten Schritte in diesem f\u00fcr uns neuen Land.",
"title": "SBK018 Ausreise (Teil 2)",
"subtitle": "Die Ausreise ist genehmigt \u2013 wie ging es nun weiter? Wir sprechen in dieser Folge \u00fcber die Zeit bis zum Ausreisetag, unsere Ankunft in der BRD und die ersten Schritte in diesem f\u00fcr uns neuen Land.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK018_Ausreise_Teil_2.mp3.torrent"
},
{
"subtitle": "Meine Eltern haben 1987 einen Ausreiseantrag gestellt. Warum sie diesen Schritt gewagt haben, welche Konsequenzen er mit sich brachte und was w\u00e4hrend der zweij\u00e4hrigen Wartezeit bis zur Ausreisegenehmigung alles geschah, dar\u00fcber sprechen wir in dieser Folge.",
"title": "SBK017 Ausreise (Teil 1)",
"subtitle": "Meine Eltern haben 1987 einen Ausreiseantrag gestellt. Warum sie diesen Schritt gewagt haben, welche Konsequenzen er mit sich brachte und was w\u00e4hrend der zweij\u00e4hrigen Wartezeit bis zur Ausreisegenehmigung alles geschah, dar\u00fcber sprechen wir in dieser Folge.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK017_Ausreise_Teil_1.mp3.torrent"
},
{
"subtitle": "Ost, West, Mann, Frau: Mit Katrin R\u00f6nicke spreche ich \u00fcber die unterschiedlichen Geschlechterbilder in der DDR und der BRD und wie es war, als M\u00e4dchen oder Junge in den beiden Deutschlands aufzuwachsen.",
"title": "SBK016 Geschlechterrollen",
"subtitle": "Ost, West, Mann, Frau: Mit Katrin R\u00f6nicke spreche ich \u00fcber die unterschiedlichen Geschlechterbilder in der DDR und der BRD und wie es war, als M\u00e4dchen oder Junge in den beiden Deutschlands aufzuwachsen.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK016_Geschlechterrollen.mp3.torrent"
},
{
"subtitle": "Alle einsteigen und Vorsicht bei der Abfahrt! Mit Ingo Ebel spreche ich in dieser Episode \u00fcber die Deutsche Reichsbahn.",
"title": "SBK015 Deutsche Reichsbahn",
"subtitle": "Alle einsteigen und Vorsicht bei der Abfahrt! Mit Ingo Ebel spreche ich in dieser Episode \u00fcber die Deutsche Reichsbahn.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK015_Deutsche_Reichsbahn.mp3.torrent"
},
{
"subtitle": "In der letzten Sendung f\u00fcr 2012 sprechen wir \u00fcber das Weihnachtsfest in der DDR.",
"title": "SBK014 Weihnachten",
"subtitle": "In der letzten Sendung f\u00fcr 2012 sprechen wir \u00fcber das Weihnachtsfest in der DDR.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK014_Weihnachten.mp3.torrent"
},
{
"subtitle": "Die Anf\u00e4nge des digitalen Zeitalters in der DDR besch\u00e4ftigen meinen Papa und mich in dieser Episode.",
"title": "SBK013 Computer",
"subtitle": "Die Anf\u00e4nge des digitalen Zeitalters in der DDR besch\u00e4ftigen meinen Papa und mich in dieser Episode.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK013_Computer.mp3.torrent"
},
{
"subtitle": "In Spielfilml\u00e4nge pr\u00e4sentiert sich die aktuelle Episode. Mit Eric vom Kinocast spreche ich \u00fcber das Kino in der DDR.",
"title": "SBK012 Kino",
"subtitle": "In Spielfilml\u00e4nge pr\u00e4sentiert sich die aktuelle Episode. Mit Eric vom Kinocast spreche ich \u00fcber das Kino in der DDR.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK012_Kino.mp3.torrent"
},
{
"subtitle": "Die Massenmedien Radio und Fernsehen besch\u00e4ftigen uns im dritten Teil unserer Medienreihe. Darin sprechen wir \u00fcber den Rundfunk in der DDR.",
"title": "SBK011 Radio und Fernsehfunk",
"subtitle": "Die Massenmedien Radio und Fernsehen besch\u00e4ftigen uns im dritten Teil unserer Medienreihe. Darin sprechen wir \u00fcber den Rundfunk in der DDR.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK011_Radio_und_Fernsehfunk.mp3.torrent"
},
{
"subtitle": "In dieser Ausgabe \u2013 dem zweiten Teil unserer Medienreihe \u2013 sprechen wir \u00fcber B\u00fccher in der DDR.",
"title": "SBK010 B\u00fccher",
"subtitle": "In dieser Ausgabe \u2013 dem zweiten Teil unserer Medienreihe \u2013 sprechen wir \u00fcber B\u00fccher in der DDR.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK010_Buecher.mp3.torrent"
},
{
"subtitle": "In dieser und den n\u00e4chsten beiden Episoden sprechen wir \u00fcber verschiedene DDR-Medien, von der gedruckten Zeitung \u00fcber B\u00fccher bis hin zum Rundfunk. Im ersten Teil schauen wir uns das Presseangebot etwas genauer an.",
"title": "SBK009 Zeitungen und Zeitschriften",
"subtitle": "In dieser und den n\u00e4chsten beiden Episoden sprechen wir \u00fcber verschiedene DDR-Medien, von der gedruckten Zeitung \u00fcber B\u00fccher bis hin zum Rundfunk. Im ersten Teil schauen wir uns das Presseangebot etwas genauer an.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK009_Zeitungen_und_Zeitschriften.mp3.torrent"
},
{
"subtitle": "Comics in der DDR? Klar, auch die gab es! Und deren ber\u00fchmtester Vertreter ist das MOSAIK. Ich spreche mit dem k\u00fcnstlerischen Leiter des MOSAIK, J\u00f6rg Reuter, \u00fcber seine Zeit als Comicmacher in der DDR \u2013 und heute.",
"title": "SBK008 Comic MOSAIK",
"subtitle": "Comics in der DDR? Klar, auch die gab es! Und deren ber\u00fchmtester Vertreter ist das MOSAIK. Ich spreche mit dem k\u00fcnstlerischen Leiter des MOSAIK, J\u00f6rg Reuter, \u00fcber seine Zeit als Comicmacher in der DDR \u2013 und heute.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK008_Comic_MOSAIK.mp3.torrent"
},
{
"subtitle": "Wie kam man als DDR-B\u00fcrger von A nach B? Zu Fu\u00df, mit Bus und Bahn oder gar mit dem eigenen Auto? Womit man in der DDR alles unterwegs war, dar\u00fcber sprechen wir in der heutigen Episode.",
"title": "SBK007 Verkehrsmittel",
"subtitle": "Wie kam man als DDR-B\u00fcrger von A nach B? Zu Fu\u00df, mit Bus und Bahn oder gar mit dem eigenen Auto? Womit man in der DDR alles unterwegs war, dar\u00fcber sprechen wir in der heutigen Episode.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK007_Verkehrsmittel.mp3.torrent"
},
{
"subtitle": "Sommer, Sonne, Strand und Meer: Auch in der DDR zog es die Menschen im Urlaub in die Ferne. In unserer Urlaubsfolge sprechen wir in gewohnter Besetzung \u00fcber Ferienspiele, wichtige Anmeldelisten und FDGB-Heime.",
"title": "SBK006 Urlaub",
"subtitle": "Sommer, Sonne, Strand und Meer: Auch in der DDR zog es die Menschen im Urlaub in die Ferne. In unserer Urlaubsfolge sprechen wir in gewohnter Besetzung \u00fcber Ferienspiele, wichtige Anmeldelisten und FDGB-Heime.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK006_Urlaub.mp3.torrent"
},
{
"subtitle": "Die Brettspiele Monopoly, Sagaland oder Scotland Yard gab es in der DDR nicht zu kaufen. Und sie wurden dennoch gespielt, weil kreative Bastler sie einfach nachgemacht haben. Das Projekt \"Nachgemacht\" rettet solche Spielekopien vor dem Vergessen.",
"title": "SBK005 Spielekopien",
"subtitle": "Die Brettspiele Monopoly, Sagaland oder Scotland Yard gab es in der DDR nicht zu kaufen. Und sie wurden dennoch gespielt, weil kreative Bastler sie einfach nachgemacht haben. Das Projekt \"Nachgemacht\" rettet solche Spielekopien vor dem Vergessen.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK005_Spielekopien.mp3.torrent"
},
{
"subtitle": "Diese Folge ist komplett durchgestylt: Wir sprechen \u00fcber Kleidung und Mode in der DDR.",
"title": "SBK004 Kleidung und Mode",
"subtitle": "Diese Folge ist komplett durchgestylt: Wir sprechen \u00fcber Kleidung und Mode in der DDR.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK004_Kleidung_und_Mode.mp3.torrent"
},
{
"subtitle": "Nahtlos schlie\u00dfen wir an die letzte Folge an und sprechen \u00fcber den Oberstufenunterricht im DDR-Schulsystem.",
"title": "SBK003 Schulsystem (Teil 2)",
"subtitle": "Nahtlos schlie\u00dfen wir an die letzte Folge an und sprechen \u00fcber den Oberstufenunterricht im DDR-Schulsystem.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK003_Schulsystem_Teil_2.mp3.torrent"
},
{
"subtitle": "Auf dem Stundenplan steht heute das Schulsystem in der DDR. Aufgrund der vielen Aspekte, die dieses Themenfeld in sich birgt, ist diese Ausgabe der erste Teil einer Doppelfolge.",
"title": "SBK002 Schulsystem (Teil 1)",
"subtitle": "Auf dem Stundenplan steht heute das Schulsystem in der DDR. Aufgrund der vielen Aspekte, die dieses Themenfeld in sich birgt, ist diese Ausgabe der erste Teil einer Doppelfolge.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK002_Schulsystem_Teil_1.mp3.torrent"
},
{
"subtitle": "Die erste Folge nimmt sich das Schulfach vor, das dem Podcast seinen Namen gegeben hat: Staatsb\u00fcrgerkunde oder kurz \"Stab\u00fc\" genannt. Welchem Zweck diente dieses Fach? Welche Inhalte sollten im Unterricht vermittelt werden? Und wie gingen Lehrer und Sch\u00fcler mit offensichtlichen Widerspr\u00fcchen zwischen Fach und Realit\u00e4t um?",
"title": "SBK001 Stab\u00fc",
"subtitle": "Die erste Folge nimmt sich das Schulfach vor, das dem Podcast seinen Namen gegeben hat: Staatsb\u00fcrgerkunde oder kurz \"Stab\u00fc\" genannt. Welchem Zweck diente dieses Fach? Welche Inhalte sollten im Unterricht vermittelt werden? Und wie gingen Lehrer und Sch\u00fcler mit offensichtlichen Widerspr\u00fcchen zwischen Fach und Realit\u00e4t um?",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK001_Stabue.mp3.torrent"
},
{
"subtitle": "Los geht's: Die Nullnummer ist da! Darin erkl\u00e4re ich, was ich mit \"Staatsb\u00fcrgerkunde\" vorhabe, wann die erste regul\u00e4re Folge zu h\u00f6ren sein wird um worum es darin geht.",
"title": "SBK000 Nullnummer",
"subtitle": "Los geht's: Die Nullnummer ist da! Darin erkl\u00e4re ich, was ich mit \"Staatsb\u00fcrgerkunde\" vorhabe, wann die erste regul\u00e4re Folge zu h\u00f6ren sein wird um worum es darin geht.",
"filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK000_Nullnummer.mp3.torrent"
}
],

33
testenv/tests/feed/testfeed.py
View File

@@ -2,24 +2,22 @@ __author__ = 'dev'
import unittest
from feed.feed import Feed
from utilities.jsonfile import JsonFile
from config.config import Config
import os.path
import feedparser
import utilities.file_methods as fm
class TestFeed(unittest.TestCase):
def setUp(self):
super().setUp()
self.testFeed = Feed("sbk", "podcast", "application/x-bittorrent", "testfeeds/podcast/sbk/sbk.xml")
def test_load_new_feed(self):
js = JsonFile("testfeeds/podcast/sbk/sbk.json")
js.check_and_remove_file()
fm.check_and_remove_file("testfeeds/podcast/sbk/sbk.json")
self.testFeed.load_new_feed()
self.assertTrue(os.path.exists("testfeeds/podcast/sbk/sbk.json"))
self.assertIsNotNone(js.read_json_file())
self.assertIsNotNone(fm.read_json_file("testfeeds/podcast/sbk/sbk.json"))
def test_load_new_feed_error_feed_already_exits(self):
self.assertRaises(AssertionError, self.testFeed.load_new_feed)
@@ -33,8 +31,7 @@ class TestFeed(unittest.TestCase):
self.assertTrue(os.path.exists("testfeeds/podcast/sbk/sbk.json"))
def test_load_existing_feed_error_feed_not_exits(self):
js = JsonFile("testfeeds/podcast/sbk/sbk.json")
js.check_and_remove_file()
fm.check_and_remove_file("testfeeds/podcast/sbk/sbk.json")
self.assertRaises(AssertionError, self.testFeed.load_existing_feed)
def test_load_existing_feed_error_none_serializer(self):
@@ -59,8 +56,7 @@ class TestFeed(unittest.TestCase):
def test_setup_feed(self):
self.assertTrue(os.path.exists("testfeeds/podcast/sbk/"))
self.assertTrue(os.path.exists("testfeeds/podcast/sbk/sbk-config.json"))
js = JsonFile("testfeeds/podcast/sbk/sbk-config.json")
self.assertIsNotNone(js.read_json_file())
self.assertIsNotNone(fm.read_json_file("testfeeds/podcast/sbk/sbk-config.json"))
self.assertIsNotNone(self.testFeed.feed_config)
self.assertIsNotNone(self.testFeed.feed_folder_path)
self.assertIsNotNone(self.testFeed.config_path)
@@ -72,7 +68,7 @@ class TestFeed(unittest.TestCase):
"http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/")
self.assertRaises(AssertionError, self.testFeed.setup_feed, "sbk", "podcast", None,
"http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/")
self.assertRaises(AssertionError, self.testFeed.setup_feed, "sbk", "podcast","audio/mpeg", None)
self.assertRaises(AssertionError, self.testFeed.setup_feed, "sbk", "podcast", "audio/mpeg", None)
def test_create_feed_config_path(self):
self.testFeed.config_path = "foo"
@@ -87,8 +83,8 @@ class TestFeed(unittest.TestCase):
self.assertRaises(AssertionError, self.testFeed.new_feed_folder)
def test_create_feed_config_file(self):
feed_config = self.testFeed.create_feed_config_file("sbk", "podcast", "audio/mpeg",
"http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/")
feed_config = Feed.create_feed_config_file("sbk", "podcast", "audio/mpeg",
"http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/")
self.assertIsNotNone(feed_config)
self.assertEqual("sbk", feed_config["FeedName"])
self.assertEqual("podcast", feed_config["FeedType"])
@@ -96,16 +92,17 @@ class TestFeed(unittest.TestCase):
self.assertEqual("http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/", feed_config["FeedUrl"])
def test_create_feed_config_file_error_wrong_parameter(self):
self.assertRaises(AssertionError, self.testFeed.create_feed_config_file, None, "podcast",
self.assertRaises(AssertionError, Feed.create_feed_config_file, None, "podcast",
"audio/mpeg", "http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/")
self.assertRaises(AssertionError, self.testFeed.create_feed_config_file, "sbk", None,
self.assertRaises(AssertionError, Feed.create_feed_config_file, "sbk", None,
"audio/mpeg", "http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/")
self.assertRaises(AssertionError, self.testFeed.create_feed_config_file, "sbk", "podcast", None,
self.assertRaises(AssertionError, Feed.create_feed_config_file, "sbk", "podcast", None,
"http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/")
self.assertRaises(AssertionError, self.testFeed.create_feed_config_file, "sbk", "podcast",
self.assertRaises(AssertionError, Feed.create_feed_config_file, "sbk", "podcast",
"audio/mpeg", None)
self.assertRaises(AssertionError, self.testFeed.create_feed_config_file, "sbk", "podcast",
self.assertRaises(AssertionError, Feed.create_feed_config_file, "sbk", "podcast",
"audiomg", None)
if __name__ == '__main__':
unittest.main()

101
testenv/tests/utilities/test_file_method.py Normal file
View File

@@ -0,0 +1,101 @@
__author__ = 'dev'
import feedparser
import os.path
import unittest
import utilities.file_methods as fm
class TestFileMethod(unittest.TestCase):
def setUp(self):
self.__text_file_path = "test.txt"
self.__json_file_path = "test.json"
self.__file_wrong_file_path = "noFile.txt"
self.__text_file_content = "this is a test"
self.__json_object_file_content = {"1": "4711", "123": "0815"}
self.__json_string_file_content = "{\"1\": \"4711\", \"123\": \"0815\"}"
self.__feed_file_path = "testfeeds/rss/feed.xml"
self.__feed_json_file_path = "testfeed.json"
self.__empty_string = ""
self.__wrong_dict = "{1}"
def tearDown(self):
fm.check_and_remove_file(self.__text_file_path)
fm.check_and_remove_file(self.__json_file_path)
def test_write_text_file(self):
fm.write_text_file(self.__text_file_path, self.__text_file_content)
self.assertTrue(fm.exists_file(self.__text_file_path))
self.assertEqual(fm.read_text_file(self.__text_file_path), self.__text_file_content)
def test_read_text_file(self):
fm.write_text_file(self.__text_file_path, self.__text_file_content)
self.assertEqual(fm.read_text_file(self.__text_file_path), self.__text_file_content)
def test_read_text_file_non_existing_file(self):
self.assertRaises(FileNotFoundError, fm.read_text_file, self.__file_wrong_file_path)
def test_exists_file_true_case(self):
fm.write_text_file(self.__text_file_path, self.__text_file_content)
self.assertEqual(os.path.isfile(self.__text_file_path), fm.exists_file(self.__text_file_path))
def test_exists_file_false_case(self):
self.assertEqual(os.path.isfile(self.__text_file_path), fm.exists_file(self.__text_file_path))
def test_check_and_remove_file(self):
fm.write_text_file(self.__text_file_path, self.__text_file_content)
fm.check_and_remove_file(self.__text_file_path)
self.assertFalse(fm.exists_file(self.__text_file_path))
def test_read_json_file(self):
fm.write_json_file(self.__json_file_path, self.__json_object_file_content)
jo = fm.read_json_file(self.__json_file_path)
self.assertDictEqual(jo, self.__json_object_file_content)
def test_read_json_file_from_string(self):
fm.write_json_file(self.__json_file_path, self.__json_string_file_content)
jo = fm.read_json_file(self.__json_file_path)
self.assertDictEqual(jo, self.__json_object_file_content)
def test_read_json_file_returns_error_if_json_object_is_emptystring(self):
fm.write_text_file(self.__json_file_path, self.__empty_string)
self.assertRaises(ValueError, fm.read_json_file, self.__json_file_path)
def test_read_json_file_returns_error_if_json_object_is_wrong_json_string(self):
fm.write_text_file(self.__json_file_path, self.__wrong_dict)
self.assertRaises(ValueError, fm.read_json_file, self.__json_file_path)
def test_write_json_file(self):
fm.write_json_file(self.__json_file_path, self.__json_object_file_content)
self.assertTrue(os.path.isfile(self.__json_file_path))
def test_write_json_string_file(self):
fm.write_json_file(self.__json_file_path, self.__json_string_file_content )
self.assertTrue(os.path.isfile(self.__json_file_path))
def test_write_json_file_returns_error_if_json_object_is_emptystring(self):
self.assertRaises(ValueError, fm.write_json_file, self.__json_file_path, self.__empty_string)
def test_write_json_file_returns_error_if_json_object_is_wrong_json_string(self):
self.assertRaises(ValueError, fm.write_json_file, self.__json_file_path, self.__wrong_dict)
def test_read_feed_file(self):
feed = fm.read_feed_file(self.__feed_file_path)
self.assertTrue(isinstance(feed, feedparser.FeedParserDict))
def test_write_feed_json_file(self):
feed = fm.read_feed_file(self.__feed_file_path)
self.assertTrue(isinstance(feed, feedparser.FeedParserDict))
fm.write_feed_json_file(self.__feed_json_file_path, feed, None)
feed2 = fm.read_json_file(self.__feed_json_file_path)
self.assertTrue(isinstance(feed2, dict))
fm.check_and_remove_file(self.__feed_json_file_path)
def test_write_feed_file_none_feed_parser_object(self):
self.assertRaises(AssertionError, fm.write_feed_json_file, self.__feed_json_file_path, None, None)
fm.check_and_remove_file(self.__feed_json_file_path)
if __name__ == '__main__':
unittest.main()

34
testenv/tests/utilities/testfeedfile.py
View File

@@ -1,34 +0,0 @@
__author__ = 'stubbfel'
import unittest
import feedparser
from utilities.feedfile import FeedFile
class FeedUtilitiesTest(unittest.TestCase):
def setUp(self):
self.__ff = FeedFile("testfeeds/rss/feed.xml")
def test_read_feed_file(self):
feed = self.__ff.read_feed_file()
self.assertTrue(isinstance(feed, feedparser.FeedParserDict))
def test_json_feed_file(self):
feed = self.__ff.read_feed_file()
ff2 = FeedFile("testfeed.xml")
serializer = None
ff2.write_feed_json_file(feed, serializer)
feed2 = ff2.read_feed_file()
self.assertTrue(isinstance(feed2, feedparser.FeedParserDict))
ff2.check_and_remove_file()
# self.assertDictEqual(feed, feed2)
def test_write_feed_file_none_feedparser_object(self):
feed = "Fail"
ff2 = FeedFile("testfeed.xml")
serializer = None
self.assertRaises(AssertionError, ff2.write_feed_json_file, feed, serializer)
ff2.check_and_remove_file()
if __name__ == '__main__':
unittest.main()

54
testenv/tests/utilities/testjsonutilities.py
View File

@@ -1,54 +0,0 @@
__author__ = 'stubbfel'
import unittest
from utilities.jsonfile import JsonFile
from utilities.textfile import TextFile
import os.path
class JsonUtilitiesTest(unittest.TestCase):
def setUp(self):
self.__jf = JsonFile("test.json")
self.__jf.check_and_remove_file()
def tearDown(self):
self.__jf.check_and_remove_file()
def test_read_json_file(self):
self.__jf.write_json_file({1: "4711", "123": "0815"})
jo = self.__jf.read_json_file()
self.assertEqual(jo["1"], "4711")
self.assertEqual(jo["123"], "0815")
def test_read_json_file_from_string(self):
self.__jf.write_json_file("{\"1\": \"4711\", \"123\": \"0815\"}")
jo = self.__jf.read_json_file()
self.assertEqual(jo["1"], "4711")
self.assertEqual(jo["123"], "0815")
def test_read_json_file_returns_error_if_json_object_is_emptystring(self):
tf = TextFile("test.json")
tf.write_text_file("")
self.assertRaises(ValueError, self.__jf.read_json_file)
def test_read_json_file_returns_error_if_json_object_is_wrong_json_string(self):
tf = TextFile("test.json")
tf.write_text_file("{1}")
self.assertRaises(ValueError, self.__jf.read_json_file)
def test_write_json_file(self):
self.__jf.write_json_file({1: "4711", "123": "0815"})
self.assertTrue(os.path.isfile("test.json"))
def test_write_json_file(self):
self.__jf.write_json_file("{\"1\": \"4711\", \"123\": \"0815\"}")
self.assertTrue(os.path.isfile("test.json"))
def test_write_json_file_returns_error_if_json_object_is_emptystring(self):
self.assertRaises(ValueError, self.__jf.write_json_file, "")
def test_write_json_file_returns_error_if_json_object_is_wrong_json_string(self):
self.assertRaises(ValueError, self.__jf.write_json_file, "{1}")
if __name__ == '__main__':
unittest.main()

14
testenv/tests/utilities/testpodcastserializer.py
View File

@@ -2,26 +2,24 @@ __author__ = 'dev'
import unittest
from utilities.podcastserializer import PodcastSerializer
from utilities.feedfile import FeedFile
import utilities.file_methods as fm
class PodCastSerializerUtilitiesTest(unittest.TestCase):
def setUp(self):
self.__podcastfeed= FeedFile("testfeeds/podcast/sbk/sbk.xml").read_feed_file()
self.__podcastfeed= fm.read_feed_file("testfeeds/podcast/sbk/sbk.xml")
self.__serializer = PodcastSerializer("application/x-bittorrent")
def test_serialize(self):
ff2 = FeedFile("testfeed.json")
ff2.write_feed_json_file(self.__podcastfeed, self.__serializer)
feed = ff2.read_json_file()
fm.write_feed_json_file("testfeed.json", self.__podcastfeed, self.__serializer)
feed = fm.read_json_file("testfeed.json")
self.assertIsNotNone(feed)
self.assertIsInstance(feed, dict)
self.assertNotEqual(feed, self.__podcastfeed)
ff2.check_and_remove_file();
fm.check_and_remove_file("testfeed.json")
if __name__ == '__main__':
unittest.main()

48
testenv/tests/utilities/testtextfileutility.py
View File

@@ -1,48 +0,0 @@
__author__ = 'stubbfel'
import unittest
from utilities.textfile import TextFile
import os.path
class TextFileUtilitiesTest(unittest.TestCase):
def setUp(self):
self.__tf = TextFile("test.txt")
self.__tf.check_and_remove_file()
def tearDown(self):
self.__tf.check_and_remove_file()
def test_write_text_file(self):
self.__tf.write_text_file("this is a test")
self.assertTrue(self.__tf.exists_file)
self.assertEqual(self.__tf.read_text_file(), "this is a test")
def test_read_text_file(self):
self.__tf.write_text_file("this is a test")
self.assertEqual(self.__tf.read_text_file(), "this is a test")
def test_read_text_file_non_existing_file(self):
self.assertRaises(FileNotFoundError, self.__tf.read_text_file)
def test_exists_file_true_case(self):
self.assertEqual(os.path.isfile("test.txt"), self.__tf.exists_file)
def test_exists_file_false_case(self):
self.assertEqual(os.path.isfile("test.txt"), self.__tf.exists_file)
def test_check_and_remove_file(self):
self.__tf.write_text_file("this is a test")
self.__tf.check_and_remove_file()
self.assertFalse(self.__tf.exists_file)
def test_get_filename_true(self):
self.assertEqual(self.__tf.get_filename, "test.txt")
def test_get_filename_false(self):
self.assertNotEqual(self.__tf.get_filename, "test1.txt")
if __name__ == '__main__':
unittest.main()