%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /usr/lib/python3/dist-packages/twisted/logger/test/__pycache__/
Upload File :
Create Path :
Current File : //usr/lib/python3/dist-packages/twisted/logger/test/__pycache__/test_json.cpython-312.pyc

�

Ϫ�fbG��>�dZddlmZmZddlmZmZmZmZm	Z	m
Z
ddlmZddl
mZddlmZddlmZddlmZd	d
lmZd	dlmZd	dlmZd	d
lmZmZd	dlmZm Z m!Z!m"Z"m#Z$d	dl%m&Z&d	dl'm(Z(d	dl)m*Z*dede+de+fd�Z,Gd�de�Z-Gd�de�Z.Gd�de�Z/y)z$
Tests for L{twisted.logger._json}.
�)�BytesIO�StringIO)�IO�Any�List�Optional�Sequence�cast)�implementer)�BrokenMethodImplementation)�verifyObject)�Failure)�TestCase�)�extractField)�formatEvent)�globalLogPublisher)�ILogObserver�LogEvent)�eventAsJSON�
eventFromJSON�eventsFromJSONLogFile�jsonFileLogObserver�log)�LogLevel)�Logger)�LogPublisher�testCase�	savedJSON�returnc�t�|j|t�|j|jd�d�|S)a*
    Assert a few things about the result of L{eventAsJSON}, then return it.

    @param testCase: The L{TestCase} with which to perform the assertions.
    @param savedJSON: The result of L{eventAsJSON}.

    @return: C{savedJSON}

    @raise AssertionError: If any of the preconditions fail.
    �
r)�assertIsInstance�str�assertEqual�count)rrs  �?/usr/lib/python3/dist-packages/twisted/logger/test/test_json.py�savedJSONInvariantsr(!s3��
���i��-��������.��2���c�p�eZdZdZdedefd�Zdd�Zdd�Zdd�Z	dd	�Z
dd
�Zdd�Zdd�Z
dd
�Zdd�Zdd�Zy)�
SaveLoadTestsz2
    Tests for loading and saving log events.
    �eventr c�,�t|t|��S)z�
        Serialize some an events, assert some things about it, and return the
        JSON.

        @param event: An event.

        @return: JSON.
        )r(r)�selfr,s  r'�savedEventJSONzSaveLoadTests.savedEventJSON6s��#�4��U�);�<�<r)Nc�X�|jt|ji��i�y)zX
        Saving and loading an empty dictionary results in an empty dictionary.
        N�r%rr/�r.s r'�test_simpleSaveLoadz!SaveLoadTests.test_simpleSaveLoadAs$��	
����t�':�':�2�'>�?��Dr)c	�d�|jt|jddd���ddd��y)a
        Saving and loading a dictionary with some simple values in it results
        in those same simple values in the output; according to JSON's rules,
        though, all dictionary keys must be L{str} and any non-L{str}
        keys will be converted.
        r�4)��3��1r7Nr1r2s r'�
test_saveLoadzSaveLoadTests.test_saveLoadGs2��	
����$�-�-�!�#�.>�?�@��#��	
r)c	�x�|jt|jdt�d���dddid��y)zx
        Saving and loading an object which cannot be represented in JSON will
        result in a placeholder.
        rr8�
unpersistableTN�r%rr/�objectr2s r'�test_saveUnPersistablez$SaveLoadTests.test_saveUnPersistableSs9��
	
����$�-�-�A�F�H�.E�F�G��?�D�1�2�	
r)c	�x�|jt|jdt�d���dddid��y)zD
        Non-ASCII keys and values can be saved and loaded.
        u䌡)uሴr7r<TNr=r2s r'�test_saveNonASCIIzSaveLoadTests.test_saveNonASCII]s9��	
����$�-�-����.Q�R�S����&=�>�	
r)c	���dttd��i}|jddi�|jt	|j|��dttd��j
d�i�y)zx
        Any L{bytes} objects will be saved as if they are latin-1 so they can
        be faithfully re-loaded.
        �hello�sskipped�okay�charmapN)�bytes�range�updater%rr/�decode)r.�
inputEvents  r'�test_saveByteszSaveLoadTests.test_saveBytesfsi��
�u�U�3�Z�0�1�
�	���:�v�.�/�����$�-�-�j�9�:�
�e�E�#�J�'�.�.�y�9�:�	
r)c��Gd�d�}d|d�d�}t|j|��}|jt|�d�y)a

        Saving and loading an object which cannot be represented in JSON, but
        has a string representation which I{can} be saved as JSON, will result
        in the same string formatting; any extractable fields will retain their
        data types.
        c�(�eZdZdeddfd�Zdefd�Zy)�@SaveLoadTests.test_saveUnPersistableThenFormat.<locals>.Reprable�valuer Nc��||_y�N�rP)r.rPs  r'�__init__zISaveLoadTests.test_saveUnPersistableThenFormat.<locals>.Reprable.__init__~s	��"��
r)c��y)N�reprable�r2s r'�__repr__zISaveLoadTests.test_saveUnPersistableThenFormat.<locals>.Reprable.__repr__�s��!r))�__name__�
__module__�__qualname__r>rTr$rXrWr)r'�ReprablerO}s!��
#�f�
#��
#�
"�#�
"r)r\z{object} {object.value}���
log_formatr>z
reprable 7N)rr/r%r)r.r\rK�outputEvents    r'� test_saveUnPersistableThenFormatz.SaveLoadTests.test_saveUnPersistableThenFormatusG��	"�	"�%>��RS��U�
�#�D�$7�$7�
�$C�D������[�1�<�@r)c��Gd�d�}td|���}t|j|��}|jt	d|�d�|jttd|�|jttd|�y)	zs
        L{extractField} can extract fields from an object that's been saved and
        loaded from JSON.
        c��eZdZdd�Zy)�8SaveLoadTests.test_extractingFieldsPostLoad.<locals>.ObjNc��d|_y)N�YrSr2s r'rTzASaveLoadTests.test_extractingFieldsPostLoad.<locals>.Obj.__init__�s	�� ��
r)�r N)rYrZr[rTrWr)r'�Objrd�s��
!r)rhz{object.value}r^zobject.valuerfr>N)�dictrr/r%r�assertRaises�KeyError)r.rhrK�loadedEvents    r'�test_extractingFieldsPostLoadz+SaveLoadTests.test_extractingFieldsPostLoad�ss��	!�	!��%5�c�e�D�
�#�D�$7�$7�
�$C�D������n�k�B�C�H�
	
���(�L�(�K�H����(�L�(�J�Gr)c���g}ttt|j���}	ddz|jt|�d�t|j|d��d}|j|t
�|j|jt��|j|j�t�y#t$rt�}|j
d|�Y��wxYw)zl
        Round-tripping a failure through L{eventAsJSON} preserves its class and
        structure.
        ��observerr6rza message about failure�log_failureN)rr
r�append�ZeroDivisionErrorr�failurer%�lenrr/r#�
assertTrue�check�getTracebackr$)r.�eventsr�f�loadeds     r'�test_failureStructurePreservedz,SaveLoadTests.test_failureStructurePreserved�s���
"$���d�<����?�@��	6�
��E�	
����V��a�(��t�2�2�6�!�9�=�>�}�M�����f�g�.�������%6�7�8����f�1�1�3�S�9��!�	6��	�A��K�K�1�1�5�	6�s�C�%C/�.C/c��ttj��}t|j	|��}|j|dtj�y)zo
        It's important that the C{log_level} key remain a
        L{constantly.NamedConstant} object.
        ��	log_levelrN)rir�warnrr/�assertIs)r.rKrls   r'�test_saveLoadLevelz SaveLoadTests.test_saveLoadLevel�s>��
�H�M�M�2�
�#�D�$7�$7�
�$C�D���
�
�k�+�.��
�
�>r)c�R�td�}|j|td���y)z�
        If a saved bit of JSON (let's say, from a future version of Twisted)
        were to persist a different log_level, it will resolve as None.
        zZ{"log_level": {"name": "other", "__class_uuid__": "02E59486-F24D-46AD-8224-3ACDF2A5732A"}}Nr~)rr%ri)r.rls  r'�test_saveLoadUnknownLevelz'SaveLoadTests.test_saveLoadUnknownLevel�s+��
$�
I�
��	
����d�T�&:�;r)rg)rYrZr[�__doc__rr$r/r3r:r?rArLrarmr|r�r�rWr)r'r+r+1sO���	=�H�	=��	=�E�

�
�
�

�A�&H�(:�$?�	<r)r+c�B�eZdZdZd
d�Zddeddfd�Zd
d�Zd
d�Zd
d	�Z	y)�FileLogObserverTestsz+
    Tests for L{jsonFileLogObserver}.
    r Nc���t�5}t|�}	tt|�ddd�y#t$r}|j|�Yd}~�(d}~wwxYw#1swYyxYw)zh
        A L{FileLogObserver} returned by L{jsonFileLogObserver} is an
        L{ILogObserver}.
        N)rrr
