Changeset 90d1e90 in trunk

Timestamp:

2021-12-01T20:05:29Z (3 years ago)

Author:

Jean-Paul Calderone <exarkun@…>

Branches:

master

Children:

eee1f09

Parents:

7626a02b

Message:

rewrite the Eliot interaction tests to make expected behavior clearer

and to have explicit assertions about that behavior

File:

• src/allmydata/test/test_eliotutil.py (modified) (3 diffs)

src/allmydata/test/test_eliotutil.py ¶

@@ -28 +28 @@
 from testtools import (
     TestCase,
-)
-from testtools import (
     TestResult,
 )
@@ -35 +33 @@
     Is,
     IsInstance,
+    Not,
     MatchesStructure,
     Equals,
@@ -78 +77 @@
 
 
-class EliotLoggedTestTests(AsyncTestCase):
-    """
-    Tests for the automatic log-related provided by ``EliotLoggedRunTest``.
-    """
+def passes():
+    """
+    Create a matcher that matches a ``TestCase`` that runs without failures or
+    errors.
+    """
+    def run(case):
+        result = TestResult()
+        case.run(result)
+        return result.wasSuccessful()
+    return AfterPreprocessing(run, Equals(True))
+
+
+class EliotLoggedTestTests(TestCase):
+    """
+    Tests for the automatic log-related provided by ``AsyncTestCase``.
+
+    This class uses ``testtools.TestCase`` because it is inconvenient to nest
+    ``AsyncTestCase`` inside ``AsyncTestCase`` (in particular, Eliot messages
+    emitted by the inner test case get observed by the outer test case and if
+    an inner case emits invalid messages they cause the outer test case to
+    fail).
+    """
+    def test_fails(self):
+        """
+        A test method of an ``AsyncTestCase`` subclass can fail.
+        """
+        class UnderTest(AsyncTestCase):
+            def test_it(self):
+                self.fail("make sure it can fail")
+
+        self.assertThat(UnderTest("test_it"), Not(passes()))
+
+    def test_unserializable_fails(self):
+        """
+        A test method of an ``AsyncTestCase`` subclass that logs an unserializable
+        value with Eliot fails.
+        """
+        class world(object):
+            """
+            an unserializable object
+            """
+
+        class UnderTest(AsyncTestCase):
+            def test_it(self):
+                Message.log(hello=world)
+
+        self.assertThat(UnderTest("test_it"), Not(passes()))
+
+    def test_logs_non_utf_8_byte(self):
+        """
+        A test method of an ``AsyncTestCase`` subclass can log a message that
+        contains a non-UTF-8 byte string and return ``None`` and pass.
+        """
+        class UnderTest(AsyncTestCase):
+            def test_it(self):
+                Message.log(hello=b"\xFF")
+
+        self.assertThat(UnderTest("test_it"), passes())
+
     def test_returns_none(self):
-        Message.log(hello="world")
+        """
+        A test method of an ``AsyncTestCase`` subclass can log a message and
+        return ``None`` and pass.
+        """
+        class UnderTest(AsyncTestCase):
+            def test_it(self):
+                Message.log(hello="world")
+
+        self.assertThat(UnderTest("test_it"), passes())
 
     def test_returns_fired_deferred(self):
-        Message.log(hello="world")
-        return succeed(None)
+        """
+        A test method of an ``AsyncTestCase`` subclass can log a message and
+        return an already-fired ``Deferred`` and pass.
+        """
+        class UnderTest(AsyncTestCase):
+            def test_it(self):
+                Message.log(hello="world")
+                return succeed(None)
+
+        self.assertThat(UnderTest("test_it"), passes())
 
     def test_returns_unfired_deferred(self):
-        Message.log(hello="world")
-        # @eliot_logged_test automatically gives us an action context but it's
-        # still our responsibility to maintain it across stack-busting
-        # operations.
-        d = DeferredContext(deferLater(reactor, 0.0, lambda: None))
-        d.addCallback(lambda ignored: Message.log(goodbye="world"))
-        # We didn't start an action.  We're not finishing an action.
-        return d.result
-
-    def test_logs_non_utf_8_byte(self):
-        """
-        If an Eliot message is emitted that contains a non-UTF-8 byte string then
-        the test nevertheless passes.
-        """
-        Message.log(hello=b"\xFF")
+        """
+        A test method of an ``AsyncTestCase`` subclass can log a message and
+        return an unfired ``Deferred`` and pass when the ``Deferred`` fires.
+        """
+        class UnderTest(AsyncTestCase):
+            def test_it(self):
+                Message.log(hello="world")
+                # @eliot_logged_test automatically gives us an action context
+                # but it's still our responsibility to maintain it across
+                # stack-busting operations.
+                d = DeferredContext(deferLater(reactor, 0.0, lambda: None))
+                d.addCallback(lambda ignored: Message.log(goodbye="world"))
+                # We didn't start an action.  We're not finishing an action.
+                return d.result
+
+        self.assertThat(UnderTest("test_it"), passes())