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

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()