ebuild/test_repository.py: modernize tests to pytest

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

1 files changed, 211 insertions, 270 deletions

diff --git a/tests/ebuild/test_repository.py b/tests/ebuild/test_repository.py
index 5a580cd6..cfee767c 100644
--- a/tests/ebuild/test_repository.py
+++ b/tests/ebuild/test_repository.py
@@ -1,353 +1,294 @@
-import os
 import textwrap
-from unittest import mock
+from pathlib import Path
+
+import pytest
 
 from pkgcore.ebuild import eclass_cache
-from pkgcore.ebuild import errors as ebuild_errors
 from pkgcore.ebuild import repository, restricts
 from pkgcore.ebuild.atom import atom
 from pkgcore.repository import errors
-from snakeoil.fileutils import touch
-from snakeoil.osutils import ensure_dirs, pjoin
-from snakeoil.test.mixins import TempDirMixin
+from snakeoil.contexts import chdir
 
 
-class TestUnconfiguredTree(TempDirMixin):
+class TestUnconfiguredTree:
 
     def mk_tree(self, path, *args, **kwds):
         eclasses = kwds.pop('eclass_cache', None)
         if eclasses is None:
-            epath = pjoin(path, 'eclass')
-            ensure_dirs(epath)
-            eclasses = eclass_cache.cache(epath)
-        ensure_dirs(pjoin(path, 'profiles'))
-        return repository.UnconfiguredTree(path, eclass_cache=eclasses, *args, **kwds)
+            (epath := path / 'eclass').mkdir(parents=True, exist_ok=True)
+            eclasses = eclass_cache.cache(str(epath))
+        (path / 'profiles').mkdir(exist_ok=True)
+        return repository.UnconfiguredTree(str(path), eclass_cache=eclasses, *args, **kwds)
 
-    def setUp(self):
-        TempDirMixin.setUp(self)
-        self.pdir = pjoin(self.dir, 'profiles')
-        ensure_dirs(self.pdir)
+    @pytest.fixture
+    def pdir(self, tmp_path):
+        (pdir := tmp_path / 'profiles').mkdir(exist_ok=True)
 
         # silence missing masters warnings
-        ensure_dirs(pjoin(self.dir, 'metadata'))
-        with open(pjoin(self.dir, 'metadata', 'layout.conf'), 'w') as f:
-            f.write('masters =\n')
+        if not (tmp_path / 'metadata').exists():
+            (tmp_path / 'metadata').mkdir()
+            (tmp_path / 'metadata' / 'layout.conf').write_text('masters =\n')
+
+        return pdir
+
+    def test_repo_from_file(self, tmp_path):
+        (tmp_path / 'random').write_text('random')
+        with pytest.raises(errors.InitializationError):
+            return repository.UnconfiguredTree(str(tmp_path / 'random'), eclass_cache=None)
 
-    def test_basics(self):
-        repo = self.mk_tree(self.dir)
+    def test_basics(self, tmp_path, pdir, caplog):
+        repo = self.mk_tree(tmp_path)
         # Just make sure these do not raise.