rr�fail)r.�
fileHandlerp�es    r'�test_interfacez#FileLogObserverTests.test_interface�s]��
�Z�	�:�*�:�6�H�
��\�8�4�	�	��.�
��	�	�!����
��		�	�s+�A�1�	A�A�A�A�A�A!�recordSeparatorc���t�5}t||�}td��}||�|j|j	�|�d��ddd�y#1swYyxYw)a!
        Asserts that an observer created by L{jsonFileLogObserver} with the
        given arguments writes events serialized as JSON text, using the given
        record separator.

        @param recordSeparator: C{recordSeparator} argument to
            L{jsonFileLogObserver}
        r6��xz	{"x": 1}
N)rrrir%�getvalue)r.r�r�rpr,s     r'�assertObserverWritesJSONz-FileLogObserverTests.assertObserverWritesJSON�sa���Z�	V�:�*�:��G�H��1�I�E��U�O����Z�0�0�2��6G�|�4T�U�		V�	V�	V�s�AA�A!c�$�|j�y)z�
        A L{FileLogObserver} created by L{jsonFileLogObserver} writes events
        serialzed as JSON text to a file when it observes events.
        By default, the record separator is C{"\x1e"}.
        N�r�r2s r'�(test_observeWritesDefaultRecordSeparatorz=FileLogObserverTests.test_observeWritesDefaultRecordSeparator�s��	
�%�%�'r)c�(�|jd��y)z�
        A L{FileLogObserver} created by L{jsonFileLogObserver} writes events
        serialzed as JSON text to a file when it observes events.
        This test sets the record separator to C{""}.
        ��r�Nr�r2s r'�&test_observeWritesEmptyRecordSeparatorz;FileLogObserverTests.test_observeWritesEmptyRecordSeparator�s��	
�%�%�b�%�9r)c���t�}t�}g}|jtt|j
��|jt
|��t|��}	ddzt|j��}tt|��}dttddf�fd�}||�||�y#t$r|jd�Y�owxYw)	z�
        A L{FileLogObserver} created by L{jsonFileLogObserver} writes failures
        serialized as JSON text to a file when it observes events.
        ror6rzfailed as expected�	logEventsr Nc�b���jt|�d�|\}�jd|�|d}�j|t�|j�}�j|jjjjd�tjd��y)Nr6rq�co)r%ru�assertInr#r�getTracebackObject�tb_frame�f_code�co_filename�rstrip�__file__)r��failureEvent�
failureObject�tracebackObjectr.s    �r'�checkEventsz@FileLogObserverTests.test_failureFormatting.<locals>.checkEventss�������S��^�Q�/�&�N�\��M�M�-��6�(��7�M��!�!�-��9�+�>�>�@�O�����(�(�/�/�;�;�B�B�4�H�����%�
r))rr�addObserverr
rrrrr�
BaseExceptionrtr��listrr	r)r.�io�	publisher�logged�logger�reader�deserializedr�s`       r'�test_failureFormattingz+FileLogObserverTests.test_failureFormatting�s����
�Z�� �N�	�!#�����d�<����?�@����1�"�5�6���+��	1�
��E��"�+�+�-�(���1�&�9�:��
	�8�H�#5�
	�$�
	�	�F���L�!��%�	1��N�N�/�0�	1�s�(C�C�Crg)�)
rYrZr[r�r�r$r�r�r�r�rWr)r'r�r��s1���
�
V��
V��
V�(�:�"r)r�c	��eZdZdZdd�Zdd�Z		ddeedee	de
ddfd	�Zdd
�Zdd�Z
dd�Zdd
�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zy)�LogFileReaderTestsz-
    Tests for L{eventsFromJSONLogFile}.
    r Nc���g�_tt�dtddf�fd��}|�_tj|�y)Nr,r c�t��|dtjk(r!d|vr�jj|�yyy)N�
log_namespace�record)�jsonLog�	namespace�errorEventsrr)r,r.s �r'rpz*LogFileReaderTests.setUp.<locals>.observers;����_�%��):�):�:�x�5�?P�� � �'�'��.�@Q�:r))r�rrr�logObserverrr�)r.rps` r'�setUpzLogFileReaderTests.setUpsH���+-���	�\�	"�	/�H�	/��	/�
#�	/�$����&�&�x�0r)c�B�tj|j�yrR)r�removeObserverr�r2s r'�tearDownzLogFileReaderTests.tearDown&s���)�)�$�*:�*:�;r)�inFiler��
bufferSizec���tt|||��}|jt|�ddi�|jt|�ddi�|j	t
t|�y)a|
        Test that L{eventsFromJSONLogFile} reads two pre-defined events from a
        file: C{{"x": 1}} and C{{"y": 2}}.

        @param inFile: C{inFile} argument to L{eventsFromJSONLogFile}
        @param recordSeparator: C{recordSeparator} argument to
            L{eventsFromJSONLogFile}
        @param bufferSize: C{bufferSize} argument to L{eventsFromJSONLogFile}
        r�r6�yrN)�iterrr%�nextrj�
