Merge pull request testing-cabal#592 from stephenfin/typing

Even more typing tweaks

Author: jelmer

doc/for-test-authors.rst

@@ -937,7 +937,9 @@ the ``Mismatch`` knows how to describe a failure to match.
 
 Here's an example matcher::
 
-  class IsDivisibleBy(object):
+  from testtools.matchers import Matcher
+
+  class IsDivisibleBy(Matcher):
       """Match if a number is divisible by another number."""
       def __init__(self, divider):
           self.divider = divider

tests/helpers.py

@@ -13,6 +13,7 @@
 from testtools.matchers import (
     AfterPreprocessing,
     Equals,
+    Matcher,
     MatchesDict,
     MatchesListwise,
 )
@@ -108,7 +109,7 @@ def _run_user(self, fn, *args, **kwargs):
         return run_with_stack_hidden(False, super()._run_user, fn, *args, **kwargs)
 
 
-class MatchesEvents:
+class MatchesEvents(Matcher[list[tuple[str, ...]]]):
     """Match a list of test result events.
 
     Specify events as a data structure.  Ordinary Python objects within this

tests/matchers/test_basic.py

@@ -274,7 +274,7 @@ def test_str_with_unicode(self):
 
     def test_match(self):
         matcher = StartsWith("bar")
-        self.assertIs(None, matcher.match("barf"))
+        self.assertIsNone(matcher.match("barf"))
 
     def test_mismatch_returns_does_not_start_with(self):
         matcher = StartsWith("bar")
@@ -283,11 +283,15 @@ def test_mismatch_returns_does_not_start_with(self):
     def test_mismatch_sets_matchee(self):
         matcher = StartsWith("bar")
         mismatch = matcher.match("foo")
+        self.assertIsNotNone(mismatch)
+        assert mismatch is not None
         self.assertEqual("foo", mismatch.matchee)
 
     def test_mismatch_sets_expected(self):
         matcher = StartsWith("bar")
         mismatch = matcher.match("foo")
+        self.assertIsNotNone(mismatch)
+        assert mismatch is not None
         self.assertEqual("bar", mismatch.expected)
 
 
@@ -344,11 +348,15 @@ def test_mismatch_returns_does_not_end_with(self):
     def test_mismatch_sets_matchee(self):
         matcher = EndsWith("bar")
         mismatch = matcher.match("foo")
+        self.assertIsNotNone(mismatch)
+        assert mismatch is not None
         self.assertEqual("foo", mismatch.matchee)
 
     def test_mismatch_sets_expected(self):
         matcher = EndsWith("bar")
         mismatch = matcher.match("foo")
+        self.assertIsNotNone(mismatch)
+        assert mismatch is not None
         self.assertEqual("bar", mismatch.expected)
 
 
@@ -503,6 +511,7 @@ def test_integers_mismatch(self):
         matcher = Nearly(10, delta=2)
         mismatch = matcher.match(13)
         self.assertIsNotNone(mismatch)
+        assert mismatch is not None
         self.assertIn("13", mismatch.describe())
 
     def test_exact_boundary_matches(self):
@@ -542,14 +551,17 @@ def test_default_delta(self):
     def test_non_numeric_type_mismatch(self):
         """Test that non-numeric types result in a mismatch."""
         matcher = Nearly(1.0, delta=0.1)
-        mismatch = matcher.match("string")
+        # intentional type mismatch
+        mismatch = matcher.match("string")  # type: ignore[arg-type]
         self.assertIsNotNone(mismatch)
+        assert mismatch is not None
         self.assertIn("string", mismatch.describe())
 
     def test_none_type_mismatch(self):
         """Test that None results in a mismatch."""
         matcher = Nearly(1.0, delta=0.1)
-        mismatch = matcher.match(None)
+        # intentional type mismatch
+        mismatch = matcher.match(None)  # type: ignore[arg-type]
         self.assertIsNotNone(mismatch)
 
 

tests/matchers/test_dict.py

@@ -75,6 +75,8 @@ class TestKeysEqualWithList(TestCase, TestMatchersInterface):
     def test_description(self):
         matchee = {"foo": 0, "bar": 1, "baz": 2}
         mismatch = KeysEqual("foo", "bar").match(matchee)
+        self.assertIsNotNone(mismatch)
+        assert mismatch is not None
         description = mismatch.describe()
         self.assertThat(
             description,

tests/matchers/test_filesystem.py

@@ -53,6 +53,8 @@ def test_exists(self):
     def test_not_exists(self):
         doesntexist = os.path.join(self.mkdtemp(), "doesntexist")
         mismatch = PathExists().match(doesntexist)
+        self.assertIsNotNone(mismatch)
+        assert mismatch is not None
         self.assertThat(f"{doesntexist} does not exist.", Equals(mismatch.describe()))
 
 
@@ -63,15 +65,20 @@ def test_exists(self):
 
     def test_not_exists(self):
         doesntexist = os.path.join(self.mkdtemp(), "doesntexist")
-        mismatch = DirExists().match(doesntexist)
-        self.assertThat(
-            PathExists().match(doesntexist).describe(), Equals(mismatch.describe())
-        )
+        dir_mismatch = DirExists().match(doesntexist)
+        self.assertIsNotNone(dir_mismatch)
+        assert dir_mismatch is not None
+        path_mismatch = PathExists().match(doesntexist)
+        self.assertIsNotNone(path_mismatch)
+        assert path_mismatch is not None
+        self.assertThat(path_mismatch.describe(), Equals(dir_mismatch.describe()))
 
     def test_not_a_directory(self):
         filename = os.path.join(self.mkdtemp(), "foo")
         self.touch(filename)
         mismatch = DirExists().match(filename)
+        self.assertIsNotNone(mismatch)
+        assert mismatch is not None
         self.assertThat(f"{filename} is not a directory.", Equals(mismatch.describe()))
 
 
@@ -84,14 +91,19 @@ def test_exists(self):
 
     def test_not_exists(self):
         doesntexist = os.path.join(self.mkdtemp(), "doesntexist")
-        mismatch = FileExists().match(doesntexist)
-        self.assertThat(
-            PathExists().match(doesntexist).describe(), Equals(mismatch.describe())
-        )
+        file_mismatch = FileExists().match(doesntexist)
+        self.assertIsNotNone(file_mismatch)
+        assert file_mismatch is not None
+        path_mismatch = PathExists().match(doesntexist)
+        self.assertIsNotNone(path_mismatch)
+        assert path_mismatch is not None
+        self.assertThat(path_mismatch.describe(), Equals(file_mismatch.describe()))
 
     def test_not_a_file(self):
         tempdir = self.mkdtemp()
         mismatch = FileExists().match(tempdir)
+        self.assertIsNotNone(mismatch)
+        assert mismatch is not None
         self.assertThat(f"{tempdir} is not a file.", Equals(mismatch.describe()))
 
 
@@ -102,10 +114,13 @@ def test_empty(self):
 
     def test_not_exists(self):
         doesntexist = os.path.join(self.mkdtemp(), "doesntexist")
-        mismatch = DirContains([]).match(doesntexist)
-        self.assertThat(
-            PathExists().match(doesntexist).describe(), Equals(mismatch.describe())
-        )
+        dir_mismatch = DirContains([]).match(doesntexist)
+        self.assertIsNotNone(dir_mismatch)
+        assert dir_mismatch is not None
+        path_mismatch = PathExists().match(doesntexist)
+        self.assertIsNotNone(path_mismatch)
+        assert path_mismatch is not None
+        self.assertThat(path_mismatch.describe(), Equals(dir_mismatch.describe()))
 
     def test_contains_files(self):
         tempdir = self.mkdtemp()
@@ -130,20 +145,25 @@ def test_both_specified(self):
     def test_does_not_contain_files(self):
         tempdir = self.mkdtemp()
         self.touch(os.path.join(tempdir, "foo"))
-        mismatch = DirContains(["bar", "foo"]).match(tempdir)
-        self.assertThat(
-            Equals(["bar", "foo"]).match(["foo"]).describe(),
-            Equals(mismatch.describe()),
-        )
+        mismatch_a = DirContains(["bar", "foo"]).match(tempdir)
+        self.assertIsNotNone(mismatch_a)
+        assert mismatch_a is not None
+        mismatch_b = Equals(["bar", "foo"]).match(["foo"])
+        self.assertIsNotNone(mismatch_b)
+        assert mismatch_b is not None
+        self.assertThat(mismatch_b.describe(), Equals(mismatch_a.describe()))
 
 
 class TestFileContains(TestCase, PathHelpers):
     def test_not_exists(self):
         doesntexist = os.path.join(self.mkdtemp(), "doesntexist")
-        mismatch = FileContains("").match(doesntexist)
-        self.assertThat(
-            PathExists().match(doesntexist).describe(), Equals(mismatch.describe())
-        )
+        file_mismatch = FileContains("").match(doesntexist)
+        self.assertIsNotNone(file_mismatch)
+        assert file_mismatch is not None
+        path_mismatch = PathExists().match(doesntexist)
+        self.assertIsNotNone(path_mismatch)
+        assert path_mismatch is not None
+        self.assertThat(path_mismatch.describe(), Equals(file_mismatch.describe()))
 
     def test_contains(self):
         tempdir = self.mkdtemp()
@@ -169,11 +189,13 @@ def test_does_not_contain(self):
         tempdir = self.mkdtemp()
         filename = os.path.join(tempdir, "foo")
         self.create_file(filename, "Goodbye Cruel World!")
-        mismatch = FileContains("Hello World!").match(filename)
-        self.assertThat(
-            Equals("Hello World!").match("Goodbye Cruel World!").describe(),
-            Equals(mismatch.describe()),
-        )
+        actual = FileContains("Hello World!").match(filename)
+        self.assertIsNotNone(actual)
+        assert actual is not None
+        expected = Equals("Hello World!").match("Goodbye Cruel World!")
+        self.assertIsNotNone(expected)
+        assert expected is not None
+        self.assertThat(expected.describe(), Equals(actual.describe()))
 
     def test_binary_content(self):
         tempdir = self.mkdtemp()
@@ -188,11 +210,13 @@ def test_binary_content_mismatch(self):
         filename = os.path.join(tempdir, "binary_file")
         with open(filename, "wb") as f:
             f.write(b"\x00\x01\x02")
-        mismatch = FileContains(b"\xff\xfe\xfd").match(filename)
-        self.assertThat(
-            Equals(b"\xff\xfe\xfd").match(b"\x00\x01\x02").describe(),
-            Equals(mismatch.describe()),
-        )
+        actual = FileContains(b"\xff\xfe\xfd").match(filename)
+        self.assertIsNotNone(actual)
+        assert actual is not None
+        expected = Equals(b"\xff\xfe\xfd").match(b"\x00\x01\x02")
+        self.assertIsNotNone(expected)
+        assert expected is not None
+        self.assertThat(expected.describe(), Equals(actual.describe()))
 
     def test_text_with_encoding(self):
         tempdir = self.mkdtemp()
@@ -238,10 +262,13 @@ def in_temp_dir(x):
         tarball.add(in_temp_dir("a"), "a")
         tarball.add(in_temp_dir("b"), "b")
         tarball.close()
-        mismatch = TarballContains(["d", "c"]).match(in_temp_dir("foo.tar.gz"))
-        self.assertEqual(
-            mismatch.describe(), Equals(["c", "d"]).match(["a", "b"]).describe()
-        )
+        actual = TarballContains(["d", "c"]).match(in_temp_dir("foo.tar.gz"))
+        self.assertIsNotNone(actual)
+        assert actual is not None
+        expected = Equals(["c", "d"]).match(["a", "b"])
+        self.assertIsNotNone(expected)
+        assert expected is not None
+        self.assertEqual(actual.describe(), expected.describe())
 
 
 class TestSamePath(TestCase, PathHelpers):

tests/matchers/test_higherorder.py

@@ -3,6 +3,7 @@
 from typing import ClassVar
 
 from testtools import TestCase
+from testtools.content import text_content
 from testtools.matchers import (
     DocTestMatches,
     Equals,
@@ -192,7 +193,7 @@ def test_if_message_given_message(self):
         matcher = Equals(1)
         expected = Annotate("foo", matcher)
         annotated = Annotate.if_message("foo", matcher)
-        self.assertThat(
+        self.assertThat(  # type: ignore[misc]
             annotated, MatchesStructure.fromExample(expected, "annotation", "matcher")
         )
 
@@ -201,7 +202,7 @@ class TestAnnotatedMismatch(TestCase):
     run_tests_with = FullStackRunTest
 
     def test_forwards_details(self):
-        x = Mismatch("description", {"foo": "bar"})
+        x = Mismatch("description", {"foo": text_content("bar")})
         annotated = AnnotatedMismatch("annotation", x)
         self.assertEqual(x.get_details(), annotated.get_details())
 

tests/matchers/test_impl.py

@@ -9,6 +9,7 @@
 from testtools.compat import (
     text_repr,
 )
+from testtools.content import text_content
 from testtools.matchers import (
     Equals,
     MatchesException,
@@ -30,9 +31,10 @@ class TestMismatch(TestCase):
     run_tests_with = FullStackRunTest
 
     def test_constructor_arguments(self):
-        mismatch = Mismatch("some description", {"detail": "things"})
+        detail = text_content("things")
+        mismatch = Mismatch("some description", {"detail": detail})
         self.assertEqual("some description", mismatch.describe())
-        self.assertEqual({"detail": "things"}, mismatch.get_details())
+        self.assertEqual({"detail": detail}, mismatch.get_details())
 
     def test_constructor_no_arguments(self):
         mismatch = Mismatch()
@@ -47,30 +49,39 @@ def test_is_assertion_error(self):
         # MismatchError is an AssertionError, so that most of the time, it
         # looks like a test failure, rather than an error.
         def raise_mismatch_error():
-            raise MismatchError(2, Equals(3), Equals(3).match(2))
+            mismatch = Equals(3).match(2)
+            self.assertIsNotNone(mismatch)
+            assert mismatch is not None
+            raise MismatchError(2, Equals(3), mismatch)
 
         self.assertRaises(AssertionError, raise_mismatch_error)
 
     def test_default_description_is_mismatch(self):
         mismatch = Equals(3).match(2)
+        self.assertIsNotNone(mismatch)
+        assert mismatch is not None
         e = MismatchError(2, Equals(3), mismatch)
         self.assertEqual(mismatch.describe(), str(e))
 
     def test_default_description_unicode(self):
         matchee = "\xa7"
         matcher = Equals("a")
         mismatch = matcher.match(matchee)
+        self.assertIsNotNone(mismatch)
+        assert mismatch is not None
         e = MismatchError(matchee, matcher, mismatch)
         self.assertEqual(mismatch.describe(), str(e))
 
     def test_verbose_description(self):
         matchee = 2
         matcher = Equals(3)
-        mismatch = matcher.match(2)
+        mismatch = matcher.match(matchee)
+        self.assertIsNotNone(mismatch)
+        assert mismatch is not None
         e = MismatchError(matchee, matcher, mismatch, True)
         expected = (
             f"Match failed. Matchee: {matchee!r}\nMatcher: {matcher}\n"
-            f"Difference: {matcher.match(matchee).describe()}\n"
+            f"Difference: {mismatch.describe()}\n"
         )
         self.assertEqual(expected, str(e))
 
@@ -80,6 +91,8 @@ def test_verbose_unicode(self):
         matchee = "\xa7"
         matcher = Equals("a")
         mismatch = matcher.match(matchee)
+        self.assertIsNotNone(mismatch)
+        assert mismatch is not None
         expected = (
             f"Match failed. Matchee: {text_repr(matchee)}\nMatcher: {matcher}\n"
             f"Difference: {mismatch.describe()}\n"
@@ -92,17 +105,17 @@ class TestMismatchDecorator(TestCase):
     run_tests_with = FullStackRunTest
 
     def test_forwards_description(self):
-        x = Mismatch("description", {"foo": "bar"})
+        x = Mismatch("description", {"foo": text_content("bar")})
         decorated = MismatchDecorator(x)
         self.assertEqual(x.describe(), decorated.describe())
 
     def test_forwards_details(self):
-        x = Mismatch("description", {"foo": "bar"})
+        x = Mismatch("description", {"foo": text_content("bar")})
         decorated = MismatchDecorator(x)
         self.assertEqual(x.get_details(), decorated.get_details())
 
     def test_repr(self):
-        x = Mismatch("description", {"foo": "bar"})
+        x = Mismatch("description", {"foo": text_content("bar")})
         decorated = MismatchDecorator(x)
         self.assertEqual(
             f"<testtools.matchers.MismatchDecorator({x!r})>", repr(decorated)