logxpy 0.1.0__py3-none-any.whl

logxpy/tests/test_parse.py

@@ -0,0 +1,309 @@
+"""
+Tests for L{eliot._parse}.
+"""
+
+from unittest import TestCase
+from itertools import chain, zip_longest
+
+from hypothesis import strategies as st, given, assume
+
+from pyrsistent import PClass, field, pvector_field
+
+from .. import start_action, Message
+from ..testing import MemoryLogger
+from ..parse import Task, Parser
+from .._message import (
+    WrittenMessage,
+    MESSAGE_TYPE_FIELD,
+    TASK_LEVEL_FIELD,
+    TASK_UUID_FIELD,
+)
+from .._action import FAILED_STATUS, ACTION_STATUS_FIELD, WrittenAction
+from .strategies import labels
+
+
+class ActionStructure(PClass):
+    """
+    A tree structure used to generate/compare to Eliot trees.
+
+    Individual messages are encoded as a unicode string; actions are
+    encoded as a L{ActionStructure} instance.
+    """
+
+    type = field(type=(str, None.__class__))
+    children = pvector_field(object)  # XXX ("StubAction", unicode))
+    failed = field(type=bool)
+
+    @classmethod
+    def from_written(cls, written):
+        """
+        Create an L{ActionStructure} or L{str} from a L{WrittenAction} or
+        L{WrittenMessage}.
+        """
+        if isinstance(written, WrittenMessage):
+            return written.as_dict()[MESSAGE_TYPE_FIELD]
+        else:  # WrittenAction
+            if not written.end_message:
+                raise AssertionError("Missing end message.")
+            return cls(
+                type=written.action_type,
+                failed=(
+                    written.end_message.contents[ACTION_STATUS_FIELD] == FAILED_STATUS
+                ),
+                children=[cls.from_written(o) for o in written.children],
+            )
+
+    @classmethod
+    def to_eliot(cls, structure_or_message, logger):
+        """
+        Given a L{ActionStructure} or L{str}, generate appropriate
+        structured Eliot log mesages to given L{MemoryLogger}.
+        """
+        if isinstance(structure_or_message, cls):
+            action = structure_or_message
+            try:
+                with start_action(logger, action_type=action.type):
+                    for child in action.children:
+                        cls.to_eliot(child, logger)
+                    if structure_or_message.failed:
+                        raise RuntimeError("Make the logxpy action fail.")
+            except RuntimeError:
+                pass
+        else:
+            Message.new(message_type=structure_or_message).write(logger)
+        return logger.messages
+
+
+@st.composite
+def action_structures(draw):
+    """
+    A Hypothesis strategy that creates a tree of L{ActionStructure} and
+    L{str}.
+    """
+    tree = draw(st.recursive(labels, st.lists, max_leaves=20))
+
+    def to_structure(tree_or_message):
+        if isinstance(tree_or_message, list):
+            return ActionStructure(
+                type=draw(labels),
+                failed=draw(st.booleans()),
+                children=[to_structure(o) for o in tree_or_message],
+            )
+        else:
+            return tree_or_message
+
+    return to_structure(tree)
+
+
+def _structure_and_messages(structure):
+    messages = ActionStructure.to_eliot(structure, MemoryLogger())
+    return st.permutations(messages).map(lambda permuted: (structure, permuted))
+
+
+# Hypothesis strategy that creates a tuple of ActionStructure/unicode and
+# corresponding serialized Eliot messages, randomly shuffled.
+STRUCTURES_WITH_MESSAGES = action_structures().flatmap(_structure_and_messages)
+
+
+def parse_to_task(messages):
+    """
+    Feed a set of messages to a L{Task}.
+
+    @param messages: Sequence of messages dictionaries to parse.
+
+    @return: Resulting L{Task}.
+    """
+    task = Task()
+    for message in messages:
+        task = task.add(message)
+    return task
+
+
+class TaskTests(TestCase):
+    """
+    Tests for L{Task}.
+    """
+
+    @given(structure_and_messages=STRUCTURES_WITH_MESSAGES)
+    def test_missing_action(self, structure_and_messages):
+        """
+        If we parse messages (in shuffled order) but a start message is
+        missing then the structure is still deduced correctly from the
+        remaining messages.
+        """
+        action_structure, messages = structure_and_messages
+        assume(not isinstance(action_structure, str))
+
+        # Remove first start message we encounter; since messages are
+        # shuffled the location removed will differ over Hypothesis test
+        # iterations:
+        messages = messages[:]
+        for i, message in enumerate(messages):
+            if message[TASK_LEVEL_FIELD][-1] == 1:  # start message
+                del messages[i]
+                break
+
+        task = parse_to_task(messages)
+        parsed_structure = ActionStructure.from_written(task.root())
+
+        # We expect the action with missing start message to otherwise
+        # be parsed correctly:
+        self.assertEqual(parsed_structure, action_structure)
+
+    @given(structure_and_messages=STRUCTURES_WITH_MESSAGES)
+    def test_parse_from_random_order(self, structure_and_messages):
+        """
+        If we shuffle messages and parse them the parser builds a tree of
+        actions that is the same as the one used to generate the messages.
+
+        Shuffled messages means we have to deal with (temporarily) missing
+        information sufficiently well to be able to parse correctly once
+        the missing information arrives.
+        """
+        action_structure, messages = structure_and_messages
+
+        task = Task()
+        for message in messages:
+            task = task.add(message)
+
+        # Assert parsed structure matches input structure:
+        parsed_structure = ActionStructure.from_written(task.root())
+        self.assertEqual(parsed_structure, action_structure)
+
+    @given(structure_and_messages=STRUCTURES_WITH_MESSAGES)
+    def test_is_complete(self, structure_and_messages):
+        """
+        ``Task.is_complete()`` only returns true when all messages within the
+        tree have been delivered.
+        """
+        action_structure, messages = structure_and_messages
+
+        task = Task()
+        completed = []
+        for message in messages:
+            task = task.add(message)
+            completed.append(task.is_complete())
+
+        self.assertEqual(completed, [False for m in messages[:-1]] + [True])
+
+    def test_parse_contents(self):
+        """
+        L{{Task.add}} parses the contents of the messages it receives.
+        """
+        logger = MemoryLogger()
+        with start_action(logger, action_type="xxx", y=123) as ctx:
+            Message.new(message_type="zzz", z=4).write(logger)
+            ctx.add_success_fields(foo=[1, 2])
+        messages = logger.messages
+        expected = WrittenAction.from_messages(
+            WrittenMessage.from_dict(messages[0]),
+            [WrittenMessage.from_dict(messages[1])],
+            WrittenMessage.from_dict(messages[2]),
+        )
+
+        task = parse_to_task(messages)
+        self.assertEqual(task.root(), expected)
+
+
+class ParserTests(TestCase):
+    """
+    Tests for L{Parser}.
+    """
+
+    @given(
+        structure_and_messages1=STRUCTURES_WITH_MESSAGES,
+        structure_and_messages2=STRUCTURES_WITH_MESSAGES,
+        structure_and_messages3=STRUCTURES_WITH_MESSAGES,
+    )
+    def test_parse_into_tasks(
+        self, structure_and_messages1, structure_and_messages2, structure_and_messages3
+    ):
+        """
+        Adding messages to a L{Parser} parses them into a L{Task} instances.
+        """
+        _, messages1 = structure_and_messages1
+        _, messages2 = structure_and_messages2
+        _, messages3 = structure_and_messages3
+        all_messages = (messages1, messages2, messages3)
+        # Need unique UUIDs per task:
+        assume(len(set(m[0][TASK_UUID_FIELD] for m in all_messages)) == 3)
+
+        parser = Parser()
+        all_tasks = []
+        for message in chain(*zip_longest(*all_messages)):
+            if message is not None:
+                completed_tasks, parser = parser.add(message)
+                all_tasks.extend(completed_tasks)
+
+        self.assertCountEqual(all_tasks, [parse_to_task(msgs) for msgs in all_messages])
+
+    @given(structure_and_messages=STRUCTURES_WITH_MESSAGES)
+    def test_incomplete_tasks(self, structure_and_messages):
+        """
+        Until a L{Task} is fully parsed, it is returned in
+        L{Parser.incomplete_tasks}.
+        """
+        _, messages = structure_and_messages
+        parser = Parser()
+        task = Task()
+        incomplete_matches = []
+        for message in messages[:-1]:
+            _, parser = parser.add(message)
+            task = task.add(message)
+            incomplete_matches.append(parser.incomplete_tasks() == [task])
+
+        task = task.add(messages[-1])
+        _, parser = parser.add(messages[-1])
+        self.assertEqual(
+            dict(
+                incomplete_matches=incomplete_matches,
+                final_incompleted=parser.incomplete_tasks(),
+            ),
+            dict(incomplete_matches=[True] * (len(messages) - 1), final_incompleted=[]),
+        )
+
+    @given(
+        structure_and_messages1=STRUCTURES_WITH_MESSAGES,
+        structure_and_messages2=STRUCTURES_WITH_MESSAGES,
+        structure_and_messages3=STRUCTURES_WITH_MESSAGES,
+    )
+    def test_parse_stream(
+        self, structure_and_messages1, structure_and_messages2, structure_and_messages3
+    ):
+        """
+        L{Parser.parse_stream} returns an iterable of completed and then
+        incompleted tasks.
+        """
+        _, messages1 = structure_and_messages1
+        _, messages2 = structure_and_messages2
+        _, messages3 = structure_and_messages3
+        # Need at least one non-dropped message in partial tree:
+        assume(len(messages3) > 1)
+        # Need unique UUIDs per task:
+        assume(
+            len(set(m[0][TASK_UUID_FIELD] for m in (messages1, messages2, messages3)))
+            == 3
+        )
+
+        # Two complete tasks, one incomplete task:
+        all_messages = (messages1, messages2, messages3[:-1])
+
+        all_tasks = list(
+            Parser.parse_stream(
+                [m for m in chain(*zip_longest(*all_messages)) if m is not None]
+            )
+        )
+        self.assertCountEqual(all_tasks, [parse_to_task(msgs) for msgs in all_messages])
+
+
+class BackwardsCompatibility(TestCase):
+    """Tests for backwards compatibility."""
+
+    def test_imports(self):
+        """Old ways of importing still work."""
+        import eliot._parse
+        from logxpy import _parse
+        import eliot.parse
+
+        self.assertIs(eliot.parse, eliot._parse)
+        self.assertIs(_parse, eliot.parse)

