fs/test_fs.py: modernize tests to pytest

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

1 files changed, 73 insertions, 85 deletions

diff --git a/tests/fs/test_fs.py b/tests/fs/test_fs.py
index 248f5cc85..ffb4b1296 100644
--- a/tests/fs/test_fs.py
+++ b/tests/fs/test_fs.py
@@ -1,11 +1,9 @@
-import os
+import pytest
 
 from pkgcore.fs import fs
 from snakeoil.chksum import get_chksums
 from snakeoil.data_source import data_source
 from snakeoil.osutils import normpath, pjoin
-from snakeoil.test import TestCase
-from snakeoil.test.mixins import tempdir_decorator
 
 
 class base:
@@ -17,72 +15,72 @@ class base:
         return self.kls(location, **kwds)
 
     def test_basename(self):
-        self.assertEqual(self.make_obj(location='/asdf').basename, 'asdf')
-        self.assertEqual(self.make_obj(location='/a/b').basename, 'b')
+        assert self.make_obj(location='/asdf').basename == 'asdf'
+        assert self.make_obj(location='/a/b').basename == 'b'
 
     def test_dirname(self):
-        self.assertEqual(self.make_obj(location='/asdf').dirname, '/')
-        self.assertEqual(self.make_obj(location='/a/b').dirname, '/a')
+        assert self.make_obj(location='/asdf').dirname == '/'
+        assert self.make_obj(location='/a/b').dirname == '/a'
 
-    def test_location_normalization(self):
-        for loc in ('/tmp/a', '/tmp//a', '/tmp//', '/tmp/a/..'):
-            self.assertEqual(self.make_obj(location=loc).location,
-                normpath(loc), reflective=False)
+    @pytest.mark.parametrize("loc", ('/tmp/a', '/tmp//a', '/tmp//', '/tmp/a/..'))
+    def test_location_normalization(self, loc):
+        assert self.make_obj(location=loc).location == normpath(loc)
 
     def test_change_attributes(self):
         # simple test...
         o = self.make_obj("/foon")
-        self.assertNotEqual(o, o.change_attributes(location="/nanners"))
+        assert o != o.change_attributes(location="/nanners")
 
     def test_init(self):
         mkobj = self.make_obj
         o = mkobj("/tmp/foo")
-        self.assertEqual(o.location, "/tmp/foo")
-        self.assertEqual(mkobj(mtime=100).mtime, 100)
-        self.assertEqual(mkobj(mode=0o660).mode, 0o660)
+        assert o.location == "/tmp/foo"
+        assert mkobj(mtime=100).mtime == 100
+        assert mkobj(mode=0o660).mode == 0o660
         # ensure the highband stays in..
-        self.assertEqual(mkobj(mode=0o42660).mode, 0o42660)
-        self.assertEqual(mkobj(uid=0).uid, 0)
-        self.assertEqual(mkobj(gid=0).gid, 0)
+        assert mkobj(mode=0o42660).mode == 0o42660
+        assert mkobj(uid=0).uid == 0
+        assert mkobj(gid=0).gid == 0
 
     def test_hash(self):
         # might seem odd, but done this way to avoid the any potential
         # false positives from str's hash returning the same
-        d = {self.make_obj("/tmp/foo"):None}
+        d = {self.make_obj("/tmp/foo"): None}
         # ensure it's accessible without a KeyError
         d[self.make_obj("/tmp/foo")]
 
     def test_eq(self):
         o = self.make_obj("/tmp/foo")
-        self.assertEqual(o, self.make_obj("/tmp/foo"))
-        self.assertNotEqual(o, self.make_obj("/tmp/foo2"))
+        assert o == self.make_obj("/tmp/foo")
+        assert o != self.make_obj("/tmp/foo2")
 
     def test_setattr(self):
         o = self.make_obj()
         for attr in o.__attrs__:
-            self.assertRaises(AttributeError, setattr, o, attr, "monkies")
+            with pytest.raises(AttributeError):
+                setattr(o, attr, "monkies")
 
-    @tempdir_decorator
-    def test_realpath(self):
+    def test_realpath(self, tmp_path):
         # just to be safe, since this could trash some tests.
