logxpy 0.1.0__py3-none-any.whl

logxpy/tests/test_api.py

@@ -0,0 +1,86 @@
+"""
+Tests for the public API exposed by L{eliot}.
+"""
+
+from unittest import TestCase
+
+from .._output import Logger
+import logxpy
+
+
+class PublicAPITests(TestCase):
+    """
+    Tests for the public API.
+    """
+
+    def test_addDestination(self):
+        """
+        L{eliot.addDestination} adds destinations to the L{Destinations}
+        attached to L{Logger}.
+        """
+        o = object()
+        eliot.addDestination(o)
+        self.addCleanup(eliot.removeDestination, o)
+        self.assertIn(o, Logger._destinations._destinations)
+
+    def test_removeDestination(self):
+        """
+        L{eliot.addDestination} removes destinations from the L{Destinations}
+        attached to L{Logger}.
+        """
+        self.assertEqual(eliot.removeDestination, Logger._destinations.remove)
+
+    def test_addGlobalFields(self):
+        """
+        L{eliot.addGlobalFields} calls the corresponding method on the
+        L{Destinations} attached to L{Logger}.
+        """
+        self.assertEqual(eliot.addGlobalFields, Logger._destinations.addGlobalFields)
+
+
+class PEP8Tests(TestCase):
+    """
+    Tests for the PEP 8 variant of the the public API.
+    """
+
+    def test_add_destination(self):
+        """
+        L{eliot.addDestionation} is the same as L{eliot.add_destination}.
+        """
+        self.assertIs(eliot.add_destination, eliot.addDestination)
+
+    def test_remove_destination(self):
+        """
+        L{eliot.removeDestionation} is the same as L{eliot.remove_destination}.
+        """
+        self.assertIs(eliot.remove_destination, eliot.removeDestination)
+
+    def test_add_global_fields(self):
+        """
+        L{eliot.add_global_fields} is the same as L{eliot.addGlobalFields}.
+        """
+        self.assertIs(eliot.add_global_fields, eliot.addGlobalFields)
+
+    def test_write_traceback(self):
+        """
+        L{eliot.writeTraceback} is the same as L{eliot.write_traceback}.
+        """
+        self.assertIs(eliot.write_traceback, eliot.writeTraceback)
+
+    def test_write_failure(self):
+        """
+        L{eliot.writeFailure} is the same as L{eliot.write_failure}.
+        """
+        self.assertIs(eliot.write_failure, eliot.writeFailure)
+
+    def test_start_task(self):
+        """
+        L{eliot.startTask} is the same as L{eliot.start_task}.
+        """
+        self.assertIs(eliot.start_task, eliot.startTask)
+
+    def test_start_action(self):
+        """
+        L{eliot.startAction} is the same as L{eliot.start_action}.
+        """
+        self.assertIs(eliot.start_action, eliot.startAction)

logxpy/tests/test_async.py

@@ -0,0 +1,67 @@
+"""Tests for eliot._async."""
+from unittest import TestCase
+import asyncio
+from logxpy._async import action, aaction, scope, _emit_handlers
+
+class AsyncActionTests(TestCase):
+    def test_sync_action(self):
+        """Sync action context manager works."""
+        records = []
+        def handler(r): records.append(r)
+        _emit_handlers.append(handler)
+        self.addCleanup(_emit_handlers.remove, handler)
+        
+        with action("test_action", x=1):
+            pass
+            
+        self.assertEqual(len(records), 2)
+        start, end = records
+        self.assertEqual(start.action_status, "started")
+        self.assertEqual(end.action_status, "succeeded")
+        self.assertEqual(start.task_uuid, end.task_uuid)
+
+    def test_async_action(self):
+        """Async action context manager works."""
+        records = []
+        def handler(r): records.append(r)
+        _emit_handlers.append(handler)
+        self.addCleanup(_emit_handlers.remove, handler)
+        
+        async def run():
+            async with aaction("test_async", y=2):
+                pass
+        
+        asyncio.run(run())
+        
+        self.assertEqual(len(records), 2)
+        start, end = records
+        self.assertEqual(start.action_type, "test_async")
+        self.assertEqual(end.action_status, "succeeded")
+
+    def test_scope(self):
+        """Scope context manager merges context."""
+        records = []
+        def handler(r): records.append(r)
+        _emit_handlers.append(handler)
+        self.addCleanup(_emit_handlers.remove, handler)
+        
+        with scope(a=1):
+            with action("scoped"):
+                pass
+                
+        self.assertEqual(records[0].context.get("a"), 1)
+
+    def test_async_scope(self):
+        """Scope works in async context."""
+        records = []
+        def handler(r): records.append(r)
+        _emit_handlers.append(handler)
+        self.addCleanup(_emit_handlers.remove, handler)
+        
+        async def run():
+            with scope(b=2):
+                async with aaction("async_scoped"):
+                    pass
+        
+        asyncio.run(run())
+        self.assertEqual(records[0].context.get("b"), 2)

