Testler elden geçirilmeli. Geçirilmeli ki yeni taga çıktıktan sonra tag açarken…

Testler elden geçirilmeli. Geçirilmeli ki yeni taga çıktıktan sonra tag açarken testleri verene kadar ellemeyelim

tests/metadata.xml → tests/addfiles/metadata.xml

 <?xml version="1.0" ?>
-<PISI>
+<INARY>
     <Source>
         <Name>
             popt
@@ -84,4 +84,4 @@
             149691
         </InstalledSize>
     </Package>
-</PISI>
+</INARY>

tests/addfiles/mirrors.conf

+apache  http://www.eu.apache.org/dist/
+cpan    http://search.cpan.org/CPAN/
+cpan    http://cpan.ulak.net.tr/
+gnu	http://ftp.gnu.org/gnu/

tests/archivetests.py

@@ -5,13 +5,13 @@ from inary import uri
 from inary import archive
 from inary import sourcearchive
 from inary import fetcher
-from inary.specfile import SpecFile
+from inary.data.specfile import SpecFile
 from os.path import join, exists
 
 class ArchiveTestCase(unittest.TestCase):
 
     def testTarUnpack(self):
-        spec = SpecFile('repos/pardus-2007/system/base/curl/pspec.xml')
+        spec = SpecFile('repos/repo1/system/base/curl/pspec.xml')
         targetDir = '/tmp/tests'
         archives = sourcearchive.SourceArchives(spec)
         archives.unpack(targetDir)
@@ -20,7 +20,7 @@ class ArchiveTestCase(unittest.TestCase):
 
 
     def testUnpackTarCond(self):
-        spec = SpecFile('repos/pardus-2007/system/base/curl/pspec.xml')
+        spec = SpecFile('repos/repo1/system/base/curl/pspec.xml')
         targetDir = '/tmp'
         archives = sourcearchive.SourceArchives(spec)
         for archive in spec.source.archive:
@@ -32,7 +32,7 @@ class ArchiveTestCase(unittest.TestCase):
             assert archive.type == 'targz'
 
     def testZipUnpack(self):
-        spec = SpecFile('repos/pardus-2007/system/base/openssl/pspec.xml')
+        spec = SpecFile('repos/repo1/system/base/openssl/pspec.xml')
         targetDir = '/tmp/tests'
         archives = sourcearchive.SourceArchives(spec)
         archives.fetch()
@@ -40,7 +40,7 @@ class ArchiveTestCase(unittest.TestCase):
         assert not exists(targetDir + '/openssl')
 
     def testMakeZip(self):
-        spec = SpecFile('repos/pardus-2007/system/base/openssl/pspec.xml')
+        spec = SpecFile('repos/repo1/system/base/openssl/pspec.xml')
         targetDir = '/tmp/tests'
         archives = sourcearchive.SourceArchives(spec)
         archives.fetch(interactive = False)

tests/conflicttests.py

@@ -2,32 +2,32 @@
 import unittest
 import inary
 import inary.context as ctx
-import inary.conflict
+import inary.analyzer.conflict
 
 class ConflictTestCase(unittest.TestCase):
 
     def testInstalledPackageConflicts(self):
         inary.api.install(["ethtool"])
-        confinfo = inary.conflict.Conflict()
+        confinfo = inary.analyzer.conflict.Conflict()
         confinfo.package = "ethtool"
         confinfo.version = "6"
         confinfo.release = "1"
-        assert not inary.conflict.installed_package_conflicts(confinfo)
+        assert not inary.analyzer.conflict.installed_package_conflicts(confinfo)
         inary.api.remove(["ethtool"])
 
     def testCalculateConflicts(self):
         packagedb = inary.db.packagedb.PackageDB()
         packages = ["ethtool", "zlib", "ctorrent"]
-        assert inary.conflict.calculate_conflicts(packages, packagedb)
+        assert inary.analyzer.conflict.calculate_conflicts(packages, packagedb)
 
     def testConflictCheck(self):
-        # In our sample repo1, inary conflicts with bar.
+        # In our sample repo1, inary.analyzer.conflicts with bar.
         # If this fails, it may affect database test case results.
