logxpy 0.1.0__py3-none-any.whl

logxpy/tests/test_json.py

@@ -0,0 +1,208 @@
+"""
+Tests for L{eliot.json}.
+"""
+
+from unittest import TestCase, skipUnless, skipIf
+from json import loads
+from importlib.metadata import PackageNotFoundError, version as package_version
+
+try:
+    import numpy as np
+except ImportError:
+    np = None
+
+from logxpy.json import (
+    EliotJSONEncoder,
+    json_default,
+    _encoder_to_default_function,
+    _dumps_unicode as dumps,
+)
+
+
+def package_installed(name: str) -> bool:
+    """Return whether the package is installed."""
+    try:
+        package_version(name)
+        return True
+    except PackageNotFoundError:
+        return False
+
+
+class EliotJSONEncoderTests(TestCase):
+    """Tests for L{EliotJSONEncoder} and L{json_default}."""
+
+    @skipUnless(np, "NumPy not installed.")
+    def test_numpy(self):
+        """NumPy objects get serialized to readable JSON."""
+        encoder_default = _encoder_to_default_function(EliotJSONEncoder())
+        l = [
+            np.float32(12.5),
+            np.float64(2.0),
+            np.float16(0.5),
+            np.bool_(True),
+            np.str_("hello"),
+            np.byte(12),
+            np.short(12),
+            np.intc(-13),
+            np.int_(0),
+            np.longlong(100),
+            np.intp(7),
+            np.ubyte(12),
+            np.ushort(12),
+            np.uintc(13),
+            np.ulonglong(100),
+            np.uintp(7),
+            np.int8(1),
+            np.int16(3),
+            np.int32(4),
+            np.int64(5),
+            np.uint8(1),
+            np.uint16(3),
+            np.uint32(4),
+            np.uint64(5),
+        ]
+        l2 = [l, np.array([1, 2, 3])]
+        roundtripped = loads(dumps(l2, default=encoder_default))
+        self.assertEqual([l, [1, 2, 3]], roundtripped)
+        roundtripped2 = loads(dumps(l2, default=json_default))
+        self.assertEqual([l, [1, 2, 3]], roundtripped2)
+
+    @skipIf(np, "NumPy is installed.")
+    def test_numpy_not_imported(self):
+        """If NumPy is not available, C{json_default} continues to work.
+
+        This ensures NumPy isn't a hard dependency.
+        """
+        with self.assertRaises(TypeError):
+            dumps([object()], default=json_default)
+        self.assertEqual(dumps(12, default=json_default), "12")
+
+    @skipUnless(np, "NumPy is not installed.")
+    def test_large_numpy_array(self):
+        """
+        Large NumPy arrays are not serialized completely, since this is (A) a
+        performance hit (B) probably a mistake on the user's part.
+        """
+        a1000 = np.array([0] * 10000)
+        self.assertEqual(loads(dumps(a1000, default=json_default)), a1000.tolist())
+        a1002 = np.zeros((2, 5001))
+        a1002[0][0] = 12
+        a1002[0][1] = 13
+        a1002[1][1] = 500
+        self.assertEqual(
+            loads(dumps(a1002, default=json_default)),
+            {"array_start": a1002.flat[:10000].tolist(), "original_shape": [2, 5001]},
+        )
+
+    def test_basic_types(self):
+        """Test serialization of basic Python types."""
+        from pathlib import Path
+        from datetime import datetime, date, time
+        from uuid import UUID
+        from collections import defaultdict, OrderedDict, Counter
+        from enum import Enum
+
+        class TestEnum(Enum):
+            A = 1
+            B = "test"
+
+        test_data = {
+            "path": Path("/tmp/test"),
+            "datetime": datetime(2024, 1, 1, 12, 0),
+            "date": date(2024, 1, 1),
+            "time": time(12, 0),
+            "uuid": UUID("12345678-1234-5678-1234-567812345678"),
+            "set": {1, 2, 3},
+            "defaultdict": defaultdict(list, {"a": [1, 2]}),
+            "ordered_dict": OrderedDict([("a", 1), ("b", 2)]),
+            "counter": Counter(["a", "a", "b"]),
+            "complex": 1 + 2j,
+            "enum": TestEnum.A,
+            "enum2": TestEnum.B,
+        }
+
+        serialized = loads(dumps(test_data, default=json_default))
+
+        self.assertEqual(serialized["path"], "/tmp/test")
+        self.assertEqual(serialized["datetime"], "2024-01-01T12:00:00")
+        self.assertEqual(serialized["date"], "2024-01-01")
+        self.assertEqual(serialized["time"], "12:00:00")
+        self.assertEqual(serialized["uuid"], "12345678-1234-5678-1234-567812345678")
+        self.assertEqual(serialized["set"], [1, 2, 3])
+        self.assertEqual(serialized["defaultdict"], {"a": [1, 2]})
+        self.assertEqual(serialized["ordered_dict"], {"a": 1, "b": 2})
+        self.assertEqual(serialized["counter"], {"a": 2, "b": 1})
+        self.assertEqual(serialized["complex"], {"real": 1.0, "imag": 2.0})
+        self.assertEqual(serialized["enum"], 1)
+        self.assertEqual(serialized["enum2"], "test")
+
+    @skipUnless(package_installed("pydantic"), "Pydantic not installed.")
+    def test_pydantic(self):
+        """Test serialization of Pydantic models."""
+        from pydantic import BaseModel
+
+        class TestModel(BaseModel):
+            name: str
+            value: int
+
+        model = TestModel(name="test", value=42)
+        serialized = loads(dumps(model, default=json_default))
+        self.assertEqual(serialized, {"name": "test", "value": 42})
+
+    @skipUnless(package_installed("pandas"), "Pandas not installed.")
+    def test_pandas(self):
+        """Test serialization of Pandas objects."""
+        import pandas as pd
+
+        # Test Timestamp
+        ts = pd.Timestamp("2024-01-01 12:00:00")
+        self.assertEqual(loads(dumps(ts, default=json_default)), "2024-01-01T12:00:00")
+
+        # Test Series
+        series = pd.Series([1, 2, 3])
+        self.assertEqual(loads(dumps(series, default=json_default)), [1, 2, 3])
+
+        # Test DataFrame
+        df = pd.DataFrame({"a": [1, 2], "b": [3, 4]})
+        self.assertEqual(
+            loads(dumps(df, default=json_default)), [{"a": 1, "b": 3}, {"a": 2, "b": 4}]
+        )
+
+        # Test Interval
+        interval = pd.Interval(0, 1, closed="both")
+        self.assertEqual(
+            loads(dumps(interval, default=json_default)),
+            {"left": 0, "right": 1, "closed": "both"},
+        )
+
+        # Test Period
+        period = pd.Period("2024-01")
+        self.assertEqual(loads(dumps(period, default=json_default)), "2024-01")
+
+    @skipUnless(package_installed("polars"), "Polars not installed.")
+    def test_polars(self):
+        """Test serialization of Polars objects."""
+        import polars as pl
+
+        # Test Series
+        series = pl.Series("a", [1, 2, 3])
+        self.assertEqual(loads(dumps(series, default=json_default)), [1, 2, 3])
+
+        # Test DataFrame
+        df = pl.DataFrame({"a": [1, 2], "b": [3, 4]})
+        self.assertEqual(
+            loads(dumps(df, default=json_default)), [{"a": 1, "b": 3}, {"a": 2, "b": 4}]
+        )
+
+    def test_dataclass(self):
+        """Test serialization of dataclasses."""
+        from dataclasses import dataclass
+
+        @dataclass
+        class TestDataClass:
+            name: str
+            value: int
+
+        obj = TestDataClass(name="test", value=42)
+        serialized = loads(dumps(obj, default=json_default))
+        self.assertEqual(serialized, {"name": "test", "value": 42})