logxpy/tests/test_pool.py

@@ -0,0 +1,55 @@
+"""Tests for eliot._pool."""
+from unittest import TestCase
+import asyncio
+from logxpy._pool import Channel, Pool
+
+class ChannelTests(TestCase):
+    def test_send_recv(self):
+        """Channel sends and receives items."""
+        async def run():
+            c = Channel(size=10)
+            await c.send(1)
+            await c.send(2)
+            self.assertEqual(await c.recv(), 1)
+            self.assertEqual(await c.recv(), 2)
+        asyncio.run(run())
+
+    def test_close(self):
+        """Closed channel returns None."""
+        async def run():
+            c = Channel()
+            await c.send(1)
+            c.close()
+            self.assertEqual(await c.recv(), 1)
+            self.assertEqual(await c.recv(), None)
+        asyncio.run(run())
+
+    def test_drop_oldest(self):
+        """Channel drops oldest when full if requested."""
+        async def run():
+            c = Channel(size=2, drop_oldest=True)
+            await c.send(1)
+            await c.send(2)
+            await c.send(3) # Should drop 1
+            
+            self.assertEqual(c.stats.dropped, 1)
+            self.assertEqual(await c.recv(), 2)
+            self.assertEqual(await c.recv(), 3)
+        asyncio.run(run())
+
+class PoolTests(TestCase):
+    def test_cpu_pool(self):
+        """CPU pool executes function."""
+        async def run():
+            pool = Pool()
+            res = await pool.cpu(sum, [1, 2, 3])
+            self.assertEqual(res, 6)
+        asyncio.run(run())
+
+    def test_io_pool(self):
+        """IO pool executes function."""
+        async def run():
+            pool = Pool()
+            res = await pool.io(str, 123)
+            self.assertEqual(res, "123")
+        asyncio.run(run())

