Merge pull request #4391 from radarhere/pytest

Convert various tests to pytest style

Author: hugovk

Tests/test_features.py

@@ -1,10 +1,8 @@
 import io
-import unittest
 
+import pytest
 from PIL import features
 
-from .helper import PillowTestCase
-
 try:
     from PIL import _webp
 
@@ -13,78 +11,85 @@
     HAVE_WEBP = False
 
 
-class TestFeatures(PillowTestCase):
-    def test_check(self):
-        # Check the correctness of the convenience function
-        for module in features.modules:
-            self.assertEqual(features.check_module(module), features.check(module))
-        for codec in features.codecs:
-            self.assertEqual(features.check_codec(codec), features.check(codec))
-        for feature in features.features:
-            self.assertEqual(features.check_feature(feature), features.check(feature))
-
-    @unittest.skipUnless(HAVE_WEBP, "WebP not available")
-    def test_webp_transparency(self):
-        self.assertEqual(
-            features.check("transp_webp"), not _webp.WebPDecoderBuggyAlpha()
-        )
-        self.assertEqual(features.check("transp_webp"), _webp.HAVE_TRANSPARENCY)
-
-    @unittest.skipUnless(HAVE_WEBP, "WebP not available")
-    def test_webp_mux(self):
-        self.assertEqual(features.check("webp_mux"), _webp.HAVE_WEBPMUX)
-
-    @unittest.skipUnless(HAVE_WEBP, "WebP not available")
-    def test_webp_anim(self):
-        self.assertEqual(features.check("webp_anim"), _webp.HAVE_WEBPANIM)
-
-    def test_check_modules(self):
-        for feature in features.modules:
-            self.assertIn(features.check_module(feature), [True, False])
-        for feature in features.codecs:
-            self.assertIn(features.check_codec(feature), [True, False])
-
-    def test_supported_modules(self):
-        self.assertIsInstance(features.get_supported_modules(), list)
-        self.assertIsInstance(features.get_supported_codecs(), list)
-        self.assertIsInstance(features.get_supported_features(), list)
-        self.assertIsInstance(features.get_supported(), list)
-
-    def test_unsupported_codec(self):
-        # Arrange
-        codec = "unsupported_codec"
-        # Act / Assert
-        self.assertRaises(ValueError, features.check_codec, codec)
-
-    def test_unsupported_module(self):
-        # Arrange
-        module = "unsupported_module"
-        # Act / Assert
-        self.assertRaises(ValueError, features.check_module, module)
-
-    def test_pilinfo(self):
-        buf = io.StringIO()
-        features.pilinfo(buf)
-        out = buf.getvalue()
-        lines = out.splitlines()
-        self.assertEqual(lines[0], "-" * 68)
-        self.assertTrue(lines[1].startswith("Pillow "))
-        self.assertTrue(lines[2].startswith("Python "))
-        lines = lines[3:]
-        while lines[0].startswith("    "):
-            lines = lines[1:]
-        self.assertEqual(lines[0], "-" * 68)
-        self.assertTrue(lines[1].startswith("Python modules loaded from "))
-        self.assertTrue(lines[2].startswith("Binary modules loaded from "))
-        self.assertEqual(lines[3], "-" * 68)
-        jpeg = (
-            "\n"
-            + "-" * 68
-            + "\n"
-            + "JPEG image/jpeg\n"
-            + "Extensions: .jfif, .jpe, .jpeg, .jpg\n"
-            + "Features: open, save\n"
-            + "-" * 68
-            + "\n"
-        )
-        self.assertIn(jpeg, out)
+def test_check():
+    # Check the correctness of the convenience function
+    for module in features.modules:
+        assert features.check_module(module) == features.check(module)
+    for codec in features.codecs:
+        assert features.check_codec(codec) == features.check(codec)
+    for feature in features.features:
+        assert features.check_feature(feature) == features.check(feature)
+
+
+@pytest.mark.skipif(not HAVE_WEBP, reason="WebP not available")
+def test_webp_transparency():
+    assert features.check("transp_webp") != _webp.WebPDecoderBuggyAlpha()
+    assert features.check("transp_webp") == _webp.HAVE_TRANSPARENCY
+
+
+@pytest.mark.skipif(not HAVE_WEBP, reason="WebP not available")
+def test_webp_mux():
+    assert features.check("webp_mux") == _webp.HAVE_WEBPMUX
+
+
+@pytest.mark.skipif(not HAVE_WEBP, reason="WebP not available")
+def test_webp_anim():
+    assert features.check("webp_anim") == _webp.HAVE_WEBPANIM
+
+
+def test_check_modules():
+    for feature in features.modules:
+        assert features.check_module(feature) in [True, False]
+    for feature in features.codecs:
+        assert features.check_codec(feature) in [True, False]
+
+
+def test_supported_modules():
+    assert isinstance(features.get_supported_modules(), list)
+    assert isinstance(features.get_supported_codecs(), list)
+    assert isinstance(features.get_supported_features(), list)
+    assert isinstance(features.get_supported(), list)
+
+
+def test_unsupported_codec():
+    # Arrange
+    codec = "unsupported_codec"
+    # Act / Assert
+    with pytest.raises(ValueError):
+        features.check_codec(codec)
+
+
+def test_unsupported_module():
+    # Arrange
+    module = "unsupported_module"
+    # Act / Assert
+    with pytest.raises(ValueError):
+        features.check_module(module)
+
+
+def test_pilinfo():
+    buf = io.StringIO()
+    features.pilinfo(buf)
+    out = buf.getvalue()
+    lines = out.splitlines()
+    assert lines[0] == "-" * 68
+    assert lines[1].startswith("Pillow ")
+    assert lines[2].startswith("Python ")
+    lines = lines[3:]
+    while lines[0].startswith("    "):
+        lines = lines[1:]
+    assert lines[0] == "-" * 68
+    assert lines[1].startswith("Python modules loaded from ")
+    assert lines[2].startswith("Binary modules loaded from ")
+    assert lines[3] == "-" * 68
+    jpeg = (
+        "\n"
+        + "-" * 68
+        + "\n"
+        + "JPEG image/jpeg\n"
+        + "Extensions: .jfif, .jpe, .jpeg, .jpg\n"
+        + "Features: open, save\n"
+        + "-" * 68
+        + "\n"
+    )
+    assert jpeg in out