-        inary.api.add_repo("repo1", "repos/repo1-bin/pisi-index.xml")
+        inary.api.add_repo("repo1", "repos/repo1-bin/inary-index.xml")
         inary.api.update_repo("repo1")
         inary.api.install(["inary"])
 
-        myconflict = inary.conflict.Conflict()
+        myconflict = inary.analyzer.conflict.Conflict()
         myconflict.package = "bar"
         myconflict.version = "0.3"
         myconflict.release = "1"
@@ -41,14 +41,14 @@ class ConflictTestCase(unittest.TestCase):
 
     def testInterRepoCrossConflicts(self):
         #If this fails, it may affect database test case results
-        inary.api.add_repo("repo1", "repos/repo1-bin/pisi-index.xml")
+        inary.api.add_repo("repo1", "repos/repo1-bin/inary-index.xml")
         inary.api.update_repo("repo1")
 
         inary.api.install(["inary", "foo"])
         before = inary.api.list_installed()
         inary.api.remove_repo("repo1")
 
-        inary.api.add_repo("repo2", "repos/repo2-bin/pisi-index.xml")
+        inary.api.add_repo("repo2", "repos/repo2-bin/inary-index.xml")
         inary.api.update_repo("repo2")
         inary.api.upgrade(["inary"])
         after = inary.api.list_installed()

tests/database/componentdbtest.py

@@ -20,16 +20,16 @@ class ComponentDBTestCase(testcase.TestCase):
         self.componentdb = inary.db.componentdb.ComponentDB()
 
     def testHasComponent(self):
-        assert self.componentdb.has_component("system.base", "pardus-2007")
-        assert not self.componentdb.has_component("hede.hodo", "pardus-2007")
-        assert self.componentdb.has_component("applications.network", "contrib-2007")
-        assert not self.componentdb.has_component("hede.hodo", "contrib-2007")
+        assert self.componentdb.has_component("system.base", "repo1")
+        assert not self.componentdb.has_component("hede.hodo", "repo1")
+        assert self.componentdb.has_component("applications.network", "repo2")
+        assert not self.componentdb.has_component("hede.hodo", "repo2")
         assert self.componentdb.has_component("applications.network")
 
     def testListComponents(self):
