logxpy 0.1.0__py3-none-any.whl

logxpy/tests/test_fmt.py

@@ -0,0 +1,42 @@
+"""Tests for eliot._fmt."""
+from unittest import TestCase
+from logxpy._fmt import format_value, DFFormatter, TensorFormatter
+
+class MockDF:
+    shape = (10, 2)
+    columns = ["a", "b"]
+    dtypes = {"a": "int", "b": "float"}
+    def head(self, n): return self
+    def to_dict(self, orient): return [{"a": 1, "b": 1.1}]
+
+class MockTensor:
+    shape = (2, 2)
+    dtype = "float32"
+    device = "cpu"
+    def min(self): return 0.0
+    def max(self): return 1.0
+    def mean(self): return 0.5
+
+class FormatTests(TestCase):
+    def test_truncate(self):
+        """Values are truncated."""
+        long_str = "x" * 1000
+        res = format_value(long_str, max_len=10)
+        self.assertEqual(len(res), 13) # 10 + "..."
+        
+    def test_df_formatter(self):
+        """DataFrames are formatted."""
+        # Mocking get_module is hard without dependency injection, 
+        # so we'll test the formatter directly assuming support check passed
+        fmt = DFFormatter()
+        res = fmt.format(MockDF())
+        self.assertEqual(res["_type"], "DataFrame")
+        self.assertEqual(res["shape"], [10, 2])
+
+    def test_tensor_formatter(self):
+        """Tensors are formatted."""
+        fmt = TensorFormatter()
+        self.assertTrue(fmt.supports(MockTensor()))
+        res = fmt.format(MockTensor())
+        self.assertEqual(res["_type"], "MockTensor")
+        self.assertEqual(res["dtype"], "float32")

logxpy/tests/test_generators.py

