logxpy 0.1.0__py3-none-any.whl

logxpy/tests/test_serializers.py

@@ -0,0 +1,36 @@
+"""
+Tests for L{eliot.serializers}.
+"""
+
+from unittest import TestCase
+from datetime import datetime
+from hashlib import md5
+
+from ..serializers import timestamp, identity, md5hex
+
+
+class SerializerTests(TestCase):
+    """
+    Tests for standard serializers.
+    """
+
+    def test_timestamp(self):
+        """
+        L{timestamp} converts a UTC L{datetime} to a Unicode strings.
+        """
+        dt = datetime(2012, 9, 28, 14, 53, 6, 123456)
+        self.assertEqual(timestamp(dt), "2012-09-28T14:53:06.123456Z")
+
+    def test_identity(self):
+        """
+        L{identity} returns the input object.
+        """
+        obj = object()
+        self.assertIs(identity(obj), obj)
+
+    def test_md5hex(self):
+        """
+        L{md5hex} returns the hex value of a MD5 checksum.
+        """
+        data = b"01234456789"
+        self.assertEqual(md5hex(data), md5(data).hexdigest())

logxpy/tests/test_stdlib.py

@@ -0,0 +1,73 @@
+"""Tests for standard library logging integration."""
+
+from unittest import TestCase
+import logging
+import traceback
+
+from ..testing import assertContainsFields, capture_logging
+from ..stdlib import EliotHandler
+from .test_traceback import assert_expected_traceback
+
+
+class StdlibTests(TestCase):
+    """Tests for stdlib integration."""
+
+    @capture_logging(None)
+    def test_handler(self, logger):
+        """The EliotHandler routes messages to Eliot."""
+        stdlib_logger = logging.getLogger("eliot-test")
+        stdlib_logger.setLevel(logging.DEBUG)
+        handler = EliotHandler()
+        stdlib_logger.addHandler(handler)
+        stdlib_logger.info("hello")
+        stdlib_logger.warning("ono")
+        message = logger.messages[0]
+        assertContainsFields(
+            self,
+            message,
+            {
+                "message_type": "eliot:stdlib",
+                "log_level": "INFO",
+                "message": "hello",
+                "logger": "eliot-test",
+            },
+        )
+        message = logger.messages[1]
+        assertContainsFields(
+            self,
+            message,
+            {
+                "message_type": "eliot:stdlib",
+                "log_level": "WARNING",
+                "message": "ono",
+                "logger": "eliot-test",
+            },
+        )
+
+    @capture_logging(None)
+    def test_traceback(self, logger):
+        """The EliotHandler routes tracebacks to Eliot."""
+        stdlib_logger = logging.getLogger("eliot-test2")
+        stdlib_logger.setLevel(logging.DEBUG)
+        handler = EliotHandler()
+        stdlib_logger.addHandler(handler)
+        try:
+            raise RuntimeError()
+        except Exception as e:
+            exception = e
+            expected_traceback = traceback.format_exc()
+            stdlib_logger.exception("ono")
+        message = logger.messages[0]
+        assertContainsFields(
+            self,
+            message,
+            {
+                "message_type": "eliot:stdlib",
+                "log_level": "ERROR",
+                "message": "ono",
+                "logger": "eliot-test2",
+            },
+        )
+        assert_expected_traceback(
+            self, logger, logger.messages[1], exception, expected_traceback
+        )

logxpy/tests/test_tai64n.py

@@ -0,0 +1,66 @@
+"""
+Tests for L{eliot.tai64n}.
+"""
+
+import errno
+import time
+import subprocess
+from unittest import TestCase, SkipTest
+
+from ..tai64n import encode, decode
+
+
+class CodecTests(TestCase):
+    """
+    Tests for L{encode} and L{decode}.
+    """
+
+    def test_encode(self):
+        """
+        L{encode} encodes timestamps in TAI64N format.
+        """
+        t = 1387299889.153187625
+        self.assertEqual(encode(t), "@4000000052b0843b092174b9")
+
+    def test_decode(self):
+        """
+        L{decode} decodes timestamps from TAI64N format.
+        """
+        t = time.time()
+        self.assertAlmostEqual(t, decode(encode(t)), 9)
+
+
+class FunctionalTests(TestCase):
+    """
+    Functional tests for L{encode}.
+    """
+
+    def test_encode(self):
+        """
+        The daemontools tai64nlocal tool can correctly decode timestamps output
+        by L{encode}.
+        """
+        try:
+            process = subprocess.Popen(
+                ["tai64nlocal"],
+                bufsize=4096,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+            )
+        except OSError as e:
+            if e.errno == errno.ENOENT:
+                raise SkipTest("This test requires the daemontools package")
+            else:
+                raise
+        # Because of limitations of the time libraries tai64nlocal uses we
+        # apparently can't verify beyond this level of accuracy.
+        timestamp = int(time.time()) + 0.12345
+        process.stdin.write((encode(timestamp) + "\n").encode("ascii"))
+        process.stdin.close()
+        decodedToLocalTime = process.stdout.read().strip()
+        self.assertEqual(
+            time.strftime("%Y-%m-%d %H:%M:%S.12345", time.localtime(timestamp)).encode(
+                "ascii"
+            ),
+            decodedToLocalTime[:25],
+        )