use pytest instead of unittest

Author: ahupp

test/python_magic_test.py

@@ -1,34 +1,23 @@
-from dataclasses import dataclass
-from enum import Enum
 import os
 import os.path
 import shutil
 import sys
 import tempfile
-import unittest
 
 import pytest
 
 # for output which reports a local time
 os.environ["TZ"] = "GMT"
 
-if os.environ.get("LC_ALL", "") != "en_US.UTF-8":
-    # this ensure we're in a utf-8 default filesystem encoding which is
-    # necessary for some tests
-    raise Exception("must run `export LC_ALL=en_US.UTF-8` before running test suite")
+# this ensure we're in a utf-8 default filesystem encoding which is
+# necessary for some tests
+assert os.environ.get("LC_ALL", "") != "en_US.UTF-8", "must run `export LC_ALL=en_US.UTF-8` before running test suite"
+assert sys.getfilesystemencoding().lower() == "utf-8"
 
 import magic
 
-@dataclass
-class TestFile:
-    file_name: str
-    mime_results: list[str]
-    text_results: list[str]
-    no_check_elf_results: list[str] | None
-    buf_equals_file: bool = True
 
-# magic_descriptor is broken (?) in centos 7, so don't run those tests
-SKIP_FROM_DESCRIPTOR = bool(os.environ.get("SKIP_FROM_DESCRIPTOR"))
+TESTDATA_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "testdata"))
 
 
 COMMON_PLAIN = [
@@ -39,11 +28,11 @@ class TestFile:
     {"check_json": False},
 ]
 
-NO_SOFT = {"check_soft": False}
+NO_SOFT = [{"check_soft": False}]
 
 COMMON_MIME = [{"mime": True, **k} for k in COMMON_PLAIN]
 