logxpy/tests/test_compat.py

@@ -0,0 +1,13 @@
+"""Tests for eliot._compat."""
+from unittest import TestCase
+import warnings
+from logxpy import log_message
+
+class CompatTests(TestCase):
+    def test_deprecations(self):
+        """Old APIs emit warnings."""
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            log_message("test_msg")
+            self.assertTrue(len(w) > 0)
+            self.assertIn("deprecated", str(w[0].message))

logxpy/tests/test_config.py

@@ -0,0 +1,21 @@
+"""Tests for eliot._config."""
+from unittest import TestCase
+import os
+from logxpy._config import Config
+
+class ConfigTests(TestCase):
+    def test_defaults(self):
+        """Default config is sane."""
+        cfg = Config()
+        self.assertEqual(cfg.format, "rich")
+        self.assertEqual(cfg.destinations, ["console"])
+
+    def test_env_override(self):
+        """Environment variables override defaults."""
+        os.environ["LOGGERX_LEVEL"] = "ERROR"
+        try:
+            cfg = Config.load()
+            from eliot._types import Level
+            self.assertEqual(cfg.level, Level.ERROR)
+        finally:
+            del os.environ["LOGGERX_LEVEL"]

logxpy/tests/test_coroutines.py

@@ -0,0 +1,105 @@
+"""
+Tests for coroutines.
+
+Imported into test_coroutine.py when running tests under Python 3.5 or later;
+in earlier versions of Python this code is a syntax error.
+"""
+
+import asyncio
+from unittest import TestCase
+
+from ..testing import capture_logging
+from ..parse import Parser
+from .. import start_action
+
+
+async def standalone_coro():
+    """
+    Log a message inside a new coroutine.
+    """
+    await asyncio.sleep(0.1)
+    with start_action(action_type="standalone"):
+        pass
+
+
+async def calling_coro():
+    """
+    Log an action inside a coroutine, and call another coroutine.
+    """
+    with start_action(action_type="calling"):
+        await standalone_coro()
+
+
+def run_coroutines(*async_functions):
+    """
+    Run a coroutine until it finishes.
+    """
+    loop = asyncio.get_event_loop()
+    futures = [asyncio.ensure_future(f()) for f in async_functions]
+
+    async def wait_for_futures():
+        for future in futures:
+            await future
+
+    loop.run_until_complete(wait_for_futures())
+
+
+class CoroutineTests(TestCase):
+    """
+    Tests for coroutines.
+    """
+
+    @capture_logging(None)
+    def test_multiple_coroutines_contexts(self, logger):
+        """
+        Each top-level coroutine has its own Eliot logging context.
+        """
+
+        async def waiting_coro():
+            with start_action(action_type="waiting"):
+                await asyncio.sleep(0.5)
+
+        run_coroutines(waiting_coro, standalone_coro)
+        trees = Parser.parse_stream(logger.messages)
+        self.assertEqual(
+            sorted([(t.root().action_type, t.root().children) for t in trees]),
+            [("standalone", []), ("waiting", [])],
+        )
+
+    @capture_logging(None)
+    def test_await_inherits_coroutine_contexts(self, logger):
+        """
+        awaited coroutines inherit the logging context.
+        """
+        run_coroutines(calling_coro)
+        [tree] = Parser.parse_stream(logger.messages)
+        root = tree.root()
+        [child] = root.children
+        self.assertEqual(
+            (root.action_type, child.action_type, child.children),
+            ("calling", "standalone", []),
+        )
+
+    @capture_logging(None)
+    def test_interleaved_coroutines(self, logger):
+        """
+        start_action() started in one coroutine doesn't impact another in a
+        different coroutine.
+        """
+
+        async def coro_sleep(delay, action_type):
+            with start_action(action_type=action_type):
+                await asyncio.sleep(delay)
+
+        async def main():
+            with start_action(action_type="main"):
+                f1 = asyncio.ensure_future(coro_sleep(1, "a"))
+                f2 = asyncio.ensure_future(coro_sleep(0.5, "b"))
+                await f1
+                await f2
+
+        run_coroutines(main)
+        [tree] = list(Parser.parse_stream(logger.messages))
+        root = tree.root()
+        self.assertEqual(root.action_type, "main")
+        self.assertEqual(sorted([c.action_type for c in root.children]), ["a", "b"])