Tests/test_file_cur.py

@@ -1,28 +1,29 @@
+import pytest
 from PIL import CurImagePlugin, Image
 
-from .helper import PillowTestCase
-
 TEST_FILE = "Tests/images/deerstalker.cur"
 
 
-class TestFileCur(PillowTestCase):
-    def test_sanity(self):
-        with Image.open(TEST_FILE) as im:
-            self.assertEqual(im.size, (32, 32))
-            self.assertIsInstance(im, CurImagePlugin.CurImageFile)
-            # Check some pixel colors to ensure image is loaded properly
-            self.assertEqual(im.getpixel((10, 1)), (0, 0, 0, 0))
-            self.assertEqual(im.getpixel((11, 1)), (253, 254, 254, 1))
-            self.assertEqual(im.getpixel((16, 16)), (84, 87, 86, 255))
+def test_sanity():
+    with Image.open(TEST_FILE) as im:
+        assert im.size == (32, 32)
+        assert isinstance(im, CurImagePlugin.CurImageFile)
+        # Check some pixel colors to ensure image is loaded properly
+        assert im.getpixel((10, 1)) == (0, 0, 0, 0)
+        assert im.getpixel((11, 1)) == (253, 254, 254, 1)
+        assert im.getpixel((16, 16)) == (84, 87, 86, 255)
+
 
-    def test_invalid_file(self):
-        invalid_file = "Tests/images/flower.jpg"
+def test_invalid_file():
+    invalid_file = "Tests/images/flower.jpg"
 
-        self.assertRaises(SyntaxError, CurImagePlugin.CurImageFile, invalid_file)
+    with pytest.raises(SyntaxError):
+        CurImagePlugin.CurImageFile(invalid_file)
 
-        no_cursors_file = "Tests/images/no_cursors.cur"
+    no_cursors_file = "Tests/images/no_cursors.cur"
 
-        cur = CurImagePlugin.CurImageFile(TEST_FILE)
-        cur.fp.close()
-        with open(no_cursors_file, "rb") as cur.fp:
-            self.assertRaises(TypeError, cur._open)
+    cur = CurImagePlugin.CurImageFile(TEST_FILE)
+    cur.fp.close()
+    with open(no_cursors_file, "rb") as cur.fp:
+        with pytest.raises(TypeError):
+            cur._open()

Tests/test_file_fitsstub.py

@@ -1,46 +1,47 @@
+import pytest
 from PIL import FitsStubImagePlugin, Image
 
-from .helper import PillowTestCase
-
 TEST_FILE = "Tests/images/hopper.fits"
 
 
-class TestFileFitsStub(PillowTestCase):
-    def test_open(self):
-        # Act
-        with Image.open(TEST_FILE) as im:
+def test_open():
+    # Act
+    with Image.open(TEST_FILE) as im:
+
+        # Assert
+        assert im.format == "FITS"
+
+        # Dummy data from the stub
+        assert im.mode == "F"
+        assert im.size == (1, 1)
+
 