-        self.assertTrue(str(repo))
-        self.assertTrue(repr(repo))
-
-        self.assertRaises(
-            errors.InitializationError,
-            self.mk_tree, pjoin(self.dir, 'missing'))
-
-        with open(pjoin(self.dir, 'random'), 'w') as f:
-            f.write('random')
-        self.assertRaises(
-            errors.InitializationError,
-            self.mk_tree, pjoin(self.dir, 'random'))
-
-    def test_thirdpartymirrors(self):
-        with open(pjoin(self.pdir, 'thirdpartymirrors'), 'w') as f:
-            f.write(textwrap.dedent('''\
-                spork http://sporks/ http://moresporks/
-                foon foon://foons/
-            '''))
-        mirrors = self.mk_tree(self.dir).mirrors
-        self.assertEqual(['foon', 'spork'], sorted(mirrors))
-        self.assertEqual(
-            ['http://moresporks/', 'http://sporks/'],
-            sorted(mirrors['spork']))
-        with open(pjoin(self.pdir, 'thirdpartymirrors'), 'w') as f:
-            f.write("foon  dar\n")
-        self.assertEqual(list(self.mk_tree(self.dir).mirrors.keys()), ['foon'])
-
-    def test_repo_id(self):
-        dir1 = pjoin(self.dir, '1')
-        os.mkdir(dir1, 0o755)
-        repo = self.mk_tree(dir1)
-        self.assertEqual(repo.repo_id, dir1)
-        dir2 = pjoin(self.dir, '2')
-        ensure_dirs(pjoin(dir2, 'profiles'))
-        with open(pjoin(dir2, 'profiles', 'repo_name'), 'w') as f:
-            f.write('testrepo\n')
+        assert str(repo)
+        assert repr(repo)
+
+        caplog.clear()
+        self.mk_tree(tmp_path / 'missing')
+        assert caplog.text
+
+    def test_thirdpartymirrors(self, tmp_path, pdir):
+        (pdir / 'thirdpartymirrors').write_text(textwrap.dedent('''\
+            spork http://sporks/ http://moresporks/
+            foon foon://foons/
+        '''))
+        mirrors = self.mk_tree(tmp_path).mirrors
+        assert set(mirrors) == {'spork', 'foon'}
+        assert set(mirrors['spork']) == {'http://moresporks/', 'http://sporks/'}
+        (pdir / 'thirdpartymirrors').write_text("foon  dar\n")
+        assert set(self.mk_tree(tmp_path).mirrors.keys()) == {'foon'}
+
+    def test_repo_id(self, tmp_path):
+        repo = self.mk_tree(dir1 := tmp_path / '1')
+        assert repo.repo_id == str(dir1)
+
+        (dir2 := tmp_path / '2').mkdir(0o755)
+        (dir2 / 'profiles').mkdir()
+        (dir2 / 'profiles' / 'repo_name').write_text('testrepo\n')
         repo = self.mk_tree(dir2)
-        self.assertEqual('testrepo', repo.repo_id)
+        assert repo.repo_id == 'testrepo'
 
-    def test_licenses(self):
-        licenses = ('GPL-2', 'GPL-3+', 'BSD')
-        ensure_dirs(pjoin(self.dir, 'licenses'))
+    def test_licenses(self, tmp_path):
+        licenses = {'GPL-2', 'GPL-3+', 'BSD'}
+        (tmp_path / 'licenses').mkdir()
         for license in licenses:
-            touch(pjoin(self.dir, 'licenses', license))
-        repo = self.mk_tree(self.dir)
-        self.assertEqual(sorted(repo.licenses), sorted(licenses))
-
-    def test_masters(self):
-        repo = self.mk_tree(self.dir)
-        self.assertEqual(repo.masters, ())
-
-    def test_path_restrict(self):
-        repo_dir = pjoin(self.dir, 'repo')
-        sym_repo_dir = pjoin(self.dir, 'sym_repo')
-        os.symlink(repo_dir, sym_repo_dir)
-
-        ensure_dirs(pjoin(repo_dir, 'profiles'))
-        with open(pjoin(repo_dir, 'profiles', 'repo_name'), 'w') as f:
-            f.write('testrepo\n')
-        ensure_dirs(pjoin(repo_dir, 'cat', 'foo'))
-        ensure_dirs(pjoin(repo_dir, 'cat', 'bar'))
-        ensure_dirs(pjoin(repo_dir, 'tac', 'oof'))
-        touch(pjoin(repo_dir, 'skel.ebuild'))
-        touch(pjoin(repo_dir, 'cat', 'foo', 'Manifest'))
-        ebuilds = (
-            pjoin(repo_dir, 'cat', 'foo', 'foo-1.ebuild'),
-            pjoin(repo_dir, 'cat', 'foo', 'foo-2.ebuild'),
-            pjoin(repo_dir, 'cat', 'bar', 'bar-1.ebuild'),
-            pjoin(repo_dir, 'tac', 'oof', 'oof-1.ebuild'),
-        )
-        for ebuild in ebuilds:
-            with open(ebuild, 'w') as f:
-                f.write('SLOT=0\n')
-
-        # specify repo category dirs
-        with open(pjoin(repo_dir, 'profiles', 'categories'), 'w') as f:
-            f.write('cat\n')
-            f.write('tac\n')
+            (tmp_path / 'licenses' / license).touch()
+        repo = self.mk_tree(tmp_path)
+        assert set(repo.licenses) == licenses
+
+    def test_masters(self, tmp_path):
+        repo = self.mk_tree(tmp_path)
+        assert repo.masters == ()
+
+    def test_path_restrict(self, tmp_path, tmp_path_factory):
+        repo_dir = tmp_path_factory.mktemp('repo', numbered=True)
+        sym_repo_dir = tmp_path_factory.mktemp('sym_repo', numbered=True)
+        sym_repo_dir.rmdir()
+        sym_repo_dir.symlink_to(repo_dir)
+
+        (repo_dir / 'profiles').mkdir()
+        (repo_dir / 'profiles' / 'repo_name').write_text('testrepo\n')
+        (repo_dir / 'profiles' / 'categories').write_text('cat\ntac\n')
+        (repo_dir / 'skel.ebuild').touch()
+        (repo_dir / 'cat' / 'foo').mkdir(parents=True)
+        (repo_dir / 'cat' / 'foo' / 'Manifest').touch()
+        (repo_dir / 'cat' / 'foo' / 'foo-1.ebuild').write_text('SLOT=0\n')
+        (repo_dir / 'cat' / 'foo' / 'foo-2.ebuild').write_text('SLOT=0\n')
+        (repo_dir / 'cat' / 'bar').mkdir(parents=True)
+        (repo_dir / 'cat' / 'bar' / 'bar-1.ebuild').write_text('SLOT=0\n')
+        (repo_dir / 'tac' / 'oof').mkdir(parents=True)
+        (repo_dir / 'tac' / 'oof' / 'oof-1.ebuild').write_text('SLOT=0\n')
 
         for d in (repo_dir, sym_repo_dir):
             repo = self.mk_tree(d)