logxpy/tests/test_loggerx.py

@@ -0,0 +1,44 @@
+"""Tests for eliot.loggerx."""
+from unittest import TestCase
+from logxpy.loggerx import Logger, log
+from logxpy._async import _emit_handlers
+from logxpy._types import Level
+
+class LoggerTests(TestCase):
+    def setUp(self):
+        self.records = []
+        _emit_handlers.append(self.records.append)
+    
+    def tearDown(self):
+        _emit_handlers.remove(self.records.append)
+
+    def test_levels(self):
+        """Logger methods emit correct levels."""
+        log.info("info msg")
+        log.error("error msg")
+        
+        self.assertEqual(len(self.records), 2)
+        self.assertEqual(self.records[0].level, Level.INFO)
+        self.assertEqual(self.records[1].level, Level.ERROR)
+
+    def test_fluent(self):
+        """Logger methods return self."""
+        l = Logger()
+        self.assertIs(l.info("msg"), l)
+
+    def test_context(self):
+        """Logger respects scope."""
+        with log.scope(ctx=1):
+            log.info("msg")
+            
+        self.assertEqual(self.records[0].context["ctx"], 1)
+
+    def test_types(self):
+        """Type methods format data."""
+        log.json({"a": 1})
+        self.assertIn('"a": 1', self.records[0].fields["content"])
+
+    def test_child(self):
+        """Child logger inherits settings."""
+        child = log.new("child")
+        self.assertEqual(child._name, "root.child")