-        assert set(self.componentdb.list_components("pardus-2007")) == set(["system", "system.base", 
+        assert set(self.componentdb.list_components("repo1")) == set(["system", "system.base", 
                                                                             "applications", "applications.network"])
-        assert set(self.componentdb.list_components("contrib-2007")) == set(["applications", "applications.util",
+        assert set(self.componentdb.list_components("repo2")) == set(["applications", "applications.util",
                                                                              "applications.network"])
         assert set(self.componentdb.list_components()) == set(["system", "system.base", 
                                                                "applications", "applications.network",
@@ -41,7 +41,7 @@ class ComponentDBTestCase(testcase.TestCase):
         assert "ncftp" in component.packages
         assert "lynx" not in component.packages
 
-        component = self.componentdb.get_component("applications.network", "contrib-2007")
+        component = self.componentdb.get_component("applications.network", "repo2")
         assert component.name == "applications.network"
         assert "lynx" in component.packages
         assert "ncftp" not in component.packages
@@ -57,11 +57,11 @@ class ComponentDBTestCase(testcase.TestCase):
         assert "ncftp" in packages
         assert "lynx" not in packages
 
-        packages = self.componentdb.get_packages("applications.network", "contrib-2007")
+        packages = self.componentdb.get_packages("applications.network", "repo2")
         assert "lynx" in packages
         assert "ncftp" not in packages
 
-        packages = self.componentdb.get_packages("applications", "contrib-2007", walk = True)
+        packages = self.componentdb.get_packages("applications", "repo2", walk = True)
         assert "cpulimit" and "lynx" in packages
         assert "ncftp" not in packages
 
@@ -78,8 +78,8 @@ class ComponentDBTestCase(testcase.TestCase):
         packages = self.componentdb.search_component(["applic"])
         assert set(packages) == set(['applications', 'applications.network', 'applications.util'])
 
-        packages = self.componentdb.search_component(["system", "base"], repo="pardus-2007")
+        packages = self.componentdb.search_component(["system", "base"], repo="repo1")
         assert set(packages) == set(["system.base"])
 
-        packages = self.componentdb.search_component(["system", "base"], repo="contrib-2007")
+        packages = self.componentdb.search_component(["system", "base"], repo="repo2")
         assert not packages

tests/database/filesdbtest.py

@@ -15,7 +15,7 @@ import inary
 
 class FilesDBTestCase(testcase.TestCase):
 
-    filesdb = inary.db.filesdb.FilesDB()
+    filesdb = inary.db.filesldb.FilesLDB()
 
     def testHasFile(self):
         assert not self.filesdb.has_file("usr/bin/ethtool")

tests/database/itembyrepotest.py

@@ -18,20 +18,20 @@ class TestDB:
         self.packages = {}
         self.obsoletes = {}
 
-        self.packages["pardus-2007"] = {"aggdraw":"package aggdraw",
+        self.packages["repo1"] = {"aggdraw":"package aggdraw",
                                         "acpica":"package acpica"}
-        self.packages["contrib-2007"] = {"kdiff3":"package kdiff3",
+        self.packages["repo2"] = {"kdiff3":"package kdiff3",
                                          "kmess":"package kmess"}
 
-        self.obsoletes["pardus-2007"] = ["wengophone", "rar"]
-        self.obsoletes["contrib-2007"] = ["xara"]
+        self.obsoletes["repo1"] = ["wengophone", "rar"]
+        self.obsoletes["repo2"] = ["xara"]
 
         self.tdb = inary.db.itembyrepo.ItemByRepo(self.packages)
         self.odb = inary.db.itembyrepo.ItemByRepo(self.obsoletes)
 
         # original item_repos in ItemByRepo uses repodb.list_repos
         def item_repos(repo=None):
-            repos = ["pardus-2007", "contrib-2007"]
+            repos = ["repo1", "repo2"]
             if repo:
                 repos = [repo]
             return repos
@@ -44,48 +44,48 @@ class ItemByRepoTestCase(testcase.TestCase):
     testdb = TestDB()
 
     def testHasRepository(self):
-        assert self.testdb.tdb.has_repo("pardus-2007")
-        assert self.testdb.tdb.has_repo("contrib-2007")
+        assert self.testdb.tdb.has_repo("repo1")
+        assert self.testdb.tdb.has_repo("repo2")
         assert not self.testdb.tdb.has_repo("hedehodo")
 
     def testHasItem(self):
-        assert self.testdb.tdb.has_item("kdiff3", "contrib-2007")
-        assert not self.testdb.tdb.has_item("kdiff3", "pardus-2007")
+        assert self.testdb.tdb.has_item("kdiff3", "repo2")
+        assert not self.testdb.tdb.has_item("kdiff3", "repo1")
         assert self.testdb.tdb.has_item("acpica")
 
     def testWhichRepo(self):
-        assert self.testdb.tdb.which_repo("aggdraw") == "pardus-2007"
-        assert self.testdb.tdb.which_repo("kmess") == "contrib-2007"
+        assert self.testdb.tdb.which_repo("aggdraw") == "repo1"
+        assert self.testdb.tdb.which_repo("kmess") == "repo2"
 
     def testGetItemAndRepository(self):
         pkg, repo = self.testdb.tdb.get_item_repo("acpica")
         assert pkg == "package acpica"
-        assert repo == "pardus-2007"
+        assert repo == "repo1"
 
         pkg, repo = self.testdb.tdb.get_item_repo("kmess")
         assert pkg == "package kmess"
-        assert repo == "contrib-2007"
+        assert repo == "repo2"
 
     def testItemRepos(self):
         db = inary.db.itembyrepo.ItemByRepo({})
         assert db.item_repos("caracal") == ["caracal"]
         # repos were created by testcase.py
-        assert db.item_repos() == ['pardus-2007', 'contrib-2007', 'pardus-2007-src']
+        assert db.item_repos() == ['repo1', 'repo2', 'repo1-src']
 
     def testGetItem(self):
         assert self.testdb.tdb.get_item("acpica") == "package acpica"
         assert self.testdb.tdb.get_item("kmess") == "package kmess"
 
     def testGetItemOfRepository(self):
-        assert self.testdb.tdb.get_item("acpica", "pardus-2007") == "package acpica"
-        assert self.testdb.tdb.get_item("kmess", "contrib-2007") == "package kmess"
+        assert self.testdb.tdb.get_item("acpica", "repo1") == "package acpica"
+        assert self.testdb.tdb.get_item("kmess", "repo2") == "package kmess"
 
     def testGetItemKeys(self):
-        assert set(self.testdb.tdb.get_item_keys("pardus-2007")) == set(["aggdraw", "acpica"])
-        assert set(self.testdb.tdb.get_item_keys("contrib-2007")) == set(["kdiff3", "kmess"])
+        assert set(self.testdb.tdb.get_item_keys("repo1")) == set(["aggdraw", "acpica"])
+        assert set(self.testdb.tdb.get_item_keys("repo2")) == set(["kdiff3", "kmess"])
         assert set(self.testdb.tdb.get_item_keys()) == set(["kdiff3", "kmess", "aggdraw", "acpica"])
 
     def testGetListItem(self):
-        assert set(self.testdb.odb.get_list_item("pardus-2007")) == set(['rar', 'wengophone'])
-        assert set(self.testdb.odb.get_list_item("contrib-2007")) == set(['xara'])
+        assert set(self.testdb.odb.get_list_item("repo1")) == set(['rar', 'wengophone'])
+        assert set(self.testdb.odb.get_list_item("repo2")) == set(['xara'])
         assert set(self.testdb.odb.get_list_item()) == set(['rar', 'xara', 'wengophone'])

tests/database/packagedbtest.py

@@ -20,36 +20,36 @@ class PackageDBTestCase(testcase.TestCase):
         self.packagedb = inary.db.packagedb.PackageDB()
 
     def testGetPackage(self):
-        pkg = self.packagedb.get_package("ncftp", "pardus-2007")
+        pkg = self.packagedb.get_package("ncftp", "repo1")
         assert pkg.name == "ncftp"
 
-        pkg = self.packagedb.get_package("lynx", "contrib-2007")
+        pkg = self.packagedb.get_package("lynx", "repo2")
         assert pkg.name == "lynx"
 
         pkg = self.packagedb.get_package("cpulimit")
         assert pkg.name == "cpulimit"
 
     def testHasPackage(self):
-        assert self.packagedb.has_package("ncftp", "pardus-2007")
-        assert not self.packagedb.has_package("ncftp", "contrib-2007")
+        assert self.packagedb.has_package("ncftp", "repo1")
+        assert not self.packagedb.has_package("ncftp", "repo2")
         assert self.packagedb.has_package("lynx")
 
     def testGetVersion(self):
-        version, release, build = self.packagedb.get_version("lynx", "contrib-2007")
+        version, release, build = self.packagedb.get_version("lynx", "repo2")
         assert version == "0.3"
         assert release == "1"
 
     def testWhichRepo(self):
-        assert self.packagedb.which_repo("lynx") == "contrib-2007"
+        assert self.packagedb.which_repo("lynx") == "repo2"
 
     def testGetPackageAndRepository(self):
         pkg, repo = self.packagedb.get_package_repo("cpulimit")
         assert pkg.name == "cpulimit"
-        assert repo == "contrib-2007"
+        assert repo == "repo2"
 
     def testGetObsoletes(self):
-        assert set(self.packagedb.get_obsoletes("pardus-2007")) == set(["wengophone", "rar"])
-        assert set(self.packagedb.get_obsoletes("contrib-2007")) == set(["xara"])
+        assert set(self.packagedb.get_obsoletes("repo1")) == set(["wengophone", "rar"])
+        assert set(self.packagedb.get_obsoletes("repo2")) == set(["xara"])
         assert set(self.packagedb.get_obsoletes()) == set(["wengophone", "rar", "xara"])
 
     def testGetReverseDependencies(self):
@@ -62,17 +62,17 @@ class PackageDBTestCase(testcase.TestCase):
         assert not self.packagedb.get_replaces()
 
     def testListPackages(self):
-        assert set(self.packagedb.list_packages("pardus-2007")) == set(['nfdump', 'ethtool', 'ncftp', 
+        assert set(self.packagedb.list_packages("repo1")) == set(['nfdump', 'ethtool', 'ncftp', 
                                                                         'libidn', 'zlib', 'db4', 'openssl', 
                                                                         'jpeg', 'pam', 'shadow', 'bogofilter', 
                                                                         'curl', 'gsl', 'bash', 'cracklib'])
 
-        assert set(self.packagedb.list_packages("contrib-2007")) == set(['libpcap', 'ctorrent', 'lft', 'lynx', 
+        assert set(self.packagedb.list_packages("repo2")) == set(['libpcap', 'ctorrent', 'lft', 'lynx', 
                                                                          'iat', 'cpulimit', 'rpl'])
 
     def testSearchPackage(self):
         packages = self.packagedb.search_package(["bogo", "filter"])
         packages = ["bogofilter"]
 
-        packages = self.packagedb.search_package(["cpu", "limit"], repo="contrib-2007")
+        packages = self.packagedb.search_package(["cpu", "limit"], repo="repo2")
         packages = ["cpulimit"]

tests/database/repodbtest.py

@@ -20,14 +20,14 @@ class RepoDBTestCase(testcase.TestCase):
         self.repodb = inary.db.repodb.RepoDB()
 
     def testAddRemoveRepo(self):
-        assert "contrib-2007-src" not in self.repodb.list_repos()
-        repo = inary.db.repodb.Repo(pisi.uri.URI("repos/contrib-2007/pisi-index.xml"))
-        self.repodb.add_repo("contrib-2007-src", repo)
-        assert "contrib-2007-src" in self.repodb.list_repos()
-        self.repodb.remove_repo("contrib-2007-src")
-        assert "contrib-2007" in self.repodb.list_repos()
-        assert "pardus-2007" in self.repodb.list_repos()
-        assert "contrib-2007-src" not in self.repodb.list_repos()
+        assert "repo2-src" not in self.repodb.list_repos()
+        repo = inary.db.repodb.Repo(pisi.uri.URI("repos/repo2/pisi-index.xml"))
+        self.repodb.add_repo("repo2-src", repo)
+        assert "repo2-src" in self.repodb.list_repos()
+        self.repodb.remove_repo("repo2-src")
+        assert "repo2" in self.repodb.list_repos()
+        assert "repo1" in self.repodb.list_repos()
+        assert "repo2-src" not in self.repodb.list_repos()
 
     def testAddRemoveCycle(self):
         for r in range(30):
@@ -40,25 +40,25 @@ class RepoDBTestCase(testcase.TestCase):
         assert "test-repo" not in self.repodb.list_repos()
 
     def testListRepos(self):
-        assert set(self.repodb.list_repos()) == set(['pardus-2007', 'contrib-2007', 'pardus-2007-src'])
+        assert set(self.repodb.list_repos()) == set(['repo1', 'repo2', 'repo1-src'])
 
     def testGetSourceRepos(self):
-        assert set(self.repodb.get_source_repos()) == set(['pardus-2007-src'])
+        assert set(self.repodb.get_source_repos()) == set(['repo1-src'])
 
     def testGetBinaryRepos(self):
-        assert set(self.repodb.get_binary_repos()) == set(['pardus-2007', 'contrib-2007'])
+        assert set(self.repodb.get_binary_repos()) == set(['repo1', 'repo2'])
 
     def testGetRepo(self):
-        repo = self.repodb.get_repo("pardus-2007")
+        repo = self.repodb.get_repo("repo1")
         uri = repo.indexuri
-        assert uri.get_uri() == "repos/pardus-2007-bin/inary-index.xml"
+        assert uri.get_uri() == "repos/repo1-bin/inary-index.xml"
 
     def testRepoOrder(self):
         repoorder = inary.db.repodb.RepoOrder()
-        assert repoorder.get_order() == ['pardus-2007', 'contrib-2007', 'pardus-2007-src']
+        assert repoorder.get_order() == ['repo1', 'repo2', 'repo1-src']
 
         repoorder.add("test-repo", "http://test-repo/inary-index.xml")
-        assert repoorder.get_order() == ['pardus-2007', 'contrib-2007', 'pardus-2007-src', 'test-repo']
+        assert repoorder.get_order() == ['repo1', 'repo2', 'repo1-src', 'test-repo']
 
         repoorder.remove("test-repo")
-        assert repoorder.get_order() == ['pardus-2007', 'contrib-2007', 'pardus-2007-src']
+        assert repoorder.get_order() == ['repo1', 'repo2', 'repo1-src']

tests/database/sourcedbtest.py

@@ -37,7 +37,7 @@ class SourceDBTestCase(testcase.TestCase):
         assert spec.source.partOf == "applications.network"
 
     def testGetSpecOfRepository(self):
-        spec = self.sourcedb.get_spec("ethtool", "pardus-2007-src")
+        spec = self.sourcedb.get_spec("ethtool", "repo1-src")
         assert spec.source.name == "ethtool"
         assert spec.source.partOf == "applications.network"
 
@@ -45,7 +45,7 @@ class SourceDBTestCase(testcase.TestCase):
         spec, repo = self.sourcedb.get_spec_repo("ethtool")
         assert spec.source.name == "ethtool"
         assert spec.source.partOf == "applications.network"
-        assert repo == "pardus-2007-src"
+        assert repo == "repo1-src"
 
     def testGetSourceFromPackage(self):
         # FIXME: Add multi package from source to createrepo.py
@@ -56,7 +56,7 @@ class SourceDBTestCase(testcase.TestCase):
         packages = self.sourcedb.search_spec(["open", "ssl"])
         assert set(["openssl"]) == set(packages)
 
-        packages = self.sourcedb.search_spec(["bogo", "filter"], repo="pardus-2007-src")
+        packages = self.sourcedb.search_spec(["bogo", "filter"], repo="repo1-src")
         assert set(["bogofilter"]) == set(packages)
 
 

tests/database/testcase.py

@@ -15,9 +15,9 @@ class TestCase(unittest.TestCase):
         ctx.config.values.general.distribution_release = "2007"
 
         if not inary.api.list_repos():
-            inary.api.add_repo("pardus-2007", "repos/pardus-2007-bin/pisi-index.xml")
-            inary.api.add_repo("contrib-2007", "repos/contrib-2007-bin/pisi-index.xml")
-            inary.api.add_repo("pardus-2007-src", "repos/pardus-2007/pisi-index.xml")
-            inary.api.update_repo("pardus-2007")
-            inary.api.update_repo("contrib-2007")
-            inary.api.update_repo("pardus-2007-src")
+            inary.api.add_repo("repo1", "repos/repo1-bin/pisi-index.xml")
+            inary.api.add_repo("repo2", "repos/repo2-bin/pisi-index.xml")
+            inary.api.add_repo("repo1-src", "repos/repo1/pisi-index.xml")
+            inary.api.update_repo("repo1")
+            inary.api.update_repo("repo2")
+            inary.api.update_repo("repo1-src")

tests/dependencytest.py

 import unittest
-import inary.relation
-import inary.dependency
+import inary.data.relation
+import inary.analyzer.dependency
 
 class DependencyTestCase(unittest.TestCase):
 
     def testDictSatisfiesDep(self):
         inary.api.install(["ethtool"])
-        relation = inary.relation.Relation()
+        relation = inary.data.relation.Relation()
         relation.package = "ethtool"
 
         inary.api.install(["zlib"])
-        rel = inary.relation.Relation()
+        rel = inary.data.relation.Relation()
         rel.package = "zlib"
 
-        depinfo = inary.dependency.Dependency(relation)
+        depinfo = inary.analyzer.dependency.Dependency(relation)
         dictionary = {"ethtool": [" "],"zlib":["a","b"],"ctorrent":["c"]}
         assert not depinfo.satisfied_by_dict_repo(dictionary)
-        depinf = inary.dependency.Dependency(rel)
+        depinf = inary.analyzer.dependency.Dependency(rel)
         assert not depinf.satisfied_by_dict_repo(dictionary)
 
     def testInstalledSatisfiesDep(self):
         inary.api.install(["ctorrent"])
-        relation = inary.relation.Relation()
+        relation = inary.data.relation.Relation()
         relation.package = "ctorrent"
-        depinfo = inary.dependency.Dependency(relation)
+        depinfo = inary.analyzer.dependency.Dependency(relation)
         assert not depinfo.satisfied_by_installed()
 
     def testRepoSatisfiesDependency(self):
         inary.api.install(["ethtool"])
-        relation = inary.relation.Relation()
+        relation = inary.data.relation.Relation()
         relation.package = "ctorrent"
-        depinfo = inary.dependency.Dependency(relation)
+        depinfo = inary.analyzer.dependency.Dependency(relation)
         assert not depinfo.satisfied_by_repo()

tests/fetchtest.py

@@ -3,7 +3,7 @@ import os
 import base64
 import inary.context as ctx
 import inary.api
-from inary.specfile import SpecFile
+from inary.data.specfile import SpecFile
 from inary.fetcher import Fetcher
 from inary import util
 from inary import uri
@@ -13,7 +13,7 @@ class FetchTestCase(unittest.TestCase):
     def setUp(self):
         unittest.TestCase.setUp(self)
         self.spec = SpecFile()
-        self.spec.read('repos/pardus-2007/system/base/curl/pspec.xml')
+        self.spec.read('repos/repo1/system/base/curl/pspec.xml')
         self.url = uri.URI(self.spec.source.archive[0].uri)
         self.url.set_auth_info(("user", "pass"))
         self.destpath = ctx.config.archives_dir()

tests/filestest.py

 import unittest
-import inary.files
+import inary.data.files
 
 class FilesTestCase(unittest.TestCase):
 
@@ -7,13 +7,13 @@ class FilesTestCase(unittest.TestCase):
         unittest.TestCase.setUp(self)
 
     def testFileInfo(self):
-        file1 = inary.files.FileInfo(path = '/usr/bin/acpi')
+        file1 = inary.data.files.FileInfo(path = '/usr/bin/acpi')
         file1.type = 'init'
         file1.size = '30'
 
-        file2 = inary.files.FileInfo(path = '/sbin/blkid', type = 'ctors', size = '8')
+        file2 = inary.data.files.FileInfo(path = '/sbin/blkid', type = 'ctors', size = '8')
 
     def testFiles(self):
-        self.files = inary.files.Files()
-        self.files.read('repos/pardus-2007/system/base/curl/pspec.xml')
+        self.files = inary.data.files.Files()
+        self.files.read('repos/repo1/system/base/curl/pspec.xml')
 

tests/filetest.py

 import unittest
-from inary.specfile import SpecFile
+from inary.data.specfile import SpecFile
 from inary import uri
 from inary.file import File
 
@@ -9,26 +9,26 @@ class FileTestCase(unittest.TestCase):
         unittest.TestCase.setUp(self)
 
     def testMakeUri(self):
-        spec = SpecFile("repos/pardus-2007/system/base/curl/pspec.xml")
+        spec = SpecFile("repos/repo1/system/base/curl/pspec.xml")
         url = uri.URI(spec.source.archive[0].uri)
         self.assertTrue(File.make_uri(url))
 
     def testChooseMethod(self):
-        compress = File('repos/contrib-2007/inary-index.xml', File.read)
+        compress = File('repos/repo2/inary-index.xml', File.read)
         self.assertTrue(File.choose_method('inary.conf', compress))
 
     def testDecompress(self):
-        localfile = File('repos/pardus-2007/system/base/curl/pspec.xml', File.read)
-        compress = File('repos/contrib-2007/inary-index.xml', File.read)
+        localfile = File('repos/repo1/system/base/curl/pspec.xml', File.read)
+        compress = File('repos/repo2/inary-index.xml', File.read)
         self.assertTrue(File.decompress(localfile,compress))
 
     def testLocalFile(self):
-        f = File('repos/pardus-2007/system/base/curl/pspec.xml', File.read)
+        f = File('repos/repo1/system/base/curl/pspec.xml', File.read)
         r = f.readlines()
         assert (len(r) > 0)
 
     def testRemoteRead(self):
-        f = File('http://www.pardus.org.tr/urunler/pardus-2009.2-Geronticus_eremita-surum-notlari-tr.html', File.read)
+        f = File('http://www.sulin.org.tr/urunler/pardus-2009.2-Geronticus_eremita-surum-notlari-tr.html', File.read)
         r = f.readlines()
         assert (len(r) > 0)
 

tests/graphtest.py

 import unittest
 import os
 import inary
-from inary import graph
+from inary.data import pgraph
 
 class GraphTestCase(unittest.TestCase):
     def setUp(self):
-        self.g0 = inary.graph.Digraph()
+        self.g0 = inary.pgraph.Digraph()
         self.g0.add_edge(1,2)
         self.g0.add_edge(1,3)
         self.g0.add_edge(2,3)
         self.g0.add_edge(3,4)
         self.g0.add_edge(4,1)
 
-        self.g1 = inary.graph.Digraph()
+        self.g1 = inary.pgraph.Digraph()
         self.g1.add_edge(0,2)
         self.g1.add_edge(0,3)
         self.g1.add_edge(2,4)

tests/historytest.py

 import unittest
-import inary.relation
+import inary.data.relation
 
 class HistoryTestCase(unittest.TestCase):
 

tests/metadatatest.py

 import unittest
 import os
 
-from inary import metadata
+from inary.data import metadata
 from inary import util
 
 class MetadataTestCase(unittest.TestCase):

tests/packagetest.py

@@ -37,7 +37,7 @@ class PackageTestCase(unittest.TestCase):
         pkg.extract_file("files.xml",cur)
         if os.path.exists("files.xml"):
             self.fail("File extract error")
-        pkg.extract_inary_files("002_remove.xml")
+        pkg.extract_inary.data.files("002_remove.xml")
         if os.path.exists("002_remove.xml"):
             self.fail("Pisi files extract error")
 

tests/relationtest.py

 
 import unittest
-import inary.relation
+import inary.data.relation
 
 class RelationTestCase(unittest.TestCase):
     def testInstalledPackageSatisfies(self):
         inary.api.install(["ethtool"])
-        relation = inary.relation.Relation()
+        relation = inary.data.relation.Relation()
 
         relation.package = "ethtool"
         # Test version = X
         relation.version = "0.3"
-        assert inary.relation.installed_package_satisfies(relation)
+        assert inary.data.relation.installed_package_satisfies(relation)
         relation.version = None
 
         # Test versionFrom = X
         relation.versionFrom = "0.3"
-        assert inary.relation.installed_package_satisfies(relation)
+        assert inary.data.relation.installed_package_satisfies(relation)
         relation.versionFrom = "8"
-        assert not inary.relation.installed_package_satisfies(relation)
+        assert not inary.data.relation.installed_package_satisfies(relation)
         relation.versionFrom = None
         
         #Test versionTo = X
         relation.versionTo = "8"
-        assert inary.relation.installed_package_satisfies(relation)
+        assert inary.data.relation.installed_package_satisfies(relation)
         relation.versionTo = "0.1"
-        assert not inary.relation.installed_package_satisfies(relation)
+        assert not inary.data.relation.installed_package_satisfies(relation)
         relation.versionTo = None
         
         #Test release = X
         relation.release = "3"
-        assert not inary.relation.installed_package_satisfies(relation)
+        assert not inary.data.relation.installed_package_satisfies(relation)
         relation.release = "1"
-        assert inary.relation.installed_package_satisfies(relation)
+        assert inary.data.relation.installed_package_satisfies(relation)
         relation.release = None
 
         #test releaseFrom = X
         relation.releaseFrom = "1"
-        assert inary.relation.installed_package_satisfies(relation)
+        assert inary.data.relation.installed_package_satisfies(relation)
         relation.releaseFrom = "7"
-        assert not inary.relation.installed_package_satisfies(relation)
+        assert not inary.data.relation.installed_package_satisfies(relation)
         relation.releaseFrom = None
 
         #test releaseTo = X
         relation.releaseTo = "7"
-        assert inary.relation.installed_package_satisfies(relation)
+