+            location = Path(repo.location)
             for path in (
-                    self.dir,  # path not in repo
-                    pjoin(repo.location, 'a'),  # nonexistent category dir
-                    pjoin(repo.location, 'profiles'),  # non-category dir
-                    pjoin(repo.location, 'skel.ebuild'),  # not in the correct cat/PN dir layout
-                    pjoin(repo.location, 'cat', 'a'),  # nonexistent package dir
-                    pjoin(repo.location, 'cat', 'foo', 'foo-0.ebuild'),  # nonexistent ebuild file
-                    pjoin(repo.location, 'cat', 'foo', 'Manifest'),  # non-ebuild file
-                    ):
-                self.assertRaises(ValueError, repo.path_restrict, path)
+                tmp_path,  # path not in repo
+                location / 'a',  # nonexistent category dir
+                # location / 'profiles',  # non-category dir
+                location / 'skel.ebuild',  # not in the correct cat/PN dir layout
+                location / 'cat' / 'a',  # nonexistent package dir
+                location / 'cat' / 'foo' / 'foo-0.ebuild',  # nonexistent ebuild file
+                location / 'cat' / 'foo' / 'Manifest',  # non-ebuild file
+            ):
+                with pytest.raises(ValueError):
+                    repo.path_restrict(str(path))
 
             # repo dir
             restriction = repo.path_restrict(repo.location)
-            self.assertEqual(len(restriction), 1)
-            self.assertInstance(restriction[0], restricts.RepositoryDep)
+            assert len(restriction) == 1
+            assert isinstance(restriction[0], restricts.RepositoryDep)
             # matches all 4 ebuilds in the repo
-            self.assertEqual(len(repo.match(restriction)), 4)
+            assert len(repo.match(restriction)) == 4
 
             # category dir
-            restriction = repo.path_restrict(pjoin(repo.location, 'cat'))
-            self.assertEqual(len(restriction), 2)
-            self.assertInstance(restriction[1], restricts.CategoryDep)
+            restriction = repo.path_restrict(str(location / 'cat'))
+            assert len(restriction) == 2
+            assert isinstance(restriction[1], restricts.CategoryDep)
             # matches all 3 ebuilds in the category
-            self.assertEqual(len(repo.match(restriction)), 3)
+            assert len(repo.match(restriction)) == 3
 
             # relative category dir
-            with mock.patch('os.getcwd', return_value=repo.location):
+            with chdir(repo.location):
                 restriction = repo.path_restrict('cat')