-            # Assert
-            self.assertEqual(im.format, "FITS")
+def test_invalid_file():
+    # Arrange
+    invalid_file = "Tests/images/flower.jpg"
 
-            # Dummy data from the stub
-            self.assertEqual(im.mode, "F")
-            self.assertEqual(im.size, (1, 1))
+    # Act / Assert
+    with pytest.raises(SyntaxError):
+        FitsStubImagePlugin.FITSStubImageFile(invalid_file)
 
-    def test_invalid_file(self):
-        # Arrange
-        invalid_file = "Tests/images/flower.jpg"
 
-        # Act / Assert
-        self.assertRaises(
-            SyntaxError, FitsStubImagePlugin.FITSStubImageFile, invalid_file
-        )
+def test_load():
+    # Arrange
+    with Image.open(TEST_FILE) as im:
 
-    def test_load(self):
-        # Arrange
-        with Image.open(TEST_FILE) as im:
+        # Act / Assert: stub cannot load without an implemented handler
+        with pytest.raises(IOError):
+            im.load()
 
-            # Act / Assert: stub cannot load without an implemented handler
-            self.assertRaises(IOError, im.load)
 
-    def test_save(self):
-        # Arrange
-        with Image.open(TEST_FILE) as im:
-            dummy_fp = None
-            dummy_filename = "dummy.filename"
+def test_save():
+    # Arrange
+    with Image.open(TEST_FILE) as im:
+        dummy_fp = None
+        dummy_filename = "dummy.filename"
 
-            # Act / Assert: stub cannot save without an implemented handler
-            self.assertRaises(IOError, im.save, dummy_filename)
-            self.assertRaises(
-                IOError, FitsStubImagePlugin._save, im, dummy_fp, dummy_filename
-            )
+        # Act / Assert: stub cannot save without an implemented handler
+        with pytest.raises(IOError):
+            im.save(dummy_filename)
+        with pytest.raises(IOError):
+            FitsStubImagePlugin._save(im, dummy_fp, dummy_filename)

Tests/test_file_gribstub.py

@@ -1,42 +1,46 @@
+import pytest
 from PIL import GribStubImagePlugin, Image
 
-from .helper import PillowTestCase, hopper
+from .helper import hopper
 
 TEST_FILE = "Tests/images/WAlaska.wind.7days.grb"
 
 
-class TestFileGribStub(PillowTestCase):
-    def test_open(self):
-        # Act
-        with Image.open(TEST_FILE) as im:
+def test_open():
+    # Act
+    with Image.open(TEST_FILE) as im:
 
-            # Assert
-            self.assertEqual(im.format, "GRIB")
+        # Assert
+        assert im.format == "GRIB"
 
-            # Dummy data from the stub
-            self.assertEqual(im.mode, "F")
-            self.assertEqual(im.size, (1, 1))
+        # Dummy data from the stub
+        assert im.mode == "F"
+        assert im.size == (1, 1)
 
-    def test_invalid_file(self):
-        # Arrange
-        invalid_file = "Tests/images/flower.jpg"
 
-        # Act / Assert
-        self.assertRaises(
-            SyntaxError, GribStubImagePlugin.GribStubImageFile, invalid_file
-        )
+def test_invalid_file():
+    # Arrange
+    invalid_file = "Tests/images/flower.jpg"
 
-    def test_load(self):
-        # Arrange
-        with Image.open(TEST_FILE) as im:
+    # Act / Assert
+    with pytest.raises(SyntaxError):
+        GribStubImagePlugin.GribStubImageFile(invalid_file)
 
-            # Act / Assert: stub cannot load without an implemented handler
-            self.assertRaises(IOError, im.load)
 
-    def test_save(self):
-        # Arrange
-        im = hopper()
-        tmpfile = self.tempfile("temp.grib")
+def test_load():
+    # Arrange
+    with Image.open(TEST_FILE) as im:
 
-        # Act / Assert: stub cannot save without an implemented handler
-        self.assertRaises(IOError, im.save, tmpfile)
+        # Act / Assert: stub cannot load without an implemented handler
+        with pytest.raises(IOError):
+            im.load()
+
+
+def test_save(tmp_path):
+    # Arrange
+    im = hopper()
+    tmpfile = str(tmp_path / "temp.grib")
+
+    # Act / Assert: stub cannot save without an implemented handler
+    with pytest.raises(IOError):
+        im.save(tmpfile)