resolver/test_*.py: modernize tests to pytest

Signed-off-by: Arthur Zamarin <arthurzam@gentoo.org>

3 files changed, 64 insertions, 74 deletions

diff --git a/tests/resolver/test_choice_point.py b/tests/resolver/test_choice_point.py
index a6a15e3ea..99901952a 100644
--- a/tests/resolver/test_choice_point.py
+++ b/tests/resolver/test_choice_point.py
@@ -1,6 +1,6 @@
+import pytest
 from pkgcore.resolver.choice_point import choice_point
 from pkgcore.restrictions.boolean import AndRestriction, OrRestriction
-from snakeoil.test import TestCase
 
 
 class fake_package:
@@ -17,11 +17,11 @@ class fake_package:
                 ("marker", None)):
             setattr(self, k, kwds.get(k, v))
 
-class TestChoicePoint(TestCase):
+class TestChoicePoint:
 
     @staticmethod
     def gen_choice_point():
-        return choice_point("asdf", [
+        return choice_point("asdf", (
             fake_package(marker=1, depend=OrRestriction(
                         "ordep1", "ordep2", "dependordep"),
                 rdepend=AndRestriction(
@@ -31,53 +31,52 @@ class TestChoicePoint(TestCase):
             fake_package(marker=2, depend=AndRestriction(
                         "anddep1", "anddep2"),
                 rdepend=OrRestriction("or1", "or2"),
-                pdepend=OrRestriction("prdep1", "or3"))])
+                pdepend=OrRestriction("prdep1", "or3"))))
 
     def test_depend_rdepend_stepping(self):
         c = self.gen_choice_point()
-        self.assertEqual(c.depend, [["ordep1", "ordep2", "dependordep"]])
-        self.assertEqual(
-            sorted(c.rdepend),
-            sorted([['anddep1'], ['anddep2'], ['ordep1', 'andordep2'],
-                    ['pkg1and']]))
+        assert c.depend == [["ordep1", "ordep2", "dependordep"]]
+        assert sorted(c.rdepend) == sorted([['anddep1'], ['anddep2'], ['ordep1', 'andordep2'], ['pkg1and']])
         c.reduce_atoms("ordep1")
-        self.assertEqual(c.depend, [['ordep2', 'dependordep']])
-        self.assertEqual(
-            sorted(c.rdepend),
-            sorted([['anddep1'], ['anddep2'], ['andordep2'], ['pkg1and']]))
+        assert c.depend == [['ordep2', 'dependordep']]
+        assert sorted(c.rdepend) == sorted([['anddep1'], ['anddep2'], ['andordep2'], ['pkg1and']])
         c.reduce_atoms("pkg1and")
         c.reduce_atoms("or1")
-        self.assertEqual(c.rdepend, [["or2"]])
+        assert c.rdepend == [["or2"]]
         c.reduce_atoms("prdep1")
-        self.assertEqual(c.depend, [['anddep1'], ['anddep2']])
-        self.assertEqual(c.pdepend, [["or3"]])
+        assert c.depend == [['anddep1'], ['anddep2']]
+        assert c.pdepend == [["or3"]]
         c.reduce_atoms("or3")
-        self.assertRaises(IndexError, lambda: c.depend)
+        with pytest.raises(IndexError):
+            c.depend
 
     def test_current_pkg(self):
         c = self.gen_choice_point()
-        self.assertEqual(c.current_pkg.marker, 1)
+        assert c.current_pkg.marker == 1
         c.reduce_atoms("pkg1and")
-        self.assertEqual(c.current_pkg.marker, 2)
+        assert c.current_pkg.marker == 2
 
     def test_reduce(self):
         c = self.gen_choice_point()
-        self.assertEqual(c.current_pkg.marker, 1)
-        self.assertEqual(c.reduce_atoms("dependordep"), False)
-        self.assertEqual(c.reduce_atoms("ordep2"), False)
-        self.assertEqual(c.reduce_atoms("ordep1"), True)
-        self.assertEqual(c.current_pkg.marker, 2)
+        assert c.current_pkg.marker == 1
+        assert not c.reduce_atoms("dependordep")
+        assert not c.reduce_atoms("ordep2")
+        assert c.reduce_atoms("ordep1")
+        assert c.current_pkg.marker == 2
         c = self.gen_choice_point()
-        self.assertEqual(c.reduce_atoms("anddep2"), True)
+        assert c.reduce_atoms("anddep2")
         c = self.gen_choice_point()
         c.reduce_atoms("anddep1")
-        self.assertRaises(IndexError, lambda: c.depend)
-        self.assertRaises(IndexError, lambda: c.rdepend)
-        self.assertRaises(IndexError, lambda: c.pdepend)
+        with pytest.raises(IndexError):
+            c.depend
+        with pytest.raises(IndexError):
+            c.rdepend
+        with pytest.raises(IndexError):
+            c.pdepend
 
     def test_nonzero(self):
         c = self.gen_choice_point()
-        self.assertEqual(bool(c), True)
-        self.assertEqual(c.current_pkg.marker, 1)
+        assert bool(c)
+        assert c.current_pkg.marker == 1
         c.reduce_atoms("anddep1")
-        self.assertEqual(bool(c), False)
+        assert not bool(c)
diff --git a/tests/resolver/test_pigeonholes.py b/tests/resolver/test_pigeonholes.py
index 817f85541..480ad3fb4 100644
--- a/tests/resolver/test_pigeonholes.py
+++ b/tests/resolver/test_pigeonholes.py
@@ -1,6 +1,6 @@
+import pytest
 from pkgcore.resolver.pigeonholes import PigeonHoledSlots
 from pkgcore.restrictions import restriction
-from snakeoil.test import TestCase
 
 from .test_choice_point import fake_package
 
@@ -20,43 +20,43 @@ class fake_blocker(restriction.base):
         return f"fake_atom({self.key}, {self.blocks})"
 
     def match(self, obj):
-        for x in self.blocks:
-            if x is obj:
-                return True
-        return False
+        return any(x is obj for x in self.blocks)
 
-class SlotTesting(TestCase):
+
+class TestSlot:
 
     def test_add(self):
         c = PigeonHoledSlots()
         o = fake_package()
-        self.assertEqual([], c.fill_slotting(o))
+        assert not c.fill_slotting(o)
         # test that it doesn't invalidly block o when (innefficiently)
         # doing a re-add
-        self.assertEqual([o], c.fill_slotting(o))
-        self.assertEqual([o], c.fill_slotting(fake_package()))
-        self.assertFalse(c.fill_slotting(fake_package(slot=1, key=1)))
+        assert c.fill_slotting(o) == [o]
+        assert c.fill_slotting(fake_package()) == [o]
+        assert not c.fill_slotting(fake_package(slot=1, key=1))
 
     def test_add_limiter(self):
         c = PigeonHoledSlots()
         p = fake_package()
         o = fake_blocker(None, p)
-        self.assertFalse([], c.fill_slotting(p))
-        self.assertEqual([p], c.add_limiter(o))
+        assert not c.fill_slotting(p)
+        assert c.add_limiter(o) == [p]
         c.remove_slotting(p)
-        self.assertEqual([o], c.fill_slotting(p))
+        assert c.fill_slotting(p) == [o]
         # note we're doing 'is' tests in fake_blocker
-        self.assertFalse([], c.fill_slotting(fake_package()))
+        assert not c.fill_slotting(fake_package())
 
     def test_remove_slotting(self):
         c = PigeonHoledSlots()
         p, p2 = fake_package(), fake_package(slot=2)
         o = fake_blocker(None, p)
-        self.assertFalse([], c.add_limiter(o))
+        assert not c.add_limiter(o)
         c.remove_limiter(o)
-        self.assertRaises(KeyError, c.remove_slotting, o)
-        self.assertRaises(KeyError, c.remove_limiter, o)
-        self.assertFalse([], c.fill_slotting(p))
-        self.assertFalse([], c.fill_slotting(p2))
+        with pytest.raises(KeyError):
+            c.remove_slotting(o)
+        with pytest.raises(KeyError):
+            c.remove_limiter(o)
+        assert not c.fill_slotting(p)
+        assert not c.fill_slotting(p2)
         c.remove_slotting(p)
         c.remove_slotting(p2)
diff --git a/tests/resolver/test_plan.py b/tests/resolver/test_plan.py
index 95c43d809..a84929b21 100644
--- a/tests/resolver/test_plan.py
+++ b/tests/resolver/test_plan.py
@@ -1,28 +1,19 @@
+import pytest
 from pkgcore.resolver import plan
 from pkgcore.test.misc import FakePkg
-from snakeoil.currying import post_curry
-from snakeoil.test import TestCase
 
 
-class TestPkgSorting(TestCase):
-
-    def check_it(self, sorter, vers, expected, iter_sort_target=False):
-        pkgs = [FakePkg(f"d-b/a-{x}") for x in vers]
-        if iter_sort_target:
-            pkgs = [[x, []] for x in pkgs]
-        pkgs = list(sorter(pkgs))
-        if iter_sort_target:
-            pkgs = [x[0] for x in pkgs]
-        self.assertEqual([int(x.fullver) for x in pkgs], expected)
-
-    test_highest_iter_sort = post_curry(check_it, plan.highest_iter_sort,
-        [7,9,3,2], [9,7,3,2], True)
-
-    test_lowest_iter_sort = post_curry(check_it, plan.lowest_iter_sort,
-        [7,9,4,2], [2,4,7,9], True)
-
-    test_pkg_sort_highest = post_curry(check_it, plan.pkg_sort_highest,
-        [1,9,7,10], [10,9,7,1])
-
-    test_pkg_sort_lowest = post_curry(check_it, plan.pkg_sort_lowest,
-        [11,9,1,6], [1,6,9,11])
+@pytest.mark.parametrize(("sorter", "vers", "expected", "iter_sort_target"), (
+    pytest.param(plan.highest_iter_sort, [7,9,3,2], [9,7,3,2], True, id="highest iter"),
+    pytest.param(plan.lowest_iter_sort, [7,9,4,2], [2,4,7,9], True, id="lowest iter"),
+    pytest.param(plan.pkg_sort_highest, [1,9,7,10], [10,9,7,1], False, id="pkg highest"),
+    pytest.param(plan.pkg_sort_lowest, [11,9,1,6], [1,6,9,11], False, id="pkg lowest"),
+))
+def test_pkg_sorting(sorter, vers, expected, iter_sort_target):
+    pkgs = [FakePkg(f"d-b/a-{x}") for x in vers]
+    if iter_sort_target:
+        pkgs = [[x, []] for x in pkgs]
+    pkgs = list(sorter(pkgs))
+    if iter_sort_target:
+        pkgs = [x[0] for x in pkgs]
+    assert [int(x.fullver) for x in pkgs] == expected