-        self.dir = os.path.realpath(self.dir)
-        os.mkdir(pjoin(self.dir, "test1"))
-        obj = self.make_obj(location=pjoin(self.dir, "test1", "foon"))
-        self.assertIdentical(obj, obj.realpath())
-        os.symlink(pjoin(self.dir, "test1"), pjoin(self.dir, "test2"))
-        obj = self.make_obj(location=pjoin(self.dir, "test2", "foon"))
+        (tmp_path / "test1").mkdir()
+        obj = self.make_obj(location=str(tmp_path / "test1" / "foon"))
+        assert obj is obj.realpath()
+
+        (tmp_path / "test2").symlink_to(tmp_path / "test1")
+        obj = self.make_obj(location=str(tmp_path / "test2" / "foon"))
         new_obj = obj.realpath()
-        self.assertNotIdentical(obj, new_obj)
-        self.assertEqual(new_obj.location, pjoin(self.dir, "test1", "foon"), reflective=False)
-        os.symlink(pjoin(self.dir, "test3"), pjoin(self.dir, "nonexistent"))
-        obj = self.make_obj(pjoin(self.dir, "nonexistent", "foon"))
+        assert obj is not new_obj
+        assert new_obj.location == str(tmp_path / "test1" / "foon")
+
+        (tmp_path / "nonexistent").symlink_to(tmp_path / "test3")
+        obj = self.make_obj(str(tmp_path / "nonexistent" / "foon"))
         # path is incomplete; should still realpath it.
         new_obj = obj.realpath()
-        self.assertNotIdentical(obj, new_obj)
-        self.assertEqual(new_obj.location, pjoin(self.dir, "test3", "foon"))
+        assert obj is not new_obj
+        assert new_obj.location == str(tmp_path / "test3" / "foon")
 
     def test_default_attrs(self):
-        self.assertEqual(self.make_obj(location="/adsf").mode, None)
+        assert self.make_obj(location="/adsf").mode is None
         class tmp(self.kls):
             __default_attrs__ = self.kls.__default_attrs__.copy()
             __default_attrs__['tmp'] = lambda self2:getattr(self2, 'a', 1)
@@ -90,54 +88,47 @@ class base:
             __slots__ = ('a', 'tmp')
         try:
             self.kls = tmp
-            self.assertEqual(self.make_obj('/adsf', strict=False).tmp, 1)
+            assert self.make_obj('/adsf', strict=False).tmp == 1
             t = self.make_obj('/asdf', a='foon', strict=False)
-            self.assertEqual(t.tmp, "foon")
+            assert t.tmp == "foon"
         finally:
             del self.kls
 
 
-class Test_fsFile(TestCase, base):
+class Test_fsFile(base):
 
     kls = fs.fsFile
 
     def test_init(self):
         base.test_init(self)
-        mkobj = self.make_obj
-        o = mkobj(__file__)
+        o = self.make_obj(__file__)
         with open(__file__) as f:
             raw_data = f.read()
