Move _AssertRaisesContext

This allows us to avoid the quoting due to a forward reference. We also
drop some unnecessary `type: ignore` comments. This is done in
preparation of some typing bug fixes.

Signed-off-by: Stephen Finucane <stephen@that.guru>

Author: stephenfin

testtools/testcase.py

@@ -243,6 +243,61 @@ def unique_text_generator(prefix: str) -> Iterator[str]:
         index = index + 1
 
 
+class _AssertRaisesContext(Generic[_E]):
+    """A context manager to handle expected exceptions for assertRaises.
+
+    This provides compatibility with unittest's assertRaises context manager.
+    """
+
+    def __init__(
+        self,
+        expected: type[_E] | tuple[type[BaseException], ...],
+        test_case: "TestCase",
+        msg: str | None = None,
+    ) -> None:
+        """Construct an `_AssertRaisesContext`.
+
+        :param expected: The type of exception to expect.
+        :param test_case: The TestCase instance using this context.
+        :param msg: An optional message explaining the failure.
+        """
+        self.expected = expected
+        self.test_case = test_case
+        self.msg = msg
+        self.exception: _E | None = None
+
+    def __enter__(self) -> "Self":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: types.TracebackType | None,
+    ) -> bool:
+        if exc_type is None:
+            try:
+                if isinstance(self.expected, tuple):
+                    exc_name = "({})".format(
+                        ", ".join(e.__name__ for e in self.expected)
+                    )
+                else:
+                    exc_name = self.expected.__name__
+            except AttributeError:
+                exc_name = str(self.expected)
+            if self.msg:
+                error_msg = f"{exc_name} not raised : {self.msg}"
+            else:
+                error_msg = f"{exc_name} not raised"
+            raise self.test_case.failureException(error_msg)
+        if not issubclass(exc_type, self.expected):
+            # let unexpected exceptions pass through
+            return False
+        # store exception for later retrieval
+        self.exception = cast(_E, exc_value)
+        return True
+
+
 class TestCase(unittest.TestCase):
     """Extensions to the basic TestCase.
 
@@ -513,41 +568,41 @@ def assertRaises(
         **kwargs: _P.kwargs,
     ) -> BaseException: ...
 
-    @overload  # type: ignore[override]
+    @overload
     def assertRaises(
         self,
         expected_exception: type[_E],
         callable: None = ...,
-    ) -> "_AssertRaisesContext[_E]": ...
+    ) -> _AssertRaisesContext[_E]: ...
 
-    @overload  # type: ignore[override]
+    @overload
     def assertRaises(
         self,
         expected_exception: tuple[type[_E], type[_E2]],
         callable: None = ...,
-    ) -> "_AssertRaisesContext[_E | _E2]": ...
+    ) -> _AssertRaisesContext[_E | _E2]: ...
 
-    @overload  # type: ignore[override]
+    @overload
     def assertRaises(
         self,
         expected_exception: tuple[type[_E], type[_E2], type[_E3]],
         callable: None = ...,
-    ) -> "_AssertRaisesContext[_E | _E2 | _E3]": ...
+    ) -> _AssertRaisesContext[_E | _E2 | _E3]: ...
 
-    @overload  # type: ignore[override]
+    @overload
     def assertRaises(
         self,
         expected_exception: tuple[type[BaseException], ...],
         callable: None = ...,
-    ) -> "_AssertRaisesContext[BaseException]": ...
+    ) -> _AssertRaisesContext[BaseException]: ...
 
-    def assertRaises(  # type: ignore[override, misc]
+    def assertRaises(  # type: ignore[misc]
         self,
         expected_exception: type[BaseException] | tuple[type[BaseException], ...],
         callable: Callable[_P, _R] | None = None,
         *args: _P.args,
         **kwargs: _P.kwargs,
-    ) -> "_AssertRaisesContext[BaseException] | BaseException":
+    ) -> _AssertRaisesContext[BaseException] | BaseException:
         """Fail unless an exception of class expected_exception is thrown
         by callable when invoked with arguments args and keyword
         arguments kwargs. If a different type of exception is
@@ -1247,61 +1302,6 @@ def _id(obj: _F) -> _F:
     return _id
 
 
-class _AssertRaisesContext(Generic[_E]):
-    """A context manager to handle expected exceptions for assertRaises.
-
-    This provides compatibility with unittest's assertRaises context manager.
-    """
-
-    def __init__(
-        self,
-        expected: type[_E] | tuple[type[BaseException], ...],
-        test_case: TestCase,
-        msg: str | None = None,
-    ) -> None:
-        """Construct an `_AssertRaisesContext`.
-
-        :param expected: The type of exception to expect.
-        :param test_case: The TestCase instance using this context.
-        :param msg: An optional message explaining the failure.
-        """
-        self.expected = expected
-        self.test_case = test_case
-        self.msg = msg
-        self.exception: _E | None = None
-
-    def __enter__(self) -> "Self":
-        return self
-
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_value: BaseException | None,
-        traceback: types.TracebackType | None,
-    ) -> bool:
-        if exc_type is None:
-            try:
-                if isinstance(self.expected, tuple):
-                    exc_name = "({})".format(
-                        ", ".join(e.__name__ for e in self.expected)
-                    )
-                else:
-                    exc_name = self.expected.__name__
-            except AttributeError:
-                exc_name = str(self.expected)
-            if self.msg:
-                error_msg = f"{exc_name} not raised : {self.msg}"
-            else:
-                error_msg = f"{exc_name} not raised"
-            raise self.test_case.failureException(error_msg)
-        if not issubclass(exc_type, self.expected):
-            # let unexpected exceptions pass through
-            return False
-        # store exception for later retrieval
-        self.exception = cast(_E, exc_value)
-        return True
-
-
 class ExpectedException:
     """A context manager to handle expected exceptions.