-                self.assertEqual(len(restriction), 2)
-                self.assertInstance(restriction[1], restricts.CategoryDep)
+                assert len(restriction) == 2
+                assert isinstance(restriction[1], restricts.CategoryDep)
                 # matches all 3 ebuilds in the category
-                self.assertEqual(len(repo.match(restriction)), 3)
+                assert len(repo.match(restriction)) == 3
 
             # package dir
-            restriction = repo.path_restrict(pjoin(repo.location, 'cat', 'foo'))
-            self.assertEqual(len(restriction), 3)
-            self.assertInstance(restriction[2], restricts.PackageDep)
+            restriction = repo.path_restrict(str(location / 'cat' / 'foo'))
+            assert len(restriction) == 3
+            assert isinstance(restriction[2], restricts.PackageDep)
             # matches both ebuilds in the package dir
-            self.assertEqual(len(repo.match(restriction)), 2)
+            assert len(repo.match(restriction)) == 2
 
             # relative package dir
-            with mock.patch('os.getcwd', return_value=repo.location):
+            with chdir(repo.location):
                 restriction = repo.path_restrict('cat/foo')
-                self.assertEqual(len(restriction), 3)
-                self.assertInstance(restriction[2], restricts.PackageDep)
+                assert len(restriction) == 3
+                assert isinstance(restriction[2], restricts.PackageDep)
                 # matches both ebuilds in the package dir
-                self.assertEqual(len(repo.match(restriction)), 2)
+                assert len(repo.match(restriction)) == 2
 
             # ebuild file
-            restriction = repo.path_restrict(pjoin(repo.location, 'cat', 'foo', 'foo-1.ebuild'))
-            self.assertEqual(len(restriction), 4)
-            self.assertInstance(restriction[3], restricts.VersionMatch)
+            restriction = repo.path_restrict(str(location / 'cat' / 'foo' / 'foo-1.ebuild'))
+            assert len(restriction) == 4
+            assert isinstance(restriction[3], restricts.VersionMatch)
             # specific ebuild version match
-            self.assertEqual(len(repo.match(restriction)), 1)
+            assert len(repo.match(restriction)) == 1
 
             # relative ebuild file path
-            with mock.patch('os.getcwd', return_value=os.path.realpath(pjoin(repo.location, 'cat', 'foo'))):
+            with chdir((location / 'cat' / 'foo').resolve()):
                 restriction = repo.path_restrict('./foo-1.ebuild')
-                self.assertEqual(len(restriction), 4)
-                self.assertInstance(restriction[3], restricts.VersionMatch)
+                assert len(restriction) == 4
+                assert isinstance(restriction[3], restricts.VersionMatch)
                 # specific ebuild version match
-                self.assertEqual(len(repo.match(restriction)), 1)
+                assert len(repo.match(restriction)) == 1
 
-    def test_categories_packages(self):
-        ensure_dirs(pjoin(self.dir, 'cat', 'pkg'))
-        ensure_dirs(pjoin(self.dir, 'empty', 'empty'))
-        touch(pjoin(self.dir, 'cat', 'pkg', 'pkg-3.ebuild'))
-        repo = self.mk_tree(self.dir)
+    def test_categories_packages(self, tmp_path):
+        (tmp_path / 'cat' / 'pkg').mkdir(parents=True)
+        (tmp_path / 'empty' / 'empty').mkdir(parents=True)
+        (tmp_path / 'cat' / 'pkg' / 'pkg-3.ebuild').touch()
+        repo = self.mk_tree(tmp_path)
         assert {'cat': (), 'empty': ()} == dict(repo.categories)
         assert {'cat': ('pkg',), 'empty': ('empty',)} == dict(repo.packages)
         assert {('cat', 'pkg'): ('3',), ('empty', 'empty'): ()} == dict(repo.versions)
 