logxpy/tests/test_dask.py

@@ -0,0 +1,211 @@
+"""Tests for eliot.dask."""
+
+from unittest import TestCase, skipUnless
+
+from ..testing import capture_logging, LoggedAction, LoggedMessage
+from .. import start_action, log_message
+
+try:
+    import dask
+    from dask.bag import from_sequence
+    from dask.distributed import Client
+    import dask.dataframe as dd
+    import pandas as pd
+except ImportError:
+    dask = None
+else:
+    from ..dask import (
+        compute_with_trace,
+        _RunWithEliotContext,
+        _add_logging,
+        persist_with_trace,
+    )
+
+
+@skipUnless(dask, "Dask not available.")
+class DaskTests(TestCase):
+    """Tests for end-to-end functionality."""
+
+    def setUp(self):
+        dask.config.set(scheduler="threading")
+
+    def test_compute(self):
+        """compute_with_trace() runs the same logic as compute()."""
+        bag = from_sequence([1, 2, 3])
+        bag = bag.map(lambda x: x * 7).map(lambda x: x * 4)
+        bag = bag.fold(lambda x, y: x + y)
+        self.assertEqual(dask.compute(bag), compute_with_trace(bag))
+
+    def test_future(self):
+        """compute_with_trace() can handle Futures."""
+        client = Client(processes=False)
+        self.addCleanup(client.shutdown)
+        [bag] = dask.persist(from_sequence([1, 2, 3]))
+        bag = bag.map(lambda x: x * 5)
+        result = dask.compute(bag)
+        self.assertEqual(result, ([5, 10, 15],))
+        self.assertEqual(result, compute_with_trace(bag))
+
+    def test_persist_result(self):
+        """persist_with_trace() runs the same logic as process()."""
+        client = Client(processes=False)
+        self.addCleanup(client.shutdown)
+        bag = from_sequence([1, 2, 3])
+        bag = bag.map(lambda x: x * 7)
+        self.assertEqual(
+            [b.compute() for b in dask.persist(bag)],
+            [b.compute() for b in persist_with_trace(bag)],
+        )
+
+    def test_persist_pandas(self):
+        """persist_with_trace() with a Pandas dataframe.
+
+        This ensures we don't blow up, which used to be the case.
+        """
+        df = pd.DataFrame()
+        df = dd.from_pandas(df, npartitions=1)
+        persist_with_trace(df)
+
+    @capture_logging(None)
+    def test_persist_logging(self, logger):
+        """persist_with_trace() preserves Eliot context."""
+
+        def persister(bag):
+            [bag] = persist_with_trace(bag)
+            return dask.compute(bag)
+
+        self.assert_logging(logger, persister, "dask:persist")
+
+    @capture_logging(None)
+    def test_compute_logging(self, logger):
+        """compute_with_trace() preserves Eliot context."""
+        self.assert_logging(logger, compute_with_trace, "dask:compute")
+
+    def assert_logging(self, logger, run_with_trace, top_action_name):
+        """Utility function for _with_trace() logging tests."""
+
+        def mult(x):
+            log_message(message_type="mult")
+            return x * 4
+
+        def summer(x, y):
+            log_message(message_type="finally")
+            return x + y
+
+        bag = from_sequence([1, 2])
+        bag = bag.map(mult).fold(summer)
+        with start_action(action_type="act1"):
+            run_with_trace(bag)
+
+        [logged_action] = LoggedAction.ofType(logger.messages, "act1")
+        self.assertEqual(
+            logged_action.type_tree(),
+            {
+                "act1": [
+                    {
+                        top_action_name: [
+                            {"eliot:remote_task": ["dask:task", "mult"]},
+                            {"eliot:remote_task": ["dask:task", "mult"]},
+                            {"eliot:remote_task": ["dask:task", "finally"]},
+                        ]
+                    }
+                ]
+            },
+        )
+
+        # Make sure dependencies are tracked:
+        (
+            mult1_msg,
+            mult2_msg,
+            final_msg,
+        ) = LoggedMessage.ofType(logger.messages, "dask:task")
+        self.assertEqual(
+            sorted(final_msg.message["dependencies"]),
+            sorted([mult1_msg.message["key"], mult2_msg.message["key"]]),
+        )
+
+        # Make sure dependencies are logically earlier in the logs:
+        self.assertTrue(
+            mult1_msg.message["task_level"] < final_msg.message["task_level"]
+        )
+        self.assertTrue(
+            mult2_msg.message["task_level"] < final_msg.message["task_level"]
+        )
+
+
+@skipUnless(dask, "Dask not available.")
+class AddLoggingTests(TestCase):
+    """Tests for _add_logging()."""
+
+    maxDiff = None
+
+    def test_add_logging_to_full_graph(self):
+        """_add_logging() recreates Dask graph with wrappers."""
+        bag = from_sequence([1, 2, 3])
+        bag = bag.map(lambda x: x * 7).map(lambda x: x * 4)
+        bag = bag.fold(lambda x, y: x + y)
+        graph = bag.__dask_graph__()
+
+        # Add logging:
+        with start_action(action_type="bleh"):
+            logging_added = _add_logging(graph)
+
+        # Ensure resulting graph hasn't changed substantively:
+        logging_removed = {}
+        for key, value in logging_added.items():
+            if callable(value[0]):
+                func, args = value[0], value[1:]
+                self.assertIsInstance(func, _RunWithEliotContext)
+                value = (func.func,) + args
+            logging_removed[key] = value
+
+        self.assertEqual(logging_removed, graph)
+
+    def test_add_logging_explicit(self):
+        """_add_logging() on more edge cases of the graph."""
+
+        def add(s):
+            return s + "s"
+
+        def add2(s):
+            return s + "s"
+
+        # b runs first, then d, then a and c.
+        graph = {
+            "a": "d",
+            "d": [1, 2, (add, "b")],
+            ("b", 0): 1,
+            "c": (add2, "d"),
+        }
+
+        with start_action(action_type="bleh") as action:
+            task_id = action.task_uuid
+            self.assertEqual(
+                _add_logging(graph),
+                {
+                    "d": [
+                        1,
+                        2,
+                        (
+                            _RunWithEliotContext(
+                                task_id=task_id + "@/2",
+                                func=add,
+                                key="d",
+                                dependencies=["b"],
+                            ),
+                            "b",
+                        ),
+                    ],
+                    "a": "d",
+                    ("b", 0): 1,
+                    "c": (
+                        _RunWithEliotContext(
+                            task_id=task_id + "@/3",
+                            func=add2,
+                            key="c",
+                            dependencies=["d"],
+                        ),
+                        "d",
+                    ),
+                },
+            )