logxpy/tests/test_logwriter.py

@@ -0,0 +1,262 @@
+"""
+Tests for L{eliot.logwriter}.
+"""
+
+import time
+import threading
+
+from io import BytesIO
+
+try:
+    from zope.interface.verify import verifyClass
+    from twisted.internet import reactor
+    from twisted.trial.unittest import TestCase
+    from twisted.application.service import IService
+    from twisted.python import threadable
+except ImportError:
+    # Make tests not run at all.
+    TestCase = object
+else:
+    # Make sure we always import this if Twisted is available, so broken
+    # logwriter.py causes a failure:
+    from ..logwriter import ThreadedWriter
+
+from .. import Logger, removeDestination, FileDestination
+
+
+class BlockingFile(object):
+    """
+    A file-like whose writes can be blocked.
+
+    Also, allow calling C{getvalue} after C{close}, unlike L{BytesIO}.
+    """
+
+    def __init__(self):
+        self.file = BytesIO()
+        self.lock = threading.Lock()
+        self.data = b""
+
+    def block(self):
+        """
+        Prevent writes until L{unblock} is called.
+        """
+        self.lock.acquire()
+
+    def unblock(self):
+        """
+        Allow writes if L{block} was previous called.
+        """
+        self.lock.release()
+
+    def getvalue(self):
+        """
+        Get written bytes.
+
+        @return: Written bytes.
+        """
+        return self.data
+
+    def write(self, data):
+        with self.lock:
+            self.file.write(data)
+
+    def flush(self):
+        self.data = self.file.getvalue()
+
+    def close(self):
+        self.file.close()
+
+
+class ThreadedWriterTests(TestCase):
+    """
+    Tests for L{ThreadedWriter}.
+
+    Many of these tests involve interactions across threads, so they
+    arbitrarily wait for up to 5 seconds to reduce chances of slow thread
+    switching causing the test to fail.
+    """
+
+    def test_interface(self):
+        """
+        L{ThreadedWriter} provides L{IService}.
+        """
+        verifyClass(IService, ThreadedWriter)
+
+    def test_name(self):
+        """
+        L{ThreadedWriter} has a name.
+        """
+        self.assertEqual(ThreadedWriter.name, "Eliot Log Writer")
+
+    def test_startServiceRunning(self):
+        """
+        L{ThreadedWriter.startService} starts the service as required by the
+        L{IService} interface.
+        """
+        writer = ThreadedWriter(FileDestination(file=BytesIO()), reactor)
+        self.assertFalse(writer.running)
+        writer.startService()
+        self.addCleanup(writer.stopService)
+        self.assertTrue(writer.running)
+
+    def test_stopServiceRunning(self):
+        """
+        L{ThreadedWriter.stopService} stops the service as required by the
+        L{IService} interface.
+        """
+        writer = ThreadedWriter(FileDestination(file=BytesIO()), reactor)
+        writer.startService()
+        d = writer.stopService()
+        d.addCallback(lambda _: self.assertFalse(writer.running))
+        return d
+
+    def test_startServiceStartsThread(self):
+        """
+        L{ThreadedWriter.startService} starts up a thread running
+        L{ThreadedWriter._writer}.
+        """
+        previousThreads = threading.enumerate()
+        result = []
+        event = threading.Event()
+
+        def _reader():
+            current = threading.current_thread()
+            if current not in previousThreads:
+                result.append(current)
+            event.set()
+
+        writer = ThreadedWriter(FileDestination(file=BytesIO()), reactor)
+        writer._reader = _reader
+        writer.startService()
+        event.wait()
+        self.assertTrue(result)
+        # Make sure thread is dead so it doesn't die half way through another
+        # test:
+        result[0].join(5)
+
+    def test_stopServiceStopsThread(self):
+        """
+        L{ThreadedWriter.stopService} stops the writer thread.
+        """
+        previousThreads = set(threading.enumerate())
+        writer = ThreadedWriter(FileDestination(file=BytesIO()), reactor)
+        writer.startService()
+        start = time.time()
+        while set(threading.enumerate()) == previousThreads and (
+            time.time() - start < 5
+        ):
+            time.sleep(0.0001)
+        # If not true the next assertion might pass by mistake:
+        self.assertNotEqual(set(threading.enumerate()), previousThreads)
+        writer.stopService()
+        while set(threading.enumerate()) != previousThreads and (
+            time.time() - start < 5
+        ):
+            time.sleep(0.0001)
+        self.assertEqual(set(threading.enumerate()), previousThreads)
+
+    def test_stopServiceFinishesWriting(self):
+        """
+        L{ThreadedWriter.stopService} stops the writer thread, but only after
+        all queued writes are written out.
+        """
+        f = BlockingFile()
+        writer = ThreadedWriter(FileDestination(file=f), reactor)
+        f.block()
+        writer.startService()
+        for i in range(100):
+            writer({"write": 123})
+        threads = threading.enumerate()
+        writer.stopService()
+        # Make sure writes didn't happen before the stopService, thus making the
+        # test pointless:
+        self.assertEqual(f.getvalue(), b"")
+        f.unblock()
+        start = time.time()
+        while threading.enumerate() == threads and time.time() - start < 5:
+            time.sleep(0.0001)
+        self.assertEqual(f.getvalue(), b'{"write":123}\n' * 100)
+
+    def test_stopServiceResult(self):
+        """
+        L{ThreadedWriter.stopService} returns a L{Deferred} that fires only
+        after the thread has shut down.
+        """
+        f = BlockingFile()
+        writer = ThreadedWriter(FileDestination(file=f), reactor)
+        f.block()
+        writer.startService()
+
+        writer({"hello": 123})
+        threads = threading.enumerate()
+        d = writer.stopService()
+        f.unblock()
+
+        def done(_):
+            self.assertEqual(f.getvalue(), b'{"hello":123}\n')
+            self.assertNotEqual(threading.enumerate(), threads)
+
+        d.addCallback(done)
+        return d
+
+    def test_noChangeToIOThread(self):
+        """
+        Running a L{ThreadedWriter} doesn't modify the Twisted registered IO
+        thread.
+        """
+        writer = ThreadedWriter(FileDestination(file=BytesIO()), reactor)
+        writer.startService()
+        d = writer.stopService()
+        # Either the current thread (the one running the tests) is the the I/O
+        # thread or the I/O thread was never set. Either may happen depending on
+        # how and whether the reactor has been started by the unittesting
+        # framework.
+        d.addCallback(
+            lambda _: self.assertIn(
+                threadable.ioThread, (None, threading.current_thread().ident)
+            )
+        )
+        return d
+
+    def test_startServiceRegistersDestination(self):
+        """
+        L{ThreadedWriter.startService} registers itself as an Eliot log
+        destination.
+        """
+        f = BlockingFile()
+        writer = ThreadedWriter(FileDestination(file=f), reactor)
+        writer.startService()
+        Logger().write({"x": "abc"})
+        d = writer.stopService()
+        d.addCallback(lambda _: self.assertIn(b"abc", f.getvalue()))
+        return d
+
+    def test_stopServiceUnregistersDestination(self):
+        """
+        L{ThreadedWriter.stopService} unregisters itself as an Eliot log
+        destination.
+        """
+        writer = ThreadedWriter(FileDestination(file=BytesIO()), reactor)
+        writer.startService()
+        d = writer.stopService()
+        d.addCallback(lambda _: removeDestination(writer))
+        return self.assertFailure(d, ValueError)
+
+    def test_call(self):
+        """
+        The message passed to L{ThreadedWriter.__call__} is passed to the
+        underlying destination in the writer thread.
+        """
+        result = []
+
+        def destination(message):
+            result.append((message, threading.current_thread().ident))
+
+        writer = ThreadedWriter(destination, reactor)
+        writer.startService()
+        thread_ident = writer._thread.ident
+        msg = {"key": 123}
+        writer(msg)
+        d = writer.stopService()
+        d.addCallback(lambda _: self.assertEqual(result, [(msg, thread_ident)]))
+        return d