1#@!#!123s

: / lib / python3 / dist-packages / twisted / logger / test /
Filename : test_flatten.py
back
# -*- coding: utf-8 -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
Test cases for L{twisted.logger._format}.
"""

from itertools import count
import json

try:
    from time import tzset
    # We should upgrade to a version of pyflakes that does not require this.
    tzset
except ImportError:
    tzset = None

from twisted.trial import unittest

from .._format import formatEvent
from .._flatten import (
    flattenEvent, extractField, KeyFlattener, aFormatter
)



class FlatFormattingTests(unittest.TestCase):
    """
    Tests for flattened event formatting functions.
    """

    def test_formatFlatEvent(self):
        """
        L{flattenEvent} will "flatten" an event so that, if scrubbed of all but
        serializable objects, it will preserve all necessary data to be
        formatted once serialized.  When presented with an event thusly
        flattened, L{formatEvent} will produce the same output.
        """
        counter = count()

        class Ephemeral(object):
            attribute = "value"

        event1 = dict(
            log_format=(
                "callable: {callme()} "
                "attribute: {object.attribute} "
                "numrepr: {number!r} "
                "numstr: {number!s} "
                "strrepr: {string!r} "
                "unistr: {unistr!s}"
            ),
            callme=lambda: next(counter), object=Ephemeral(),
            number=7, string="hello", unistr=u"ö"
        )

        flattenEvent(event1)

        event2 = dict(event1)
        del event2["callme"]
        del event2["object"]
        event3 = json.loads(json.dumps(event2))
        self.assertEqual(
            formatEvent(event3),
            (
                u"callable: 0 "
                "attribute: value "
                "numrepr: 7 "
                "numstr: 7 "
                "strrepr: 'hello' "
                u"unistr: ö"
            )
        )


    def test_formatFlatEventBadFormat(self):
        """
        If the format string is invalid, an error is produced.
        """
        event1 = dict(
            log_format=(
                "strrepr: {string!X}"
            ),
            string="hello",
        )

        flattenEvent(event1)
        event2 = json.loads(json.dumps(event1))

        self.assertTrue(
            formatEvent(event2).startswith(u"Unable to format event")
        )


    def test_formatFlatEventWithMutatedFields(self):
        """
        L{formatEvent} will prefer the stored C{str()} or C{repr()} value for
        an object, in case the other version.
        """
        class Unpersistable(object):
            """
            Unpersitable object.
            """
            destructed = False

            def selfDestruct(self):
                """
                Self destruct.
                """
                self.destructed = True

            def __repr__(self):
                if self.destructed:
                    return "post-serialization garbage"
                else:
                    return "un-persistable"

        up = Unpersistable()
        event1 = dict(
            log_format="unpersistable: {unpersistable}", unpersistable=up
        )

        flattenEvent(event1)
        up.selfDestruct()

        self.assertEqual(formatEvent(event1), "unpersistable: un-persistable")


    def test_keyFlattening(self):
        """
        Test that L{KeyFlattener.flatKey} returns the expected keys for format
        fields.
        """

        def keyFromFormat(format):
            for (
                literalText,
                fieldName,
                formatSpec,
                conversion,
            ) in aFormatter.parse(format):
                return KeyFlattener().flatKey(
                    fieldName, formatSpec, conversion
                )

        # No name
        try:
            self.assertEqual(keyFromFormat("{}"), "!:")
        except ValueError:
            # In python 2.6, an empty field name causes Formatter.parse to
            # raise ValueError.
            # In Python 2.7, it's allowed, so this exception is unexpected.
            raise

        # Just a name
        self.assertEqual(keyFromFormat("{foo}"), "foo!:")

        # Add conversion
        self.assertEqual(keyFromFormat("{foo!s}"), "foo!s:")
        self.assertEqual(keyFromFormat("{foo!r}"), "foo!r:")

        # Add format spec
        self.assertEqual(keyFromFormat("{foo:%s}"), "foo!:%s")
        self.assertEqual(keyFromFormat("{foo:!}"), "foo!:!")
        self.assertEqual(keyFromFormat("{foo::}"), "foo!::")

        # Both
        self.assertEqual(keyFromFormat("{foo!s:%s}"), "foo!s:%s")
        self.assertEqual(keyFromFormat("{foo!s:!}"), "foo!s:!")
        self.assertEqual(keyFromFormat("{foo!s::}"), "foo!s::")
        [keyPlusLiteral] = aFormatter.parse("{x}")
        key = keyPlusLiteral[1:]
        sameFlattener = KeyFlattener()
        self.assertEqual(sameFlattener.flatKey(*key), "x!:")
        self.assertEqual(sameFlattener.flatKey(*key), "x!:/2")


    def _test_formatFlatEvent_fieldNamesSame(self, event=None):
        """
        The same format field used twice in one event is rendered twice.

        @param event: An event to flatten.  If L{None}, create a new event.
        @return: C{event} or the event created.
        """
        if event is None:
            counter = count()

            class CountStr(object):
                """
                Hack
                """
                def __str__(self):
                    return str(next(counter))

            event = dict(
                log_format="{x} {x}",
                x=CountStr(),
            )

        flattenEvent(event)
        self.assertEqual(formatEvent(event), u"0 1")

        return event


    def test_formatFlatEventFieldNamesSame(self):
        """
        The same format field used twice in one event is rendered twice.
        """
        self._test_formatFlatEvent_fieldNamesSame()


    def test_formatFlatEventFieldNamesSameAgain(self):
        """
        The same event flattened twice gives the same (already rendered)
        result.
        """
        event = self._test_formatFlatEvent_fieldNamesSame()
        self._test_formatFlatEvent_fieldNamesSame(event)


    def test_formatEventFlatTrailingText(self):
        """
        L{formatEvent} will handle a flattened event with tailing text after
        a replacement field.
        """
        event = dict(
            log_format="test {x} trailing",
            x='value',
        )
        flattenEvent(event)

        result = formatEvent(event)

        self.assertEqual(result, u"test value trailing")


    def test_extractField(self, flattenFirst=lambda x: x):
        """
        L{extractField} will extract a field used in the format string.

        @param flattenFirst: callable to flatten an event
        """
        class ObjectWithRepr(object):
            def __repr__(self):
                return "repr"

        class Something(object):
            def __init__(self):
                self.number = 7
                self.object = ObjectWithRepr()

            def __getstate__(self):
                raise NotImplementedError("Just in case.")

        event = dict(
            log_format="{something.number} {something.object}",
            something=Something(),
        )

        flattened = flattenFirst(event)

        def extract(field):
            return extractField(field, flattened)

        self.assertEqual(extract("something.number"), 7)
        self.assertEqual(extract("something.number!s"), "7")
        self.assertEqual(extract("something.object!s"), "repr")


    def test_extractFieldFlattenFirst(self):
        """
        L{extractField} behaves identically if the event is explicitly
        flattened first.
        """
        def flattened(evt):
            flattenEvent(evt)
            return evt
        self.test_extractField(flattened)


    def test_flattenEventWithoutFormat(self):
        """
        L{flattenEvent} will do nothing to an event with no format string.
        """
        inputEvent = {'a': 'b', 'c': 1}
        flattenEvent(inputEvent)
        self.assertEqual(inputEvent, {'a': 'b', 'c': 1})


    def test_flattenEventWithInertFormat(self):
        """
        L{flattenEvent} will do nothing to an event with a format string that
        contains no format fields.
        """
        inputEvent = {'a': 'b', 'c': 1, 'log_format': 'simple message'}
        flattenEvent(inputEvent)
        self.assertEqual(
            inputEvent,
            {
                'a': 'b',
                'c': 1,
                'log_format': 'simple message',
            }
        )


    def test_flattenEventWithNoneFormat(self):
        """
        L{flattenEvent} will do nothing to an event with log_format set to
        None.
        """
        inputEvent = {'a': 'b', 'c': 1, 'log_format': None}
        flattenEvent(inputEvent)
        self.assertEqual(
            inputEvent,
            {
                'a': 'b',
                'c': 1,
                'log_format': None,
            }
        )