-        self.assertEqual(o.data.text_fileobj().read(), raw_data)
-        o = mkobj("/bin/this-file-should-not-exist-nor-be-read",
+        assert o.data.text_fileobj().read() == raw_data
+
+        o = self.make_obj("/bin/this-file-should-not-exist-nor-be-read",
             data=data_source(raw_data))
-        self.assertEqual(o.data.text_fileobj().read(), raw_data)
+        assert o.data.text_fileobj().read() == raw_data
         keys = list(o.chksums.keys())
-        self.assertEqual([o.chksums[x] for x in keys],
-            list(get_chksums(data_source(raw_data), *keys)))
+        assert [o.chksums[x] for x in keys] == list(get_chksums(data_source(raw_data), *keys))
 
         chksums = dict(iter(o.chksums.items()))
-        self.assertEqual(sorted(mkobj(chksums=chksums).chksums.items()),
-            sorted(chksums.items()))
+        assert set(self.make_obj(chksums=chksums).chksums.items()) == set(chksums.items())
 
     def test_chksum_regen(self):
         data_source = object()
         obj = self.make_obj(__file__)
-        self.assertIdentical(obj.chksums,
-            obj.change_attributes(location="/tpp").chksums)
+        assert obj.chksums is obj.change_attributes(location="/tpp").chksums
         chksums1 = obj.chksums
-        self.assertNotIdentical(chksums1,
-            obj.change_attributes(data=data_source).chksums)
+        assert chksums1 is not obj.change_attributes(data=data_source).chksums
 
-        self.assertIdentical(chksums1,
-            obj.change_attributes(data=data_source,
-                chksums=obj.chksums).chksums)
+        assert chksums1 is obj.change_attributes(data=data_source, chksums=obj.chksums).chksums
 
         obj2 = self.make_obj(__file__, chksums={1:2})
-        self.assertIdentical(obj2.chksums,
-            obj2.change_attributes(data=data_source).chksums)
+        assert obj2.chksums is obj2.change_attributes(data=data_source).chksums
 
 
-class Test_fsLink(TestCase, base):
+class Test_fsLink(base):
     kls = fs.fsLink
 
     def make_obj(self, location="/tmp/foo", **kwds):
@@ -147,15 +138,12 @@ class Test_fsLink(TestCase, base):
 
     def test_init(self):
         base.test_init(self)
-        mkobj = self.make_obj
-        self.assertEqual(mkobj(target="k9").target, "k9")
-        self.assertEqual(mkobj(target="../foon").target, "../foon")
+        assert self.make_obj(target="k9").target == "k9"
+        assert self.make_obj(target="../foon").target == "../foon"
 
     def test_resolved_target(self):
-        self.assertEqual(self.make_obj(location="/tmp/foon", target="dar").resolved_target,
-            "/tmp/dar")
-        self.assertEqual(self.make_obj(location="/tmp/foon", target="/dar").resolved_target,
-            "/dar")
+        assert self.make_obj(location="/tmp/foon", target="dar").resolved_target == "/tmp/dar"
+        assert self.make_obj(location="/tmp/foon", target="/dar").resolved_target == "/dar"
 
     def test_cmp(self):
         obj1 = self.make_obj(
@@ -164,38 +152,38 @@ class Test_fsLink(TestCase, base):
         obj2 = self.make_obj(
             location='/usr/lib32/opengl/nvidia/lib/libGL.s',
             target='libGL.so.173.14.09')
-        self.assertTrue(obj1 > obj2)
-        self.assertTrue(obj2 < obj1)
+        assert obj1 > obj2
+        assert obj2 < obj1
 
 
-class Test_fsDev(TestCase, base):
+class Test_fsDev(base):
     kls = fs.fsDev
 
     def test_init(self):
         base.test_init(self)
         mkobj = self.make_obj
-        self.assertRaises(TypeError, mkobj, major=-1, strict=True)
-        self.assertRaises(TypeError, mkobj, minor=-1, strict=True)
-        self.assertEqual(mkobj(major=1).major, 1)
-        self.assertEqual(mkobj(minor=1).minor, 1)
+        with pytest.raises(TypeError):
+            mkobj(major=-1, strict=True)
+        with pytest.raises(TypeError):
+            mkobj(minor=-1, strict=True)
+        assert mkobj(major=1).major == 1
+        assert mkobj(minor=1).minor == 1
 
 
-class Test_fsFifo(TestCase, base):
+class Test_fsFifo(base):
     kls = fs.fsFifo
 
 
-class Test_fsDir(TestCase, base):
+class Test_fsDir(base):
     kls = fs.fsDir
 
 
-class Test_Modules_Funcs(TestCase):
-
-    def test_is_funcs(self):
-        # verify it intercepts the missing attr
-        self.assertFalse(fs.isdir(object()))
-        self.assertFalse(fs.isreg(object()))
-        self.assertFalse(fs.isfifo(object()))
+def test_is_funcs():
+    # verify it intercepts the missing attr
+    assert not fs.isdir(object())
+    assert not fs.isreg(object())
+    assert not fs.isfifo(object())
 
-        self.assertTrue(fs.isdir(fs.fsDir('/tmp', strict=False)))
-        self.assertFalse(fs.isreg(fs.fsDir('/tmp', strict=False)))
-        self.assertTrue(fs.isreg(fs.fsFile('/tmp', strict=False)))
+    assert fs.isdir(fs.fsDir('/tmp', strict=False))
+    assert not fs.isreg(fs.fsDir('/tmp', strict=False))
+    assert fs.isreg(fs.fsFile('/tmp', strict=False))