StopIteration)r.r�r�r�rys     r'�_readEventszLogFileReaderTests._readEvents)sZ���+�F�O�Z�P�Q������f���Q�x�0�����f���Q�x�0����-��v�6r)c��td�5}|j|�|jt|j�d�ddd�y#1swYyxYw)z�
        L{eventsFromJSONLogFile} reads events from a file and automatically
        detects use of C{"\x1e"} as the record separator.
        �{"x": 1}
{"y": 2}
rN�rr�r%rur��r.r�s  r'�&test_readEventsAutoWithRecordSeparatorz9LogFileReaderTests.test_readEventsAutoWithRecordSeparator>sM��
�7�
8�	7�J����Z�(����S��!1�!1�2�A�6�	7�	7�	7���7A�Ac��td�5}|j|�|jt|j�d�ddd�y#1swYyxYw)z�
        L{eventsFromJSONLogFile} reads events from a file and automatically
        detects use of C{""} as the record separator.
        z{"x": 1}
{"y": 2}
rNr�r�s  r'�'test_readEventsAutoEmptyRecordSeparatorz:LogFileReaderTests.test_readEventsAutoEmptyRecordSeparatorGsM��
�/�
0�	7�J����Z�(����S��!1�!1�2�A�6�	7�	7�	7�r�c��td�5}|j|d��|jt|j�d�ddd�y#1swYyxYw)z{
        L{eventsFromJSONLogFile} reads events from a file and is told to use
        a specific record separator.
        z{"x": 1}
{"y": 2}
�r�rNr�r�s  r'�&test_readEventsExplicitRecordSeparatorz9LogFileReaderTests.test_readEventsExplicitRecordSeparatorPsR���7�
8�	7�J����Z���@����S��!1�!1�2�A�6�	7�	7�	7���9A�Ac��td�5}|j|d��|jt|j�d�ddd�y#1swYyxYw)zM
        L{eventsFromJSONLogFile} handles buffering a partial event.
        r�r6�r�rNr�r�s  r'�test_readEventsPartialBufferz/LogFileReaderTests.test_readEventsPartialBufferZsR���7�
8�	7�J����Z�A��6����S��!1�!1�2�A�6�	7�	7�	7�r�c��td�5}tt|��}|jt	|�ddi�|jtt|�|jt|j�d�|j|jddd�|j|jddd	�d
d
d
�y
#1swYy
xYw)zF
        If the JSON text for a record is truncated, skip it.
        z{"x": 1{"y": 2}
r�rr6rr_z0Unable to read truncated JSON record: {record!r}r�s{"x": 1N�	rr�rr%r�rjr�rur��r.r�rys   r'�test_readTruncatedz%LogFileReaderTests.test_readTruncatedcs����4�
5�	H���/�
�;�<�F����T�&�\�C��8�4����m�T�6�:�
���S��!1�!1�2�A�6����� � ��#�L�1�B�
�
���T�-�-�a�0��:�J�G�	H�	H�	H���B6C�Cc�&�td�5}tt|��}|jt	|�ddi�|jtt|�|jt|j�d�ddd�y#1swYyxYw)zc
        If the file being read from vends L{str}, strings decode from JSON
        as-is.
        u{"currency": "€"}
�currency�€rNr�r�s   r'�test_readUnicodez#LogFileReaderTests.test_readUnicodeusz���4�
5�	7���/�
�;�<�F����T�&�\�J��+A�B����m�T�6�:����S��!1�!1�2�A�6�	7�	7�	7���A2B�Bc�&�td�5}tt|��}|jt	|�ddi�|jtt|�|jt|j�d�ddd�y#1swYyxYw)zh
        If the file being read from vends L{bytes}, strings decode from JSON as
        UTF-8.
        s{"currency": "€"}
