test/**.py: modernize tests to pytest

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

7 files changed, 482 insertions, 542 deletions

diff --git a/tests/cache/test_base.py b/tests/cache/test_base.py
index 4ed852b1a..6b3fdc22f 100644
--- a/tests/cache/test_base.py
+++ b/tests/cache/test_base.py
@@ -79,7 +79,7 @@ class DictCacheBulk(bulk):
         return iter(self._data.keys())
 
 
-class BaseTest:
+class TestBase:
 
     cache_keys = ("foo", "_eclasses_")
 
@@ -178,7 +178,7 @@ class BaseTest:
         assert len(tracker) == 3
 
 
-class TestBulk(BaseTest):
+class TestBulk(TestBase):
 
     def get_db(self, readonly=False):
         return DictCacheBulk(auxdbkeys=self.cache_keys,
diff --git a/tests/ebuild/test_digest.py b/tests/ebuild/test_digest.py
index 8163bc3c7..86d32e471 100644
--- a/tests/ebuild/test_digest.py
+++ b/tests/ebuild/test_digest.py
@@ -4,7 +4,6 @@ import tempfile
 from pkgcore import gpg
 from pkgcore.ebuild import digest
 from snakeoil.data_source import local_source
-from snakeoil.test import TestCase
 
 # "Line too long" (and our custom more aggressive version of that)
 # pylint: disable-msg=C0301,CPC01
@@ -49,7 +48,7 @@ for x in pure_manifest2.split("\n"):
     del chksum, l, i
 
 
-class TestManifest(TestCase):
+class TestManifest:
 
     convert_source = staticmethod(lambda x:x)
 
@@ -78,11 +77,11 @@ class TestManifest(TestCase):
         for dtype, d in (("DIST", dist), ("AUX", aux),
             ("EBUILD", ebuild), ("MISC", misc)):
             req_d = pure_manifest2_chksums[dtype]
-            self.assertEqual(sorted(req_d), sorted(d))
+            assert set(req_d) == set(d)
             for k, v in req_d.items():
                 i1 = sorted(v)
                 i2 = sorted(d[k].items())
-                self.assertEqual(i1, i2, msg="{i1!r} != {i2!r}\nfor {dtype} {k}")
+                assert i1 == i2
 
 
 class TestManifestDataSource(TestManifest):
diff --git a/tests/ebuild/test_filter_env.py b/tests/ebuild/test_filter_env.py
index 0fbb49ec6..89d91f5c2 100644
--- a/tests/ebuild/test_filter_env.py
+++ b/tests/ebuild/test_filter_env.py
@@ -1,13 +1,11 @@
 import io
-from functools import partial
+import textwrap
 
-from pkgcore.ebuild import filter_env
-from snakeoil.test import TestCase
+import pytest
+from pkgcore.ebuild.filter_env import main_run
 
 
-class TestFilterEnv(TestCase):
-
-    filter_env = staticmethod(partial(filter_env.main_run))
+class TestFilterEnv:
 
     def get_output(self, raw_data, funcs=None, vars=None, preserve_funcs=False,
                    preserve_vars=False, debug=False, global_envvar_callback=None):
@@ -16,230 +14,211 @@ class TestFilterEnv(TestCase):
             funcs = funcs.split(',')
         if vars:
             vars = vars.split(',')
-        self.filter_env(out, raw_data, vars, funcs, preserve_vars, preserve_funcs,
+        main_run(out, raw_data, vars, funcs, preserve_vars, preserve_funcs,
             global_envvar_callback=global_envvar_callback)
         return out.getvalue().decode('utf-8')
 
     def test_function_foo(self):
         ret = ''.join(self.get_output("function foo() {:;}", funcs="foo"))
-        self.assertEqual(ret, '')
+        assert ret == ''
         ret = ''.join(self.get_output("functionfoo() {:;}", funcs="foo"))
-        self.assertEqual(ret, 'functionfoo() {:;}')
+        assert ret == 'functionfoo() {:;}'
 
     def test_simple(self):
-        data = \
-"""
-foo() {
-    :
-}
-
-bar() {
-    :
-}
-"""
+        data = textwrap.dedent("""\
+            foo() {
+                :
+            }
+
+            bar() {
+                :
+            }
+        """)
         ret = ''.join(self.get_output(data))
-        self.assertIn('foo', ret)
-        self.assertIn('bar', ret)
+        assert 'foo' in ret
+        assert 'bar' in ret
         ret = ''.join(self.get_output(data, funcs='foo'))
-        self.assertNotIn('foo', ret)
-        self.assertIn('bar', ret)
+        assert 'foo' not in ret
+        assert 'bar' in ret
         ret = ''.join(self.get_output(data, funcs='bar'))
-        self.assertIn('foo', ret)
-        self.assertNotIn('bar', ret)
+        assert 'foo' in ret
+        assert 'bar' not in ret
         ret = ''.join(self.get_output(data, funcs='bar,foo'))
-        self.assertNotIn('foo', ret)
-        self.assertNotIn('bar', ret)
+        assert 'foo' not in ret
+        assert 'bar' not in ret
 
     def test1(self):
-        data = \
-"""
-MODULE_NAMES=${MODULE_NAMES//${i}(*};
-tc-arch ()
-{
-    tc-ninja_magic_to_arch portage $@
-}
-"""
+        data = textwrap.dedent("""\
+            MODULE_NAMES=${MODULE_NAMES//${i}(*};
+            tc-arch ()
+            {
+                tc-ninja_magic_to_arch portage $@
+            }
+        """)
         ret = ''.join(self.get_output(data, vars='MODULE_NAMES'))
-        self.assertNotIn('MODULE_NAMES', ret)
-        self.assertIn('tc-arch', ret)
+        assert 'MODULE_NAMES' not in ret
+        assert 'tc-arch' in ret
 
     def test_comments(self):
         data = "dar=${yar##.%}\nfoo() {\n:\n}\n"
         ret = ''.join(self.get_output(data, vars='dar'))
-        self.assertNotIn('dar', ret)
-        self.assertIn('foo', ret)
-
-        data = \
-"""
-src_unpack() {
-    use idn && {
-       # BIND 9.4.0 doesn't have this patch
-       :
-    }
-}
-
-src_compile() {
-    :
-}
-"""
-        self.assertIn('src_unpack', ''.join(
-            self.get_output(data, funcs='src_compile')))
+        assert 'dar' not in ret
+        assert 'foo' in ret
+
+        data = textwrap.dedent("""\
+            src_unpack() {
+                use idn && {
+                # BIND 9.4.0 doesn't have this patch
+                :
+                }
+            }
+
+            src_compile() {
+                :
+            }
+        """)
+        assert 'src_unpack' in ''.join(self.get_output(data, funcs='src_compile'))
         ret = ''.join(self.get_output(data, funcs='src_unpack'))
-        self.assertIn('src_compile', ret)
-        self.assertNotIn('src_unpack', ret)
-        data = \
-"""src_install() {
-    local -f ${f##*=}
-}
-
-pkg_postinst() {
-    :
-}
-"""
-        self.assertNotIn('pkg_postinst',
-            ''.join(self.get_output(data, funcs='pkg_postinst')))
-        data = \
-"""src_unpack() {
-    fnames=$(scanelf -pyqs__uClibc_start_main -F%F#s)
-}
-src_compile() {
-    :
-}
-"""
-        self.assertIn('src_compile',
-            ''.join(self.get_output(data, funcs='src_unpack')))
-
-        data = \
-"""findtclver() {
-    [ "$(#i)" = "3" ]
-}
-
-pkg_setup() {
-    :
-}
-"""
-        self.assertIn('pkg_setup',
-            ''.join(self.get_output(data, funcs='findtclver')))
+        assert 'src_compile' in ret
+        assert 'src_unpack' not in ret
+        data = textwrap.dedent("""\
+            src_install() {
+                local -f ${f##*=}
+            }
+
+            pkg_postinst() {
+                :
+            }
+        """)
+        assert 'pkg_postinst' not in ''.join(self.get_output(data, funcs='pkg_postinst'))
+        data = textwrap.dedent("""\
+            src_unpack() {
+                fnames=$(scanelf -pyqs__uClibc_start_main -F%F#s)
+            }
+            src_compile() {
+                :
+            }
+        """)
+        assert 'src_compile' in ''.join(self.get_output(data, funcs='src_unpack'))
+
+        data = textwrap.dedent("""\
+            findtclver() {
+                [ "$(#i)" = "3" ]
+            }
+
+            pkg_setup() {
+                :
+            }
+        """)
+        assert 'pkg_setup' in ''.join(self.get_output(data, funcs='findtclver'))
 
     def test_here(self):
-        data = \
-"""
-src_install() {
-    cat >${D}/etc/modules.d/davfs2 <<EOF
-alias char-major-67 coda
-alias /dev/davfs*   coda
-EOF
-}
-
-pkg_setup() {
-    :
-}
-"""
-        self.assertNotIn('pkg_setup', ''.join(self.get_output(data,
-            funcs='pkg_setup')))
-
-        data = \
-"""
-pkg_setup() {
-        while read line; do elog "${line}"; done <<EOF
-The default behaviour of tcsh has significantly changed starting from
-version 6.14-r1.  In contrast to previous ebuilds, the amount of
-customisation to the default shell's behaviour has been reduced to a
-bare minimum (a customised prompt).
-If you rely on the customisations provided by previous ebuilds, you will
-have to copy over the relevant (now commented out) parts to your own
-~/.tcshrc.  Please check all tcsh-* files in
-/usr/share/doc/${P}/examples/ and include their behaviour in your own
-configuration files.
-The tcsh-complete file is not any longer sourced by the default system
-scripts.
-EOF
-}
-
-pkg_foo() {
-    :
-}
-"""
-        self.assertNotIn('pkg_foo', ''.join(self.get_output(data,
-            funcs='pkg_foo')))
+        data = textwrap.dedent("""\
+            src_install() {
+                cat >${D}/etc/modules.d/davfs2 <<EOF
+            alias char-major-67 coda
+            alias /dev/davfs*   coda
+            EOF
+            }
+
+            pkg_setup() {
+                :
+            }
+        """)
+        assert 'pkg_setup' not in ''.join(self.get_output(data, funcs='pkg_setup'))
+
+        data = textwrap.dedent("""\
+            pkg_setup() {
+                    while read line; do elog "${line}"; done <<EOF
+            The default behaviour of tcsh has significantly changed starting from
+            version 6.14-r1.  In contrast to previous ebuilds, the amount of
+            customisation to the default shell's behaviour has been reduced to a
+            bare minimum (a customised prompt).
+            If you rely on the customisations provided by previous ebuilds, you will
+            have to copy over the relevant (now commented out) parts to your own
+            ~/.tcshrc.  Please check all tcsh-* files in
+            /usr/share/doc/${P}/examples/ and include their behaviour in your own
+            configuration files.
+            The tcsh-complete file is not any longer sourced by the default system
+            scripts.
+            EOF
+            }
+
+            pkg_foo() {
+                :
+            }
+        """)
+        assert 'pkg_foo' not in ''.join(self.get_output(data, funcs='pkg_foo'))
 
     def test_vars(self):
-        data = \
-"""
-f() {
-    x=$y
-}
-
-z() {
-    :
-}
-"""
-        self.assertIn('z', ''.join(self.get_output(data,
-            funcs='f')))
-
-        data = \
-"""
-f() {
-    x="${y}"
-}
-
-z() {
-    :
-}
-"""
-        self.assertIn('z', ''.join(self.get_output(data,
-            funcs='f')))
-
-        data = \
-"""src_compile() {
-    $(ABI=foo get_libdir)
-}
-
-pkg_setup() {
-    :
-}
-"""
-        self.assertIn('pkg_setup', ''.join(self.get_output(data,
-            funcs='src_compile')))
+        data = textwrap.dedent("""\
+            f() {
+                x=$y
+            }
+
+            z() {
+                :
+            }
+        """)
+        assert 'z' in ''.join(self.get_output(data, funcs='f'))
+
+        data = textwrap.dedent("""\
+            f() {
+                x="${y}"
+            }
+
+            z() {
+                :
+            }
+        """)
+        assert 'z' in ''.join(self.get_output(data, funcs='f'))
+
+        data = textwrap.dedent("""\
+            src_compile() {
+                $(ABI=foo get_libdir)
+            }
+
+            pkg_setup() {
+                :
+            }
+        """)
+        assert 'pkg_setup' in ''.join(self.get_output(data, funcs='src_compile'))
 
     def test_quoting(self):
-        data = \
-"""
-pkg_postinst() {
-    einfo " /bin/ls ${ROOT}etc/init.d/net.* | grep -v '/net.lo$' | xargs -n1 ln -sfvn net.lo"
-}
-
-pkg_setup() {
-    :
-}
-"""
-        self.assertIn('pkg_setup', ''.join(self.get_output(data,
-            funcs='pkg_postinst')))
-
-        data = \
-"""src_unpack() {
-    testExp=$'\177\105\114\106\001\001\001'
-}
-
-src_install() {
-    :
-}
-"""
-        self.assertIn('src_install', ''.join(self.get_output(data,
-            funcs='src_unpack')))
+        data = textwrap.dedent("""\
+            pkg_postinst() {
+                einfo " /bin/ls ${ROOT}etc/init.d/net.* | grep -v '/net.lo$' | xargs -n1 ln -sfvn net.lo"
+            }
+
+            pkg_setup() {
+                :
+            }
+        """)
+        assert 'pkg_setup' in ''.join(self.get_output(data, funcs='pkg_postinst'))
+
+        data = textwrap.dedent("""\
+            src_unpack() {
+                testExp=$'\177\105\114\106\001\001\001'
+            }
+
+            src_install() {
+                :
+            }
+        """)
+        assert 'src_install' in ''.join(self.get_output(data, funcs='src_unpack'))
 
     def test_arg_awareness(self):
         data = "f() {\n x \\{}\n}\n"
-        self.assertNotIn('}', ''.join(self.get_output(data, 'f')))
-
-    def test_print_vars(self):
-        def assertVars(data, var_list, assert_func=self.assertEqual):
-            l = []
-            self.get_output(data, global_envvar_callback=l.append)
-            assert_func(sorted(var_list), sorted(l))
-        assertVars("f(){\nX=dar\n}", [])
-        assertVars("f(){\nX=dar\n}\nY=a", ['Y'])
-        assertVars("f(){\nX=dar\n}\nmy command\nY=a\nf=$(dar)", ['Y', 'f'])
-        assertVars("f(){\nX=dar\n}\nmy command\nY=a\nf=$(dar) foon\n", ['Y'],
-            self.assertNotEqual)
-        assertVars("f(){\nX=dar foon\n}\nY=dar\nf2(){Z=dar;}\n", ['Y'])
+        assert '}' not in ''.join(self.get_output(data, 'f'))
+
+    @pytest.mark.parametrize(("data", "var_list"), (
+        ("f(){\nX=dar\n}", set()),
+        ("f(){\nX=dar\n}\nY=a", {'Y'}),
+        ("f(){\nX=dar\n}\nmy command\nY=a\nf=$(dar)", {'Y', 'f'}),
+        ("f(){\nX=dar\n}\nmy command\nY=a\nf=$(dar) foon\n", {'Y', 'f'}),
+        ("f(){\nX=dar foon\n}\nY=dar\nf2(){Z=dar;}\n", {'Y'})
+    ))
+    def test_print_vars(self, data, var_list):
+        l = set()
+        self.get_output(data, global_envvar_callback=l.add)
+        assert var_list == l
diff --git a/tests/ebuild/test_formatter.py b/tests/ebuild/test_formatter.py
index 3b406173c..ec897b2ce 100644
--- a/tests/ebuild/test_formatter.py
+++ b/tests/ebuild/test_formatter.py
@@ -1,9 +1,6 @@
-import difflib
-
 from pkgcore.ebuild.atom import atom
 from pkgcore.ebuild.formatter import BasicFormatter, PkgcoreFormatter, PortageFormatter
 from pkgcore.test.misc import FakePkg, FakeRepo
-from snakeoil.test import TestCase
 from snakeoil.test.argparse_helpers import Bold, Color, FakeStreamFormatter, Reset
 
 
@@ -35,7 +32,8 @@ class FakeOp:
 class BaseFormatterTest:
     prefix = ()
     suffix = ('\n',)
-    def setUp(self):
+
+    def setup_method(self):
         self.fakeout = FakeStreamFormatter()
         self.fakeerr = FakeStreamFormatter()
         self.formatter = self.newFormatter()
@@ -47,14 +45,12 @@ class BaseFormatterTest:
                 autoline = self.fakeout.autoline
                 try:
                     ret = self.formatterClass.format(internal_self, *args, **kwds)
-                except Exception as e:
-                    self.assertEqual(
-                        autoline, self.fakeout.autoline,
-                        msg="exception thrown {e}, autoline was {autoline}, now is {self.fakeout.autoline}")
+                except Exception as exc:
+                    assert autoline == self.fakeout.autoline, \
+                        f"exception thrown {exc}, autoline was {autoline}, now is {self.fakeout.autoline}"
                     raise
-                self.assertEqual(
-                    autoline, self.fakeout.autoline,
-                    msg="autoline was {autoline}, now is {self.fakeout.autoline}")
+                assert autoline == self.fakeout.autoline, \
+                    f"autoline was {autoline}, now is {self.fakeout.autoline}"
                 return ret
         return state_verifying_class
 
@@ -70,12 +66,12 @@ class BaseFormatterTest:
 
     def assertOut(self, *args, **kwargs):
 
-        stringlist = []
-        objectlist = []
+        strings = []
+        objects = []
 
         args = list(args)
 
-        prefix = kwargs.setdefault("prefix", self.prefix)
+        prefix = kwargs.get("prefix", self.prefix)
         if isinstance(prefix, tuple):
             args = list(prefix) + args
         elif isinstance(prefix, list):
@@ -83,7 +79,7 @@ class BaseFormatterTest:
         else:
             args.insert(0, prefix)
 
-        suffix = kwargs.setdefault("suffix", self.suffix)
+        suffix = kwargs.get("suffix", self.suffix)
         if isinstance(suffix, tuple):
             args = args + list(suffix)
         elif isinstance(suffix, list):
@@ -93,24 +89,20 @@ class BaseFormatterTest:
 
         for arg in args:
             if isinstance(arg, str):
-                stringlist.append(arg.encode('ascii'))
+                strings.append(arg.encode('utf-8'))
             elif isinstance(arg, bytes):
-                stringlist.append(arg)
+                strings.append(arg)
             else:
-                objectlist.append(b''.join(stringlist))
-                stringlist = []
-                objectlist.append(arg)
-        objectlist.append(b''.join(stringlist))
+                objects.append(b''.join(strings))
+                strings = []
+                objects.append(arg)
+        objects.append(b''.join(strings))
 
         # Hack because a list with an empty string in is True
-        if objectlist == [b'']:
-            objectlist = []
-
-        self.assertEqual(self.fakeout.stream, objectlist, '\n' + '\n'.join(
-                difflib.unified_diff(
-                    list(repr(s) for s in objectlist),
-                    list(repr(s) for s in self.fakeout.stream),
-                    'expected', 'actual', lineterm='')))
+        if objects == [b'']:
+            objects = []
+
+        assert self.fakeout.stream == objects
         self.fakeout.resetstream()
 
     def test_end(self):
@@ -121,7 +113,7 @@ class BaseFormatterTest:
         self.assertOut(suffix=())
 
 
-class TestBasicFormatter(BaseFormatterTest, TestCase):
+class TestBasicFormatter(BaseFormatterTest):
 
     formatterClass = BasicFormatter
 
@@ -137,7 +129,7 @@ class TestBasicFormatter(BaseFormatterTest, TestCase):
         self.assertOut('app-arch/bzip2')
 
 
-class TestPkgcoreFormatter(BaseFormatterTest, TestCase):
+class TestPkgcoreFormatter(BaseFormatterTest):
 
     formatterClass = PkgcoreFormatter
 
@@ -175,12 +167,12 @@ class CountingFormatterTest(BaseFormatterTest):
 
     def newFormatter(self, **kwargs):
         kwargs.setdefault('verbosity', 1)
-        return BaseFormatterTest.newFormatter(self, **kwargs)
+        return super().newFormatter(**kwargs)
 
     def assertEnd(self, *args, **kwargs):
         kwargs.setdefault('prefix', self.endprefix)
         kwargs.setdefault('suffix', self.endsuffix)
-        BaseFormatterTest.assertOut(self, *args, **kwargs)
+        super().assertOut(*args, **kwargs)
 
     def test_end(self):
         self.formatter.end()
@@ -295,11 +287,11 @@ class CountingFormatterTest(BaseFormatterTest):
             '\nTotal: 5 packages (1 new, 1 upgrade, 1 downgrade, 1 in new slot, 1 reinstall)')
 
 
-class TestPortageFormatter(BaseFormatterTest, TestCase):
+class TestPortageFormatter(BaseFormatterTest):
 
     formatterClass = PortageFormatter
 
-    def setUp(self):
+    def setup_method(self):
         pkg = FakeMutatedPkg('app-arch/bzip2-1.0.1-r1', slot='0')
         masked_atom = atom('>=app-arch/bzip2-2.0')
         self.domain_settings = {"ACCEPT_KEYWORDS": ("amd64",)}
@@ -310,12 +302,12 @@ class TestPortageFormatter(BaseFormatterTest, TestCase):
             repo_id='repo2', location='/var/gentoo/repos/repo2',
             domain_settings=self.domain_settings)
         self.vdb = FakeRepo(repo_id='vdb', pkgs=[pkg])
-        BaseFormatterTest.setUp(self)
+        super().setup_method()
 
     def newFormatter(self, **kwargs):
         kwargs.setdefault('quiet_repo_display', False)
         kwargs.setdefault('installed_repos', self.vdb)
-        return BaseFormatterTest.newFormatter(self, **kwargs)
+        return super().newFormatter(**kwargs)
 
     def repo_id(self, repo):
         if getattr(self.formatter, 'verbosity', 0):
@@ -583,7 +575,7 @@ class TestPortageVerboseFormatter(TestPortageFormatter):
     def newFormatter(self, **kwargs):
         kwargs.setdefault("verbosity", 1)
         kwargs.setdefault("unstable_arch", "~amd64")
-        return TestPortageFormatter.newFormatter(self, **kwargs)
+        return super().newFormatter(**kwargs)
 
     def test_install_symbol_unkeyworded(self):
         self.formatter.format(
@@ -751,14 +743,14 @@ class TestPortageVerboseFormatter(TestPortageFormatter):
 class TestPortageVerboseRepoIdFormatter(TestPortageVerboseFormatter):
     suffix = [Color("fg", "cyan"), ' [1]\n']
 
-    def setUp(self):
-        TestPortageVerboseFormatter.setUp(self)
+    def setup_method(self):
+        super().setup_method()
         self.repo3 = FakeRepo(
             location='/var/gentoo/repos/repo3', domain_settings=self.domain_settings)
 
     def newFormatter(self, **kwargs):
         kwargs.setdefault("quiet_repo_display", True)
-        return TestPortageVerboseFormatter.newFormatter(self, **kwargs)
+        return super().newFormatter(**kwargs)
 
     def repo_id(self, repo):
         return ''
diff --git a/tests/fetch/test_init.py b/tests/fetch/test_init.py
index 554dc6f7a..7f69fe150 100644
--- a/tests/fetch/test_init.py
+++ b/tests/fetch/test_init.py
@@ -1,67 +1,60 @@
+import pytest
+
 from pkgcore import fetch
 from snakeoil.sequences import iflatten_instance
-from snakeoil.test import TestCase
-
 
-class base(TestCase):
 
-    def assertUri(self, obj, uri):
-        uri = list(uri)
-        self.assertEqual(list(iflatten_instance(obj)), uri)
-        if uri:
-            self.assertTrue(obj)
-        else:
-            self.assertFalse(obj)
+def assert_uri(obj, uri):
+    uri = list(uri)
+    assert list(iflatten_instance(obj)) == uri
+    assert bool(uri) == bool(obj)
 
 
-class TestFetchable(base):
+class TestFetchable:
 
     def test_init(self):
         o = fetch.fetchable("dar", uri=["asdf"], chksums={"asdf":1})
-        self.assertEqual(o.filename, "dar")
-        self.assertUri(o.uri, ["asdf"])
-        self.assertEqual(o.chksums, {"asdf":1})
+        assert o.filename == "dar"
+        assert_uri(o.uri, ["asdf"])
+        assert o.chksums == {"asdf":1}
 
     def test_eq_ne(self):
         o1 = fetch.fetchable("dar", uri=["asdf"], chksums={"asdf":1})
-        self.assertEqual(o1, o1)
+        assert o1 == o1
         o2 = fetch.fetchable("dar", uri=["asdf"], chksums={"asdf":1})
-        self.assertEqual(o1, o2)
-        self.assertNotEqual(o1,
-            fetch.fetchable("dar1", uri=["asdf"], chksums={"asdf":1}))
-        self.assertNotEqual(o1,
-            fetch.fetchable("dar", uri=["asdf1"], chksums={"asdf":1}))
-        self.assertNotEqual(o1,
-            fetch.fetchable("dar", uri=["asdf1"], chksums={"asdf":1, "foon":1}))
+        assert o1 == o2
+        assert o1 != fetch.fetchable("dar1", uri=["asdf"], chksums={"asdf":1})
+        assert o1 != fetch.fetchable("dar", uri=["asdf1"], chksums={"asdf":1})
+        assert o1 != fetch.fetchable("dar", uri=["asdf1"], chksums={"asdf":1, "foon":1})
 
 
-class TestMirror(base):
+class TestMirror:
 
     kls = fetch.mirror
-
     default_mirrors = ["http://foon", "ftp://spoon"]
-    def setUp(self):
-        self.mirror = self.kls(self.default_mirrors, "fork")
 
-    def test_init(self):
-        self.assertEqual(self.mirror.mirror_name, "fork")
+    @pytest.fixture
+    def mirror(self):
+        return self.kls(self.default_mirrors, "fork")
+
+    def test_init(self, mirror):
+        assert mirror.mirror_name == "fork"
         # explicit test should any tuple like sequence show up
-        self.assertInstance(self.mirror.mirrors, tuple)
-        self.assertEqual(self.mirror.mirrors, tuple(self.default_mirrors))
+        assert isinstance(mirror.mirrors, tuple)
+        assert mirror.mirrors == tuple(self.default_mirrors)
 
-    def test_iter(self):
-        self.assertEqual(list(self.mirror), self.default_mirrors)
+    def test_iter(self, mirror):
+        assert list(mirror) == self.default_mirrors
 
-    def test_len(self):
-        self.assertEqual(len(self.mirror), len(self.default_mirrors))
+    def test_len(self, mirror):
+        assert len(mirror) == len(self.default_mirrors)
 
-    def test_getitem(self):
-        self.assertEqual(self.mirror[1], self.default_mirrors[1])
+    def test_getitem(self, mirror):
+        assert mirror[1] == self.default_mirrors[1]
 
-    def test_eq_ne(self):
-        self.assertEqual(self.mirror, self.kls(self.default_mirrors, 'fork'))
-        self.assertNotEqual(self.mirror,
-            self.kls(self.default_mirrors + ['http://fark'], 'fork'))
+    def test_eq_ne(self, mirror):
+        assert mirror == self.kls(self.default_mirrors, 'fork')
+        assert mirror != self.kls(self.default_mirrors + ['http://fark'], 'fork')
 
 
 class TestDefaultMirror(TestMirror):
@@ -69,10 +62,11 @@ class TestDefaultMirror(TestMirror):
     kls = fetch.default_mirror
 
 
-class Test_uri_list(base):
+class Test_uri_list:
 
-    def setUp(self):
-        self.uril = fetch.uri_list("cows")
+    @pytest.fixture
+    def uril(self):
+        return fetch.uri_list("cows")
 
     @staticmethod
     def mk_uri_list(*iterable, **kwds):
@@ -85,36 +79,37 @@ class Test_uri_list(base):
                 obj.add_uri(x)
         return obj
 
-    def test_mirrors(self):
-        self.assertRaises(TypeError, self.uril.add_mirror, "cows")
+    def test_mirrors(self, uril):
+        with pytest.raises(TypeError):
+            uril.add_mirror("cows")
         mirror = fetch.mirror(["me", "WI"], "asdf")
-        self.uril.add_mirror(mirror)
-        self.assertEqual(list(self.uril), ["me/cows", "WI/cows"])
-        self.uril.add_mirror(mirror, "foon/boon")
-        self.assertUri(self.uril,
+        uril.add_mirror(mirror)
+        assert list(uril) == ["me/cows", "WI/cows"]
+        uril.add_mirror(mirror, "foon/boon")
+        assert_uri(uril,
             ["me/cows", "WI/cows", "me/foon/boon", "WI/foon/boon"])
 
-    def test_uris(self):
-        self.uril.add_uri("blar")
-        self.assertUri(self.uril, ["blar"])
+    def test_uris(self, uril):
+        uril.add_uri("blar")
+        assert_uri(uril, ["blar"])
 
-    def test_combined(self):
+    def test_combined(self, uril):
         l = ["blarn", "me/cows", "WI/cows", "madison",
             "belleville/cows", "verona/cows"]
-        self.uril.add_uri("blarn")
-        self.uril.add_mirror(fetch.mirror(["me", "WI"], "asdf"))
-        self.uril.add_uri("madison")
-        self.uril.add_mirror(fetch.default_mirror(
+        uril.add_uri("blarn")
+        uril.add_mirror(fetch.mirror(["me", "WI"], "asdf"))
+        uril.add_uri("madison")
+        uril.add_mirror(fetch.default_mirror(
             ["belleville", "verona"], "foon"))
-        self.assertUri(self.uril, l)
+        assert_uri(uril, l)
 
     def test_nonzero(self):
-        self.assertTrue(self.mk_uri_list("asdf"))
-        self.assertFalse(self.mk_uri_list())
-        self.assertFalse(self.mk_uri_list(fetch.mirror((), "mirror")))
+        assert self.mk_uri_list("asdf")
+        assert not self.mk_uri_list()
+        assert not self.mk_uri_list(fetch.mirror((), "mirror"))
 
     def test_len(self):
-        self.assertLen(self.mk_uri_list(), 0)
-        self.assertLen(self.mk_uri_list("fdas"), 1)
-        self.assertLen(self.mk_uri_list(fetch.mirror((), "mirror")), 0)
-        self.assertLen(self.mk_uri_list(fetch.mirror(("asdf",), "mirror")), 1)
+        assert len(self.mk_uri_list()) == 0
+        assert len(self.mk_uri_list("fdas")) == 1
+        assert len(self.mk_uri_list(fetch.mirror((), "mirror"))) == 0
+        assert len(self.mk_uri_list(fetch.mirror(("asdf",), "mirror"))) == 1
diff --git a/tests/fs/test_contents.py b/tests/fs/test_contents.py
index 173b8594a..c5c08dc01 100644
--- a/tests/fs/test_contents.py
+++ b/tests/fs/test_contents.py
@@ -1,10 +1,8 @@
 import os
 from functools import partial
 
+import pytest
 from pkgcore.fs import contents, fs
-from snakeoil.currying import post_curry
-from snakeoil.osutils import pjoin
-from snakeoil.test import TestCase
 
 mk_file = partial(fs.fsFile, strict=False)
 mk_dir  = partial(fs.fsDir, strict=False)
@@ -12,149 +10,133 @@ mk_link = partial(fs.fsLink, strict=False)
 mk_dev  = partial(fs.fsDev, strict=False)
 mk_fifo = partial(fs.fsFifo, strict=False)
 
-for x in ("File", "Dir", "Link", "Dev", "Fifo"):
-    globals()["mk_" + x.lower()] = partial(
-        getattr(fs, f"fs{x}"), strict=False)
-del x
 
-
-class TestContentsSet(TestCase):
-
-    locals().update((x, globals()[x]) for x in
-        ("mk_file", "mk_dir", "mk_link", "mk_dev", "mk_fifo"))
-
-    def __init__(self, *a, **kw):
-        TestCase.__init__(self, *a, **kw)
-        self.files = list(map(self.mk_file, ["/etc/blah", "/etc/foo", "/etc/dar",
-             "/tmp/dar",
-             "/tmp/blah/foo/long/ass/file/name/but/not/that/bad/really"]))
-        self.dirs = list(map(self.mk_dir, ["/tmp", "/blah", "/tmp/dar",
-            "/usr/", "/usr/bin"]))
-        self.links = [fs.fsLink(x, os.path.dirname(x), strict=False) for x in
-            ["/tmp/foo", "/usr/X11R6/lib", "/nagga/noo"]]
-        self.devs = list(map(self.mk_dev,
-            [pjoin("dev", x) for x in ["sda1", "hda", "hda2", "disks/ide1"]]))
-        self.fifos = list(map(self.mk_fifo,
-            [pjoin("tmp", y) for y in ("dar", "boo", "bah")]))
-        self.all = self.dirs + self.links + self.devs + self.fifos
+class TestContentsSet:
+    files = list(map(mk_file, ["/etc/blah", "/etc/foo", "/etc/dar",
+        "/tmp/dar",
+        "/tmp/blah/foo/long/ass/file/name/but/not/that/bad/really"]))
+    dirs = list(map(mk_dir, ["/tmp", "/blah", "/tmp/dar",
+        "/usr/", "/usr/bin"]))
+    links = [fs.fsLink(x, os.path.dirname(x), strict=False) for x in
+        ["/tmp/foo", "/usr/X11R6/lib", "/nagga/noo"]]
+    devs = list(map(mk_dev,
+        [f"dev/{x}" for x in ["sda1", "hda", "hda2", "disks/ide1"]]))
+    fifos = list(map(mk_fifo,
+        [f"tmp/{y}" for y in ("dar", "boo", "bah")]))
+    all = dirs + links + devs + fifos
 
     def test_init(self):
-        self.assertEqual(len(self.all), len(contents.contentsSet(self.all)))
-        self.assertRaises(TypeError, contents.contentsSet, self.all + [1])
+        with pytest.raises(TypeError):
+            contents.contentsSet(self.all + [1])
         contents.contentsSet(self.all)
         contents.contentsSet(self.all, mutable=True)
         # test to ensure no one screwed up the optional initials
         # making it mandatory
-        self.assertEqual(len(contents.contentsSet()), 0)
+        assert len(contents.contentsSet()) == 0
 
     def test_add(self):
         cs = contents.contentsSet(self.files + self.dirs, mutable=True)
         for x in self.links:
             cs.add(x)
-            self.assertIn(x, cs)
-        self.assertEqual(
-            len(cs),
-            len(set(x.location for x in self.files + self.dirs + self.links)))
-        self.assertRaises(AttributeError,
-            lambda:contents.contentsSet(mutable=False).add(self.devs[0]))
-        self.assertRaises(TypeError, cs.add, 1)
-        self.assertRaises(TypeError, cs.add, self.fifos)
+            assert x in cs
+        assert len(cs) == len(set(x.location for x in self.files + self.dirs + self.links))
+        with pytest.raises(AttributeError):
+            contents.contentsSet(mutable=False).add(self.devs[0])
+        with pytest.raises(TypeError):
+            cs.add(1)
+        with pytest.raises(TypeError):
+            cs.add(self.fifos)
 
     def test_remove(self):
-        self.assertRaises(AttributeError,
-            contents.contentsSet(mutable=False).remove, self.devs[0])
-        self.assertRaises(AttributeError,
-            contents.contentsSet(mutable=False).remove, 1)
+        with pytest.raises(AttributeError):
+            contents.contentsSet(mutable=False).remove(self.devs[0])
+        with pytest.raises(AttributeError):
+            contents.contentsSet(mutable=False).remove(1)
         cs = contents.contentsSet(self.all, mutable=True)
         for x in self.all:
             cs.remove(x)
         cs = contents.contentsSet(self.all, mutable=True)
         for location in (x.location for x in self.all):
             cs.remove(location)
-        self.assertEqual(len(cs), 0)
-        self.assertRaises(KeyError, cs.remove, self.all[0])
+        assert len(cs) == 0
+        with pytest.raises(KeyError):
+            cs.remove(self.all[0])
 
     def test_contains(self):
         cs = contents.contentsSet(mutable=True)
         for x in [y[0] for y in [
                 self.files, self.dirs, self.links, self.devs, self.fifos]]:
-            self.assertFalse(x in cs)
-            self.assertFalse(x.location in cs)
+            assert x not in cs
+            assert x.location not in cs
             cs.add(x)
-            self.assertTrue(x in cs)
-            self.assertTrue(x.location in cs)
+            assert x in cs
+            assert x.location in cs
             cs.remove(x)
 
     def test_clear(self):
         cs = contents.contentsSet(self.all, mutable=True)
-        self.assertTrue(len(cs))
+        assert len(cs) > 0
         cs.clear()
-        self.assertEqual(len(cs), 0)
+        assert len(cs) == 0
 
     def test_len(self):
-        self.assertEqual(len(contents.contentsSet(self.all)), len(self.all))
-
-    def iterobj(self, name, obj_class=None, forced_name=None):
+        assert len(contents.contentsSet(self.all)) == len(self.all)
+
+    fs_types = (
+        pytest.param("files", fs.fsFile, id="files"),
+        pytest.param("dirs", fs.fsDir, id="dirs"),
+        pytest.param("links", fs.fsLink, id="links"),
+        pytest.param("devs", fs.fsDev, id="devs"),
+        pytest.param("fifos", fs.fsFifo, id="fifos"),
+    )
+
+    @pytest.mark.parametrize(("name", "obj_class"), fs_types)
+    def test_iterobj(self, name, obj_class):
         s = set(getattr(self, name))
         cs = contents.contentsSet(s)
-        if forced_name is None:
-            forced_name = "iter"+name
+        forced_name = "iter" + name
 
         s2 = set(getattr(cs, forced_name)())
         if obj_class is not None:
             for x in s2:
-                post_curry(self.assertTrue, obj_class)(x)
-        self.assertEqual(s, s2)
-
-        if forced_name == "__iter__":
-            return
+                # post_curry(self.assertTrue, obj_class)(x)
+                assert bool(x)
+        assert s == s2
 
         # inversion tests now.
         s3 = set(getattr(cs, forced_name)(invert=True))
-        if obj_class is not None:
-            for x in s3:
-                post_curry(self.assertFalse, obj_class)(x)
-
-        self.assertEqual(s.symmetric_difference(s2), s3)
+        for x in s3:
+            # post_curry(self.assertFalse, obj_class)(x)
+            assert not bool(x)
 
+        assert s.symmetric_difference(s2) == s3
 
-    def listobj(self, name, obj_class=None):
+    @pytest.mark.parametrize(("name", "obj_class"), fs_types)
+    def test_listobj(self, name, obj_class):
         valid_list = getattr(self, name)
         cs = contents.contentsSet(valid_list)
         test_list = getattr(cs, name)()
         if obj_class is not None:
             for x in test_list:
-                self.assertInstance(x, obj_class)
-        self.assertEqual(set(test_list), set(valid_list))
-
-    test_iterfiles = post_curry(iterobj, "files", fs.fsFile)
-    test_files = post_curry(listobj, "files", fs.fsFile)
-
-    test_iterdirs = post_curry(iterobj, "dirs", fs.fsDir)
-    test_dirs = post_curry(listobj, "dirs", fs.fsDir)
+                assert isinstance(x, obj_class)
+        assert set(test_list) == set(valid_list)
 
-    test_iterlinks = post_curry(iterobj, "links", fs.fsLink)
-    test_links = post_curry(listobj, "links", fs.fsLink)
-
-    test_iterdevs = post_curry(iterobj, "devs", fs.fsDev)
-    test_devs = post_curry(listobj, "devs", fs.fsDev)
-
-    test_iterfifos = post_curry(iterobj, "fifos", fs.fsFifo)
-    test_fifos = post_curry(listobj, "fifos", fs.fsFifo)
-
-    test_iter = post_curry(iterobj, "all", forced_name="__iter__")
+    def test_iterobj_all(self):
+        s = set(self.all)
+        assert set(contents.contentsSet(s)) == s
 
     def test_check_instance(self):
         for x in [y[0] for y in [
                 self.files, self.dirs, self.links, self.devs, self.fifos]]:
-            self.assertEqual((x.location, x), tuple(contents.check_instance(x)))
-        self.assertRaises(TypeError, contents.check_instance, 1)
+            assert tuple(contents.check_instance(x)) == (x.location, x)
+        with pytest.raises(TypeError):
+            contents.check_instance(1)
 
 
     def check_set_op(self, name, ret, source=None):
         if source is None:
-            source = [[fs.fsDir("/tmp", strict=False)],
-                      [fs.fsFile("/tmp", strict=False)]]
+            source = ([fs.fsDir("/tmp", strict=False)],
+                      [fs.fsFile("/tmp", strict=False)])
 
         c1, c2 = [contents.contentsSet(x) for x in source]
         if name.endswith("_update"):
@@ -162,9 +144,7 @@ class TestContentsSet(TestCase):
             c3 = c1
         else:
             c3 = getattr(c1, name)(c2)
-        self.assertEqual(
-            set(ret),
-            set(x.location for x in c3))
+        assert set(ret) == {x.location for x in c3}
 
         c1, c2 = [contents.contentsSet(x) for x in source]
         if name.endswith("_update"):
@@ -172,177 +152,173 @@ class TestContentsSet(TestCase):
             c3 = c1
         else:
             c3 = getattr(c1, name)(iter(c2))
-        self.assertEqual(
-            set(ret),
-            set(x.location for x in c3))
-
-    test_intersection = post_curry(check_set_op, "intersection", ["/tmp"])
-    test_intersection_update = post_curry(check_set_op,
-        "intersection_update", ["/tmp"])
-
-    test_difference = post_curry(check_set_op, "difference", [])
-    test_difference_update = post_curry(check_set_op,
-        "difference_update", [])
-
-    test_symmetric_difference1 = post_curry(
-        check_set_op, "symmetric_difference", [])
-    test_symmetric_difference1_update = post_curry(
-        check_set_op, "symmetric_difference_update", [])
-
-    fstrings = ("/a", "/b", "/c", "/d")
-    f = list(map(mk_file, fstrings))
+        assert set(ret) == {x.location for x in c3}
+
+    fstrings = {"/a", "/b", "/c", "/d"}
+    f = tuple(map(mk_file, fstrings))
+
+    @pytest.mark.parametrize("name, ret, source", (
+        pytest.param("intersection", {"/tmp"}, None, id="intersection"),
+        pytest.param("intersection_update", {"/tmp"}, None, id="intersection_update"),
+        pytest.param("difference", set(), None, id="difference"),
+        pytest.param("difference_update", set(), None, id="difference_update"),
+        pytest.param("symmetric_difference", set(), None, id="symmetric_difference"),
+        pytest.param("symmetric_difference_update", set(), None, id="symmetric_difference_update"),
+
+        pytest.param("union", {"/tmp"}, None, id="union1"),
+        pytest.param("union", fstrings, (f[:2], f[2:]), id="union2"),
+        pytest.param("symmetric_difference", fstrings, (f[:2], f[2:]), id="symmetric_difference2"),
+        pytest.param("symmetric_difference_update", fstrings, (f[:2], f[2:]), id="symmetric_difference_update2"),
+    ))
+    def test_check_set_op(self, name, ret, source):
+        if source is None:
+            source = ([fs.fsDir("/tmp", strict=False)],
+                      [fs.fsFile("/tmp", strict=False)])
 
-    test_union1 = post_curry(check_set_op, "union", ["/tmp"])
-    test_union2 = post_curry(check_set_op, "union", fstrings, [f[:2], f[2:]])
+        c1, c2 = [contents.contentsSet(x) for x in source]
+        if name.endswith("_update"):
+            getattr(c1, name)(c2)
+            c3 = c1
+        else:
+            c3 = getattr(c1, name)(c2)
+        assert {x.location for x in c3} == ret
 
-    test_symmetric_difference2 = post_curry(
-        check_set_op, "symmetric_difference", fstrings, [f[:2], f[2:]])
-    test_symmetric_difference2_update = post_curry(
-        check_set_op, "symmetric_difference", fstrings, [f[:2], f[2:]])
+        c1, c2 = [contents.contentsSet(x) for x in source]
+        if name.endswith("_update"):
+            getattr(c1, name)(iter(c2))
+            c3 = c1
+        else:
+            c3 = getattr(c1, name)(iter(c2))
+        assert {x.location for x in c3} == ret
 
     del f, fstrings
 
-    def check_complex_set_op(self, name, *test_cases):
-        for required, data1, data2 in test_cases:
-            cset1 = contents.contentsSet(data1)
-            cset2 = contents.contentsSet(data2)
-            f = getattr(cset1, name)
-            got = f(cset2)
-            self.assertEqual(
-                got, required,
-                msg=f"{name}: expected {required}, got {got}\ncset1={cset1!r}\ncset2={cset2!r}")
-
-    test_issubset = post_curry(
-        check_complex_set_op, "issubset",
-            (True, [mk_file("/foon")], [mk_file("/foon")]),
-            (False, [mk_file("/foon")], [mk_file("/dev")]),
-            (False, [mk_file("/dev"), mk_file("/dar")], [mk_file("/dev")]),
-            (True, [mk_file("/dev"), mk_file("/dar")],
-                [mk_file("/dev"), mk_file("/dar"), mk_file("/asdf")])
-        )
-
-
-    test_issuperset = post_curry(
-        check_complex_set_op, "issuperset",
-            (True, [mk_file("/foon")], [mk_file("/foon")]),
-            (False, [mk_file("/foon")], [mk_file("/dev")]),
-            (True, [mk_file("/dev"), mk_file("/dar")], [mk_file("/dev")]),
-            (False, [mk_file("/dev")], [mk_file("/dev"), mk_file("/dev2")])
-        )
-
-
-    test_isdisjoin = post_curry(
-        check_complex_set_op, "isdisjoint",
-            (False, [mk_file("/foon")], [mk_file("/foon")]),
-            (True, [mk_file("/foon")], [mk_file("/dev")]),
-            (False, [mk_file("/dev"), mk_file("/dar")], [mk_file("/dev")]),
-            (False, [mk_file("/dev"), mk_file("/dar")],
-                [mk_file("/dev"), mk_file("/dar"), mk_file("/asdf")]),
-            (False, [mk_file("/dev"), mk_file("/dar")],
-                [mk_file("/dev"), mk_file("/dar"), mk_file("/asdf")]),
-            (True, [mk_file("/dev"), mk_file("/dar")],
-                [mk_file("/dev2"), mk_file("/dar2"), mk_file("/asdf")]),
-        )
-
+    def check_complex_set_op(self, name, required, data1, data2):
+        cset1 = contents.contentsSet(data1)
+        cset2 = contents.contentsSet(data2)
+        f = getattr(cset1, name)
+        got = f(cset2)
+        assert got == required, \
+            f"{name}: expected {required}, got {got}\ncset1={cset1!r}\ncset2={cset2!r}"
+
+    @pytest.mark.parametrize(("required", "data1", "data2"), (
+        (True, [mk_file("/foon")], [mk_file("/foon")]),
+        (False, [mk_file("/foon")], [mk_file("/dev")]),
+        (False, [mk_file("/dev"), mk_file("/dar")], [mk_file("/dev")]),
+        (True, [mk_file("/dev"), mk_file("/dar")],
+            [mk_file("/dev"), mk_file("/dar"), mk_file("/asdf")]),
+    ))
+    def test_issubset(self, required, data1, data2):
+        self.check_complex_set_op("issubset", required, data1, data2)
+
+    @pytest.mark.parametrize(("required", "data1", "data2"), (
+        (True, [mk_file("/foon")], [mk_file("/foon")]),
+        (False, [mk_file("/foon")], [mk_file("/dev")]),
+        (True, [mk_file("/dev"), mk_file("/dar")], [mk_file("/dev")]),
+        (False, [mk_file("/dev")], [mk_file("/dev"), mk_file("/dev2")]),
+    ))
+    def test_issuperset(self, required, data1, data2):
+        self.check_complex_set_op("issuperset", required, data1, data2)
+
+    @pytest.mark.parametrize(("required", "data1", "data2"), (
+        (False, [mk_file("/foon")], [mk_file("/foon")]),
+        (True, [mk_file("/foon")], [mk_file("/dev")]),
+        (False, [mk_file("/dev"), mk_file("/dar")], [mk_file("/dev")]),
+        (False, [mk_file("/dev"), mk_file("/dar")],
+            [mk_file("/dev"), mk_file("/dar"), mk_file("/asdf")]),
+        (False, [mk_file("/dev"), mk_file("/dar")],
+            [mk_file("/dev"), mk_file("/dar"), mk_file("/asdf")]),
+        (True, [mk_file("/dev"), mk_file("/dar")],
+            [mk_file("/dev2"), mk_file("/dar2"), mk_file("/asdf")]),
+    ))
+    def test_isdisjoint(self, required, data1, data2):
+        self.check_complex_set_op("isdisjoint", required, data1, data2)
 
     def test_child_nodes(self):
-        self.assertEqual(sorted(['/usr', '/usr/bin', '/usr/foo']),
-            sorted(x.location for x in contents.contentsSet(
-                [self.mk_dir("/usr"), self.mk_dir("/usr/bin"),
-                self.mk_file("/usr/foo")])))
+        assert {'/usr', '/usr/bin', '/usr/foo'} == {
+            x.location for x in contents.contentsSet(
+                [mk_dir("/usr"), mk_dir("/usr/bin"), mk_file("/usr/foo")])}
 
     def test_map_directory_structure(self):
-        old = contents.contentsSet([self.mk_dir("/dir"),
-            self.mk_link("/sym", "dir")])
-        new = contents.contentsSet([self.mk_file("/sym/a"),
-            self.mk_dir("/sym")])
+        old = contents.contentsSet([mk_dir("/dir"),
+            mk_link("/sym", "dir")])
+        new = contents.contentsSet([mk_file("/sym/a"),
+            mk_dir("/sym")])
         # verify the machinery is working as expected.
         ret = new.map_directory_structure(old)
-        self.assertEqual(sorted(ret), sorted([self.mk_dir("/dir"),
-            self.mk_file("/dir/a")]))
+        assert set(ret) == {mk_dir("/dir"), mk_file("/dir/a")}
 
         # test recursion next.
-        old.add(self.mk_link("/dir/sym", "dir2"))
-        old.add(self.mk_dir("/dir/dir2"))
-        new.add(self.mk_file("/dir/sym/b"))
-        new.add(self.mk_dir("/sym/sym"))
+        old.add(mk_link("/dir/sym", "dir2"))
+        old.add(mk_dir("/dir/dir2"))
+        new.add(mk_file("/dir/sym/b"))
+        new.add(mk_dir("/sym/sym"))
 
         ret = new.map_directory_structure(old)
-        self.assertEqual(sorted(ret), sorted([self.mk_dir("/dir"),
-            self.mk_file("/dir/a"), self.mk_dir("/dir/dir2"),
-            self.mk_file("/dir/dir2/b")]))
+        assert set(ret) == {mk_dir("/dir"), mk_file("/dir/a"),
+            mk_dir("/dir/dir2"), mk_file("/dir/dir2/b")}
 
 
     def test_add_missing_directories(self):
-        src = [self.mk_file("/dir1/a"), self.mk_file("/dir2/dir3/b"),
-            self.mk_dir("/dir1/dir4")]
+        src = [mk_file("/dir1/a"), mk_file("/dir2/dir3/b"),
+            mk_dir("/dir1/dir4")]
         cs = contents.contentsSet(src)
         cs.add_missing_directories()
-        self.assertEqual(sorted(x.location for x in cs),
-            ['/dir1', '/dir1/a', '/dir1/dir4', '/dir2', '/dir2/dir3',
-                '/dir2/dir3/b'])
+        assert {x.location for x in cs} == \
+            {'/dir1', '/dir1/a', '/dir1/dir4', '/dir2', '/dir2/dir3', '/dir2/dir3/b'}
         obj = cs['/dir1']
-        self.assertEqual(obj.mode, 0o775)
+        assert obj.mode == 0o775
 
     def test_inode_map(self):
 
         def check_it(target):
-            d = {k: sorted(v) for k, v in cs.inode_map().items()}
-            target = {k: sorted(v) for k, v in target.items()}
-            self.assertEqual(d, target)
+            d = {k: set(v) for k, v in cs.inode_map().items()}
+            target = {k: set(v) for k, v in target.items()}
+            assert d == target
 
         cs = contents.contentsSet()
-        f1 = self.mk_file("/f", dev=1, inode=1)
+        f1 = mk_file("/f", dev=1, inode=1)
         cs.add(f1)
         check_it({(1,1):[f1]})
 
-        f2 = self.mk_file("/x", dev=1, inode=2)
+        f2 = mk_file("/x", dev=1, inode=2)
         cs.add(f2)
         check_it({(1,1):[f1], (1,2):[f2]})
 
-        f3 = self.mk_file("/y", dev=2, inode=1)
+        f3 = mk_file("/y", dev=2, inode=1)
         cs.add(f3)
         check_it({(1,1):[f1], (1,2):[f2], (2,1):[f3]})
 
-        f4 = self.mk_file("/z", dev=1, inode=1)
+        f4 = mk_file("/z", dev=1, inode=1)
         cs.add(f4)
         check_it({(1,1):[f1, f4], (1,2):[f2], (2,1):[f3]})
 
 
-class Test_offset_rewriting(TestCase):
+class Test_offset_rewriting:
 
     change_offset = staticmethod(contents.change_offset_rewriter)
     offset_insert = staticmethod(contents.offset_rewriter)
 
     def test_offset_rewriter(self):
-        f = ["/foon/%i" % x for x in range(10)]
-        f.extend("/foon/%i/blah" % x for x in range(5))
+        f = [f"/foon/{x}" for x in range(10)]
+        f.extend(f"/foon/{x}/blah" for x in range(5))
         f = [fs.fsFile(x, strict=False) for x in f]
-        self.assertEqual(sorted(x.location for x in f),
-            sorted(x.location for x in self.offset_insert('/', f)))
-        self.assertEqual(
-            sorted(f'/usr{x.location}' for x in f),
-            sorted(x.location for x in self.offset_insert('/usr', f)))
-
-    def test_it(self):
-        f = ["/foon/%i" % x for x in range(10)]
-        f.extend("/foon/%i/blah" % x for x in range(5))
-        f = [fs.fsFile(x, strict=False) for x in f]
-        self.assertEqual(sorted(x.location for x in f),
-            sorted(y.location for y in self.change_offset('/usr', '/',
-                (x.change_attributes(location=f'/usr{x.location}')
-                    for x in f)
-            )))
-        self.assertEqual(sorted(x.location for x in f),
-            sorted(y.location for y in self.change_offset('/usr', '/',
-                (x.change_attributes(location=f'/usr/{x.location}')
-                    for x in f)
-            )))
-        self.assertEqual(sorted("/usr" + x.location for x in f),
-            sorted(y.location for y in self.change_offset('/', '/usr',
-                (x.change_attributes(location=f'/{x.location}')
-                    for x in f)
-            )))
-
-
+        assert {x.location for x in f} == {x.location for x in self.offset_insert('/', f)}
+        assert {f'/usr{x.location}' for x in f} == {x.location for x in self.offset_insert('/usr', f)}
 
+    def test_change_offset(self):
+        f = [f"/foon/{x}" for x in range(10)]
+        f.extend(f"/foon/{x}/blah" for x in range(5))
+        f = [fs.fsFile(x, strict=False) for x in f]
+        assert {x.location for x in f} == {
+            y.location
+            for y in self.change_offset('/usr', '/', (
+                x.change_attributes(location=f'/usr{x.location}') for x in f))}
+        assert {x.location for x in f} == {
+            y.location
+            for y in self.change_offset('/usr', '/', (
+                x.change_attributes(location=f'/usr/{x.location}') for x in f))}
+        assert {f'/usr{x.location}' for x in f} == {
+            y.location
+            for y in self.change_offset('/', '/usr', (
+                x.change_attributes(location=f'/{x.location}') for x in f))}
diff --git a/tests/package/test_base.py b/tests/package/test_base.py
index 5e99f1596..09fdf38b1 100644
--- a/tests/package/test_base.py
+++ b/tests/package/test_base.py
@@ -6,14 +6,13 @@ from pkgcore.package import base
 
 
 def fake_pkg(cat='dev-util', pkg='bsdiff', ver='1.0', **attrs):
-    return SimpleNamespace(**({
-        'category': cat,
-        'pkg': pkg,
-        'ver': ver,
-        'key': f"{cat}/{pkg}",
-        "cpvstr": f"{cat}/{pkg}-{ver}",
-        "built": False,
-    } | attrs))
+    attrs.setdefault('category', cat)
+    attrs.setdefault('pkg', pkg)
+    attrs.setdefault('ver', ver)
+    attrs.setdefault('key', f"{cat}/{pkg}")
+    attrs.setdefault('cpvstr', f"{cat}/{pkg}-{ver}")
+    attrs.setdefault('built', False)
+    return SimpleNamespace(**attrs)
 
 
 class mixin: