tests: move to repo root dir

4 files changed, 330 insertions, 0 deletions

diff --git a/tests/repository/__init__.py b/tests/repository/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/tests/repository/__init__.py
diff --git a/tests/repository/test_filtered.py b/tests/repository/test_filtered.py
new file mode 100644
index 000000000..083ec93d9
--- /dev/null
+++ b/tests/repository/test_filtered.py
@@ -0,0 +1,43 @@
+from pkgcore.ebuild.atom import atom
+from pkgcore.ebuild.cpv import VersionedCPV
+from pkgcore.repository import filtered
+from pkgcore.repository.util import SimpleTree
+from pkgcore.restrictions import packages, values
+
+
+class TestVisibility:
+
+    def setup_repos(self, restrictions=None):
+        repo = SimpleTree({
+            "dev-util": {"diffball": ["1.0", "0.7"], "bsdiff": ["0.4.1", "0.4.2"]},
+            "dev-lib": {"fake": ["1.0", "1.0-r1"]}})
+        if restrictions is None:
+            restrictions = atom("dev-util/diffball")
+        vrepo = filtered.tree(repo, restrictions)
+        return repo, vrepo
+
+    def test_filtering(self):
+        repo, vrepo = self.setup_repos()
+        a = atom("dev-lib/fake")
+        a2 = atom("dev-util/diffball")
+        assert sorted(vrepo.itermatch(a)) == sorted(repo.itermatch(a))
+        assert sorted(vrepo.itermatch(a2)) == []
+        repo, vrepo = self.setup_repos(atom("=dev-util/diffball-1.0"))
+        assert sorted(vrepo.itermatch(a)) == sorted(repo.itermatch(a))
+        assert sorted(vrepo.itermatch(a2)) == sorted([VersionedCPV("dev-util/diffball-0.7")])
+        repo, vrepo = self.setup_repos(packages.PackageRestriction(
+            "package", values.OrRestriction(
+                *[values.StrExactMatch(x) for x in ("diffball", "fake")])))
+        assert sorted(vrepo.itermatch(packages.AlwaysTrue)) == \
+            sorted(repo.itermatch(atom("dev-util/bsdiff")))
+
+        # check sentinel value handling.
+        vrepo = filtered.tree(repo, a2, sentinel_val=True)
+        assert sorted(x.cpvstr for x in vrepo) == \
+            sorted(['dev-util/diffball-0.7', 'dev-util/diffball-1.0'])
+
+    def test_iter(self):
+        repo, vrepo = self.setup_repos(packages.PackageRestriction(
+            "package", values.OrRestriction(
+                *[values.StrExactMatch(x) for x in ("diffball", "fake")])))
+        assert sorted(vrepo) == sorted(repo.itermatch(atom("dev-util/bsdiff")))
diff --git a/tests/repository/test_multiplex.py b/tests/repository/test_multiplex.py
new file mode 100644
index 000000000..10b26cc47
--- /dev/null
+++ b/tests/repository/test_multiplex.py
@@ -0,0 +1,56 @@
+from collections import OrderedDict
+from functools import partial
+
+from pkgcore.repository.multiplex import tree
+from pkgcore.repository.util import SimpleTree
+from pkgcore.restrictions import packages, values
+
+rev_sorted = partial(sorted, reverse=True)
+
+
+class TestMultiplex:
+
+    kls = staticmethod(tree)
+    tree1_pkgs = (
+        ("dev-util/diffball", ["1.0", "0.7"]),
+        ("dev-lib/fake", ["1.0", "1.0-r1"]))
+    tree2_pkgs = (
+        ("dev-util/diffball", ["1.0", "1.1"]),
+        ("dev-lib/bsdiff", ["1.0", "2.0"]))
+    tree1_list = [f"{k}-{ver}" for k, v in tree1_pkgs for ver in v]
+    tree2_list = [f"{k}-{ver}" for k, v in tree2_pkgs for ver in v]
+
+    def setup_method(self):
+        self.d1, self.d2 = {}, {}
+        for key, ver in self.tree1_pkgs:
+            cat, pkg = key.rsplit("/", 1)
+            self.d1.setdefault(cat, {}).setdefault(pkg, []).extend(ver)
+        for key, ver in self.tree2_pkgs:
+            cat, pkg = key.rsplit("/", 1)
+            self.d2.setdefault(cat, {}).setdefault(pkg, []).extend(ver)
+
+        self.d1 = OrderedDict(
+            (k, OrderedDict(self.d1[k].items()))
+            for k in sorted(self.d1, reverse=True))
+        self.d2 = OrderedDict(
+            (k, OrderedDict(self.d2[k].items()))
+            for k in sorted(self.d2, reverse=True))
+        self.tree1 = SimpleTree(self.d1)
+        self.tree2 = SimpleTree(self.d2)
+        self.ctree = self.kls(self.tree1, self.tree2)
+
+    def test_iter(self):
+        assert sorted(x.cpvstr for x in self.ctree) == \
+            sorted(self.tree1_list + self.tree2_list)
+
+    def test_itermatch(self):
+        imatch = self.ctree.itermatch
+        assert sorted(x.cpvstr for x in imatch(packages.AlwaysTrue)) == \
+            sorted(self.tree1_list + self.tree2_list)
+        p = packages.PackageRestriction("package", values.StrExactMatch("diffball"))
+        assert sorted(x.cpvstr for x in imatch(p)) == \
+            [y for y in sorted(self.tree1_list + self.tree2_list) if "/diffball" in y]
+
+    def test_sorting(self):
+        assert list(x.cpvstr for x in self.ctree.itermatch(packages.AlwaysTrue, sorter=rev_sorted)) == \
+            rev_sorted(self.tree1_list + self.tree2_list)
diff --git a/tests/repository/test_prototype.py b/tests/repository/test_prototype.py
new file mode 100644
index 000000000..1f29c6675
--- /dev/null
+++ b/tests/repository/test_prototype.py
@@ -0,0 +1,231 @@
+from collections import OrderedDict
+from functools import partial
+
+import pytest
+from snakeoil.currying import post_curry
+
+from pkgcore.ebuild.atom import atom
+from pkgcore.ebuild.cpv import VersionedCPV
+from pkgcore.operations.repo import operations
+from pkgcore.package.mutated import MutatedPkg
+from pkgcore.repository.util import SimpleTree
+from pkgcore.restrictions import boolean, packages, values
+from pkgcore.test import malleable_obj
+
+
+class TestPrototype:
+
+    def setup_method(self):
+        # we use an OrderedDict here specifically to trigger any sorter
+        # related bugs
+        d = {
+            "dev-util": {"diffball": ["1.0", "0.7"], "bsdiff": ["0.4.1", "0.4.2"]},
+            "dev-lib": {"fake": ["1.0", "1.0-r1"]}}
+        self.repo = SimpleTree(
+            OrderedDict((k, d[k]) for k in sorted(d, reverse=True)))
+
+    def test_concurrent_access(self):
+        iall = iter(self.repo)
+        self.repo.match(atom("dev-lib/fake"))
+        pkg = next(iall)
+        if pkg.category == 'dev-util':
+            self.repo.match(atom("dev-lib/fake"))
+        else:
+            self.repo.match(atom("dev-util/diffball"))
+        # should not explode...
+        list(iall)
+
+    def test_internal_lookups(self):
+        assert sorted(self.repo.categories) == sorted(["dev-lib", "dev-util"])
+        assert \
+            sorted(map("/".join, self.repo.versions)) == \
+            sorted([x for x in ["dev-util/diffball", "dev-util/bsdiff", "dev-lib/fake"]])
+        assert \
+            sorted(
+                f"{cp[0]}/{cp[1]}-{v}"
+                for cp, t in self.repo.versions.items() for v in t) == \
+            sorted([
+                "dev-util/diffball-1.0", "dev-util/diffball-0.7",
+                "dev-util/bsdiff-0.4.1", "dev-util/bsdiff-0.4.2",
+                "dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"])
+
+    def test_simple_query(self):
+        a = atom("=dev-util/diffball-1.0")
+        self.repo.match(a)
+        assert self.repo.match(a)
+        assert not self.repo.match(atom("dev-util/monkeys_rule"))
+
+    def test_identify_candidates(self):
+        with pytest.raises(TypeError):
+            self.repo.match("asdf")
+        rc = packages.PackageRestriction(
+            "category", values.StrExactMatch("dev-util"))
+        assert \
+            sorted(set(x.package for x in self.repo.itermatch(rc))) == \
+            sorted(["diffball", "bsdiff"])
+        rp = packages.PackageRestriction(
+            "package", values.StrExactMatch("diffball"))
+        assert list(x.version for x in self.repo.itermatch(rp, sorter=sorted)) == ["0.7", "1.0"]
+        assert \
+            self.repo.match(packages.OrRestriction(rc, rp), sorter=sorted) == \
+            sorted(VersionedCPV(x) for x in (
+                "dev-util/diffball-0.7", "dev-util/diffball-1.0",
+                "dev-util/bsdiff-0.4.1", "dev-util/bsdiff-0.4.2"))
+        assert \
+            sorted(self.repo.itermatch(packages.AndRestriction(rc, rp))) == \
+            sorted(VersionedCPV(x) for x in (
+                "dev-util/diffball-0.7", "dev-util/diffball-1.0"))
+        assert sorted(self.repo) == self.repo.match(packages.AlwaysTrue, sorter=sorted)
+        # mix/match cat/pkg to check that it handles that corner case
+        # properly for sorting.
+        assert \
+            sorted(self.repo, reverse=True) == \
+            self.repo.match(packages.OrRestriction(
+                rc, rp, packages.AlwaysTrue),
+                sorter=partial(sorted, reverse=True))
+        rc2 = packages.PackageRestriction(
+            "category", values.StrExactMatch("dev-lib"))
+        assert sorted(self.repo.itermatch(packages.AndRestriction(rp, rc2))) == []
+
+        # note this mixes a category level match, and a pkg level
+        # match. they *must* be treated as an or.
+        assert \
+            sorted(self.repo.itermatch(packages.OrRestriction(rp, rc2))) == \
+            sorted(VersionedCPV(x) for x in (
+                "dev-util/diffball-0.7", "dev-util/diffball-1.0",
+                "dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
+
+        # this is similar to the test above, but mixes a cat/pkg
+        # candidate with a pkg candidate
+        rp2 = packages.PackageRestriction(
+            "package", values.StrExactMatch("fake"))
+        r = packages.OrRestriction(atom("dev-util/diffball"), rp2)
+        assert \
+            sorted(self.repo.itermatch(r)) == \
+            sorted(VersionedCPV(x) for x in (
+                "dev-util/diffball-0.7", "dev-util/diffball-1.0",
+                "dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
+
+        assert \
+            sorted(self.repo.itermatch(
+                packages.OrRestriction(packages.AlwaysTrue, rp2))) == \
+            sorted(VersionedCPV(x) for x in (
+                "dev-util/diffball-0.7", "dev-util/diffball-1.0",
+                "dev-util/bsdiff-0.4.1", "dev-util/bsdiff-0.4.2",
+                "dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
+
+        assert \
+            sorted(self.repo.itermatch(packages.PackageRestriction(
+                'category', values.StrExactMatch('dev-util', negate=True)))) == \
+            sorted(VersionedCPV(x) for x in ("dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
+
+        obj = malleable_obj(livefs=False)
+        pkg_cls = post_curry(MutatedPkg, {'repo': obj})
+        assert \
+            sorted(self.repo.itermatch(boolean.AndRestriction(boolean.OrRestriction(
+                packages.PackageRestriction(
+                    "repo.livefs", values.EqualityMatch(False)),
+                packages.PackageRestriction(
+                    "category", values.StrExactMatch("virtual"))),
+                atom("dev-lib/fake")),
+                pkg_cls=pkg_cls)) == \
+            sorted(VersionedCPV(x) for x in (
+                "dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
+
+        assert \
+            sorted(self.repo.itermatch(packages.PackageRestriction(
+                'category', values.StrExactMatch('dev-lib', negate=True),
+                negate=True))) == \
+            sorted(VersionedCPV(x) for x in (
+                "dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
+
+        assert \
+            sorted(self.repo.itermatch(packages.PackageRestriction(
+                'category', values.StrExactMatch('dev-lib', negate=True), negate=True))) == \
+            sorted(VersionedCPV(x) for x in (
+                "dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
+
+    def test_iter(self):
+        expected = sorted(VersionedCPV(x) for x in (
+            "dev-util/diffball-1.0", "dev-util/diffball-0.7",
+            "dev-util/bsdiff-0.4.1", "dev-util/bsdiff-0.4.2",
+            "dev-lib/fake-1.0", "dev-lib/fake-1.0-r1"))
+        assert sorted(self.repo) == expected
+
+    def test_notify_remove(self):
+        pkg = VersionedCPV("dev-util/diffball-1.0")
+        self.repo.notify_remove_package(pkg)
+        assert list(self.repo.versions[(pkg.category, pkg.package)]) == ["0.7"]
+
+        # test version being emptied, and package updated
+        pkg = VersionedCPV("dev-util/diffball-0.7")
+        self.repo.notify_remove_package(pkg)
+        assert (pkg.category, pkg.package) not in self.repo.versions
+        assert pkg.package not in self.repo.packages[pkg.category]
+
+        # test no remaining packages, category updated
+        pkg = VersionedCPV("dev-util/bsdiff-0.4.1")
+        self.repo.notify_remove_package(pkg)
+
+        pkg = VersionedCPV("dev-util/bsdiff-0.4.2")
+        self.repo.notify_remove_package(pkg)
+        assert (pkg.category, pkg.package) not in self.repo.versions
+        assert pkg.category not in self.repo.packages
+        assert pkg.category not in self.repo.categories
+
+    def test_notify_add(self):
+        pkg = VersionedCPV("dev-util/diffball-1.2")
+        self.repo.notify_add_package(pkg)
+        assert sorted(self.repo.versions[(pkg.category, pkg.package)]) == \
+            sorted(["1.0", "1.2", "0.7"])
+
+        pkg = VersionedCPV("foo/bar-1.0")
+        self.repo.notify_add_package(pkg)
+        assert pkg.category in self.repo.categories
+        assert pkg.category in self.repo.packages
+        ver_key = (pkg.category, pkg.package)
+        assert ver_key in self.repo.versions
+        assert list(self.repo.versions[ver_key]) == ["1.0"]
+
+        pkg = VersionedCPV("foo/cows-1.0")
+        self.repo.notify_add_package(pkg)
+        assert (pkg.category, pkg.package) in self.repo.versions
+
+    def _simple_redirect_test(self, attr, arg1='=dev-util/diffball-1.0', arg2=None):
+        l = []
+        uniq_obj = object()
+
+        def f(*a, **kw):
+            a = a[1:-1]
+            l.extend((a, kw))
+            return uniq_obj
+        # if replace, override _replace since replace reflects to it
+
+        class my_ops(operations):
+            locals()[f'_cmd_implementation_{attr}'] = f
+        self.repo.operations_kls = my_ops
+        args = [self.repo.match(atom(arg1))]
+        if arg2:
+            args.append(VersionedCPV(arg2))
+        self.repo.frozen = False
+        op = getattr(self.repo.operations, attr)
+
+        def simple_check(op, args, **kw):
+            l[:] = []
+            assert op(*args, **kw) == uniq_obj
+            assert len(l) == 2
+            assert list(l[0]) == args
+            assert l
+
+        assert self.repo.operations.supports(attr)
+        simple_check(op, args)
+        assert not l[1]
+        simple_check(op, args)
+        assert 'force' not in l[1]
+        self.repo.frozen = True
+        assert not self.repo.operations.supports(attr)
+        assert not hasattr(self.repo.operations, attr)
+
+    test_replace = post_curry(_simple_redirect_test, 'replace', arg2='dev-util/diffball-1.1')
+    test_uninstall = post_curry(_simple_redirect_test, 'uninstall')
+    test_install = post_curry(_simple_redirect_test, 'install')