From 7e7adc64713f74976d5994af36b5f758620fb37b Mon Sep 17 00:00:00 2001 From: RaNaN Date: Sat, 13 Oct 2012 21:39:58 +0200 Subject: added JSON and WS client, re organized tests, new classes for easier api tests --- tests/__init__.py | 0 tests/api/ApiProxy.py | 68 ++++++++++ tests/api/ApiTester.py | 35 +++++ tests/api/__init__.py | 0 tests/api/test_JSONBackend.py | 27 ++++ tests/api/test_api.py | 39 ++++++ tests/api/test_noargs.py | 29 ++++ tests/config/db.version | 1 - tests/helper/Stubs.py | 3 + tests/manager/__init__.py | 0 tests/manager/test_filemanager.py | 223 +++++++++++++++++++++++++++++++ tests/manager/test_interactionManager.py | 58 ++++++++ tests/other/__init__.py | 0 tests/other/test_configparser.py | 53 ++++++++ tests/other/test_database.py | 192 ++++++++++++++++++++++++++ tests/other/test_syntax.py | 43 ++++++ tests/test_api.py | 18 --- tests/test_backends.py | 59 -------- tests/test_configparser.py | 48 ------- tests/test_database.py | 195 --------------------------- tests/test_filemanager.py | 223 ------------------------------- tests/test_interactionManager.py | 58 -------- tests/test_syntax.py | 43 ------ 23 files changed, 770 insertions(+), 645 deletions(-) create mode 100644 tests/__init__.py create mode 100644 tests/api/ApiProxy.py create mode 100644 tests/api/ApiTester.py create mode 100644 tests/api/__init__.py create mode 100644 tests/api/test_JSONBackend.py create mode 100644 tests/api/test_api.py create mode 100644 tests/api/test_noargs.py delete mode 100644 tests/config/db.version create mode 100644 tests/manager/__init__.py create mode 100644 tests/manager/test_filemanager.py create mode 100644 tests/manager/test_interactionManager.py create mode 100644 tests/other/__init__.py create mode 100644 tests/other/test_configparser.py create mode 100644 tests/other/test_database.py create mode 100644 tests/other/test_syntax.py delete mode 100644 tests/test_api.py delete mode 100644 tests/test_backends.py delete mode 100644 tests/test_configparser.py delete mode 100644 tests/test_database.py delete mode 100644 tests/test_filemanager.py delete mode 100644 tests/test_interactionManager.py delete mode 100644 tests/test_syntax.py (limited to 'tests') diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/api/ApiProxy.py b/tests/api/ApiProxy.py new file mode 100644 index 000000000..74c938870 --- /dev/null +++ b/tests/api/ApiProxy.py @@ -0,0 +1,68 @@ +# -*- coding: utf-8 -*- + + +from module.remote.ttypes_debug import classes, methods + +class ApiProxy: + """ Proxy that does type checking on the api """ + + def __init__(self, api, user="User", pw="test"): + self.api = api + self.user = user + self.pw = pw + + if user and pw is not None: + self.api.login(user, pw) + + def assert_type(self, result, type): + if not type: return # void + try: + # Complex attribute + if isinstance(type, tuple): + # Optional result + if type[0] is None: + # Only check if not None + if result is not None: self.assert_type(result, type[1]) + + # List + elif type[0] == list: + assert isinstance(result, list) + for item in result: + self.assert_type(item, type[1]) + # Dict + elif type[0] == dict: + assert isinstance(result, dict) + for k, v in result.iteritems(): + self.assert_type(k, type[1]) + self.assert_type(v, type[2]) + + # Struct - Api class + elif hasattr(result, "__name__") and result.__name__ in classes: + for attr, atype in zip(result.__slots__, classes[result.__name__]): + self.assert_type(getattr(result, attr), atype) + else: # simple object + assert isinstance(result, type) + except AssertionError: + print "Assertion for %s as %s failed" % (result, type) + raise + + + def call(self, func, *args, **kwargs): + result = getattr(self.api, func)(*args, **kwargs) + self.assert_type(result, methods[func]) + + return result + + + def __getattr__(self, item): + def call(*args, **kwargs): + return self.call(item, *args, **kwargs) + + return call + +if __name__ == "__main__": + + from module.remote.JSONClient import JSONClient + + api = ApiProxy(JSONClient(), "User", "test") + api.getServerVersion() \ No newline at end of file diff --git a/tests/api/ApiTester.py b/tests/api/ApiTester.py new file mode 100644 index 000000000..b17a7655e --- /dev/null +++ b/tests/api/ApiTester.py @@ -0,0 +1,35 @@ +# -*- coding: utf-8 -*- + +from module.remote.JSONClient import JSONClient +from module.remote.WSClient import WSClient + +from ApiProxy import ApiProxy + +class ApiTester: + + tester= [] + + @classmethod + def register(cls, tester): + cls.tester.append(tester) + + @classmethod + def get_methods(cls): + """ All available methods for testing """ + methods = [] + for t in cls.tester: + methods.extend(getattr(t, attr) for attr in dir(t) if attr.startswith("test_")) + return methods + + def __init__(self): + ApiTester.register(self) + self.api = None + + def setApi(self, api): + self.api = api + + def enableJSON(self): + self.api = ApiProxy(JSONClient()) + + def enableWS(self): + self.api = ApiProxy(WSClient()) diff --git a/tests/api/__init__.py b/tests/api/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/api/test_JSONBackend.py b/tests/api/test_JSONBackend.py new file mode 100644 index 000000000..a3805497b --- /dev/null +++ b/tests/api/test_JSONBackend.py @@ -0,0 +1,27 @@ +# -*- coding: utf-8 -*- + +from nose.tools import raises + +from module.remote.JSONClient import JSONClient + +class TestJSONBackend: + + def setUp(self): + self.client = JSONClient() + + def test_login(self): + self.client.login("User", "test") + self.client.getServerVersion() + self.client.logout() + + def test_wronglogin(self): + ret = self.client.login("WrongUser", "wrongpw") + assert ret == False + + @raises(Exception) + def test_access(self): + self.client.getServerVersion() + + @raises(Exception) + def test_unknown_method(self): + self.client.sdfdsg() diff --git a/tests/api/test_api.py b/tests/api/test_api.py new file mode 100644 index 000000000..68448b891 --- /dev/null +++ b/tests/api/test_api.py @@ -0,0 +1,39 @@ + +from unittest import TestCase +from random import choice + +from pyLoadCore import Core + +from ApiTester import ApiTester + +class TestAPI(TestCase): + """ + Test all available testers randomly and on all backends + """ + core = None + + @classmethod + def setUpClass(cls): + from test_noargs import TestNoArgs + + cls.core = Core() + cls.core.start(False, False, True) + for Test in (TestNoArgs,): + t = Test() + t.enableJSON() + t = Test() + t.enableWS() + t = Test() + t.setApi(cls.core.api) + + cls.methods = ApiTester.get_methods() + + @classmethod + def tearDownClass(cls): + cls.core.shutdown() + + def test_random(self, n=10000): + + for i in range(n): + func = choice(self.methods) + func() diff --git a/tests/api/test_noargs.py b/tests/api/test_noargs.py new file mode 100644 index 000000000..02e49cf13 --- /dev/null +++ b/tests/api/test_noargs.py @@ -0,0 +1,29 @@ +# -*- coding: utf-8 -*- + +import inspect + +from ApiTester import ApiTester + +from module.remote.ttypes import Iface + +IGNORE = ('kill', 'restart') + +class TestNoArgs(ApiTester): + def setUp(self): + self.enableJSON() + +# Setup test_methods dynamically, only these which require no arguments +for name in dir(Iface): + if name.startswith("_") or name in IGNORE: continue + + spec = inspect.getargspec(getattr(Iface, name)) + if len(spec.args) == 1 and (not spec.varargs or len(spec.varargs) == 0): + def meta_test(name): #retain local scope + def test(self): + getattr(self.api, name)() + test.func_name = "test_%s" % name + return test + + setattr(TestNoArgs, "test_%s" % name, meta_test(name)) + + del meta_test \ No newline at end of file diff --git a/tests/config/db.version b/tests/config/db.version deleted file mode 100644 index bf0d87ab1..000000000 --- a/tests/config/db.version +++ /dev/null @@ -1 +0,0 @@ -4 \ No newline at end of file diff --git a/tests/helper/Stubs.py b/tests/helper/Stubs.py index 5c44cfb58..4ebd12592 100644 --- a/tests/helper/Stubs.py +++ b/tests/helper/Stubs.py @@ -4,6 +4,7 @@ import sys from os.path import abspath, dirname, join from time import strftime from traceback import format_exc +from collections import defaultdict sys.path.append(abspath(join(dirname(__file__), "..", "..", "module", "lib"))) sys.path.append(abspath(join(dirname(__file__), "..", ".."))) @@ -73,6 +74,8 @@ class Core: self.cache = {} self.packageCache = {} + self.statusMsg = defaultdict(lambda: "statusmsg") + self.log = LogStub() def getServerVersion(self): diff --git a/tests/manager/__init__.py b/tests/manager/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/manager/test_filemanager.py b/tests/manager/test_filemanager.py new file mode 100644 index 000000000..81acea4d0 --- /dev/null +++ b/tests/manager/test_filemanager.py @@ -0,0 +1,223 @@ +# -*- coding: utf-8 -*- + +from random import choice + +from tests.helper.Stubs import Core +from tests.helper.BenchmarkTest import BenchmarkTest + +from module.database import DatabaseBackend +# disable asyncronous queries +DatabaseBackend.async = DatabaseBackend.queue + +from module.Api import DownloadState +from module.FileManager import FileManager + + +class TestFileManager(BenchmarkTest): + bench = ["add_packages", "add_files", "get_files_root", "get", + "get_package_content", "get_package_tree", + "order_package", "order_files", "move"] + + pids = [-1] + count = 100 + + @classmethod + def setUpClass(cls): + c = Core() + # db needs seperate initialisation + cls.db = c.db = DatabaseBackend(c) + cls.db.setup() + cls.db.purgeAll() + + cls.m = cls.db.manager = FileManager(c) + + @classmethod + def tearDownClass(cls): + cls.db.purgeAll() + cls.db.shutdown() + + + # benchmarker ignore setup + def setUp(self): + self.db.purgeAll() + self.pids = [-1] + + self.count = 20 + self.test_add_packages() + self.test_add_files() + + def test_add_packages(self): + for i in range(100): + pid = self.m.addPackage("name", "folder", choice(self.pids), "", "", "", False) + self.pids.append(pid) + + if -1 in self.pids: + self.pids.remove(-1) + + def test_add_files(self): + for pid in self.pids: + self.m.addLinks([("plugin %d" % i, "url %s" % i) for i in range(self.count)], pid) + + count = self.m.getQueueCount() + files = self.count * len(self.pids) + # in test runner files get added twice + assert count == files or count == files * 2 + + def test_get(self): + info = self.m.getPackageInfo(choice(self.pids)) + assert info.stats.linkstotal == self.count + + fid = choice(info.fids) + f = self.m.getFile(fid) + assert f.fid in self.m.files + + f.name = "new name" + f.sync() + finfo = self.m.getFileInfo(fid) + assert finfo is not None + assert finfo.name == "new name" + + p = self.m.getPackage(choice(self.pids)) + assert p is not None + assert p.pid in self.m.packages + p.sync() + + p.delete() + + self.m.getTree(-1, True, None) + + def test_get_filtered(self): + all = self.m.getTree(-1, True, None) + finished = self.m.getTree(-1, True, DownloadState.Finished) + unfinished = self.m.getTree(-1, True, DownloadState.Unfinished) + + assert len(finished.files) + len(unfinished.files) == len(all.files) == self.m.getFileCount() + + + def test_get_files_root(self): + view = self.m.getTree(-1, True, None) + + for pid in self.pids: + assert pid in view.packages + + assert len(view.packages) == len(self.pids) + + p = choice(view.packages.values()) + assert len(p.fids) == self.count + assert p.stats.linkstotal == self.count + + + def test_get_package_content(self): + view = self.m.getTree(choice(self.pids), False, None) + p = view.root + + assert len(view.packages) == len(p.pids) + for pid in p.pids: assert pid in view.packages + + def test_get_package_tree(self): + view = self.m.getTree(choice(self.pids), True, None) + for pid in view.root.pids: assert pid in view.packages + for fid in view.root.fids: assert fid in view.files + + def test_delete(self): + self.m.deleteFile(self.count * 5) + self.m.deletePackage(choice(self.pids)) + + def test_order_package(self): + parent = self.m.addPackage("order", "", -1, "", "", "", False) + self.m.addLinks([("url", "plugin") for i in range(100)], parent) + + pids = [self.m.addPackage("c", "", parent, "", "", "", False) for i in range(5)] + v = self.m.getTree(parent, False, None) + self.assert_ordered(pids, 0, 5, v.root.pids, v.packages, True) + + pid = v.packages.keys()[0] + self.assert_pack_ordered(parent, pid, 3) + self.assert_pack_ordered(parent, pid, 0) + self.assert_pack_ordered(parent, pid, 0) + self.assert_pack_ordered(parent, pid, 4) + pid = v.packages.keys()[2] + self.assert_pack_ordered(parent, pid, 4) + self.assert_pack_ordered(parent, pid, 3) + self.assert_pack_ordered(parent, pid, 2) + + + def test_order_files(self): + parent = self.m.addPackage("order", "", -1, "", "", "", False) + self.m.addLinks([("url", "plugin") for i in range(100)], parent) + v = self.m.getTree(parent, False, None) + + fids = v.root.fids[10:20] + v = self.assert_files_ordered(parent, fids, 0) + + fids = v.root.fids[20:30] + + self.m.orderFiles(fids, parent, 99) + v = self.m.getTree(parent, False, None) + assert fids[-1] == v.root.fids[-1] + assert fids[0] == v.root.fids[90] + self.assert_ordered(fids, 90, 100, v.root.fids, v.files) + + fids = v.root.fids[80:] + v = self.assert_files_ordered(parent, fids, 20) + + self.m.orderFiles(fids, parent, 80) + v = self.m.getTree(parent, False, None) + self.assert_ordered(fids, 61, 81, v.root.fids, v.files) + + fids = v.root.fids[50:51] + self.m.orderFiles(fids, parent, 99) + v = self.m.getTree(parent, False, None) + self.assert_ordered(fids, 99, 100, v.root.fids, v.files) + + fids = v.root.fids[50:51] + v = self.assert_files_ordered(parent, fids, 0) + + + def assert_files_ordered(self, parent, fids, pos): + fs = [self.m.getFile(choice(fids)) for i in range(5)] + self.m.orderFiles(fids, parent, pos) + v = self.m.getTree(parent, False, False) + self.assert_ordered(fids, pos, pos+len(fids), v.root.fids, v.files) + + return v + + def assert_pack_ordered(self, parent, pid, pos): + self.m.orderPackage(pid, pos) + v = self.m.getTree(parent, False, False) + self.assert_ordered([pid], pos, pos+1, v.root.pids, v.packages, True) + + # assert that ordering is total, complete with no gaps + def assert_ordered(self, part, start, end, data, dict, pack=False): + assert data[start:end] == part + if pack: + assert sorted([p.packageorder for p in dict.values()]) == range(len(dict)) + assert [dict[pid].packageorder for pid in part] == range(start, end) + else: + assert sorted([f.fileorder for f in dict.values()]) == range(len(dict)) + assert [dict[fid].fileorder for fid in part] == range(start, end) + + + def test_move(self): + + pid = self.pids[-1] + pid2 = self.pids[1] + + self.m.movePackage(pid, -1) + v = self.m.getTree(-1, False, False) + + assert v.root.pids[-1] == pid + assert sorted([p.packageorder for p in v.packages.values()]) == range(len(v.packages)) + + v = self.m.getTree(pid, False, False) + fids = v.root.fids[10:20] + self.m.moveFiles(fids, pid2) + v = self.m.getTree(pid2, False, False) + + assert sorted([f.fileorder for f in v.files.values()]) == range(len(v.files)) + assert len(v.files) == self.count + len(fids) + + + +if __name__ == "__main__": + TestFileManager.benchmark() \ No newline at end of file diff --git a/tests/manager/test_interactionManager.py b/tests/manager/test_interactionManager.py new file mode 100644 index 000000000..db233bb25 --- /dev/null +++ b/tests/manager/test_interactionManager.py @@ -0,0 +1,58 @@ +# -*- coding: utf-8 -*- + +from unittest import TestCase +from tests.helper.Stubs import Core + +from module.Api import Input, Output +from module.interaction.InteractionManager import InteractionManager + +class TestInteractionManager(TestCase): + + @classmethod + def setUpClass(cls): + cls.core = Core() + + def setUp(self): + self.im = InteractionManager(self.core) + + + def test_notifications(self): + + n = self.im.createNotification("test", "notify") + assert self.im.getNotifications() == [n] + + for i in range(10): + self.im.createNotification("title", "test") + + assert len(self.im.getNotifications()) == 11 + + + def test_captcha(self): + assert self.im.getTask() is None + + t = self.im.newCaptchaTask("1", "", "") + assert t.output == Output.Captcha + self.im.handleTask(t) + assert t is self.im.getTask() + + t2 = self.im.newCaptchaTask("2", "", "") + self.im.handleTask(t2) + + assert self.im.getTask(Output.Query) is None + assert self.im.getTask() is t + + self.im.removeTask(t) + assert self.im.getTask() is t2 + + self.im.getTaskByID(t2.iid) + assert self.im.getTask() is None + + + def test_query(self): + assert self.im.getTask() is None + t = self.im.newQueryTask(Input.Text, None, "text") + assert t.description == "text" + self.im.handleTask(t) + + assert self.im.getTask(Output.Query) is t + assert self.im.getTask(Output.Captcha) is None \ No newline at end of file diff --git a/tests/other/__init__.py b/tests/other/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/tests/other/test_configparser.py b/tests/other/test_configparser.py new file mode 100644 index 000000000..acb05c63e --- /dev/null +++ b/tests/other/test_configparser.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- + +from collections import defaultdict +from tests.helper.Stubs import Core + +from module.database import DatabaseBackend +from module.config.ConfigParser import ConfigParser + +# TODO +class TestConfigParser(): + + db = None + + @classmethod + def setUpClass(cls): + cls.db = DatabaseBackend(Core()) + cls.db.manager = cls.db.core + cls.db.manager.statusMsg = defaultdict(lambda: "statusmsg") + cls.config = ConfigParser() + cls.db.setup() + cls.db.clearAllConfigs() + + @classmethod + def tearDownClass(cls): + cls.db.shutdown() + + def test_db(self): + + self.db.saveConfig("plugin", "some value", 0) + self.db.saveConfig("plugin", "some other value", 1) + + assert self.db.loadConfig("plugin", 0) == "some value" + assert self.db.loadConfig("plugin", 1) == "some other value" + + d = self.db.loadAllConfigs() + assert d[0]["plugin"] == "some value" + + self.db.deleteConfig("plugin") + + assert not self.db.loadAllConfigs() + + + def test_dict(self): + + assert self.config["general"]["language"] + self.config["general"]["language"] = "de" + assert self.config["general"]["language"] == "de" + + def test_config(self): + pass + + def test_userconfig(self): + pass \ No newline at end of file diff --git a/tests/other/test_database.py b/tests/other/test_database.py new file mode 100644 index 000000000..dd733b4ff --- /dev/null +++ b/tests/other/test_database.py @@ -0,0 +1,192 @@ +# -*- coding: utf-8 -*- + +from tests.helper.Stubs import Core +from tests.helper.BenchmarkTest import BenchmarkTest + +from module.Api import DownloadState +from module.database import DatabaseBackend + +# disable asyncronous queries +DatabaseBackend.async = DatabaseBackend.queue + +from random import choice + +class TestDatabase(BenchmarkTest): + bench = ["insert", "insert_links", "insert_many", "get_packages", + "get_files", "get_files_queued", "get_package_childs", "get_package_files", + "get_package_data", "get_file_data", "find_files", "collector", "purge"] + pids = None + fids = None + owner = 123 + pstatus = 0 + + @classmethod + def setUpClass(cls): + cls.pids = [-1] + cls.fids = [] + + cls.db = DatabaseBackend(Core()) + cls.db.manager = cls.db.core + + cls.db.setup() + cls.db.purgeAll() + + @classmethod + def tearDownClass(cls): + cls.db.purgeAll() + cls.db.shutdown() + + # benchmarker ignore setup + def setUp(self): + self.db.purgeAll() + self.pids = [-1] + self.fids = [] + + self.test_insert(20) + self.test_insert_many() + self.fids = self.db.getAllFiles().keys() + + + def test_insert(self, n=200): + for i in range(n): + pid = self.db.addPackage("name", "folder", choice(self.pids), "password", "site", "comment", self.pstatus, + self.owner) + self.pids.append(pid) + + def test_insert_links(self): + for i in range(10000): + fid = self.db.addLink("url %s" % i, "name", "plugin", choice(self.pids), self.owner) + self.fids.append(fid) + + def test_insert_many(self): + for pid in self.pids: + self.db.addLinks([("url %s" % i, "plugin") for i in range(50)], pid, self.owner) + + def test_get_packages(self): + packs = self.db.getAllPackages() + n = len(packs) + assert n == len(self.pids) - 1 + + print "Fetched %d packages" % n + self.assert_pack(choice(packs.values())) + + def test_get_files(self): + files = self.db.getAllFiles() + n = len(files) + assert n >= len(self.pids) + + print "Fetched %d files" % n + self.assert_file(choice(files.values())) + + def test_get_files_queued(self): + files = self.db.getAllFiles(state=DownloadState.Unfinished) + print "Fetched %d files queued" % len(files) + + def test_delete(self): + pid = choice(self.pids) + self.db.deletePackage(pid) + self.pids.remove(pid) + + def test_get_package_childs(self): + pid = choice(self.pids) + packs = self.db.getAllPackages(root=pid) + + print "Package %d has %d packages" % (pid, len(packs)) + self.assert_pack(choice(packs.values())) + + def test_get_package_files(self): + pid = choice(self.pids) + files = self.db.getAllFiles(package=pid) + + print "Package %d has %d files" % (pid, len(files)) + self.assert_file(choice(files.values())) + + def test_get_package_data(self, stats=False): + pid = choice(self.pids) + p = self.db.getPackageInfo(pid, stats) + self.assert_pack(p) + # test again with stat + if not stats: + self.test_get_package_data(True) + + def test_get_file_data(self): + fid = choice(self.fids) + f = self.db.getFileInfo(fid) + self.assert_file(f) + + def test_find_files(self): + files = self.db.getAllFiles(search="1") + print "Found %s files" % len(files) + f = choice(files.values()) + + assert "1" in f.name + + def test_collector(self): + self.db.saveCollector(0, "data") + assert self.db.retrieveCollector(0) == "data" + self.db.deleteCollector(0) + + def test_purge(self): + self.db.purgeLinks() + + + def test_user_context(self): + self.db.purgeAll() + + p1 = self.db.addPackage("name", "folder", 0, "password", "site", "comment", self.pstatus, 0) + self.db.addLink("url", "name", "plugin", p1, 0) + p2 = self.db.addPackage("name", "folder", 0, "password", "site", "comment", self.pstatus, 1) + self.db.addLink("url", "name", "plugin", p2, 1) + + assert len(self.db.getAllPackages(owner=0)) == 1 == len(self.db.getAllFiles(owner=0)) + assert len(self.db.getAllPackages(root=0, owner=0)) == 1 == len(self.db.getAllFiles(package=p1, owner=0)) + assert len(self.db.getAllPackages(owner=1)) == 1 == len(self.db.getAllFiles(owner=1)) + assert len(self.db.getAllPackages(root=0, owner=1)) == 1 == len(self.db.getAllFiles(package=p2, owner=1)) + assert len(self.db.getAllPackages()) == 2 == len(self.db.getAllFiles()) + + self.db.deletePackage(p1, 1) + assert len(self.db.getAllPackages(owner=0)) == 1 == len(self.db.getAllFiles(owner=0)) + self.db.deletePackage(p1, 0) + assert len(self.db.getAllPackages(owner=1)) == 1 == len(self.db.getAllFiles(owner=1)) + self.db.deletePackage(p2) + + assert len(self.db.getAllPackages()) == 0 + + def test_count(self): + self.db.purgeAll() + + assert self.db.filecount() == 0 + assert self.db.queuecount() == 0 + assert self.db.processcount() == 0 + + def assert_file(self, f): + try: + assert f is not None + self.assert_int(f, ("fid", "status", "size", "media", "fileorder", "added", "package", "owner")) + assert f.status in range(5) + assert f.owner == self.owner + assert f.media in range(1024) + assert f.package in self.pids + assert f.added > 10 ** 6 # date is usually big integer + except: + print f + raise + + def assert_pack(self, p): + try: + assert p is not None + self.assert_int(p, ("pid", "root", "added", "status", "packageorder", "owner")) + assert p.pid in self.pids + assert p.owner == self.owner + assert p.status in range(5) + assert p.root in self.pids + assert p.added > 10 ** 6 + except: + print p + raise + + def assert_int(self, obj, list): + for attr in list: assert type(getattr(obj, attr)) == int + +if __name__ == "__main__": + TestDatabase.benchmark() \ No newline at end of file diff --git a/tests/other/test_syntax.py b/tests/other/test_syntax.py new file mode 100644 index 000000000..fbf7edf8f --- /dev/null +++ b/tests/other/test_syntax.py @@ -0,0 +1,43 @@ +# -*- coding: utf-8 -*- + +from os import walk +from os.path import abspath, dirname, join + +from unittest import TestCase + +PATH = abspath(join(dirname(abspath(__file__)), "..", "..", "")) + +# needed to register globals +from tests.helper import Stubs + +class TestSyntax(TestCase): + pass + + +for path, dirs, files in walk(join(PATH, "module")): + + for f in files: + if not f.endswith(".py") or f.startswith("__"): continue + fpath = join(path, f) + pack = fpath.replace(PATH, "")[1:-3] #replace / and .py + imp = pack.replace("/", ".") + packages = imp.split(".") + #__import__(imp) + + # to much sideeffect when importing + if "web" in packages or "lib" in packages: continue + if "ThriftTest" in packages: continue + + # currying + def meta(imp, sig): + def _test(self=None): + __import__(imp) + + _test.func_name = sig + return _test + + # generate test methods + sig = "test_%s_%s" % (packages[-2], packages[-1]) + + + setattr(TestSyntax, sig, meta(imp, sig)) \ No newline at end of file diff --git a/tests/test_api.py b/tests/test_api.py deleted file mode 100644 index 0171b46bb..000000000 --- a/tests/test_api.py +++ /dev/null @@ -1,18 +0,0 @@ - -from unittest import TestCase - -from pyLoadCore import Core -from module.common.APIExerciser import APIExerciser - -class TestApi(TestCase): - - @classmethod - def setUpClass(cls): - cls.core = Core() - cls.core.start(False, False, True) - - def test_random(self): - api = APIExerciser(self.core) - - for i in range(2000): - api.testAPI() diff --git a/tests/test_backends.py b/tests/test_backends.py deleted file mode 100644 index 71ccedd2f..000000000 --- a/tests/test_backends.py +++ /dev/null @@ -1,59 +0,0 @@ -# -*- coding: utf-8 -*- - - -from urllib import urlencode -from urllib2 import urlopen, HTTPError -from json import loads - -from logging import log - -from module.common import APIExerciser - -url = "http://localhost:8001/api/%s" - -class TestBackends(): - - def setUp(self): - u = urlopen(url % "login", data=urlencode({"username": "TestUser", "password": "sometestpw"})) - self.key = loads(u.read()) - assert self.key is not False - - def test_random(self): - api = APIExerciser.APIExerciser(None, True, "TestUser", "sometestpw") - - assert api.api.login("crapp", "wrong pw") is False - - for i in range(0, 1000): - api.testAPI() - - def call(self, name, post=None): - if not post: post = {} - post["session"] = self.key - u = urlopen(url % name, data=urlencode(post)) - return loads(u.read()) - - def test_wronglogin(self): - u = urlopen(url % "login", data=urlencode({"username": "crap", "password": "wrongpw"})) - assert loads(u.read()) is False - - def test_access(self): - try: - urlopen(url % "getServerVersion") - except HTTPError, e: - assert e.code == 403 - else: - assert False - - def test_status(self): - ret = self.call("statusServer") - log(1, str(ret)) - assert "pause" in ret - assert "queue" in ret - - def test_unknown_method(self): - try: - self.call("notExisting") - except HTTPError, e: - assert e.code == 404 - else: - assert False diff --git a/tests/test_configparser.py b/tests/test_configparser.py deleted file mode 100644 index d797c7912..000000000 --- a/tests/test_configparser.py +++ /dev/null @@ -1,48 +0,0 @@ -# -*- coding: utf-8 -*- - -from collections import defaultdict -from helper.Stubs import Core - -from module.database import DatabaseBackend -from module.config.ConfigParser import ConfigParser - -# TODO -class TestConfigParser(): - - @classmethod - def setUpClass(cls): - cls.db = DatabaseBackend(Core()) - cls.db.manager = cls.db.core - cls.db.manager.statusMsg = defaultdict(lambda: "statusmsg") - cls.config = ConfigParser() - cls.db.setup() - cls.db.clearAllConfigs() - - - def test_db(self): - - self.db.saveConfig("plugin", "some value", 0) - self.db.saveConfig("plugin", "some other value", 1) - - assert self.db.loadConfig("plugin", 0) == "some value" - assert self.db.loadConfig("plugin", 1) == "some other value" - - d = self.db.loadAllConfigs() - assert d[0]["plugin"] == "some value" - - self.db.deleteConfig("plugin") - - assert not self.db.loadAllConfigs() - - - def test_dict(self): - - assert self.config["general"]["language"] - self.config["general"]["language"] = "de" - assert self.config["general"]["language"] == "de" - - def test_config(self): - pass - - def test_userconfig(self): - pass \ No newline at end of file diff --git a/tests/test_database.py b/tests/test_database.py deleted file mode 100644 index fb134ff41..000000000 --- a/tests/test_database.py +++ /dev/null @@ -1,195 +0,0 @@ -# -*- coding: utf-8 -*- - -from collections import defaultdict - -from helper.Stubs import Core -from helper.BenchmarkTest import BenchmarkTest - -from module.Api import DownloadState -from module.database import DatabaseBackend - -# disable asyncronous queries -DatabaseBackend.async = DatabaseBackend.queue - -from random import choice - -class TestDatabase(BenchmarkTest): - bench = ["insert", "insert_links", "insert_many", "get_packages", - "get_files", "get_files_queued", "get_package_childs", "get_package_files", - "get_package_data", "get_file_data", "find_files", "collector", "purge"] - pids = None - fids = None - owner = 123 - pstatus = 0 - - @classmethod - def setUpClass(cls): - cls.pids = [-1] - cls.fids = [] - - cls.db = DatabaseBackend(Core()) - cls.db.manager = cls.db.core - cls.db.manager.statusMsg = defaultdict(lambda: "statusmsg") - - cls.db.setup() - cls.db.purgeAll() - - @classmethod - def tearDownClass(cls): - cls.db.purgeAll() - cls.db.shutdown() - - # benchmarker ignore setup - def setUp(self): - self.db.purgeAll() - self.pids = [-1] - self.fids = [] - - self.test_insert(20) - self.test_insert_many() - self.fids = self.db.getAllFiles().keys() - - - def test_insert(self, n=200): - for i in range(n): - pid = self.db.addPackage("name", "folder", choice(self.pids), "password", "site", "comment", self.pstatus, - self.owner) - self.pids.append(pid) - - def test_insert_links(self): - for i in range(10000): - fid = self.db.addLink("url %s" % i, "name", "plugin", choice(self.pids), self.owner) - self.fids.append(fid) - - def test_insert_many(self): - for pid in self.pids: - self.db.addLinks([("url %s" % i, "plugin") for i in range(50)], pid, self.owner) - - def test_get_packages(self): - packs = self.db.getAllPackages() - n = len(packs) - assert n == len(self.pids) - 1 - - print "Fetched %d packages" % n - self.assert_pack(choice(packs.values())) - - def test_get_files(self): - files = self.db.getAllFiles() - n = len(files) - assert n >= len(self.pids) - - print "Fetched %d files" % n - self.assert_file(choice(files.values())) - - def test_get_files_queued(self): - files = self.db.getAllFiles(state=DownloadState.Unfinished) - print "Fetched %d files queued" % len(files) - - def test_delete(self): - pid = choice(self.pids) - self.db.deletePackage(pid) - self.pids.remove(pid) - - def test_get_package_childs(self): - pid = choice(self.pids) - packs = self.db.getAllPackages(root=pid) - - print "Package %d has %d packages" % (pid, len(packs)) - self.assert_pack(choice(packs.values())) - - def test_get_package_files(self): - pid = choice(self.pids) - files = self.db.getAllFiles(package=pid) - - print "Package %d has %d files" % (pid, len(files)) - self.assert_file(choice(files.values())) - - def test_get_package_data(self, stats=False): - pid = choice(self.pids) - p = self.db.getPackageInfo(pid, stats) - self.assert_pack(p) - # test again with stat - if not stats: - self.test_get_package_data(True) - - def test_get_file_data(self): - fid = choice(self.fids) - f = self.db.getFileInfo(fid) - self.assert_file(f) - - def test_find_files(self): - files = self.db.getAllFiles(search="1") - print "Found %s files" % len(files) - f = choice(files.values()) - - assert "1" in f.name - - def test_collector(self): - self.db.saveCollector(0, "data") - assert self.db.retrieveCollector(0) == "data" - self.db.deleteCollector(0) - - def test_purge(self): - self.db.purgeLinks() - - - def test_user_context(self): - self.db.purgeAll() - - p1 = self.db.addPackage("name", "folder", 0, "password", "site", "comment", self.pstatus, 0) - self.db.addLink("url", "name", "plugin", p1, 0) - p2 = self.db.addPackage("name", "folder", 0, "password", "site", "comment", self.pstatus, 1) - self.db.addLink("url", "name", "plugin", p2, 1) - - assert len(self.db.getAllPackages(owner=0)) == 1 == len(self.db.getAllFiles(owner=0)) - assert len(self.db.getAllPackages(root=0, owner=0)) == 1 == len(self.db.getAllFiles(package=p1, owner=0)) - assert len(self.db.getAllPackages(owner=1)) == 1 == len(self.db.getAllFiles(owner=1)) - assert len(self.db.getAllPackages(root=0, owner=1)) == 1 == len(self.db.getAllFiles(package=p2, owner=1)) - assert len(self.db.getAllPackages()) == 2 == len(self.db.getAllFiles()) - - self.db.deletePackage(p1, 1) - assert len(self.db.getAllPackages(owner=0)) == 1 == len(self.db.getAllFiles(owner=0)) - self.db.deletePackage(p1, 0) - assert len(self.db.getAllPackages(owner=1)) == 1 == len(self.db.getAllFiles(owner=1)) - self.db.deletePackage(p2) - - assert len(self.db.getAllPackages()) == 0 - - def test_count(self): - self.db.purgeAll() - - assert self.db.filecount() == 0 - assert self.db.queuecount() == 0 - assert self.db.processcount() == 0 - - def assert_file(self, f): - try: - assert f is not None - self.assert_int(f, ("fid", "status", "size", "media", "fileorder", "added", "package", "owner")) - assert f.status in range(5) - assert f.owner == self.owner - assert f.media in range(1024) - assert f.package in self.pids - assert f.added > 10 ** 6 # date is usually big integer - except: - print f - raise - - def assert_pack(self, p): - try: - assert p is not None - self.assert_int(p, ("pid", "root", "added", "status", "packageorder", "owner")) - assert p.pid in self.pids - assert p.owner == self.owner - assert p.status in range(5) - assert p.root in self.pids - assert p.added > 10 ** 6 - except: - print p - raise - - def assert_int(self, obj, list): - for attr in list: assert type(getattr(obj, attr)) == int - -if __name__ == "__main__": - TestDatabase.benchmark() \ No newline at end of file diff --git a/tests/test_filemanager.py b/tests/test_filemanager.py deleted file mode 100644 index 7b82840b1..000000000 --- a/tests/test_filemanager.py +++ /dev/null @@ -1,223 +0,0 @@ -# -*- coding: utf-8 -*- - -from random import choice - -from helper.Stubs import Core -from helper.BenchmarkTest import BenchmarkTest - -from module.database import DatabaseBackend -# disable asyncronous queries -DatabaseBackend.async = DatabaseBackend.queue - -from module.Api import DownloadState -from module.FileManager import FileManager - - -class TestFileManager(BenchmarkTest): - bench = ["add_packages", "add_files", "get_files_root", "get", - "get_package_content", "get_package_tree", - "order_package", "order_files", "move"] - - pids = [-1] - count = 100 - - @classmethod - def setUpClass(cls): - c = Core() - # db needs seperate initialisation - cls.db = c.db = DatabaseBackend(c) - cls.db.setup() - cls.db.purgeAll() - - cls.m = cls.db.manager = FileManager(c) - - @classmethod - def tearDownClass(cls): - cls.db.purgeAll() - cls.db.shutdown() - - - # benchmarker ignore setup - def setUp(self): - self.db.purgeAll() - self.pids = [-1] - - self.count = 20 - self.test_add_packages() - self.test_add_files() - - def test_add_packages(self): - for i in range(100): - pid = self.m.addPackage("name", "folder", choice(self.pids), "", "", "", False) - self.pids.append(pid) - - if -1 in self.pids: - self.pids.remove(-1) - - def test_add_files(self): - for pid in self.pids: - self.m.addLinks([("plugin %d" % i, "url %s" % i) for i in range(self.count)], pid) - - count = self.m.getQueueCount() - files = self.count * len(self.pids) - # in test runner files get added twice - assert count == files or count == files * 2 - - def test_get(self): - info = self.m.getPackageInfo(choice(self.pids)) - assert info.stats.linkstotal == self.count - - fid = choice(info.fids) - f = self.m.getFile(fid) - assert f.fid in self.m.files - - f.name = "new name" - f.sync() - finfo = self.m.getFileInfo(fid) - assert finfo is not None - assert finfo.name == "new name" - - p = self.m.getPackage(choice(self.pids)) - assert p is not None - assert p.pid in self.m.packages - p.sync() - - p.delete() - - self.m.getTree(-1, True, None) - - def test_get_filtered(self): - all = self.m.getTree(-1, True, None) - finished = self.m.getTree(-1, True, DownloadState.Finished) - unfinished = self.m.getTree(-1, True, DownloadState.Unfinished) - - assert len(finished.files) + len(unfinished.files) == len(all.files) == self.m.getFileCount() - - - def test_get_files_root(self): - view = self.m.getTree(-1, True, None) - - for pid in self.pids: - assert pid in view.packages - - assert len(view.packages) == len(self.pids) - - p = choice(view.packages.values()) - assert len(p.fids) == self.count - assert p.stats.linkstotal == self.count - - - def test_get_package_content(self): - view = self.m.getTree(choice(self.pids), False, None) - p = view.root - - assert len(view.packages) == len(p.pids) - for pid in p.pids: assert pid in view.packages - - def test_get_package_tree(self): - view = self.m.getTree(choice(self.pids), True, None) - for pid in view.root.pids: assert pid in view.packages - for fid in view.root.fids: assert fid in view.files - - def test_delete(self): - self.m.deleteFile(self.count * 5) - self.m.deletePackage(choice(self.pids)) - - def test_order_package(self): - parent = self.m.addPackage("order", "", -1, "", "", "", False) - self.m.addLinks([("url", "plugin") for i in range(100)], parent) - - pids = [self.m.addPackage("c", "", parent, "", "", "", False) for i in range(5)] - v = self.m.getTree(parent, False, None) - self.assert_ordered(pids, 0, 5, v.root.pids, v.packages, True) - - pid = v.packages.keys()[0] - self.assert_pack_ordered(parent, pid, 3) - self.assert_pack_ordered(parent, pid, 0) - self.assert_pack_ordered(parent, pid, 0) - self.assert_pack_ordered(parent, pid, 4) - pid = v.packages.keys()[2] - self.assert_pack_ordered(parent, pid, 4) - self.assert_pack_ordered(parent, pid, 3) - self.assert_pack_ordered(parent, pid, 2) - - - def test_order_files(self): - parent = self.m.addPackage("order", "", -1, "", "", "", False) - self.m.addLinks([("url", "plugin") for i in range(100)], parent) - v = self.m.getTree(parent, False, None) - - fids = v.root.fids[10:20] - v = self.assert_files_ordered(parent, fids, 0) - - fids = v.root.fids[20:30] - - self.m.orderFiles(fids, parent, 99) - v = self.m.getTree(parent, False, None) - assert fids[-1] == v.root.fids[-1] - assert fids[0] == v.root.fids[90] - self.assert_ordered(fids, 90, 100, v.root.fids, v.files) - - fids = v.root.fids[80:] - v = self.assert_files_ordered(parent, fids, 20) - - self.m.orderFiles(fids, parent, 80) - v = self.m.getTree(parent, False, None) - self.assert_ordered(fids, 61, 81, v.root.fids, v.files) - - fids = v.root.fids[50:51] - self.m.orderFiles(fids, parent, 99) - v = self.m.getTree(parent, False, None) - self.assert_ordered(fids, 99, 100, v.root.fids, v.files) - - fids = v.root.fids[50:51] - v = self.assert_files_ordered(parent, fids, 0) - - - def assert_files_ordered(self, parent, fids, pos): - fs = [self.m.getFile(choice(fids)) for i in range(5)] - self.m.orderFiles(fids, parent, pos) - v = self.m.getTree(parent, False, False) - self.assert_ordered(fids, pos, pos+len(fids), v.root.fids, v.files) - - return v - - def assert_pack_ordered(self, parent, pid, pos): - self.m.orderPackage(pid, pos) - v = self.m.getTree(parent, False, False) - self.assert_ordered([pid], pos, pos+1, v.root.pids, v.packages, True) - - # assert that ordering is total, complete with no gaps - def assert_ordered(self, part, start, end, data, dict, pack=False): - assert data[start:end] == part - if pack: - assert sorted([p.packageorder for p in dict.values()]) == range(len(dict)) - assert [dict[pid].packageorder for pid in part] == range(start, end) - else: - assert sorted([f.fileorder for f in dict.values()]) == range(len(dict)) - assert [dict[fid].fileorder for fid in part] == range(start, end) - - - def test_move(self): - - pid = self.pids[-1] - pid2 = self.pids[1] - - self.m.movePackage(pid, -1) - v = self.m.getTree(-1, False, False) - - assert v.root.pids[-1] == pid - assert sorted([p.packageorder for p in v.packages.values()]) == range(len(v.packages)) - - v = self.m.getTree(pid, False, False) - fids = v.root.fids[10:20] - self.m.moveFiles(fids, pid2) - v = self.m.getTree(pid2, False, False) - - assert sorted([f.fileorder for f in v.files.values()]) == range(len(v.files)) - assert len(v.files) == self.count + len(fids) - - - -if __name__ == "__main__": - TestFileManager.benchmark() \ No newline at end of file diff --git a/tests/test_interactionManager.py b/tests/test_interactionManager.py deleted file mode 100644 index 920d84b9d..000000000 --- a/tests/test_interactionManager.py +++ /dev/null @@ -1,58 +0,0 @@ -# -*- coding: utf-8 -*- - -from unittest import TestCase -from helper.Stubs import Core - -from module.Api import Input, Output -from module.interaction.InteractionManager import InteractionManager - -class TestInteractionManager(TestCase): - - @classmethod - def setUpClass(cls): - cls.core = Core() - - def setUp(self): - self.im = InteractionManager(self.core) - - - def test_notifications(self): - - n = self.im.createNotification("test", "notify") - assert self.im.getNotifications() == [n] - - for i in range(10): - self.im.createNotification("title", "test") - - assert len(self.im.getNotifications()) == 11 - - - def test_captcha(self): - assert self.im.getTask() is None - - t = self.im.newCaptchaTask("1", "", "") - assert t.output == Output.Captcha - self.im.handleTask(t) - assert t is self.im.getTask() - - t2 = self.im.newCaptchaTask("2", "", "") - self.im.handleTask(t2) - - assert self.im.getTask(Output.Query) is None - assert self.im.getTask() is t - - self.im.removeTask(t) - assert self.im.getTask() is t2 - - self.im.getTaskByID(t2.iid) - assert self.im.getTask() is None - - - def test_query(self): - assert self.im.getTask() is None - t = self.im.newQueryTask(Input.Text, None, "text") - assert t.description == "text" - self.im.handleTask(t) - - assert self.im.getTask(Output.Query) is t - assert self.im.getTask(Output.Captcha) is None \ No newline at end of file diff --git a/tests/test_syntax.py b/tests/test_syntax.py deleted file mode 100644 index a4cc53ee5..000000000 --- a/tests/test_syntax.py +++ /dev/null @@ -1,43 +0,0 @@ -# -*- coding: utf-8 -*- - -from os import walk -from os.path import abspath, dirname, join - -from unittest import TestCase - -PATH = abspath(join(dirname(abspath(__file__)), "..", "")) - -# needed to register globals -from helper import Stubs - -class TestSyntax(TestCase): - pass - - -for path, dirs, files in walk(join(PATH, "module")): - - for f in files: - if not f.endswith(".py") or f.startswith("__"): continue - fpath = join(path, f) - pack = fpath.replace(PATH, "")[1:-3] #replace / and .py - imp = pack.replace("/", ".") - packages = imp.split(".") - #__import__(imp) - - # to much sideeffect when importing - if "web" in packages or "lib" in packages: continue - if "ThriftTest" in packages: continue - - # currying - def meta(imp, sig): - def _test(self=None): - __import__(imp) - - _test.func_name = sig - return _test - - # generate test methods - sig = "test_%s_%s" % (packages[-2], packages[-1]) - - - setattr(TestSyntax, sig, meta(imp, sig)) \ No newline at end of file -- cgit v1.2.3