twisted · graingert · Nov 13, 2023 · Nov 13, 2023
diff --git a/src/twisted/newsfragments/12037.feature b/src/twisted/newsfragments/12037.feature
@@ -0,0 +1 @@
+add asyncSetUp and asyncTearDown for type annotated TestCases without ``# type: ignore[override]``
diff --git a/src/twisted/trial/_asynctest.py b/src/twisted/trial/_asynctest.py
@@ -131,8 +131,12 @@ def onTimeout(d):
     def __call__(self, *args, **kwargs):
         return self.run(*args, **kwargs)
 
+    async def asyncSetUp(self) -> None:
+        return None
+
     def deferSetUp(self, ignored, result):
         d = self._run("setUp", result)
+        d.addCallback(lambda _: self._run("asyncSetUp", result))
         d.addCallbacks(
            self.deferTestMethod,
             self._ebDeferSetUp,
@@ -185,8 +189,12 @@ def _ebDeferTestMethod(self, f, result):
         else:
             result.addError(self, f)
 
+    async def asyncTearDown(self) -> None:
+        return None
+
     def deferTearDown(self, ignored, result):
-        d = self._run("tearDown", result)
+        d = self._run("asyncTearDown", result)
+        d.addCallback(lambda _: self._run("tearDown", result))
         d.addErrback(self._ebDeferTearDown, result)
         return d
 

diff --git a/src/twisted/trial/test/detests.py b/src/twisted/trial/test/detests.py
@@ -231,3 +231,73 @@ def setUp(self):
     def testMethod(self):
         self.methodCalled = True
         return self.d
+
+
+class AsyncSetUpOK(unittest.TestCase):
+    async def asyncSetUp(self) -> None:
+        self._cb_setUpCalled(await defer.succeed("value"))
+
+    def _cb_setUpCalled(self, ignored: object) -> None:
+        self._setUpCalled = True
+
+    def test_ok(self) -> None:
+        self.assertTrue(self._setUpCalled)
+
+
+class AsyncSetUpFail(unittest.TestCase):
+    testCalled = False
+
+    async def asyncSetUp(self) -> None:
+        await defer.succeed("value")
+        raise unittest.FailTest("i fail")
+
+    def test_ok(self) -> None:
+        AsyncSetUpFail.testCalled = True
+        self.fail("I should not get called")
+
+
+class AsyncSetUpCallbackFail(unittest.TestCase):
+    testCalled = False
+
+    async def asyncSetUp(self) -> None:
+        self._cb_setUpCalled(await defer.succeed("value"))
+
+    def _cb_setUpCalled(self, ignored: object) -> None:
+        self.fail("deliberate failure")
+
+    def test_ok(self) -> None:
+        AsyncSetUpCallbackFail.testCalled = True
+
+
+class AsyncSetUpError(unittest.TestCase):
+    testCalled = False
+
+    async def asyncSetUp(self) -> None:
+        await defer.succeed("value")
+        raise RuntimeError("deliberate error")
+
+    def test_ok(self) -> None:
+        AsyncSetUpError.testCalled = True
+
+
+class AsyncSetUpNeverFire(unittest.TestCase):
+    testCalled = False
+
+    async def asyncSetUp(self) -> None:
+        await defer.Deferred()
+
+    def test_ok(self) -> None:
+        AsyncSetUpNeverFire.testCalled = True
+
+
+class AsyncSetUpSkip(unittest.TestCase):
+    testCalled = False
+
+    async def setUp(self) -> None:
+        self._cb1(await defer.succeed("value"))
+
+    def _cb1(self, ignored: object) -> None:
+        raise unittest.SkipTest("skip me")
+
+    def test_ok(self) -> None:
+        AsyncSetUpSkip.testCalled = True
diff --git a/src/twisted/trial/test/test_deferred.py b/src/twisted/trial/test/test_deferred.py
@@ -254,5 +254,62 @@ def test_callbackReturnsNonCallingDeferred(self) -> None:
         self._wasTimeout(result.errors[0][1])
 
 
+class AsyncSetUpTests(unittest.TestCase):
+    def _loadSuite(
+        self, klass: type[pyunit.TestCase]
+    ) -> tuple[reporter.TestResult, pyunit.TestSuite]:
+        loader = pyunit.TestLoader()
+        r = reporter.TestResult()
+        s = loader.loadTestsFromTestCase(klass)
+        return r, s
+
+    def test_success(self) -> None:
+        result, suite = self._loadSuite(detests.AsyncSetUpOK)
+        suite(result)
+        self.assertTrue(result.wasSuccessful())
+        self.assertEqual(result.testsRun, 1)
+
+    def test_fail(self) -> None:
+        self.assertFalse(detests.AsyncSetUpFail.testCalled)
+        result, suite = self._loadSuite(detests.AsyncSetUpFail)
+        suite(result)
+        self.assertFalse(result.wasSuccessful())
+        self.assertEqual(result.testsRun, 1)
+        self.assertEqual(len(result.failures), 0)
+        self.assertEqual(len(result.errors), 1)
+        self.assertFalse(detests.AsyncSetUpFail.testCalled)
+
+    def test_callbackFail(self) -> None:
+        self.assertFalse(detests.AsyncSetUpCallbackFail.testCalled)
+        result, suite = self._loadSuite(detests.AsyncSetUpCallbackFail)
+        suite(result)
+        self.assertFalse(result.wasSuccessful())
+        self.assertEqual(result.testsRun, 1)
+        self.assertEqual(len(result.failures), 0)
+        self.assertEqual(len(result.errors), 1)
+        self.assertFalse(detests.AsyncSetUpCallbackFail.testCalled)
+
+    def test_error(self) -> None:
+        self.assertFalse(detests.AsyncSetUpError.testCalled)
+        result, suite = self._loadSuite(detests.AsyncSetUpError)
+        suite(result)
+        self.assertFalse(result.wasSuccessful())
+        self.assertEqual(result.testsRun, 1)
+        self.assertEqual(len(result.failures), 0)
+        self.assertEqual(len(result.errors), 1)
+        self.assertFalse(detests.AsyncSetUpError.testCalled)
+
+    def test_skip(self) -> None:
+        self.assertFalse(detests.AsyncSetUpSkip.testCalled)
+        result, suite = self._loadSuite(detests.AsyncSetUpSkip)
+        suite(result)
+        self.assertTrue(result.wasSuccessful())
+        self.assertEqual(result.testsRun, 1)
+        self.assertEqual(len(result.failures), 0)
+        self.assertEqual(len(result.errors), 0)
+        self.assertEqual(len(result.skips), 1)
+        self.assertFalse(detests.AsyncSetUpSkip.testCalled)
+
+
 # The test loader erroneously attempts to run this:
 del TestTester
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		add asyncSetUp and asyncTearDown for type annotated TestCases without ``# type: ignore[override]``