r�r�rN�	rr�rr%r�rjr�rur�r�s   r'�test_readUTF8Bytesz%LogFileReaderTests.test_readUTF8Bytes�s|���:�
;�	7�z��/�
�;�<�F�
���T�&�\�J��+A�B����m�T�6�:����S��!1�!1�2�A�6�
	7�	7�	7�r�c�*�td�5}tt|d���}|jt	|�ddi�|jtt|�|jt|j�d�ddd�y#1swYyxYw)z�
        If the JSON text for a record is truncated in the middle of a two-byte
        Unicode codepoint, we don't want to see a codec exception and the
        stream is read properly when the additional data arrives.
        s{"x": "€"}
�r�r�r�rNr�r�s   r'�test_readTruncatedUTF8Bytesz.LogFileReaderTests.test_readTruncatedUTF8Bytes�s{���3�
4�	7�
��/�
�q�I�J�F����T�&�\�C��?�;����m�T�6�:����S��!1�!1�2�A�6�	7�	7�	7�s�A4B	�	Bc��td�5}tt|��}|jt	|�ddi�|jtt|�|jt|j�d�|j|jddd�|j|jddd	�d
d
d
�y
#1swYy
xYw)zh
        If the JSON text for a record contains invalid UTF-8 text, ignore that
        record.
        s{"x": "�"}
{"y": 2}
r�rr6rr_z2Unable to decode UTF-8 for JSON record: {record!r}r�s{"x": "�"}
Nr�r�s   r'�test_readInvalidUTF8Bytesz,LogFileReaderTests.test_readInvalidUTF8Bytes�s����A�
B�	T�j��/�
�;�<�F����T�&�\�C��8�4����m�T�6�:�
���S��!1�!1�2�A�6����� � ��#�L�1�D�
�
���T�-�-�a�0��:�<R�S�	T�	T�	T�r�c��td�5}tt|��}|jt	|�ddi�|jtt|�|jt|j�d�|j|jddd�|j|jddd	�d
d
d
�y
#1swYy
xYw)zD
        If the JSON text for a record is invalid, skip it.
        z{"x": }
{"y": 2}
r�rr6rr_�&Unable to read JSON record: {record!r}r�s{"x": }
Nr�r�s   r'�test_readInvalidJSONz'LogFileReaderTests.test_readInvalidJSON�s����6�
7�	J�:��/�
�;�<�F����T�&�\�C��8�4����m�T�6�:�
���S��!1�!1�2�A�6����� � ��#�L�1�8�
�
���T�-�-�a�0��:�L�I�	J�	J�	J�r�c�b�td�5}t|�}|jtt|�|jt
|j�d�|j|jddd�|j|jddd�ddd�y#1swYyxYw)	zI
        Multiple events without a record separator are skipped.
        z{"x": 1}
{"y": 2}
r6rr_r�r�s{"x": 1}
{"y": 2}
N)rrrjr�r�r%rur�r�s   r'�test_readUnseparatedz'LogFileReaderTests.test_readUnseparated�s����3�
4�	U�
�*�:�6�F����m�T�6�:�
���S��!1�!1�2�A�6����� � ��#�L�1�8�
�
���T�-�-�a�0��:�<S�T�	U�	U�	U�s�BB%�%B.c�:�td��}t�5}t|�}||�|jd�t	|�}|jt
|�|f�|jt|j�d�ddd�y#1swYyxYw)z�
        Data written by a L{FileLogObserver} returned by L{jsonFileLogObserver}
        and read by L{eventsFromJSONLogFile} is reconstructed properly.
        r6r�rN)	rirr�seekrr%�tuplerur�)r.r,r�rprys     r'�test_roundTripz!LogFileReaderTests.test_roundTrip�s���
�q�	��
�Z�	7�:�*�:�6�H��U�O��O�O�A��*�:�6�F����U�6�]�U�H�5����S��!1�!1�2�A�6�	7�	7�	7�s�A1B�Brg)Ni)rYrZr[r�r�r�rrrr$�intr�r�r�r�r�r�r�r�r�r�r�r�r�rWr)r'r�r�s����
1�<�*.��	7��3��7�"�#��7��	7�

�7�*7�7�7�7�H�$7�7�
7�T�(J�$U�"7r)r�N)0r�r�rr�typingrrrrr	r
�zope.interfacer�zope.interface.exceptionsr�zope.interface.verifyr
�twisted.python.failurer�twisted.trial.unittestr�_flattenr�_formatr�_globalr�_interfacesrr�_jsonrrrrrr��_levelsr�_loggerr�	_observerrr$r(r+r�r�rWr)r'�<module>rs����!�:�:�&�@�.�*�+�#�!�(�0�����$�
�(�
�s�
�s�
� O<�H�O<�dO"�8�O"�dP7��P7r)

Zerion Mini Shell 1.0