remove old tests

7 files changed, 0 insertions, 691 deletions

diff --git a/tests/test_dummy.py b/tests/test_dummy.py
deleted file mode 100644
index 58df716..0000000
--- a/tests/test_dummy.py
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-    test_dummy.py
-    ~~~~~~~~~~~~~
-    
-    dummy test suite
-    
-    :copyright: (c) 2013 by Jauhien Piatlicki
-    :license: GPL-2, see LICENSE for more details.
-"""
-
-import unittest
-
-from tests.base import BaseTest
-
-class TestDummy(BaseTest):
-    
-    def test_dummy(self):
-        self.assertEqual('works', 'works')
-
-def suite():
-    suite = unittest.TestSuite()
-    suite.addTest(TestDummy('test_dummy'))
-    return suite
diff --git a/tests/test_ebuild.py b/tests/test_ebuild.py
deleted file mode 100644
index 7488152..0000000
--- a/tests/test_ebuild.py
+++ /dev/null
@@ -1,90 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-    test_ebuild.py
-    ~~~~~~~~~~~~~~~~~~
-    
-    ebuild generator test suite
-    
-    :copyright: (c) 2013 by Jauhien Piatlicki
-    :license: GPL-2, see LICENSE for more details.
-"""
-
-import os, tempfile, unittest
-
-from g_sorcery import ebuild, package_db, exceptions, g_collections
-
-from tests.base import BaseTest
-
-package = package_db.Package("app-test", "test", "0.1")
-package2 = package_db.Package("app-test", "tst", "1")
-
-class DummyDB(package_db.PackageDB):
-    def __init__(self, directory, repo_uri="", db_uri=""):
-        super(DummyDB, self).__init__(directory, repo_uri, db_uri)
-
-    def generate_tree(self):
-        self.add_category("app-test")
-        self.add_package(package,
-                         {"author" : "jauhien", "homepage" : "127.0.0.1"})
-        self.add_package(package2,
-                         {"author" : "unknown", "homepage" : "example.com"})
-
-
-class DummyEbuildGenerator(ebuild.EbuildGenerator):
-    def get_template(self, ebuild, description):
-        tmpl = ["test", "author: %(author)s", "homepage: %(homepage)s", "var: $var"]
-        return tmpl
-
-
-class TestEbuildGenerator(BaseTest):
-
-    def test_process(self):
-        eg = DummyEbuildGenerator(None)
-        tst_dict = {"a" : "d", "b" : "e", "c" : "f"}
-        ebuild = ["%(a)s", "%(b)s", "%(c)s"]
-        ebuild = eg.process(ebuild, tst_dict)
-        self.assertEqual(ebuild, ["d", "e", "f"])
-
-    def test_generate(self):
-        db = DummyDB(self.tempdir.name)
-        db.generate()
-        eg = DummyEbuildGenerator(db)
-        ebuild = eg.generate(package)
-        self.assertEqual(ebuild, ['test', 'author: jauhien',
-                                  'homepage: 127.0.0.1', 'var: $var'])
-
-
-class DummyEbuildGeneratorFromFile(ebuild.EbuildGeneratorFromFile):
-    def __init__(self, db, path):
-        super(DummyEbuildGeneratorFromFile, self).__init__(db)
-        self.path = path
-    
-    def get_template_file(self, package, description):
-        return self.path
-
-
-class TestEbuildGeneratorFromFile(BaseTest):
-
-    def test_generate(self):
-        db = DummyDB(os.path.join(self.tempdir.name, 'tstdb'))
-        db.generate()
-        tmpl = os.path.join(self.tempdir.name, 'tst.tmpl')
-        with open(tmpl, 'w') as f:
-            f.write("""test
-author: %(author)s
-homepage: %(homepage)s
-var: $var""")
-        eg = DummyEbuildGeneratorFromFile(db, tmpl)
-        ebuild = eg.generate(package)
-        self.assertEqual(ebuild, ['test', 'author: jauhien',
-                                  'homepage: 127.0.0.1', 'var: $var'])
-        
-        
-def suite():
-    suite = unittest.TestSuite()
-    suite.addTest(TestEbuildGenerator('test_process'))
-    suite.addTest(TestEbuildGenerator('test_generate'))
-    suite.addTest(TestEbuildGeneratorFromFile('test_generate'))
-    return suite
diff --git a/tests/test_elpa_db.py b/tests/test_elpa_db.py
deleted file mode 100644
index cd6ebc2..0000000
--- a/tests/test_elpa_db.py
+++ /dev/null
@@ -1,142 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-    test_elpa_db.py
-    ~~~~~~~~~~~~~~~
-    
-    ELPA package database test suite
-    
-    :copyright: (c) 2013 by Jauhien Piatlicki
-    :license: GPL-2, see LICENSE for more details.
-"""
-
-import os
-
-import unittest
-
-from g_elpa import elpa_db
-
-from g_sorcery import exceptions, package_db
-
-from tests.server import Server
-
-from tests.base import BaseTest
-
-def generate_archive_contents(packages):
-    archive_contents = "(1"
-    for pkg in packages:
-        archive_contents += "\n(" + pkg[0] + ' . [('
-        for v in pkg[1]:
-            archive_contents += ' ' + str(v)
-        archive_contents += ')\n'
-        if pkg[4]:
-            archive_contents += '('
-            for p in pkg[4]:
-                archive_contents += '(' + p[0] + ' ('
-                for v in p[1]:
-                    archive_contents += ' ' + str(v)
-                archive_contents += '))\n'
-            archive_contents += ')'
-        else:
-            archive_contents += 'nil'
-        archive_contents += '\n "' + pkg[2] + '" ' + pkg[3] + '])' 
-    archive_contents += ')'
-    return archive_contents
-
-packages = [['ack', [1, 2],
-             "Interface to ack-like source code search tools",
-             "tar",
-             []
-             ],
-            ['dict-tree', [0, 12, 8],
-             "Dictionary data structure",
-             "tar",
-             [['trie', [0, 2, 5]],
-              ['tNFA', [0, 1, 1]],
-              ['heap', [0, 3]]]
-             ],
-            ['tNFA', [0, 1, 1],
-             "Tagged non-deterministic finite-state automata",
-             "single",
-             [['queue', [0, 1]]]
-             ],
-            ['trie', [0, 2, 6],
-             "Trie data structure",
-             "single",
-             [['tNFA', [0, 1, 1]],
-              ['queue', [0, 1]]]
-             ],
-            ['heap', [0, 3],
-             "Heap (a.k.a. priority queue) data structure",
-             "single",
-             []
-             ],
-            ['queue', [0, 1],
-             "Queue data structure",
-             "single",
-             []
-             ]
-            ]
-
-def fill_database(database, packages, tempdir):
-    prev = os.getcwd()
-    os.chdir(tempdir)
-
-    archive_contents = generate_archive_contents(packages)
-
-    with open(os.path.join(tempdir, 'archive-contents'), 'w') as f:
-        f.write(archive_contents)
-
-    server = Server()
-    server.start()
-
-    database.generate()
-
-    server.shutdown()
-    server.join()
-
-    os.chdir(prev)
-    
-
-class TestElpaDB(BaseTest):
-
-    def test_generate(self):
-        edb = elpa_db.ElpaDB(os.path.join(self.tempdir.name, 'db'),
-                             repo_uri = 'http://127.0.0.1:8080')
-        self.assertRaises(exceptions.DownloadingError, edb.generate)
-
-        fill_database(edb, packages, self.tempdir.name)
-
-        for pkg in packages:
-            package = package_db.Package('app-emacs',
-                                         pkg[0],
-                                         '.'.join(map(str, pkg[1])))
-            description = edb.get_package_description(package)
-            self.assertEqual(description['source_type'], pkg[3])
-            self.assertEqual(description['description'], pkg[2])
-            deps = []
-            depend=[]
-            for d in pkg[4]:
-                deps.append(package_db.Package('app-emacs',
-                                               d[0],
-                                               '.'.join(map(str, d[1]))))
-                depend.append('app-emacs' + '/' + d[0])
-
-            dependencies = description['dependencies']
-            for d in dependencies:
-                self.assertTrue(d in deps)
-            for d in deps:
-                self.assertTrue(d in dependencies)
-            
-            for ds in (description['depend'], description['rdepend']):
-                for d in ds:
-                    self.assertTrue(d in depend)
-                for d in depend:
-                    self.assertTrue(d in ds)
-        
-
-def suite():
-    suite = unittest.TestSuite()
-    suite.addTest(TestElpaDB('test_generate'))
-    return suite
diff --git a/tests/test_elpa_metadata.py b/tests/test_elpa_metadata.py
deleted file mode 100644
index 8144999..0000000
--- a/tests/test_elpa_metadata.py
+++ /dev/null
@@ -1,47 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-    test_elpa_metadata.py
-    ~~~~~~~~~~~~~~~~~~~~~
-    
-    ELPA metadata generator test suite
-    
-    :copyright: (c) 2013 by Jauhien Piatlicki
-    :license: GPL-2, see LICENSE for more details.
-"""
-
-import os, unittest
-
-from g_sorcery import package_db, metadata
-
-from g_elpa import elpa_db
-
-from tests.base import BaseTest
-
-from tests.test_elpa_db import fill_database, packages
-
-class TestElpaEbuildGenerator(BaseTest):
-
-    def test_generate(self):
-        edb = elpa_db.ElpaDB(os.path.join(self.tempdir.name, 'db'),
-                             repo_uri = 'http://127.0.0.1:8080')
-        fill_database(edb, packages, self.tempdir.name)
-        metadata_generator = metadata.MetadataGenerator(edb)
-        mdxml = metadata_generator.generate(package_db.Package('app-emacs', 'ack', '1.2'))
-        self.assertEqual(mdxml,
-                ['<?xml version="1.0" encoding="utf-8"?>',
-                '<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">',
-                '<pkgmetadata>',
-                '\t<maintainer>',
-                '\t\t<email>piatlicki@gmail.com</email>',
-                '\t\t<name>Jauhien Piatlicki</name>',
-                '\t</maintainer>',
-                '\t<longdescription>Interface to ack-like source code search tools</longdescription>',
-                '</pkgmetadata>'])
-
-
-def suite():
-    suite = unittest.TestSuite()
-    suite.addTest(TestElpaEbuildGenerator('test_generate'))
-    return suite
diff --git a/tests/test_fileutils.py b/tests/test_fileutils.py
deleted file mode 100644
index 4a67712..0000000
--- a/tests/test_fileutils.py
+++ /dev/null
@@ -1,119 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-    fileutils.py
-    ~~~~~~~~~~~~
-    
-    file utilities test suite
-    
-    :copyright: (c) 2013 by Jauhien Piatlicki
-    :license: GPL-2, see LICENSE for more details.
-"""
-
-import json, os, shutil, tempfile, unittest
-
-from g_sorcery import exceptions, fileutils
-
-from tests.base import BaseTest
-
-class TestFileJSON(BaseTest):
-    
-    def setUp(self):
-        super(TestFileJSON, self).setUp()
-        self.path = os.path.join(self.tempdir.name, 'tst')
-        self.name = 'tst.json'
-
-    def do_test_read_ok(self, mandatories, value_suffix=""):
-        f = fileutils.FileJSON(self.path, self.name, mandatories)
-        content = f.read()
-        for key in mandatories:
-            self.assertTrue(key in content)
-            if value_suffix:
-                value = key + value_suffix
-            else:
-                value = ""
-            self.assertEqual(content[key], value)
-        self.assertTrue(os.path.isfile(os.path.join(self.path, self.name)))
-        with open(os.path.join(self.path, self.name), 'r') as f:
-            content_f = json.load(f)
-        self.assertEqual(content, content_f)
-        
-    def test_read_dir_does_not_exist(self):
-        mandatories = ['tst1', 'tst2', 'tst3']
-        self.do_test_read_ok(mandatories)
-
-    def test_read_file_does_not_exist(self):
-        os.makedirs(self.path)
-        mandatories = ['tst1', 'tst2', 'tst3']
-        self.do_test_read_ok(mandatories)
-
-    def test_read_all_keys(self):
-        os.makedirs(self.path)
-        mandatories = ['tst1', 'tst2', 'tst3']
-        content = {}
-        for key in mandatories:
-            content[key] = key + "_v"
-        with open(os.path.join(self.path, self.name), 'w') as f:
-            json.dump(content, f)
-        self.do_test_read_ok(mandatories, "_v")
-
-    def test_read_missing_keys(self):
-        os.makedirs(self.path)
-        mandatories = ['tst1', 'tst2', 'tst3']
-        content = {}
-        for key in mandatories:
-            content[key] = key + "_v"
-        with open(os.path.join(self.path, self.name), 'w') as f:
-            json.dump(content, f)
-        f = fileutils.FileJSON(self.path, self.name, mandatories)
-        mandatories.append("tst4")
-        self.assertRaises(exceptions.FileJSONError, f.read)
-
-    def do_test_write_ok(self):
-        mandatories = ['tst1', 'tst2', 'tst3']
-        content = {}
-        for key in mandatories:
-            content[key] = key + '_v'
-        f = fileutils.FileJSON(self.path, self.name, mandatories)
-        f.write(content)
-        self.assertTrue(os.path.isfile(os.path.join(self.path, self.name)))
-        with open(os.path.join(self.path, self.name), 'r') as f:
-            content_f = json.load(f)
-        self.assertEqual(content, content_f)
-
-    def test_write_missing_keys(self):
-        content = {'tst1' : '', 'tst2' : ''}
-        mandatories = ['tst1', 'tst2', 'tst3']
-        f = fileutils.FileJSON(self.path, self.name, mandatories)
-        self.assertRaises(exceptions.FileJSONError, f.write, content)
-
-    def test_write_dir_does_not_exist(self):
-        self.do_test_write_ok()
-
-    def test_write_file_does_not_exist(self):
-        os.makedirs(self.path)
-        self.do_test_write_ok()
-
-    def test_write_all_keys(self):
-        os.makedirs(self.path)
-        mandatories = ['tst11', 'tst12']
-        content = {}
-        for key in mandatories:
-            content[key] = key + "_v"
-        with open(os.path.join(self.path, self.name), 'w') as f:
-            json.dump(content, f)
-        self.do_test_write_ok()
-
-        
-def suite():
-    suite = unittest.TestSuite()
-    suite.addTest(TestFileJSON('test_read_dir_does_not_exist'))
-    suite.addTest(TestFileJSON('test_read_file_does_not_exist'))
-    suite.addTest(TestFileJSON('test_read_all_keys'))
-    suite.addTest(TestFileJSON('test_read_missing_keys'))
-    suite.addTest(TestFileJSON('test_write_missing_keys'))
-    suite.addTest(TestFileJSON('test_write_dir_does_not_exist'))
-    suite.addTest(TestFileJSON('test_write_file_does_not_exist'))
-    suite.addTest(TestFileJSON('test_write_all_keys'))
-    return suite
diff --git a/tests/test_metadata.py b/tests/test_metadata.py
deleted file mode 100644
index 288d8b1..0000000
--- a/tests/test_metadata.py
+++ /dev/null
@@ -1,134 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-    test_metadata.py
-    ~~~~~~~~~~~~~~~~
-    
-    metadata generator test suite
-    
-    :copyright: (c) 2013 by Jauhien Piatlicki
-    :license: GPL-2, see LICENSE for more details.
-"""
-
-import xml.etree.ElementTree as ET
-
-import tempfile, unittest
-
-from g_sorcery import exceptions, metadata, package_db
-
-from tests.base import BaseTest
-
-def tostring(element):
-    return ET.tostring(element, encoding='utf-8').decode('utf-8')
-
-class TestXMLGenerator(BaseTest):
-
-    def test_generate(self):
-        schema = [{'name' : 'desc',
-                   'subtags' : [],
-                   'multiple' : (False, ""),
-                   'required' : True},
-                   {'name' : 'contact',
-                   'multiple' : (False, ""),
-                   'required' : False,
-                   'subtags' : [
-                       {'name' : 'email',
-                        'subtags' : [],
-                        'multiple' : (False, ""),
-                        'required' : True},
-                        
-                        {'name' : 'phone',
-                        'subtags' : [],
-                        'multiple' : (False, ""),
-                        'required' : False},
-                    ]},
-                    {'name' : 'multiple',
-                     'subtags' : [],
-                     'multiple' : (True, ""),
-                     'required' : False},
-                     {'name' : 'flag',
-                     'subtags' : [],
-                     'multiple' : (True, "name"),
-                     'required' : False},
-                   ]
-        xg = metadata.XMLGenerator('test_ext', schema)
-        self.assertRaises(exceptions.XMLGeneratorError, xg.generate, {})
-        tree = xg.generate({'desc' : 'test xml'})
-        self.assertEqual(tostring(tree),
-                         '<test_ext><desc>test xml</desc></test_ext>')
-        tree = xg.generate({'desc' : 'test xml', 
-                            'contact' : {'email' : 'test@example.com',
-                                         'phone' : '00-0'}})
-        self.assertEqual(tostring(tree),
-                    '<test_ext><desc>test xml</desc><contact><email>test@example.com\
-</email><phone>00-0</phone></contact></test_ext>')
-        tree = xg.generate({'desc' : 'test xml', 
-                            'multiple' : ['test1', 'test2', 'test3']})
-        self.assertEqual(tostring(tree),
-                         '<test_ext><desc>test xml</desc><multiple>test1</multiple>\
-<multiple>test2</multiple><multiple>test3</multiple></test_ext>')
-        tree = xg.generate({'desc' : 'test xml', 
-                            'flag' : [('flag1', 'test1'), ('flag2', 'test2')]})
-        self.assertEqual(tostring(tree),
-                         '<test_ext><desc>test xml</desc><flag name="flag1">test1</flag>\
-<flag name="flag2">test2</flag></test_ext>')
-
-
-class DummyMetadataGenerator(metadata.MetadataGenerator):
-    def __init__(self, db):
-        super(DummyMetadataGenerator, self).__init__(db)
-
-package = package_db.Package("app-test", "test", "0.1")
-
-description = {'herd' : ['test'],
-               'maintainer' : [{'email' : 'test@example.com', 'name' : 'testor'}],
-               'longdescription' : 'test metadata',
-               'use' : {'flag' : [('flag1', 'test flag1'), ('flag2', 'test flag2')]},
-               'upstream' : {'maintainer' : [{'name' : 'TEST'}], 'remote-id' : '001'}}
-
-resulting_metadata = ['<?xml version="1.0" encoding="utf-8"?>',
-                      '<!DOCTYPE pkgmetadata SYSTEM "http://www.gentoo.org/dtd/metadata.dtd">',
-                      '<pkgmetadata>', '\t<herd>test</herd>',
-                      '\t<maintainer>', '\t\t<email>test@example.com</email>',
-                      '\t\t<name>testor</name>', '\t</maintainer>',
-                      '\t<longdescription>test metadata</longdescription>',
-                      '\t<use>', '\t\t<flag name="flag1">test flag1</flag>',
-                      '\t\t<flag name="flag2">test flag2</flag>', '\t</use>',
-                      '\t<upstream>', '\t\t<maintainer>', '\t\t\t<name>TEST</name>',
-                      '\t\t</maintainer>', '\t\t<remote-id>001</remote-id>',
-                      '\t</upstream>', '</pkgmetadata>']
-
-class DummyDB(package_db.PackageDB):
-    def __init__(self, directory, repo_uri="", db_uri=""):
-        super(DummyDB, self).__init__(directory, repo_uri, db_uri)
-
-    def generate_tree(self):
-        self.add_category("app-test")
-        self.add_package(package, description)
-        
-
-class TestMetadataGenerator(BaseTest):
-
-    def test_process(self):
-        mg = DummyMetadataGenerator(None)
-        self.assertEqual(tostring(mg.process(None, description)),
-                         '<pkgmetadata><herd>test</herd><maintainer><email>test@example.com</email>\
-<name>testor</name></maintainer><longdescription>test metadata</longdescription><use>\
-<flag name="flag1">test flag1</flag><flag name="flag2">test flag2</flag></use>\
-<upstream><maintainer><name>TEST</name></maintainer><remote-id>001</remote-id></upstream></pkgmetadata>')
-
-    def test_generate(self):
-        db = DummyDB(self.tempdir.name)
-        db.generate()
-        mg = DummyMetadataGenerator(db)
-        metadata = mg.generate(package)
-        self.assertEqual(metadata, resulting_metadata)
-
-        
-def suite():
-    suite = unittest.TestSuite()
-    suite.addTest(TestXMLGenerator('test_generate'))
-    suite.addTest(TestMetadataGenerator('test_process'))
-    suite.addTest(TestMetadataGenerator('test_generate'))
-    return suite
diff --git a/tests/test_package_db.py b/tests/test_package_db.py
deleted file mode 100644
index b2d51a2..0000000
--- a/tests/test_package_db.py
+++ /dev/null
@@ -1,133 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-    test_package_db.py
-    ~~~~~~~~~~~~~~~~~~
-    
-    package database test suite
-    
-    :copyright: (c) 2013 by Jauhien Piatlicki
-    :license: GPL-2, see LICENSE for more details.
-"""
-
-import json, os, shutil, tempfile, unittest
-
-from g_sorcery import package_db, exceptions
-
-from tests.server import Server
-
-from tests.base import BaseTest
-
-class DummyDB(package_db.PackageDB):
-    def __init__(self, directory, packages):
-        super(DummyDB, self).__init__(directory)
-        self.packages = packages
-
-    def generate_tree(self):
-        for category in [x.category for x in self.packages]:
-            self.add_category(category)
-        for package in self.packages:
-            self.add_package(package)
-
-    def get_real_db_uri(self):
-        print(self.db_uri)
-        return self.db_uri + '/dummy.tar.gz'
-
-
-class TestDummyDB(BaseTest):
-    
-    def setUp(self):
-        super(TestDummyDB, self).setUp()
-        category1 = 'app-test'
-        category2 = 'dev-test'
-        self.packages = [package_db.Package(category1, 'test', '0.2'),
-            package_db.Package(category1, 'tst', '0.1'),
-            package_db.Package(category1, 'dummy', '1'),
-            package_db.Package(category2, 'test', '0.1'),
-            package_db.Package(category2, 'test', '0.2'),
-            package_db.Package(category2, 'tst', '0.1')]
-
-    def test_manifest(self):
-        db = DummyDB(self.tempdir.name, self.packages)
-        db.generate()
-        self.assertEqual(db.check_manifest(), (True, []))
-
-    def test_read(self):
-        db = DummyDB(self.tempdir.name, self.packages)
-        db.generate()
-        db2 = DummyDB(self.tempdir.name, self.packages)
-        db2.read()
-        self.assertEqual(db.database, db2.database)
-
-    def test_list_categories(self):
-        db = DummyDB(self.tempdir.name, self.packages)
-        db.generate()
-        categories = list(set([x.category for x in self.packages]))
-        self.assertEqual(categories, db.list_categories())
-
-    def test_list_package_names(self):
-        db = DummyDB(self.tempdir.name, self.packages)
-        db.generate()
-        categories = list(set([x.category for x in self.packages]))
-        for category in categories:
-            package_names = list(set([x.name for x in self.packages if x.category == category]))
-            self.assertEqual(package_names.sort(), db.list_package_names(category).sort())
-        self.assertRaises(exceptions.InvalidKeyError, db.list_package_names, 'no_such_category')
-
-    def test_list_package_versions(self):
-        db = DummyDB(self.tempdir.name, self.packages)
-        db.generate()
-        categories = list(set([x.category for x in self.packages]))
-        for category in categories:
-            package_names = list(set([x.name for x in self.packages if x.category == category]))
-            for name in package_names:
-                versions = [x.version for x in self.packages 
-                            if x.category == category and x.name == name]
-                self.assertEqual(versions.sort(), db.list_package_versions(category, name).sort())
-        self.assertRaises(exceptions.InvalidKeyError, db.list_package_versions, 'no_such_category', 'a')
-        self.assertRaises(exceptions.InvalidKeyError, db.list_package_versions,
-                          categories[0], 'no_such_package')
-
-    def test_sync(self):
-        src_db = DummyDB(os.path.join(self.tempdir.name, 'src_testdb'), self.packages)
-        src_db.generate()
-
-        prev = os.getcwd()
-        os.chdir(self.tempdir.name)
-        os.system('tar cvzf dummy.tar.gz src_testdb')
-        
-        server = Server()
-        server.start()
-
-        db = DummyDB(os.path.join(self.tempdir.name, 'testdb'), self.packages)
-        db.sync(db_uri='127.0.0.1:8080')
-        
-        server.shutdown()
-        server.join()
-
-        os.chdir(prev)
-
-        self.assertEqual(src_db.database, db.database)
-
-    def test_sync_fail(self):
-        db = DummyDB(os.path.join(self.tempdir.name, 'testdb'), self.packages)
-        self.assertRaises(exceptions.SyncError, db.sync, db_uri='127.0.0.1:8080')
-
-    def test_get_max_version(self):
-        db = DummyDB(os.path.join(self.tempdir.name, 'testdb'), self.packages)
-        db.generate()
-        self.assertEqual(db.get_max_version('dev-test', 'test'), '0.2')
-
-            
-def suite():
-    suite = unittest.TestSuite()
-    suite.addTest(TestDummyDB('test_manifest'))
-    suite.addTest(TestDummyDB('test_read'))
-    suite.addTest(TestDummyDB('test_list_categories'))
-    suite.addTest(TestDummyDB('test_list_package_names'))
-    suite.addTest(TestDummyDB('test_list_package_versions'))
-    suite.addTest(TestDummyDB('test_sync'))
-    suite.addTest(TestDummyDB('test_sync_fail'))
-    suite.addTest(TestDummyDB('test_get_max_version'))
-    return suite