@@ -0,0 +1,292 @@
+"""
+Tests for L{eliot._generators}.
+"""
+
+from pprint import pformat
+from unittest import TestCase
+
+from logxpy import Message, start_action
+from ..testing import capture_logging, assertHasAction
+
+from .._generators import eliot_friendly_generator_function
+
+
+def assert_expected_action_tree(
+    testcase, logger, expected_action_type, expected_type_tree
+):
+    """
+    Assert that a logger has a certain logged action with certain children.
+
+    @see: L{assert_generator_logs_action_tree}
+    """
+    logged_action = assertHasAction(testcase, logger, expected_action_type, True)
+    type_tree = logged_action.type_tree()
+    testcase.assertEqual(
+        {expected_action_type: expected_type_tree},
+        type_tree,
+        "Logger had messages:\n{}".format(pformat(logger.messages, indent=4)),
+    )
+
+
+def assert_generator_logs_action_tree(
+    testcase, generator_function, logger, expected_action_type, expected_type_tree
+):
+    """
+    Assert that exhausting a generator from the given function logs an action
+    of the given type with children matching the given type tree.
+
+    @param testcase: A test case instance to use to make assertions.
+    @type testcase: L{unittest.TestCase}
+
+    @param generator_function: A no-argument callable that returns a generator
+        to be exhausted.
+
+    @param logger: A logger to inspect for logged messages.
+    @type logger: L{MemoryLogger}
+
+    @param expected_action_type: An action type which should be logged by the
+        generator.
+    @type expected_action_type: L{unicode}
+
+    @param expected_type_tree: The types of actions and messages which should
+        be logged beneath the expected action.  The structure of this value
+        matches the structure returned by L{LoggedAction.type_tree}.
+    @type expected_type_tree: L{list}
+    """
+    list(eliot_friendly_generator_function(generator_function)())
+    assert_expected_action_tree(
+        testcase, logger, expected_action_type, expected_type_tree
+    )
+
+
+class EliotFriendlyGeneratorFunctionTests(TestCase):
+    """
+    Tests for L{eliot_friendly_generator_function}.
+    """
+
+    # Get our custom assertion failure messages *and* the standard ones.
+    longMessage = True
+
+    @capture_logging(None)
+    def test_yield_none(self, logger):
+        @eliot_friendly_generator_function
+        def g():
+            Message.log(message_type="hello")
+            yield
+            Message.log(message_type="goodbye")
+
+        g.debug = True  # output yielded messages
+
+        with start_action(action_type="the-action"):
+            list(g())
+
+        assert_expected_action_tree(
+            self, logger, "the-action", ["hello", "yielded", "goodbye"]
+        )
+
+    @capture_logging(None)
+    def test_yield_value(self, logger):
+        expected = object()
+
+        @eliot_friendly_generator_function
+        def g():
+            Message.log(message_type="hello")
+            yield expected
+            Message.log(message_type="goodbye")
+
+        g.debug = True  # output yielded messages
+
+        with start_action(action_type="the-action"):
+            self.assertEqual([expected], list(g()))
+
+        assert_expected_action_tree(
+            self, logger, "the-action", ["hello", "yielded", "goodbye"]
+        )
+
+    @capture_logging(None)
+    def test_yield_inside_another_action(self, logger):
+        @eliot_friendly_generator_function
+        def g():
+            Message.log(message_type="a")
+            with start_action(action_type="confounding-factor"):
+                Message.log(message_type="b")
+                yield None
+                Message.log(message_type="c")
+            Message.log(message_type="d")
+
+        g.debug = True  # output yielded messages
+
+        with start_action(action_type="the-action"):
+            list(g())
+
+        assert_expected_action_tree(
+            self,
+            logger,
+            "the-action",
+            ["a", {"confounding-factor": ["b", "yielded", "c"]}, "d"],
+        )
+
+    @capture_logging(None)
+    def test_yield_inside_nested_actions(self, logger):
+        @eliot_friendly_generator_function
+        def g():
+            Message.log(message_type="a")
+            with start_action(action_type="confounding-factor"):
+                Message.log(message_type="b")
+                yield None
+                with start_action(action_type="double-confounding-factor"):
+                    yield None
+                    Message.log(message_type="c")
+                Message.log(message_type="d")
+            Message.log(message_type="e")
+
+        g.debug = True  # output yielded messages
+
+        with start_action(action_type="the-action"):
+            list(g())
+
+        assert_expected_action_tree(
+            self,
+            logger,
+            "the-action",
+            [
+                "a",
+                {
+                    "confounding-factor": [
+                        "b",
+                        "yielded",
+                        {"double-confounding-factor": ["yielded", "c"]},
+                        "d",
+                    ]
+                },
+                "e",
+            ],
+        )
+
+    @capture_logging(None)
+    def test_generator_and_non_generator(self, logger):
+        @eliot_friendly_generator_function
+        def g():
+            Message.log(message_type="a")
+            yield
+            with start_action(action_type="action-a"):
+                Message.log(message_type="b")
+                yield
+                Message.log(message_type="c")
+
+            Message.log(message_type="d")
+            yield
+
+        g.debug = True  # output yielded messages
+
+        with start_action(action_type="the-action"):
+            generator = g()
+            next(generator)
+            Message.log(message_type="0")
+            next(generator)
+            Message.log(message_type="1")
+            next(generator)
+            Message.log(message_type="2")
+            self.assertRaises(StopIteration, lambda: next(generator))
+
+        assert_expected_action_tree(
+            self,
+            logger,
+            "the-action",
+            [
+                "a",
+                "yielded",
+                "0",
+                {"action-a": ["b", "yielded", "c"]},
+                "1",
+                "d",
+                "yielded",
+                "2",
+            ],
+        )
+
+    @capture_logging(None)
+    def test_concurrent_generators(self, logger):
+        @eliot_friendly_generator_function
+        def g(which):
+            Message.log(message_type="{}-a".format(which))
+            with start_action(action_type=which):
+                Message.log(message_type="{}-b".format(which))
+                yield
+                Message.log(message_type="{}-c".format(which))
+            Message.log(message_type="{}-d".format(which))
+
+        g.debug = True  # output yielded messages
+
+        gens = [g("1"), g("2")]
+        with start_action(action_type="the-action"):
+            while gens:
+                for g in gens[:]:
+                    try:
+                        next(g)
+                    except StopIteration:
+                        gens.remove(g)
+
+        assert_expected_action_tree(
+            self,
+            logger,
+            "the-action",
+            [
+                "1-a",
+                {"1": ["1-b", "yielded", "1-c"]},
+                "2-a",
+                {"2": ["2-b", "yielded", "2-c"]},
+                "1-d",
+                "2-d",
+            ],
+        )
+
+    @capture_logging(None)
+    def test_close_generator(self, logger):
+        @eliot_friendly_generator_function
+        def g():
+            Message.log(message_type="a")
+            try:
+                yield
+                Message.log(message_type="b")
+            finally:
+                Message.log(message_type="c")
+
+        g.debug = True  # output yielded messages
+
+        with start_action(action_type="the-action"):
+            gen = g()
+            next(gen)
+            gen.close()
+
+        assert_expected_action_tree(self, logger, "the-action", ["a", "yielded", "c"])
+
+    @capture_logging(None)
+    def test_nested_generators(self, logger):
+        @eliot_friendly_generator_function
+        def g(recurse):
+            with start_action(action_type="a-recurse={}".format(recurse)):
+                Message.log(message_type="m-recurse={}".format(recurse))
+                if recurse:
+                    set(g(False))
+                else:
+                    yield
+
+        g.debug = True  # output yielded messages
+
+        with start_action(action_type="the-action"):
+            set(g(True))
+
+        assert_expected_action_tree(
+            self,
+            logger,
+            "the-action",
+            [
+                {
+                    "a-recurse=True": [
+                        "m-recurse=True",
+                        {"a-recurse=False": ["m-recurse=False", "yielded"]},
+                    ]
+                }
+            ],
+        )