logxpy/tests/test_decorators.py

@@ -0,0 +1,54 @@
+"""Tests for eliot.decorators."""
+from unittest import TestCase
+import asyncio
+from logxpy.decorators import logged, timed, retry
+from logxpy._async import _emit_handlers
+
+class DecoratorTests(TestCase):
+    def setUp(self):
+        self.records = []
+        _emit_handlers.append(self.records.append)
+    
+    def tearDown(self):
+        _emit_handlers.remove(self.records.append)
+
+    def test_logged_sync(self):
+        """@logged works on sync functions."""
+        @logged
+        def func(x): return x + 1
+        
+        func(1)
+        self.assertEqual(len(self.records), 2) # start, end
+        self.assertEqual(self.records[0].fields["x"], 1)
+        self.assertEqual(self.records[1].fields["result"], 2)
+
+    def test_logged_async(self):
+        """@logged works on async functions."""
+        @logged
+        async def func(x): return x + 1
+        
+        asyncio.run(func(1))
+        self.assertEqual(len(self.records), 2)
+        self.assertEqual(self.records[1].fields["result"], 2)
+
+    def test_timed(self):
+        """@timed emits metric."""
+        @timed("my_metric")
+        def func(): pass
+        
+        func()
+        self.assertEqual(self.records[0].fields["metric"], "my_metric")
+        self.assertIn("duration_ms", self.records[0].fields)
+
+    def test_retry(self):
+        """@retry retries on failure."""
+        count = 0
+        @retry(attempts=2, delay=0)
+        def func():
+            nonlocal count
+            count += 1
+            if count < 2: raise ValueError("fail")
+            return "ok"
+            
+        self.assertEqual(func(), "ok")
+        self.assertEqual(count, 2)

