From cd2b59dce3ea1a1e368d61a90280f3feb25e6f69 Mon Sep 17 00:00:00 2001 From: stubbfel Date: Fri, 18 Jul 2014 23:18:28 +0200 Subject: [PATCH 1/5] add feed test method --- testenv/tests/feed/testfeed.py | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/testenv/tests/feed/testfeed.py b/testenv/tests/feed/testfeed.py index 51ca99e..11d259b 100644 --- a/testenv/tests/feed/testfeed.py +++ b/testenv/tests/feed/testfeed.py @@ -6,18 +6,32 @@ from feed.feed import Feed class TestFeed(unittest.TestCase): - def test_load_new_feed(self, url): + def test_load_new_feed(self): self.assertTrue(False) - def test_load_existing_feed(self, path): + def test_load_new_feed_error_feed_already_exits(self): self.assertTrue(False) - def test_load_feed(self, path): + def test_load_existing_feed(self): self.assertTrue(False) - def test_setup_feed(self, name, url, feed_type): + def test_load_existing_feed_error_feed_not_exits(self): self.assertTrue(False) + def test_load_feed(self): + self.assertTrue(False) + + def test_load_feed_error_loading_failed(self): + self.assertTrue(False) + + def test_setup_feed(self): + self.assertTrue(False) + + def test_new_feed_folder(self): + self.assertTrue(False) + + def test_create_feed_config_file(self): + self.assertTrue(False) if __name__ == '__main__': From d1e64e66dea2034583d8028e096ba1ff8d480d49 Mon Sep 17 00:00:00 2001 From: stubbfel Date: Sat, 26 Jul 2014 00:45:40 +0200 Subject: [PATCH 2/5] add create onif file and new folder --- src/config/config.py | 4 +- src/feed/feed.py | 47 ++++++++++++++++++++++- testenv/testfeeds/podcast/sbk-config.json | 5 ++- testenv/tests/config/testconfig.py | 11 ++++++ testenv/tests/feed/testfeed.py | 18 ++++++++- 5 files changed, 78 insertions(+), 7 deletions(-) diff --git a/src/config/config.py b/src/config/config.py index 23c211f..cc0dc51 100644 --- a/src/config/config.py +++ b/src/config/config.py @@ -4,5 +4,7 @@ Config = { "FeedLinkTypes" : {"application/x-bittorrent","mp3"}, "FeedTypes" : {"podcast","rss"}, "FeedStorageFolder" : "testfeeds", - "FeedStoragePrefix" : { "0" : "FeedTypes"} + "FeedStoragePrefix" : { "0" : "FeedType", "1" : "FeedName"}, + "ConfigFileSuffix" : "-config", + "ConfigFileExtension" : ".json" } \ No newline at end of file diff --git a/src/feed/feed.py b/src/feed/feed.py index 7118ff8..d0cc516 100644 --- a/src/feed/feed.py +++ b/src/feed/feed.py @@ -1,6 +1,49 @@ __author__ = 'dev' +from utilities.jsonfile import JsonFile +from config.config import Config +import os + class Feed: - def __init__(self): - self.valid_file_types = {"application/x-bittorrent","mp3"} \ No newline at end of file + def __init__(self, feed_name=None, feed_type=None, link_type=None, feed_url=None): + self.valid_file_types = {"application/x-bittorrent","mp3"} + self.feed_config = self.create_feed_config_file(feed_name, feed_type, link_type, feed_url) + + def new_feed_folder(self): + feed_folder = Config["FeedStorageFolder"] + feed_folder_prefix = Config["FeedStoragePrefix"] + + for i in range(len(feed_folder_prefix)): + value = feed_folder_prefix.get(str(i)) + if value is not None: + tmpValue = self.feed_config.get(value) + if tmpValue is not None: + value = tmpValue + + feed_folder += "/" + value + else: + break + + if not os.path.exists(feed_folder): + os.mkdir(feed_folder) + + return os.path.abspath(feed_folder) + + + + + def create_feed_config_file(self, feed_name, feed_type, link_type, feed_url): + feed_config =\ + { + "FeedName": feed_name, + "FeedType": feed_type, + "FeedUrl": feed_url, + "LinkType": link_type + } + return feed_config + + + def write_feed_config_file(self, feed_folder): + file = JsonFile(feed_folder + self.feed_config["FeedName"] + Config["ConfigFileSuffix"] + Config["ConfigFileExtension"]) + file.write_json_file(self.feed_config) \ No newline at end of file diff --git a/testenv/testfeeds/podcast/sbk-config.json b/testenv/testfeeds/podcast/sbk-config.json index b59dcbe..a792fa2 100644 --- a/testenv/testfeeds/podcast/sbk-config.json +++ b/testenv/testfeeds/podcast/sbk-config.json @@ -1,4 +1,5 @@ { - "FeedUrl" : "http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/" - "LinkType" : "application/x-bittorrent" + "FeedName": "sbk", + "FeedUrl": "http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/", + "LinkType": "application/x-bittorrent" } \ No newline at end of file diff --git a/testenv/tests/config/testconfig.py b/testenv/tests/config/testconfig.py index 74d7927..6243507 100644 --- a/testenv/tests/config/testconfig.py +++ b/testenv/tests/config/testconfig.py @@ -32,6 +32,17 @@ class TestConfig(unittest.TestCase): self.assertIsNotNone(prefix) self.assertIsInstance(prefix, dict) + def test_feed_config_file_suffix(self): + suffix = Config.get("ConfigFileSuffix") + self.assertIsNotNone(suffix) + self.assertIsInstance(suffix, str) + + def test_feed_config_file_extension(self): + extension = Config.get("ConfigFileExtension") + self.assertIsNotNone(extension) + self.assertIsInstance(extension, str) + self.assertIn(".", extension) + if __name__ == '__main__': unittest.main() diff --git a/testenv/tests/feed/testfeed.py b/testenv/tests/feed/testfeed.py index 11d259b..ee4ac70 100644 --- a/testenv/tests/feed/testfeed.py +++ b/testenv/tests/feed/testfeed.py @@ -2,10 +2,18 @@ __author__ = 'dev' import unittest from feed.feed import Feed +from utilities.jsonfile import JsonFile +from config.config import Config +import os.path class TestFeed(unittest.TestCase): + def setUp(self): + super().setUp() + self.testFeed = Feed("sbk", "podcast", "application/x-bittorrent", + "http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/") + def test_load_new_feed(self): self.assertTrue(False) @@ -28,10 +36,16 @@ class TestFeed(unittest.TestCase): self.assertTrue(False) def test_new_feed_folder(self): - self.assertTrue(False) + self.assertTrue(os.path.exists(self.testFeed.new_feed_folder())) def test_create_feed_config_file(self): - self.assertTrue(False) + feed_config = self.testFeed.create_feed_config_file("sbk", "podcast", "application/x-bittorrent", + "http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/") + self.assertIsNotNone(feed_config) + self.assertEqual("sbk", feed_config["FeedName"]) + self.assertEqual("podcast", feed_config["FeedType"]) + self.assertEqual("application/x-bittorrent", feed_config["LinkType"]) + self.assertEqual("http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/", feed_config["FeedUrl"]) if __name__ == '__main__': From 67e74675ed1cc6fc5979c8a4dc9e5d91ac6e5c78 Mon Sep 17 00:00:00 2001 From: stubbfel Date: Wed, 30 Jul 2014 22:59:03 +0200 Subject: [PATCH 3/5] add load and setup methods --- src/config/config.py | 2 +- src/feed/feed.py | 71 +++++++++++++------ src/utilities/feedfile.py | 2 +- src/utilities/podcastserializer.py | 6 +- testenv/testfeeds/podcast/sbk-config.json | 5 -- testenv/testfeeds/podcast/sbk/sbk-config.json | 6 ++ testenv/testfeeds/podcast/{ => sbk}/sbk.xml | 0 testenv/tests/feed/testfeed.py | 50 +++++++++++-- testenv/tests/utilities/testfeedfile.py | 4 +- .../tests/utilities/testpodcastserializer.py | 6 +- 10 files changed, 113 insertions(+), 39 deletions(-) delete mode 100644 testenv/testfeeds/podcast/sbk-config.json create mode 100644 testenv/testfeeds/podcast/sbk/sbk-config.json rename testenv/testfeeds/podcast/{ => sbk}/sbk.xml (100%) diff --git a/src/config/config.py b/src/config/config.py index cc0dc51..f90e6e7 100644 --- a/src/config/config.py +++ b/src/config/config.py @@ -1,7 +1,7 @@ __author__ = 'dev' Config = { - "FeedLinkTypes" : {"application/x-bittorrent","mp3"}, + "FeedLinkTypes" : {"audio/mpeg","application/x-bittorrent"}, "FeedTypes" : {"podcast","rss"}, "FeedStorageFolder" : "testfeeds", "FeedStoragePrefix" : { "0" : "FeedType", "1" : "FeedName"}, diff --git a/src/feed/feed.py b/src/feed/feed.py index d0cc516..633e66d 100644 --- a/src/feed/feed.py +++ b/src/feed/feed.py @@ -1,40 +1,67 @@ __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 + class Feed: def __init__(self, feed_name=None, feed_type=None, link_type=None, feed_url=None): - self.valid_file_types = {"application/x-bittorrent","mp3"} + self.config_path = None + self.feed_folder_path = None + self.feed_config = None + self.setup_feed(feed_name, feed_type, link_type, feed_url) + + def load_feed(self): + assert self.feed_config is not None + return feedparser.parse(self.feed_config["FeedUrl"]) + + def setup_feed(self, 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 + assert feed_url is not None + self.feed_config = self.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() def new_feed_folder(self): - feed_folder = Config["FeedStorageFolder"] - feed_folder_prefix = Config["FeedStoragePrefix"] - for i in range(len(feed_folder_prefix)): - value = feed_folder_prefix.get(str(i)) - if value is not None: - tmpValue = self.feed_config.get(value) - if tmpValue is not None: - value = tmpValue + 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 + feed_folder_prefix = Config.get("FeedStoragePrefix") + assert feed_folder_prefix is not None - feed_folder += "/" + value - else: - break + for i in range(len(feed_folder_prefix)): + value = feed_folder_prefix.get(str(i)) + if value is not None: + tmp_value = self.feed_config.get(value) + if tmp_value is not None: + value = tmp_value + feed_folder += "/" + value + else: + break - if not os.path.exists(feed_folder): + self.feed_folder_path = feed_folder + if not os.path.exists(self.feed_folder_path): os.mkdir(feed_folder) - return os.path.abspath(feed_folder) - - - + return self.feed_folder_path def create_feed_config_file(self, feed_name, feed_type, link_type, feed_url): - feed_config =\ + assert feed_name is not None + assert feed_type is not None + assert link_type is not None + assert feed_url is not None + feed_config = \ { "FeedName": feed_name, "FeedType": feed_type, @@ -43,7 +70,11 @@ class Feed: } 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, feed_folder): - file = JsonFile(feed_folder + self.feed_config["FeedName"] + Config["ConfigFileSuffix"] + Config["ConfigFileExtension"]) + def write_feed_config_file(self): + file = JsonFile(self.create_feed_config_path()) file.write_json_file(self.feed_config) \ No newline at end of file diff --git a/src/utilities/feedfile.py b/src/utilities/feedfile.py index 0271bcf..b879831 100644 --- a/src/utilities/feedfile.py +++ b/src/utilities/feedfile.py @@ -21,7 +21,7 @@ class FeedFile(JsonFile): feed_str = self.read_text_file() return feedparser.parse(feed_str) - def write_feedjson_file(self, feed, serializer=None): + 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 diff --git a/src/utilities/podcastserializer.py b/src/utilities/podcastserializer.py index 89b0c9d..1a55853 100644 --- a/src/utilities/podcastserializer.py +++ b/src/utilities/podcastserializer.py @@ -1,9 +1,13 @@ __author__ = 'dev' import json from utilities.serializer import Serializer +from config.config import Config class PodcastSerializer(Serializer): + def __init__(self, episode_file_type): + self.episode_file_type = episode_file_type + def serialize(self, dict_object): """ method convert i dict to a string. @@ -18,7 +22,7 @@ class PodcastSerializer(Serializer): for episode in dict_object["entries"]: filelink = "" for links in episode["links"]: - if links["type"] == 'application/x-bittorrent': + if links["type"] == self.episode_file_type: filelink = links["href"] tempepisode = { diff --git a/testenv/testfeeds/podcast/sbk-config.json b/testenv/testfeeds/podcast/sbk-config.json deleted file mode 100644 index a792fa2..0000000 --- a/testenv/testfeeds/podcast/sbk-config.json +++ /dev/null @@ -1,5 +0,0 @@ -{ - "FeedName": "sbk", - "FeedUrl": "http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/", - "LinkType": "application/x-bittorrent" -} \ No newline at end of file diff --git a/testenv/testfeeds/podcast/sbk/sbk-config.json b/testenv/testfeeds/podcast/sbk/sbk-config.json new file mode 100644 index 0000000..143f513 --- /dev/null +++ b/testenv/testfeeds/podcast/sbk/sbk-config.json @@ -0,0 +1,6 @@ +{ + "LinkType": "application/x-bittorrent", + "FeedUrl": "http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/", + "FeedType": "podcast", + "FeedName": "sbk" +} \ No newline at end of file diff --git a/testenv/testfeeds/podcast/sbk.xml b/testenv/testfeeds/podcast/sbk/sbk.xml similarity index 100% rename from testenv/testfeeds/podcast/sbk.xml rename to testenv/testfeeds/podcast/sbk/sbk.xml diff --git a/testenv/tests/feed/testfeed.py b/testenv/tests/feed/testfeed.py index ee4ac70..deea23c 100644 --- a/testenv/tests/feed/testfeed.py +++ b/testenv/tests/feed/testfeed.py @@ -5,14 +5,13 @@ from feed.feed import Feed from utilities.jsonfile import JsonFile from config.config import Config import os.path - +import feedparser class TestFeed(unittest.TestCase): def setUp(self): super().setUp() - self.testFeed = Feed("sbk", "podcast", "application/x-bittorrent", - "http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/") + self.testFeed = Feed("sbk", "podcast", "audio/mpeg", "testfeeds/podcast/sbk/sbk.xml") def test_load_new_feed(self): self.assertTrue(False) @@ -27,7 +26,19 @@ class TestFeed(unittest.TestCase): self.assertTrue(False) def test_load_feed(self): - self.assertTrue(False) + feed = self.testFeed.load_feed() + self.assertIsInstance(self.testFeed.load_feed(), feedparser.FeedParserDict) + self.assertEqual(0, feed["bozo"]) + + def test_load_feed_error_none_config(self): + self.testFeed.feed_config = None + self.assertRaises(AssertionError, self.testFeed.load_feed) + + def test_load_feed_error_wrong_url(self): + self.testFeed = Feed("sbk", "podcast", "audio/mpeg", "testfeeds/podcast/sbk/sbk.xm") + feed = self.testFeed.load_feed() + self.assertIsInstance(self.testFeed.load_feed(), feedparser.FeedParserDict) + self.assertEqual(1, feed["bozo"]) def test_load_feed_error_loading_failed(self): self.assertTrue(False) @@ -35,18 +46,45 @@ class TestFeed(unittest.TestCase): def test_setup_feed(self): self.assertTrue(False) + def test_setup_feed_error_none_parameter(self): + self.assertRaises(AssertionError, self.testFeed.setup_feed, None, "podcast", "audio/mpeg", + "http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/") + self.assertRaises(AssertionError, self.testFeed.setup_feed, "sbk", None, "audio/mpeg", + "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) + + def test_create_feed_config_path(self): + self.testFeed.config_path = "foo" + self.assertEqual(self.testFeed.create_feed_config_path(), "foo") + def test_new_feed_folder(self): self.assertTrue(os.path.exists(self.testFeed.new_feed_folder())) + def test_new_feed_folder_no_feed_config(self): + self.testFeed.feed_folder_path = None + self.testFeed.feed_config = None + 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", "application/x-bittorrent", + feed_config = self.testFeed.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"]) - self.assertEqual("application/x-bittorrent", feed_config["LinkType"]) + self.assertEqual("audio/mpeg", feed_config["LinkType"]) self.assertEqual("http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/", feed_config["FeedUrl"]) + def test_create_feed_config_file_error_none_parameter(self): + self.assertRaises(AssertionError, self.testFeed.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, + "audio/mpeg", "http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/") + self.assertRaises(AssertionError, self.testFeed.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", + "audio/mpeg", None) if __name__ == '__main__': unittest.main() diff --git a/testenv/tests/utilities/testfeedfile.py b/testenv/tests/utilities/testfeedfile.py index 346550e..8cadbc5 100644 --- a/testenv/tests/utilities/testfeedfile.py +++ b/testenv/tests/utilities/testfeedfile.py @@ -17,7 +17,7 @@ class FeedUtilitiesTest(unittest.TestCase): feed = self.__ff.read_feed_file() ff2 = FeedFile("testfeed.xml") serializer = None - ff2.write_feedjson_file(feed, serializer) + ff2.write_feed_json_file(feed, serializer) feed2 = ff2.read_feed_file() self.assertTrue(isinstance(feed2, feedparser.FeedParserDict)) ff2.check_and_remove_file() @@ -27,7 +27,7 @@ class FeedUtilitiesTest(unittest.TestCase): feed = "Fail" ff2 = FeedFile("testfeed.xml") serializer = None - self.assertRaises(AssertionError, ff2.write_feedjson_file, feed, serializer) + self.assertRaises(AssertionError, ff2.write_feed_json_file, feed, serializer) ff2.check_and_remove_file() if __name__ == '__main__': diff --git a/testenv/tests/utilities/testpodcastserializer.py b/testenv/tests/utilities/testpodcastserializer.py index 1207722..c83590a 100644 --- a/testenv/tests/utilities/testpodcastserializer.py +++ b/testenv/tests/utilities/testpodcastserializer.py @@ -7,12 +7,12 @@ from utilities.feedfile import FeedFile class PodCastSerializerUtilitiesTest(unittest.TestCase): def setUp(self): - self.__podcastfeed= FeedFile("testfeeds/podcast/sbk.xml").read_feed_file() - self.__serializer = PodcastSerializer() + self.__podcastfeed= FeedFile("testfeeds/podcast/sbk/sbk.xml").read_feed_file() + self.__serializer = PodcastSerializer("application/x-bittorrent") def test_serialize(self): ff2 = FeedFile("testfeed.json") - ff2.write_feedjson_file(self.__podcastfeed, self.__serializer) + ff2.write_feed_json_file(self.__podcastfeed, self.__serializer) feed = ff2.read_json_file() self.assertIsNotNone(feed) From 886953c9fcc3bc5865792c031a45092c24507c50 Mon Sep 17 00:00:00 2001 From: stubbfel Date: Wed, 30 Jul 2014 23:02:34 +0200 Subject: [PATCH 4/5] add assert --- src/feed/feed.py | 1 + testenv/tests/feed/testfeed.py | 4 +++- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/feed/feed.py b/src/feed/feed.py index 633e66d..b36dc45 100644 --- a/src/feed/feed.py +++ b/src/feed/feed.py @@ -61,6 +61,7 @@ class Feed: assert feed_type is not None assert link_type is not None assert feed_url is not None + assert link_type in Config["FeedLinkTypes"] feed_config = \ { "FeedName": feed_name, diff --git a/testenv/tests/feed/testfeed.py b/testenv/tests/feed/testfeed.py index deea23c..2efd173 100644 --- a/testenv/tests/feed/testfeed.py +++ b/testenv/tests/feed/testfeed.py @@ -76,7 +76,7 @@ class TestFeed(unittest.TestCase): self.assertEqual("audio/mpeg", feed_config["LinkType"]) self.assertEqual("http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/", feed_config["FeedUrl"]) - def test_create_feed_config_file_error_none_parameter(self): + def test_create_feed_config_file_error_wrong_parameter(self): self.assertRaises(AssertionError, self.testFeed.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, @@ -85,6 +85,8 @@ class TestFeed(unittest.TestCase): "http://www.staatsbuergerkunde-podcast.de/feed/mp3-rss/") self.assertRaises(AssertionError, self.testFeed.create_feed_config_file, "sbk", "podcast", "audio/mpeg", None) + self.assertRaises(AssertionError, self.testFeed.create_feed_config_file, "sbk", "podcast", + "audiomg", None) if __name__ == '__main__': unittest.main() From 816d196f8152e0368a52c3cfee86641a8e4fb12d Mon Sep 17 00:00:00 2001 From: stubbfel Date: Sat, 9 Aug 2014 00:35:33 +0200 Subject: [PATCH 5/5] add load methddos --- src/feed/feed.py | 30 +++++ testenv/testfeeds/podcast/sbk/sbk.json | 152 +++++++++++++++++++++++++ testenv/tests/feed/testfeed.py | 37 ++++-- 3 files changed, 210 insertions(+), 9 deletions(-) create mode 100644 testenv/testfeeds/podcast/sbk/sbk.json diff --git a/src/feed/feed.py b/src/feed/feed.py index b36dc45..fe206ed 100644 --- a/src/feed/feed.py +++ b/src/feed/feed.py @@ -14,12 +14,39 @@ class Feed: self.config_path = None self.feed_folder_path = None self.feed_config = None + self.feed_file_path = None + self.serializer = None self.setup_feed(feed_name, feed_type, link_type, feed_url) def load_feed(self): assert self.feed_config is not None return feedparser.parse(self.feed_config["FeedUrl"]) + 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) + + 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) + + 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() + + def get_serializer(self): + return { + "podcast": PodcastSerializer(self.feed_config["LinkType"]) + }.get(self.feed_config["FeedType"], PodcastSerializer(self.feed_config["LinkType"])) + def setup_feed(self, feed_name, feed_type, link_type, feed_url): assert feed_name is not None assert feed_type is not None @@ -31,6 +58,9 @@ class Feed: 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.serializer = self.get_serializer() + def new_feed_folder(self): if self.feed_folder_path is None: diff --git a/testenv/testfeeds/podcast/sbk/sbk.json b/testenv/testfeeds/podcast/sbk/sbk.json new file mode 100644 index 0000000..e9f4229 --- /dev/null +++ b/testenv/testfeeds/podcast/sbk/sbk.json @@ -0,0 +1,152 @@ +{ + "subtitle": "Vom Leben in der DDR", + "title": "Staatsb\u00fcrgerkunde", + "episodes": [ + { + "subtitle": "Von Kollektivleistungen, Planstellen und dem Lohn der Arbeit", + "title": "SBK028 Arbeit", + "filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK028_Arbeit.mp3.torrent" + }, + { + "subtitle": "Vom Traumberuf, Experimenten und Schulpolitik", + "title": "SBK027 Lehrerberuf", + "filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK027_Lehrerberuf.mp3.torrent" + }, + { + "subtitle": "Vom Konsum, geheimem Rotwein und Tieren ohne Lenden", + "title": "SBK026 Lebensmittel", + "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", + "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", + "filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK024_Kirchenmusik.mp3.torrent" + }, + { + "subtitle": "Von Halbtags-Demonstranten, Papiertauben und Tagedieben", + "title": "SBK023 Feier- und Gedenktage", + "filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK023_Feier_und_Gedenktage.mp3.torrent" + }, + { + "subtitle": "Vom Forscherdrang, Wechselblinkern und n\u00e4chtlichen Bastelrunden", + "title": "SBK022 Station", + "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", + "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", + "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", + "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)", + "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)", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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", + "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)", + "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)", + "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", + "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", + "filelink": "http://bitlove.org/nitramred/staatsbuergerkunde-mp3/SBK000_Nullnummer.mp3.torrent" + } + ], + "summary": "Ein Podcast \u00fcber das Leben in der DDR. Im Gespr\u00e4ch mit G\u00e4sten schaut Martin Fischer in jeder Folge zur\u00fcck auf die Lebensaspekte eines B\u00fcrgers der ehemaligen Deutschen Demokratischen Republik. Vom Schulsystem, dem kulturellen Leben bis hin zu den politischen Repressionen reicht das Themenspektrum. Der Podcast erscheint ungef\u00e4hr alle drei Wochen." +} \ No newline at end of file diff --git a/testenv/tests/feed/testfeed.py b/testenv/tests/feed/testfeed.py index 2efd173..fadab72 100644 --- a/testenv/tests/feed/testfeed.py +++ b/testenv/tests/feed/testfeed.py @@ -11,19 +11,35 @@ class TestFeed(unittest.TestCase): def setUp(self): super().setUp() - self.testFeed = Feed("sbk", "podcast", "audio/mpeg", "testfeeds/podcast/sbk/sbk.xml") + self.testFeed = Feed("sbk", "podcast", "application/x-bittorrent", "testfeeds/podcast/sbk/sbk.xml") def test_load_new_feed(self): - self.assertTrue(False) + js = JsonFile("testfeeds/podcast/sbk/sbk.json") + js.check_and_remove_file() + self.testFeed.load_new_feed() + self.assertTrue(os.path.exists("testfeeds/podcast/sbk/sbk.json")) + + self.assertIsNotNone(js.read_json_file()) def test_load_new_feed_error_feed_already_exits(self): - self.assertTrue(False) + self.assertRaises(AssertionError, self.testFeed.load_new_feed) + + def test_load_new_feed_error_none_serializer(self): + self.testFeed.serializer = None + self.assertRaises(AssertionError, self.testFeed.load_new_feed) def test_load_existing_feed(self): - self.assertTrue(False) + self.testFeed.load_existing_feed() + self.assertTrue(os.path.exists("testfeeds/podcast/sbk/sbk.json")) def test_load_existing_feed_error_feed_not_exits(self): - self.assertTrue(False) + js = JsonFile("testfeeds/podcast/sbk/sbk.json") + js.check_and_remove_file() + self.assertRaises(AssertionError, self.testFeed.load_existing_feed) + + def test_load_existing_feed_error_none_serializer(self): + self.testFeed.serializer = None + self.assertRaises(AssertionError, self.testFeed.load_existing_feed) def test_load_feed(self): feed = self.testFeed.load_feed() @@ -40,11 +56,14 @@ class TestFeed(unittest.TestCase): self.assertIsInstance(self.testFeed.load_feed(), feedparser.FeedParserDict) self.assertEqual(1, feed["bozo"]) - def test_load_feed_error_loading_failed(self): - self.assertTrue(False) - def test_setup_feed(self): - self.assertTrue(False) + 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(self.testFeed.feed_config) + self.assertIsNotNone(self.testFeed.feed_folder_path) + self.assertIsNotNone(self.testFeed.config_path) def test_setup_feed_error_none_parameter(self): self.assertRaises(AssertionError, self.testFeed.setup_feed, None, "podcast", "audio/mpeg",