logxpy/tests/test_journald.py

@@ -0,0 +1,246 @@
+"""
+Tests for L{eliot.journald}.
+"""
+
+from os import getpid, strerror
+from unittest import skipUnless, TestCase
+from subprocess import check_output, CalledProcessError, STDOUT
+from errno import EINVAL
+from sys import argv
+from uuid import uuid4
+from time import sleep
+from json import loads
+
+from .._output import MemoryLogger
+from .._message import TASK_UUID_FIELD
+from .. import start_action, Message, write_traceback
+
+try:
+    from ..journald import sd_journal_send, JournaldDestination
+except ImportError:
+    sd_journal_send = None
+
+
+def _journald_available():
+    """
+    :return: Boolean indicating whether journald is available to use.
+    """
+    if sd_journal_send is None:
+        return False
+    try:
+        check_output(["journalctl", "-b", "-n1"], stderr=STDOUT)
+    except (OSError, CalledProcessError):
+        return False
+    return True
+
+
+def last_journald_message():
+    """
+    @return: Last journald message from this process as a dictionary in
+         journald JSON format.
+    """
+    # It may take a little for messages to actually reach journald, so we
+    # write out marker message and wait until it arrives. We can then be
+    # sure the message right before it is the one we want.
+    marker = str(uuid4())
+    sd_journal_send(MESSAGE=marker.encode("ascii"))
+    for i in range(500):
+        messages = check_output(
+            [
+                b"journalctl",
+                b"-a",
+                b"-o",
+                b"json",
+                b"-n2",
+                b"_PID=" + str(getpid()).encode("ascii"),
+            ]
+        )
+        messages = [loads(m) for m in messages.splitlines()]
+        if len(messages) == 2 and messages[1]["MESSAGE"] == marker:
+            return messages[0]
+        sleep(0.01)
+    raise RuntimeError("Message never arrived?!")
+
+
+class SdJournaldSendTests(TestCase):
+    """
+    Functional tests for L{sd_journal_send}.
+    """
+
+    @skipUnless(
+        _journald_available(), "journald unavailable or inactive on this machine."
+    )
+    def setUp(self):
+        pass
+
+    def assert_roundtrip(self, value):
+        """
+        Write a value as a C{MESSAGE} field, assert it is output.
+
+        @param value: Value to write as unicode.
+        """
+        sd_journal_send(MESSAGE=value)
+        result = last_journald_message()
+        self.assertEqual(value, result["MESSAGE"].encode("utf-8"))
+
+    def test_message(self):
+        """
+        L{sd_journal_send} can write a C{MESSAGE} field.
+        """
+        self.assert_roundtrip(b"hello")
+
+    def test_percent(self):
+        """
+        L{sd_journal_send} can write a C{MESSAGE} field with a percent.
+
+        Underlying C API calls does printf formatting so this is a
+        plausible failure mode.
+        """
+        self.assert_roundtrip(b"hello%world")
+
+    def test_large(self):
+        """
+        L{sd_journal_send} can write a C{MESSAGE} field with a large message.
+        """
+        self.assert_roundtrip(b"hello world" * 20000)
+
+    def test_multiple_fields(self):
+        """
+        L{sd_journal_send} can send multiple fields.
+        """
+        sd_journal_send(MESSAGE=b"hello", BONUS_FIELD=b"world")
+        result = last_journald_message()
+        self.assertEqual(
+            (b"hello", b"world"),
+            (result["MESSAGE"].encode("ascii"), result["BONUS_FIELD"].encode("ascii")),
+        )
+
+    def test_error(self):
+        """
+        L{sd_journal_send} raises an error when it gets a non-0 result
+        from the underlying API.
+        """
+        with self.assertRaises(IOError) as context:
+            sd_journal_send(**{"": b"123"})
+        exc = context.exception
+        self.assertEqual((exc.errno, exc.strerror), (EINVAL, strerror(EINVAL)))
+
+
+class JournaldDestinationTests(TestCase):
+    """
+    Tests for L{JournaldDestination}.
+    """
+
+    @skipUnless(
+        _journald_available(), "journald unavailable or inactive on this machine."
+    )
+    def setUp(self):
+        self.destination = JournaldDestination()
+        self.logger = MemoryLogger()
+
+    def test_json(self):
+        """
+        The message is stored as JSON in the MESSAGE field.
+        """
+        Message.new(hello="world", key=123).write(self.logger)
+        message = self.logger.messages[0]
+        self.destination(message)
+        self.assertEqual(loads(last_journald_message()["MESSAGE"]), message)
+
+    def assert_field_for(self, message, field_name, field_value):
+        """
+        If the given message is logged by Eliot, the given journald field has
+        the expected value.
+
+        @param message: Dictionary to log.
+        @param field_name: Journald field name to check.
+        @param field_value: Expected value for the field.
+        """
+        self.destination(message)
+        self.assertEqual(last_journald_message()[field_name], field_value)
+
+    def test_action_type(self):
+        """
+        The C{action_type} is stored in the ELIOT_TYPE field.
+        """
+        action_type = "test:type"
+        start_action(self.logger, action_type=action_type)
+        self.assert_field_for(self.logger.messages[0], "ELIOT_TYPE", action_type)
+
+    def test_message_type(self):
+        """
+        The C{message_type} is stored in the ELIOT_TYPE field.
+        """
+        message_type = "test:type:message"
+        Message.new(message_type=message_type).write(self.logger)
+        self.assert_field_for(self.logger.messages[0], "ELIOT_TYPE", message_type)
+
+    def test_no_type(self):
+        """
+        An empty string is stored in ELIOT_TYPE if no type is known.
+        """
+        Message.new().write(self.logger)
+        self.assert_field_for(self.logger.messages[0], "ELIOT_TYPE", "")
+
+    def test_uuid(self):
+        """
+        The task UUID is stored in the ELIOT_TASK field.
+        """
+        start_action(self.logger, action_type="xxx")
+        self.assert_field_for(
+            self.logger.messages[0],
+            "ELIOT_TASK",
+            self.logger.messages[0][TASK_UUID_FIELD],
+        )
+
+    def test_info_priorities(self):
+        """
+        Untyped messages, action start, successful action end, random typed
+        message all get priority 6 ("info").
+        """
+        with start_action(self.logger, action_type="xxx"):
+            Message.new(message_type="msg").write(self.logger)
+            Message.new(x=123).write(self.logger)
+        priorities = []
+        for message in self.logger.messages:
+            self.destination(message)
+            priorities.append(last_journald_message()["PRIORITY"])
+        self.assertEqual(priorities, ["6", "6", "6", "6"])
+
+    def test_error_priority(self):
+        """
+        A failed action gets priority 3 ("error").
+        """
+        try:
+            with start_action(self.logger, action_type="xxx"):
+                raise ZeroDivisionError()
+        except ZeroDivisionError:
+            pass
+        self.assert_field_for(self.logger.messages[-1], "PRIORITY", "3")
+
+    def test_critical_priority(self):
+        """
+        A traceback gets priority 2 ("critical").
+        """
+        try:
+            raise ZeroDivisionError()
+        except ZeroDivisionError:
+            write_traceback(logger=self.logger)
+        self.assert_field_for(self.logger.serialize()[-1], "PRIORITY", "2")
+
+    def test_identifier(self):
+        """
+        C{SYSLOG_IDENTIFIER} defaults to C{os.path.basename(sys.argv[0])}.
+        """
+        identifier = "/usr/bin/testing123"
+        try:
+            original = argv[0]
+            argv[0] = identifier
+            # Recreate JournaldDestination with the newly set argv[0].
+            self.destination = JournaldDestination()
+            Message.new(message_type="msg").write(self.logger)
+            self.assert_field_for(
+                self.logger.messages[0], "SYSLOG_IDENTIFIER", "testing123"
+            )
+        finally:
+            argv[0] = original