logxpy/tests/test_filter.py

@@ -0,0 +1,122 @@
+"""
+Tests for L{eliot.filter}.
+"""
+
+import sys
+
+from unittest import TestCase
+from datetime import datetime
+from io import StringIO
+import inspect
+import json
+
+from .common import FakeSys
+from ..filter import EliotFilter, main, USAGE
+
+
+class EliotFilterTests(TestCase):
+    """
+    Tests for L{EliotFilter}.
+    """
+
+    def test_expression(self):
+        """
+        For each item in the incoming sequence L{EliotFilter.run} calls
+        L{EliotFilter._evaluate} with the item decoded from JSON, and writes the
+        result to the output file as JSON.
+        """
+        f = StringIO()
+        efilter = EliotFilter("J", [b'"abcd"', b"[1, 2]"], f)
+        efilter._evaluate = lambda expr: {"x": len(expr), "orig": expr}
+        self.assertEqual(f.getvalue(), "")
+        efilter.run()
+        self.assertEqual(
+            f.getvalue(),
+            json.dumps({"x": 4, "orig": "abcd"})
+            + "\n"
+            + json.dumps({"x": 2, "orig": [1, 2]})
+            + "\n",
+        )
+
+    def evaluateExpression(self, expr, message):
+        """
+        Render a single message with the given expression using
+        L{EliotFilter._evaluate}.
+        """
+        efilter = EliotFilter(expr, [], StringIO())
+        return efilter._evaluate(message)
+
+    def test_J(self):
+        """
+        The expression has access to the decoded JSON message as C{J} in its
+        locals.
+        """
+        result = self.evaluateExpression("J['a']", {"a": 123})
+        self.assertEqual(result, 123)
+
+    def test_otherLocals(self):
+        """
+        The expression has access to L{datetime} and L{timedelta} in its
+        built-ins.
+        """
+        result = self.evaluateExpression(
+            "isinstance(datetime.utcnow() - datetime.utcnow(), timedelta)", {}
+        )
+        self.assertEqual(result, True)
+
+    def test_datetimeSerialization(self):
+        """
+        Any L{datetime} in results will be serialized using L{datetime.isoformat}.
+        """
+        dt = datetime(2012, 12, 31)
+        f = StringIO()
+        EliotFilter("datetime(2012, 12, 31)", ["{}"], f).run()
+        expected = json.dumps(dt.isoformat()) + "\n"
+        self.assertEqual(f.getvalue(), expected)
+
+    def test_SKIP(self):
+        """
+        A result of C{SKIP} indicates nothing should be output.
+        """
+        f = StringIO()
+        EliotFilter("SKIP", [b'{"a": 123}'], f).run()
+        self.assertEqual(f.getvalue(), "")
+
+
+class MainTests(TestCase):
+    """
+    Test cases for L{main}.
+    """
+
+    def test_default(self):
+        """
+        By default L{main} uses information from L{sys}.
+        """
+        self.assertEqual(inspect.getfullargspec(main).defaults, (sys,))
+
+    def test_stdinOut(self):
+        """
+        L{main} reads from the C{stdin} attribute of the given C{sys} equivalent,
+        and writes rendered expressions to the C{stdout} attribute.
+        """
+        sys = FakeSys(["eliotfilter", "J[0]"], "[1, 2]\n[4, 5]\n")
+        main(sys)
+        self.assertEqual(sys.stdout.getvalue(), "1\n4\n")
+
+    def test_success(self):
+        """
+        A successful run returns C{0}.
+        """
+        sys = FakeSys(["eliotfilter", "J[0]"], "[1, 2]\n[4, 5]\n")
+        result = main(sys)
+        self.assertEqual(result, 0)
+
+    def test_noArguments(self):
+        """
+        If given no arguments, usage documentation is printed to stderr and C{1}
+        is returned.
+        """
+        sys = FakeSys(["eliotfilter"], "")
+        result = main(sys)
+        self.assertEqual(sys.stderr.getvalue(), USAGE)
+        self.assertEqual(result, 1)