logxpy 0.1.0__py3-none-any.whl

logxpy/tests/test_message.py

@@ -0,0 +1,334 @@
+"""
+Tests for L{eliot._message}.
+"""
+
+from unittest import TestCase
+from uuid import UUID
+import time
+
+from pyrsistent import pmap
+
+try:
+    from twisted.python.failure import Failure
+except ImportError:
+    Failure = None
+
+from .._message import WrittenMessage, Message, log_message
+from .._output import MemoryLogger
+from .._action import Action, start_action, TaskLevel
+from .. import add_destinations, remove_destination
+
+
+class DeprecatedMessageTests(TestCase):
+    """
+    Test for L{Message}.
+    """
+
+    def test_new(self):
+        """
+        L{Message.new} returns a new L{Message} that is initialized with the
+        given keyword arguments as its contents, and a default message type.
+        """
+        msg = Message.new(key="value", another=2)
+        self.assertEqual(msg.contents(), {"key": "value", "another": 2})
+
+    def test_contentsCopies(self):
+        """
+        L{Message.contents} returns a copy of the L{Message} contents.
+        """
+        msg = Message.new(key="value")
+        del msg.contents()["key"]
+        self.assertEqual(msg.contents(), {"key": "value"})
+
+    def test_bindOverwrites(self):
+        """
+        L{Message.bind} returns a new L{Message} whose contents include the
+        additional given fields.
+        """
+        msg = Message.new(key="value", another=2)
+        another = msg.bind(another=3, more=4)
+        self.assertIsInstance(another, Message)
+        self.assertEqual(another.contents(), {"key": "value", "another": 3, "more": 4})
+
+    def test_bindPreservesOriginal(self):
+        """
+        L{Message.bind} does not mutate the instance it is called on.
+        """
+        msg = Message.new(key=4)
+        msg.bind(key=6)
+        self.assertEqual(msg.contents(), {"key": 4})
+
+    def test_writeCallsLoggerWrite(self):
+        """
+        L{Message.write} calls the given logger's C{write} method with a
+        dictionary that is superset of the L{Message} contents.
+        """
+        logger = MemoryLogger()
+        msg = Message.new(key=4)
+        msg.write(logger)
+        self.assertEqual(len(logger.messages), 1)
+        self.assertEqual(logger.messages[0]["key"], 4)
+
+    def test_writeDefaultLogger(self):
+        """
+        L{Message.write} writes to the default logger if none is given.
+        """
+        messages = []
+        add_destinations(messages.append)
+        self.addCleanup(remove_destination, messages.append)
+        Message.new(some_key=1234).write()
+        self.assertEqual(messages[0]["some_key"], 1234)
+
+    def test_writeCreatesNewDictionary(self):
+        """
+        L{Message.write} creates a new dictionary on each call.
+
+        This is important because we mutate the dictionary in
+        ``Logger.write``, so we want to make sure the ``Message`` is unchanged
+        in that case. In general we want ``Message`` objects to be effectively
+        immutable.
+        """
+
+        class Logger(list):
+            def write(self, d, serializer):
+                self.append(d)
+
+        logger = Logger()
+        msg = Message.new(key=4)
+        msg.write(logger)
+        logger[0]["key"] = 5
+        msg.write(logger)
+        self.assertEqual(logger[1]["key"], 4)
+
+    def test_logCallsDefaultLoggerWrite(self):
+        """
+        L{Message.log} calls the default logger's C{write} method with a
+        dictionary that is superset of the L{Message} contents.
+        """
+        messages = []
+        add_destinations(messages.append)
+        self.addCleanup(remove_destination, messages.append)
+        Message.log(some_key=1234)
+        self.assertEqual(messages[0]["some_key"], 1234)
+
+    def test_defaultTime(self):
+        """
+        L{Message._time} returns L{time.time} by default.
+        """
+        msg = Message({})
+        self.assertIs(msg._time, time.time)
+
+    def test_writeAddsTimestamp(self):
+        """
+        L{Message.write} adds a C{"timestamp"} field to the dictionary written
+        to the logger, with the current time in seconds since the epoch.
+        """
+        logger = MemoryLogger()
+        msg = Message.new(key=4)
+        msg.write(logger)
+        self.assertTrue(time.time() - logger.messages[0]["timestamp"] < 0.1)
+
+    def test_write_preserves_message_type(self):
+        """
+        L{Message.write} doesn't add a C{message_type} if one is already set.
+        """
+        logger = MemoryLogger()
+        msg = Message.new(key=4, message_type="isetit")
+        msg.write(logger)
+        self.assertEqual(logger.messages[0]["message_type"], "isetit")
+        self.assertNotIn("action_type", logger.messages[0])
+
+    def test_explicitAction(self):
+        """
+        L{Message.write} adds the identification fields from the given
+        L{Action} to the dictionary written to the logger, as well as a
+        message_type if none is set.
+        """
+        logger = MemoryLogger()
+        action = Action(logger, "unique", TaskLevel(level=[]), "sys:thename")
+        msg = Message.new(key=2)
+        msg.write(logger, action)
+        written = logger.messages[0]
+        del written["timestamp"]
+        self.assertEqual(
+            written,
+            {"task_uuid": "unique", "task_level": [1], "key": 2, "message_type": ""},
+        )
+
+    def test_implicitAction(self):
+        """
+        If no L{Action} is specified, L{Message.write} adds the identification
+        fields from the current execution context's L{Action} to the
+        dictionary written to the logger.
+        """
+        logger = MemoryLogger()
+        action = Action(logger, "unique", TaskLevel(level=[]), "sys:thename")
+        msg = Message.new(key=2)
+        with action:
+            msg.write(logger)
+        written = logger.messages[0]
+        del written["timestamp"]
+        self.assertEqual(
+            written,
+            {"task_uuid": "unique", "task_level": [1], "key": 2, "message_type": ""},
+        )
+
+    def test_missingAction(self):
+        """
+        If no L{Action} is specified, and the current execution context has no
+        L{Action}, a new task_uuid is generated.
+
+        This ensures all messages have a unique identity, as specified by
+        task_uuid/task_level.
+        """
+        logger = MemoryLogger()
+        Message.new(key=2).write(logger)
+        Message.new(key=3).write(logger)
+
+        message1, message2 = logger.messages
+        self.assertEqual(
+            (
+                UUID(message1["task_uuid"]) != UUID(message2["task_uuid"]),
+                message1["task_level"],
+                message2["task_level"],
+            ),
+            (True, [1], [1]),
+        )
+
+    def test_actionCounter(self):
+        """
+        Each message written within the context of an L{Action} gets its
+        C{task_level} field incremented.
+        """
+        logger = MemoryLogger()
+        msg = Message.new(key=2)
+        with start_action(logger, "sys:thename"):
+            for i in range(4):
+                msg.write(logger)
+        # We expect 6 messages: start action, 4 standalone messages, finish
+        # action:
+        self.assertEqual(
+            [m["task_level"] for m in logger.messages], [[1], [2], [3], [4], [5], [6]]
+        )
+
+    def test_writePassesSerializer(self):
+        """
+        If a L{Message} is created with a serializer, it is passed as a second
+        argument to the logger when C{write} is called.
+        """
+
+        class ListLogger(list):
+            def write(self, dictionary, serializer):
+                self.append(serializer)
+
+        logger = ListLogger()
+        serializer = object()
+        msg = Message({}, serializer)
+        msg.write(logger)
+        self.assertIs(logger[0], serializer)
+
+    def test_serializerPassedInBind(self):
+        """
+        The L{Message} returned by L{Message.bind} includes the serializer
+        passed to the parent.
+        """
+        serializer = object()
+        msg = Message({}, serializer)
+        msg2 = msg.bind(x=1)
+        self.assertIs(msg2._serializer, serializer)
+
+    def test_newWithSerializer(self):
+        """
+        L{Message.new} can accept a serializer.
+        """
+        serializer = object()
+        msg = Message.new(serializer, x=1)
+        self.assertIs(msg._serializer, serializer)
+
+
+class WrittenMessageTests(TestCase):
+    """
+    Tests for L{WrittenMessage}.
+    """
+
+    def test_as_dict(self):
+        """
+        L{WrittenMessage.as_dict} returns the dictionary that will be serialized
+        to the log.
+        """
+        log_entry = pmap(
+            {"timestamp": 1, "task_uuid": "unique", "task_level": [1], "foo": "bar"}
+        )
+        self.assertEqual(WrittenMessage.from_dict(log_entry).as_dict(), log_entry)
+
+    def test_from_dict(self):
+        """
+        L{WrittenMessage.from_dict} converts a dictionary that has been
+        deserialized from a log into a L{WrittenMessage} object.
+        """
+        log_entry = pmap(
+            {"timestamp": 1, "task_uuid": "unique", "task_level": [1], "foo": "bar"}
+        )
+        parsed = WrittenMessage.from_dict(log_entry)
+        self.assertEqual(parsed.timestamp, 1)
+        self.assertEqual(parsed.task_uuid, "unique")
+        self.assertEqual(parsed.task_level, TaskLevel(level=[1]))
+        self.assertEqual(parsed.contents, pmap({"foo": "bar"}))
+
+
+class LogMessageTests(TestCase):
+    """Tests for L{log_message}."""
+
+    def test_writes_message(self):
+        """
+        L{log_message} writes to the default logger.
+        """
+        messages = []
+        add_destinations(messages.append)
+        self.addCleanup(remove_destination, messages.append)
+        log_message(message_type="hello", some_key=1234)
+        self.assertEqual(messages[0]["some_key"], 1234)
+        self.assertEqual(messages[0]["message_type"], "hello")
+        self.assertTrue(time.time() - messages[0]["timestamp"] < 0.1)
+
+    def test_implicitAction(self):
+        """
+        If no L{Action} is specified, L{log_message} adds the identification
+        fields from the current execution context's L{Action} to the
+        dictionary written to the logger.
+        """
+        logger = MemoryLogger()
+        action = Action(logger, "unique", TaskLevel(level=[]), "sys:thename")
+        with action:
+            log_message(key=2, message_type="a")
+        written = logger.messages[0]
+        del written["timestamp"]
+        self.assertEqual(
+            written,
+            {"task_uuid": "unique", "task_level": [1], "key": 2, "message_type": "a"},
+        )
+
+    def test_missingAction(self):
+        """
+        If no L{Action} is specified, and the current execution context has no
+        L{Action}, a new task_uuid is generated.
+
+        This ensures all messages have a unique identity, as specified by
+        task_uuid/task_level.
+        """
+        messages = []
+        add_destinations(messages.append)
+        self.addCleanup(remove_destination, messages.append)
+
+        log_message(key=2, message_type="")
+        log_message(key=3, message_type="")
+
+        message1, message2 = messages
+        self.assertEqual(
+            (
+                UUID(message1["task_uuid"]) != UUID(message2["task_uuid"]),
+                message1["task_level"],
+                message2["task_level"],
+            ),
+            (True, [1], [1]),
+        )