logxpy/tests/test_prettyprint.py

@@ -0,0 +1,303 @@
+"""
+Tests for C{eliot.prettyprint}.
+"""
+
+from unittest import TestCase
+from subprocess import check_output, Popen, PIPE
+from collections import OrderedDict
+from datetime import datetime
+
+from pyrsistent import pmap
+
+from ..json import _dumps_bytes as dumps
+from ..prettyprint import pretty_format, compact_format, REQUIRED_FIELDS
+
+SIMPLE_MESSAGE = {
+    "timestamp": 1443193754,
+    "task_uuid": "8c668cde-235b-4872-af4e-caea524bd1c0",
+    "message_type": "messagey",
+    "task_level": [1, 2],
+    "keys": [123, 456],
+}
+
+UNTYPED_MESSAGE = {
+    "timestamp": 1443193754,
+    "task_uuid": "8c668cde-235b-4872-af4e-caea524bd1c0",
+    "task_level": [1],
+    "key": 1234,
+    "abc": "def",
+}
+
+
+class FormattingTests(TestCase):
+    """
+    Tests for L{pretty_format}.
+    """
+
+    def test_message(self):
+        """
+        A typed message is printed as expected.
+        """
+        self.assertEqual(
+            pretty_format(SIMPLE_MESSAGE),
+            """\
+8c668cde-235b-4872-af4e-caea524bd1c0 -> /1/2
+2015-09-25T15:09:14Z
+  message_type: 'messagey'
+  keys: [123, 456]
+""",
+        )
+
+    def test_untyped_message(self):
+        """
+        A message with no type is printed as expected.
+        """
+        self.assertEqual(
+            pretty_format(UNTYPED_MESSAGE),
+            """\
+8c668cde-235b-4872-af4e-caea524bd1c0 -> /1
+2015-09-25T15:09:14Z
+  abc: 'def'
+  key: 1234
+""",
+        )
+
+    def test_action(self):
+        """
+        An action message is printed as expected.
+        """
+        message = {
+            "task_uuid": "8bc6ded2-446c-4b6d-abbc-4f21f1c9a7d8",
+            "place": "Statue #1",
+            "task_level": [2, 2, 2, 1],
+            "action_type": "visited",
+            "timestamp": 1443193958.0,
+            "action_status": "started",
+        }
+        self.assertEqual(
+            pretty_format(message),
+            """\
+8bc6ded2-446c-4b6d-abbc-4f21f1c9a7d8 -> /2/2/2/1
+2015-09-25T15:12:38Z
+  action_type: 'visited'
+  action_status: 'started'
+  place: 'Statue #1'
+""",
+        )
+
+    def test_multi_line(self):
+        """
+        Multiple line values are indented nicely.
+        """
+        message = {
+            "timestamp": 1443193754,
+            "task_uuid": "8c668cde-235b-4872-af4e-caea524bd1c0",
+            "task_level": [1],
+            "key": "hello\nthere\nmonkeys!\n",
+            "more": "stuff",
+        }
+        self.assertEqual(
+            pretty_format(message),
+            """\
+8c668cde-235b-4872-af4e-caea524bd1c0 -> /1
+2015-09-25T15:09:14Z
+  key: 'hello
+     |  there
+     |  monkeys!
+     |  '
+  more: 'stuff'
+""",
+        )
+
+    def test_tabs(self):
+        """
+        Tabs are formatted as tabs, not quoted.
+        """
+        message = {
+            "timestamp": 1443193754,
+            "task_uuid": "8c668cde-235b-4872-af4e-caea524bd1c0",
+            "task_level": [1],
+            "key": "hello\tmonkeys!",
+        }
+        self.assertEqual(
+            pretty_format(message),
+            """\
+8c668cde-235b-4872-af4e-caea524bd1c0 -> /1
+2015-09-25T15:09:14Z
+  key: 'hello	monkeys!'
+""",
+        )
+
+    def test_structured(self):
+        """
+        Structured field values (e.g. a dictionary) are formatted in a helpful
+        manner.
+        """
+        message = {
+            "timestamp": 1443193754,
+            "task_uuid": "8c668cde-235b-4872-af4e-caea524bd1c0",
+            "task_level": [1],
+            "key": {"value": 123, "another": [1, 2, {"more": "data"}]},
+        }
+        self.assertEqual(
+            pretty_format(message),
+            """\
+8c668cde-235b-4872-af4e-caea524bd1c0 -> /1
+2015-09-25T15:09:14Z
+  key: {'another': [1, 2, {'more': 'data'}],
+     |  'value': 123}
+""",
+        )
+
+    def test_microsecond(self):
+        """
+        Microsecond timestamps are rendered in the output.
+        """
+        message = {
+            "timestamp": 1443193754.123455,
+            "task_uuid": "8c668cde-235b-4872-af4e-caea524bd1c0",
+            "task_level": [1],
+        }
+        self.assertEqual(
+            pretty_format(message),
+            """\
+8c668cde-235b-4872-af4e-caea524bd1c0 -> /1
+2015-09-25T15:09:14.123455Z
+""",
+        )
+
+    def test_compact(self):
+        """
+        The compact mode does everything on a single line, including
+        dictionaries and multi-line messages.
+        """
+        message = {
+            "timestamp": 1443193754,
+            "task_uuid": "8c668cde-235b-4872-af4e-caea524bd1c0",
+            "task_level": [1],
+            "key": OrderedDict([("value", 123), ("another", [1, 2, {"more": "data"}])]),
+            "multiline": "hello\n\tthere!\nabc",
+        }
+        self.assertEqual(
+            compact_format(message),
+            r'8c668cde-235b-4872-af4e-caea524bd1c0/1 2015-09-25T15:09:14Z key={"value":123,"another":[1,2,{"more":"data"}]} multiline="hello\n\tthere!\nabc"',
+        )
+
+    def test_local(self):
+        """
+        Timestamps can be generated in local timezone.
+        """
+        message = {
+            "timestamp": 1443193754,
+            "task_uuid": "8c668cde-235b-4872-af4e-caea524bd1c0",
+            "task_level": [1],
+        }
+        expected = datetime.fromtimestamp(1443193754).isoformat(sep="T")
+        self.assertIn(expected, pretty_format(message, True))
+        self.assertIn(expected, compact_format(message, True))
+
+
+class CommandLineTests(TestCase):
+    """
+    Tests for the command-line tool.
+    """
+
+    def test_help(self):
+        """
+        C{--help} prints out the help text and exits.
+        """
+        result = check_output(["eliot-prettyprint", "--help"])
+        self.assertIn(b"Convert Eliot messages into more readable", result)
+
+    def write_and_read(self, lines, extra_args=()):
+        """
+        Write the given lines to the command-line on stdin, return stdout.
+
+        @param lines: Sequences of lines to write, as bytes, and lacking
+            new lines.
+        @return: Unicode-decoded result of subprocess stdout.
+        """
+        process = Popen(
+            [b"eliot-prettyprint"] + list(extra_args), stdin=PIPE, stdout=PIPE
+        )
+        process.stdin.write(b"".join(line + b"\n" for line in lines))
+        process.stdin.close()
+        result = process.stdout.read().decode("utf-8")
+        process.stdout.close()
+        return result
+
+    def test_output(self):
+        """
+        Lacking command-line arguments the process reads JSON lines from stdin
+        and writes out a pretty-printed version.
+        """
+        messages = [SIMPLE_MESSAGE, UNTYPED_MESSAGE, SIMPLE_MESSAGE]
+        stdout = self.write_and_read(map(dumps, messages))
+        self.assertEqual(
+            stdout, "".join(pretty_format(message) + "\n" for message in messages)
+        )
+
+    def test_compact_output(self):
+        """
+        In compact mode, the process reads JSON lines from stdin and writes out
+        a pretty-printed compact version.
+        """
+        messages = [SIMPLE_MESSAGE, UNTYPED_MESSAGE, SIMPLE_MESSAGE]
+        stdout = self.write_and_read(map(dumps, messages), [b"--compact"])
+        self.assertEqual(
+            stdout, "".join(compact_format(message) + "\n" for message in messages)
+        )
+
+    def test_local_timezone(self):
+        """
+        Local timezones are used if --local-timezone is given.
+        """
+        message = {
+            "timestamp": 1443193754,
+            "task_uuid": "8c668cde-235b-4872-af4e-caea524bd1c0",
+            "task_level": [1],
+        }
+        expected = datetime.fromtimestamp(1443193754).isoformat(sep="T")
+        stdout = self.write_and_read(
+            [dumps(message)], [b"--compact", b"--local-timezone"]
+        )
+        self.assertIn(expected, stdout)
+        stdout = self.write_and_read(
+            [dumps(message)], [b"--compact", b"--local-timezone"]
+        )
+        self.assertIn(expected, stdout)
+
+    def test_not_json_message(self):
+        """
+        Non-JSON lines are not formatted.
+        """
+        not_json = b"NOT JSON!!"
+        lines = [dumps(SIMPLE_MESSAGE), not_json, dumps(UNTYPED_MESSAGE)]
+        stdout = self.write_and_read(lines)
+        self.assertEqual(
+            stdout,
+            "{}\nNot JSON: {}\n\n{}\n".format(
+                pretty_format(SIMPLE_MESSAGE),
+                str(not_json),
+                pretty_format(UNTYPED_MESSAGE),
+            ),
+        )
+
+    def test_missing_required_field(self):
+        """
+        Non-Eliot JSON messages are not formatted.
+        """
+        base = pmap(SIMPLE_MESSAGE)
+        messages = [dumps(dict(base.remove(field))) for field in REQUIRED_FIELDS] + [
+            dumps(SIMPLE_MESSAGE)
+        ]
+        stdout = self.write_and_read(messages)
+        self.assertEqual(
+            stdout,
+            "{}{}\n".format(
+                "".join(
+                    "Not an Eliot message: {}\n\n".format(msg) for msg in messages[:-1]
+                ),
+                pretty_format(SIMPLE_MESSAGE),
+            ),
+        )

logxpy/tests/test_pyinstaller.py

@@ -0,0 +1,35 @@
+"""Test for pyinstaller compatibility."""
+
+from unittest import TestCase, SkipTest
+from tempfile import mkdtemp, NamedTemporaryFile
+from subprocess import check_call, CalledProcessError
+import os
+
+
+class PyInstallerTests(TestCase):
+    """Make sure PyInstaller doesn't break Eliot."""
+
+    def setUp(self):
+        try:
+            check_call(["pyinstaller", "--help"])
+        except (CalledProcessError, FileNotFoundError):
+            raise SkipTest("Can't find pyinstaller.")
+
+    def test_importable(self):
+        """The Eliot package can be imported inside a PyInstaller packaged binary."""
+        output_dir = mkdtemp()
+        with NamedTemporaryFile(mode="w") as f:
+            f.write("import eliot; import eliot.prettyprint\n")
+            f.flush()
+            check_call(
+                [
+                    "pyinstaller",
+                    "--distpath",
+                    output_dir,
+                    "-F",
+                    "-n",
+                    "importeliot",
+                    f.name,
+                ]
+            )
+        check_call([os.path.join(output_dir, "importeliot")])