-    def test_package_mask(self):
-        with open(pjoin(self.pdir, 'package.mask'), 'w') as f:
-            f.write(textwrap.dedent('''\
-                # lalala
-                it-is/broken
-                <just/newer-than-42
-            '''))
-        repo = self.mk_tree(self.dir)
-        self.assertEqual(sorted([atom('it-is/broken'),
-            atom('<just/newer-than-42')]),
-            sorted(repo.pkg_masks))
+    def test_package_mask(self, tmp_path, pdir):
+        (pdir / 'package.mask').write_text(textwrap.dedent('''\
+            # lalala
+            it-is/broken
+            <just/newer-than-42
+        '''))
+        repo = self.mk_tree(tmp_path)
+        assert set(repo.pkg_masks) == {atom('it-is/broken'), atom('<just/newer-than-42')}
 
 
 class TestSlavedTree(TestUnconfiguredTree):
 
     def mk_tree(self, path, *args, **kwds):
-        if path != self.dir:
+        if path != self.dir_slave:
             self.dir_slave = path
-            self.dir_master = pjoin(os.path.dirname(path), os.path.basename(path) + 'master')
-            ensure_dirs(self.dir_slave)
-            ensure_dirs(self.dir_master)
-            ensure_dirs(pjoin(self.dir_slave, 'profiles'))
-            ensure_dirs(pjoin(self.dir_master, 'profiles'))
+            self.dir_master = path.parent / (path.name + 'master')
+            (self.dir_slave / 'profiles').mkdir(parents=True, exist_ok=True)
+            (self.dir_master / 'profiles').mkdir(parents=True, exist_ok=True)
 
         eclasses = kwds.pop('eclass_cache', None)
         if eclasses is None:
-            epath = pjoin(self.dir_master, 'eclass')
-            ensure_dirs(epath)
-            eclasses = eclass_cache.cache(epath)
+            (epath := path / 'eclass').mkdir(parents=True, exist_ok=True)
+            eclasses = eclass_cache.cache(str(epath))
 
-        self.master_repo = repository.UnconfiguredTree(self.dir_master, eclass_cache=eclasses, *args, **kwds)
+        self.master_repo = repository.UnconfiguredTree(str(self.dir_master), eclass_cache=eclasses, *args, **kwds)
         masters = (self.master_repo,)
-        return repository.UnconfiguredTree(self.dir_slave, eclass_cache=eclasses, masters=masters, *args, **kwds)
-
-    def setUp(self):
-        TempDirMixin.setUp(self)
-        self.dir_orig = self.dir
-
-        self.dir_master = pjoin(self.dir, 'master')
-        self.dir_slave = pjoin(self.dir, 'slave')
-        ensure_dirs(self.dir_master)
-        ensure_dirs(self.dir_slave)
-
-        ensure_dirs(pjoin(self.dir_master, 'metadata'))
-        ensure_dirs(pjoin(self.dir_slave, 'metadata'))
-        # silence missing masters warnings
-        with open(pjoin(self.dir_master, 'metadata', 'layout.conf'), 'w') as f:
-            f.write('masters =\n')
-        with open(pjoin(self.dir_slave, 'metadata', 'layout.conf'), 'w') as f:
-            f.write('masters = master\n')
-
-        self.master_pdir = pjoin(self.dir_master, 'profiles')
-        self.pdir = self.slave_pdir = pjoin(self.dir_slave, 'profiles')
-        ensure_dirs(self.master_pdir)
-        ensure_dirs(self.slave_pdir)
-        # silence missing repo name warnings
-        with open(pjoin(self.master_pdir, 'repo_name'), 'w') as f:
-            f.write('master\n')
-        with open(pjoin(self.slave_pdir, 'repo_name'), 'w') as f:
-            f.write('slave\n')
-
-        self.dir = self.dir_slave
-
-    def tearDown(self):
-        self.dir = self.dir_orig
-        TempDirMixin.tearDown(self)
-
-    def _create_categories(self, master, slave, write=True):
-        with open(pjoin(self.master_pdir, 'categories'), 'w') as f:
-            f.write('\n'.join(master))
-        with open(pjoin(self.slave_pdir, 'categories'), 'w') as f:
-            f.write('\n'.join(slave))
+        return repository.UnconfiguredTree(str(self.dir_slave), eclass_cache=eclasses, masters=masters, *args, **kwds)
+
+    @pytest.fixture(autouse=True)
+    def master_repo(self, tmp_path_factory):
+        self.dir_master = tmp_path_factory.mktemp('master', numbered=True)
+        (self.dir_master / 'metadata').mkdir()
+        (self.dir_master / 'metadata' / 'layout.conf').write_text('masters =\n')
+        (self.dir_master / 'profiles').mkdir()
+        (self.dir_master / 'profiles' / 'repo_name').write_text('master\n')
+        return self.dir_master
+
+    @pytest.fixture(autouse=True)
+    def slave_repo(self, tmp_path):
+        self.dir_slave = tmp_path
+        (self.dir_slave / 'metadata').mkdir()
+        (self.dir_slave / 'metadata' / 'layout.conf').write_text('masters = master\n')
+        (self.dir_slave / 'profiles').mkdir()
+        (self.dir_slave / 'profiles' / 'repo_name').write_text('slave\n')
+        return self.dir_slave
+
+    @pytest.mark.parametrize(("master", "slave", "expected"), (
+        (('cat',), (), ('cat',)),
+        ((), ('cat',), ('cat',)),
+        (('sys-apps', 'foo'), ('cat', 'foo'), ('cat', 'foo', 'sys-apps')),
+    ))
+    def test_categories(self, master_repo, slave_repo, master, slave, expected):
+        # categories are inherited from masters
+        (master_repo / 'profiles' / 'categories').write_text('\n'.join(master))
+        (slave_repo / 'profiles' / 'categories').write_text('\n'.join(slave))
         for cat in master:
-            os.mkdir(pjoin(self.dir_master, cat), 0o755)
+            (master_repo / cat).mkdir(0o755)
         for cat in slave:
-            os.mkdir(pjoin(self.dir_slave, cat), 0o755)
-        return self.mk_tree(self.dir)
+            (slave_repo / cat).mkdir(0o755)
+        repo = self.mk_tree(slave_repo)
+        assert tuple(sorted(repo.categories)) == expected
 
-    def test_categories(self):
-        # categories are inherited from masters
-        for master, slave, expected in (
-                (('cat',), (), ('cat',)),
-                ((), ('cat',), ('cat',)),
-                (('sys-apps', 'foo'), ('cat', 'foo'), ('cat', 'foo', 'sys-apps'))):
-            # profiles/categories files exist along with category dirs
-            self.setUp()
-            repo = self._create_categories(master, slave)
-            self.assertEqual(tuple(sorted(repo.categories)), expected)
-            self.tearDown()
-
-            # no profiles/categories files created, only category dirs
-            self.setUp()
-            repo = self._create_categories(master, slave, write=False)
-            self.assertEqual(tuple(sorted(repo.categories)), expected)
-            self.tearDown()
-        self.setUp()
-
-    def test_licenses(self):
+    def test_licenses(self, master_repo, slave_repo):
         master_licenses = ('GPL-2', 'GPL-3+', 'BSD')
         slave_licenses = ('BSD-2', 'MIT')
-        ensure_dirs(pjoin(self.dir_slave, 'licenses'))
-        ensure_dirs(pjoin(self.dir_master, 'licenses'))
+        (master_repo / 'licenses').mkdir()
         for license in master_licenses:
-            touch(pjoin(self.dir_master, 'licenses', license))
+            (master_repo / 'licenses' / license).touch()
+        (slave_repo / 'licenses').mkdir()
         for license in slave_licenses:
-            touch(pjoin(self.dir_slave, 'licenses', license))
-        repo = self.mk_tree(self.dir)
-        self.assertEqual(sorted(repo.licenses), sorted(master_licenses + slave_licenses))
+            (slave_repo / 'licenses' / license).touch()
+        repo = self.mk_tree(slave_repo)
+        assert set(repo.licenses) == set(master_licenses + slave_licenses)
 
-    def test_license_groups(self):
+    def test_license_groups(self, master_repo, slave_repo):
         master_licenses = ('GPL-2', 'BSD')
         slave_licenses = ('BSD-2', 'MIT')
-        ensure_dirs(pjoin(self.dir_slave, 'licenses'))
-        ensure_dirs(pjoin(self.dir_slave, 'profiles'))
-        ensure_dirs(pjoin(self.dir_master, 'licenses'))
-        ensure_dirs(pjoin(self.dir_master, 'profiles'))
+
+        (master_repo / 'licenses').mkdir()
         for license in master_licenses:
-            touch(pjoin(self.dir_master, 'licenses', license))
-        with open(pjoin(self.dir_master, 'profiles', 'license_groups'), 'w') as f:
-            f.write(f'FREE {" ".join(master_licenses)}\n')
-            f.write(f'OSI-APPROVED @FREE\n')
+            (master_repo / 'licenses' / license).touch()
+        (master_repo / 'profiles' / 'license_groups').write_text(f'FREE {" ".join(master_licenses)}\nOSI-APPROVED @FREE\n')
+
+        (slave_repo / 'licenses').mkdir()
         for license in slave_licenses:
-            touch(pjoin(self.dir_slave, 'licenses', license))
-        with open(pjoin(self.dir_slave, 'profiles', 'license_groups'), 'w') as f:
-            f.write(f'MISC-FREE @FREE {" ".join(slave_licenses)}\n')
-            f.write('FSF-APPROVED MIT\n')
-            f.write('OSI-APPROVED @FSF-APPROVED\n')
-        repo = self.mk_tree(self.dir)
-        self.assertEqual(sorted(repo.licenses), sorted(master_licenses + slave_licenses))
-        self.assertEqual(sorted(repo.licenses.groups), ['FREE', 'FSF-APPROVED', 'MISC-FREE', 'OSI-APPROVED'])
-        self.assertIn('BSD', repo.licenses.groups['MISC-FREE'])
-
-    def test_package_deprecated(self):
-        with open(pjoin(self.master_pdir, 'package.deprecated'), 'w') as f:
-            f.write(textwrap.dedent('''\
-                # lalala
-                it-is/deprecated
-                <just/newer-than-42
-            '''))
-        repo = self.mk_tree(self.dir_slave)
-        self.assertEqual(sorted([atom('it-is/deprecated'),
-            atom('<just/newer-than-42')]),
-            sorted(list(repo.deprecated)))
-
-    def test_use_expand_desc(self):
+            (slave_repo / 'licenses' / license).touch()
+        (slave_repo / 'profiles' / 'license_groups').write_text(f'MISC-FREE @FREE {" ".join(slave_licenses)}\nFSF-APPROVED MIT\nOSI-APPROVED @FSF-APPROVED\n')
+
+        repo = self.mk_tree(slave_repo)
+        assert set(repo.licenses) == set(master_licenses + slave_licenses)
+        assert set(repo.licenses.groups) == {'FREE', 'FSF-APPROVED', 'MISC-FREE', 'OSI-APPROVED'}
+        assert 'BSD' in repo.licenses.groups['MISC-FREE']
+
+    def test_package_deprecated(self, slave_repo, master_repo):
+        (master_repo / 'profiles' / 'package.deprecated').write_text(textwrap.dedent('''\
+            # lalala
+            it-is/deprecated
+            <just/newer-than-42
+        '''))
+        repo = self.mk_tree(slave_repo)
+        assert set(repo.deprecated) == {atom('it-is/deprecated'), atom('<just/newer-than-42')}
+
+    def test_use_expand_desc(self, slave_repo, master_repo):
         use_expand_desc = {
             'example': (('example_foo', 'Build with foo'),
                         ('example_bar', 'Build with bar'))
         }
-        ensure_dirs(pjoin(self.master_pdir, 'desc'))
-        with open(pjoin(self.master_pdir, 'desc', 'example'), 'w') as f:
-            f.write(textwrap.dedent('''\
-                foo - Build with foo
-                bar - Build with bar
-            '''))
-        repo = self.mk_tree(self.dir)
+        (master_repo / 'profiles' / 'desc').mkdir()
+        (master_repo / 'profiles' / 'desc' / 'example').write_text(textwrap.dedent('''\
+            foo - Build with foo
+            bar - Build with bar
+        '''))
+        repo = self.mk_tree(slave_repo)
         assert use_expand_desc == dict(repo.use_expand_desc)
 
-    def test_masters(self):
-        repo = self.mk_tree(self.dir)
-        self.assertEqual(repo.masters, (self.master_repo,))
+    def test_masters(self, slave_repo):
+        repo = self.mk_tree(slave_repo)
+        assert repo.masters == (self.master_repo,)