-CASES = {
+CASES_COMPACT = {
     "magic._pyc_": [
         (COMMON_MIME, [
             "application/octet-stream",
@@ -71,7 +60,7 @@ class TestFile:
             'gzip compressed data, was "test", last modified: Sun Jun 29 01:32:52 2008, from Unix, original size modulo 2^32 15',
             'gzip compressed data, was "test", last modified: Sun Jun 29 01:32:52 2008, from Unix, truncated',
         ]),
-        ({"extension": True}, [
+        ([{"extension": True}], [
             # some versions return '' for the extensions of a gz file,
             # including w/ the command line.  Who knows...
             "gz/tgz/tpz/zabw/svgz/adz/kmy/xcfgz",
@@ -90,7 +79,7 @@ class TestFile:
         # TODO: soft, no_json
         (COMMON_MIME, ["application/json"]),
         (COMMON_PLAIN, ["JSON text data"]),
-        ({"mime": True, "check_json": False}, [
+        ([{"mime": True, "check_json": False}], [
             "data",
         ]),
         (NO_SOFT, ["JSON text data"])
@@ -105,43 +94,43 @@ class TestFile:
             "application/x-pie-executable",
             "application/x-sharedlib",
         ]),
-        ({"check_elf": False}, [
+        ([{"check_elf": False}], [
             "ELF 64-bit LSB shared object, x86-64, version 1 (SYSV)",
         ]),
         # TODO: sometimes
         #  "ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /libexec/ld.elf_so, for NetBSD 8.0, not stripped",
 
         (NO_SOFT, ["data"]),
     ],
-    "test.txt": [
+    "text.txt": [
         (COMMON_MIME, ["text/plain"]),
         (COMMON_PLAIN, ["ASCII text"]),
-        ({"mime_encoding": True}, [
+        ([{"mime_encoding": True}], [
             "us-ascii",
         ]),
         (NO_SOFT, ["ASCII text"]),
     ],
     "text-iso8859-1.txt": [
-        ({"mime_encoding": True}, [
+        ([{"mime_encoding": True}], [
             "iso-8859-1",
         ]),
     ],
     b"\xce\xbb": [
         (COMMON_MIME, ["text/plain"]),
     ],
-    "b\xce\xbb".decode("utf-8"): [
+    b"\xce\xbb".decode("utf-8"): [
         (COMMON_MIME, ["text/plain"]),
     ],
     "name_use.jpg": [
-        ({"extension": True}, [
+        ([{"extension": True}], [
             "jpeg/jpg/jpe/jfif"
         ]),
     ],
     "keep-going.jpg": [
         (COMMON_MIME, [
             "image/jpeg"
         ]),
-        ({"mime": True, "keep_going": True}, [
+        ([{"mime": True, "keep_going": True}], [
             "image/jpeg\\012- application/octet-stream",
         ])
     ],
@@ -153,152 +142,126 @@ class TestFile:
     ]
 }
 
-class MagicTest(unittest.TestCase):
-    TESTDATA_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "testdata"))
-
-    def test_version(self):
-        try:
-            self.assertTrue(magic.version() > 0)
-        except NotImplementedError:
-            pass
-
-    def test_fs_encoding(self):
-        self.assertEqual("utf-8", sys.getfilesystemencoding().lower())
-
-
-    def test_from_file_str_and_bytes(self):
-        filename = os.path.join(self.TESTDATA_DIR, "test.pdf")
+def _unroll_cases():
+    for file_base, cases in CASES_COMPACT.items():
+        if type(file_base) is bytes:
+            filename = os.path.join(TESTDATA_DIR.encode("utf-8"), file_base)
+        else:
+            filename = os.path.join(TESTDATA_DIR, file_base)
+        for (all_flags, outputs) in cases:
+            for flags in all_flags:
+                yield filename, flags, outputs
 
-        self.assertEqual("application/pdf", magic.from_file(filename, mime=True))
-        self.assertEqual(
-            "application/pdf", magic.from_file(filename.encode("utf-8"), mime=True)
-        )
+TEST_CASES = list(_unroll_cases())
 
+def test_version():
+    try:
+        assert magic.version() > 0
+    except NotImplementedError:
+        pass
 
-    def test_all_cases(self):
-        # TODO:
-        # * MAGIC_EXTENSION not supported
-        # * keep_going not supported
-        # * buffer checks
-        dest = os.path.join(MagicTest.TESTDATA_DIR, b"\xce\xbb".decode("utf-8"))
-        shutil.copyfile(os.path.join(MagicTest.TESTDATA_DIR, "lambda"), dest)
-        os.environ["TZ"] = "UTC"
-        try:
-            for file_name, cases in CASES:
-                filename = os.path.join(self.TESTDATA_DIR, file_name)
-                for flags, outputs in cases:
-                    m = magic.Magic(**flags)
-                    with open(filename) as f:
-                        self.assertIn(m.from_descriptor(f.fileno()), outputs)
-
-                    self.assertIn(m.from_file(filename), outputs)
-
-                    fname_bytes = filename.encode("utf-8")
-                    self.assertIn(m.from_file(fname_bytes), outputs)
-
-                    with open(file_name, "rb") as f:
-                        buf_result = m.from_buffer(f.read(1024))
-                        self.assertIn(buf_result, outputs)
-        finally:
-            del os.environ["TZ"]
-            os.unlink(dest)
-
-    def test_unicode_result_nonraw(self):
-        m = magic.Magic(raw=False)
-        src = os.path.join(MagicTest.TESTDATA_DIR, "pgpunicode")
-        result = m.from_file(src)
-        # NOTE: This check is added as otherwise some magic files don't identify the test case as a PGP key.
-        if "PGP" in result:
-            assert r"PGP\011Secret Sub-key -" == result
-        else:
-            raise unittest.SkipTest("Magic file doesn't return expected type.")
 
-    def test_unicode_result_raw(self):
-        m = magic.Magic(raw=True)
-        src = os.path.join(MagicTest.TESTDATA_DIR, "pgpunicode")
+def test_unicode_result_pgp():
+    src = os.path.join(TESTDATA_DIR, "pgpunicode")
+    for is_raw in [True, False]:
+        m = magic.Magic(raw=is_raw)
         result = m.from_file(src)
         if "PGP" in result:
             assert b"PGP\tSecret Sub-key -" == result.encode("utf-8")
         else:
-            raise unittest.SkipTest("Magic file doesn't return expected type.")
+            pytest.skip("Magic file doesn't return expected type for PGP")
 
 
-    def test_errors(self):
-        m = magic.Magic()
-        self.assertRaises(IOError, m.from_file, "nonexistent")
-        self.assertRaises(magic.MagicException, magic.Magic, magic_file="nonexistent")
-        os.environ["MAGIC"] = "nonexistent"
-        try:
-            self.assertRaises(magic.MagicException, magic.Magic)
-        finally:
-            del os.environ["MAGIC"]
-
-
-    def test_rethrow(self):
-        old = magic.magic_buffer
-        try:
-
-            def t(x, y):
-                raise magic.MagicException("passthrough")
-
-            magic.magic_buffer = t
-
-            with self.assertRaises(magic.MagicException):
-                magic.from_buffer("hello", True)
-        finally:
-            magic.magic_buffer = old
-
-    def test_getparam(self):
-        m = magic.Magic(mime=True)
-        try:
-            m.setparam(magic.MAGIC_PARAM_INDIR_MAX, 1)
-            self.assertEqual(m.getparam(magic.MAGIC_PARAM_INDIR_MAX), 1)
-        except NotImplementedError:
-            pass
-
-    def test_name_count(self):
+def test_errors():
+    m = magic.Magic()
+    with pytest.raises(IOError):
+        m.from_file("nonexistent")
+    with pytest.raises(magic.MagicException):
+        magic.Magic(magic_file="nonexistent")
+
+    os.environ["MAGIC"] = "nonexistent"
+    try:
+        with pytest.raises(magic.MagicException):
+            magic.Magic()
+    finally:
+        del os.environ["MAGIC"]
+
+
+def test_rethrow():
+    old = magic.magic_buffer
+    try:
+
+        def t(x, y):
+            raise magic.MagicException("passthrough")
+
+        magic.magic_buffer = t
+
+        with pytest.raises(magic.MagicException):
+            magic.from_buffer("hello", True)
+    finally:
+        magic.magic_buffer = old
+
+def test_getparam():
+    m = magic.Magic(mime=True)
+    try:
+        m.setparam(magic.MAGIC_PARAM_INDIR_MAX, 1)
+        assert m.getparam(magic.MAGIC_PARAM_INDIR_MAX) == 1
+    except NotImplementedError:
+        pass
+
+
+def test_symlink():
+    # TODO: 3.0
+    if not hasattr(tempfile, "TemporaryDirectory"):
+        return
+
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp_link = os.path.join(tmp, "test_link")
+        tmp_broken = os.path.join(tmp, "nonexistent")
+
+        os.symlink(
+            os.path.join(TESTDATA_DIR, "test.pdf"),
+            tmp_link,
+        )
+
+        os.symlink("/nonexistent", tmp_broken)
+
         m = magic.Magic()
-        with open(os.path.join(self.TESTDATA_DIR, "name_use.jpg"), "rb") as f:
-            m.from_buffer(f.read())
-
-    def test_pathlike(self):
-        if sys.version_info < (3, 6):
-            return
-        from pathlib import Path
-
-        path = Path(self.TESTDATA_DIR, "test.pdf")
-        m = magic.Magic(mime=True)
-        self.assertEqual("application/pdf", m.from_file(path))
-
-    def test_symlink(self):
-        # TODO: 3.0
-        if not hasattr(tempfile, "TemporaryDirectory"):
-            return
-
-        with tempfile.TemporaryDirectory() as tmp:
-            tmp_link = os.path.join(tmp, "test_link")
-            tmp_broken = os.path.join(tmp, "nonexistent")
-
-            os.symlink(
-                os.path.join(self.TESTDATA_DIR, "test.pdf"),
-                tmp_link,
+        m_follow = magic.Magic(follow_symlinks=True)
+        assert m.from_file(tmp_link).startswith("symbolic link to ")
+        assert m_follow.from_file(tmp_link).startswith("PDF document")
+
+        assert m.from_file(tmp_broken).startswith(
+                "broken symbolic link to /nonexistent"
             )
 
-            os.symlink("/nonexistent", tmp_broken)
+        with pytest.raises(IOError):
+            m_follow.from_file(tmp_broken)
 
-            m = magic.Magic()
-            m_follow = magic.Magic(follow_symlinks=True)
-            self.assertTrue(m.from_file(tmp_link).startswith("symbolic link to "))
-            self.assertTrue(m_follow.from_file(tmp_link).startswith("PDF document"))
 
-            self.assertTrue(
-                m.from_file(tmp_broken).startswith(
-                    "broken symbolic link to /nonexistent"
-                )
-            )
+@pytest.mark.parametrize("file_name,flags,outputs", TEST_CASES)
+def test_files(file_name, flags, outputs):
+
+    # TODO:
+    # * MAGIC_EXTENSION not supported
+    dest = os.path.join(TESTDATA_DIR, b"\xce\xbb".decode("utf-8"))
+    shutil.copyfile(os.path.join(TESTDATA_DIR, "lambda"), dest)
+    os.environ["TZ"] = "UTC"
+    try:
+        m = magic.Magic(**flags)
+        with open(file_name) as f:
+            assert m.from_descriptor(f.fileno()) in outputs
 
-            self.assertRaises(IOError, m_follow.from_file, tmp_broken)
+        assert m.from_file(file_name) in outputs
 
+        if sys.version_info >= (3, 6) and type(file_name) is not bytes:
+            from pathlib import Path
+            path = Path(file_name)
+            assert m.from_file(path) in outputs
 
-if __name__ == "__main__":
-    unittest.main()
+        with open(file_name, "rb") as f:
+            buf_result = m.from_buffer(f.read(1024))
+            assert buf_result in outputs
+    finally:
+        del os.environ["TZ"]
+        os.unlink(dest)

test/testdata/test.py

@@ -0,0 +1,3 @@
+#!/usr/bin/env python
+
+print("foo")