
    tf	9                         d Z ddlZddlmZ ddlmZmZ ddlmZ ddl	m
Z
 ddlmZ ddlmZmZ dd	lmZ dd
lmZ ddlmZ ddlmZmZ ddlmZmZ ddlmZ  G d dej                  Z  G d dej                  Z!dS )z+
Test cases for L{twisted.logger._legacy}.
    N)time)Listcast)implementer)BrokenMethodImplementation)verifyObject)contextlog)Failure)unittest   )formatEvent)ILogObserverLogEvent)LegacyLogObserverWrapperpublishToNewObserver)LogLevelc                       e Zd ZdZddZddZdedefdZdedefdZdd	Z	dd
Z
ddZddZddZddZddZddZddZddZddZddZddZddZdedefdZddZddZddZddZdS )LegacyLogObserverWrapperTestsz0
    Tests for L{LegacyLogObserverWrapper}.
    returnNc                     t          t          j        d           }t          |          }	 t	          t          |           dS # t
          $ r }|                     |           Y d}~dS d}~ww xY w)zD
        L{LegacyLogObserverWrapper} is an L{ILogObserver}.
        c                     d S N )es    ^/var/www/surfInsights/venv3-11/lib/python3.11/site-packages/twisted/logger/test/test_legacy.py<lambda>z>LegacyLogObserverWrapperTests.test_interface.<locals>.<lambda>"   s         N)r   	legacyLogr   r   r   r   fail)selflegacyObserverobserverr   s       r   test_interfacez,LegacyLogObserverWrapperTests.test_interface   sz     i4nnEE+N;;	x00000) 	 	 	IIaLLLLLLLLL	s   A 
A-A((A-c                     t          t          j                   G d d                      }t           |                      }|                     t          |          d           dS )zJ
        L{LegacyLogObserverWrapper} returns the expected string.
        c                   4    e Zd ZdefdZdej        ddfdZdS )?LegacyLogObserverWrapperTests.test_repr.<locals>.LegacyObserverr   c                     dS )Nz<Legacy Observer>r   r!   s    r   __repr__zHLegacyLogObserverWrapperTests.test_repr.<locals>.LegacyObserver.__repr__0   s    **r   	eventDictNc                     d S r   r   )r!   r+   s     r   __call__zHLegacyLogObserverWrapperTests.test_repr.<locals>.LegacyObserver.__call__3   s    r   )__name__
__module____qualname__strr*   r   	EventDictr-   r   r   r   LegacyObserverr'   .   sT        +# + + + +)*= $      r   r3   z+LegacyLogObserverWrapper(<Legacy Observer>)N)r   r   r   r   assertEqualrepr)r!   r3   r#   s      r   	test_reprz'LegacyLogObserverWrapperTests.test_repr)   s|    
 
Y+	,	,	 	 	 	 	 	 	 
-	,	 ,NN,<,<==h)VWWWWWr   eventc                     g t          t          j        fd          }t          |          } ||           |                     t                    d           d         S )z
        Send an event to a wrapped legacy observer and capture the event as
        seen by that observer.

        @param event: an event

        @return: the event as observed by the legacy wrapper
        c                 .                         |           S r   )append)r   eventss    r   r   z7LegacyLogObserverWrapperTests.observe.<locals>.<lambda>E   s    a@P@P r      r   )r   r   r   r   r4   len)r!   r7   r"   r#   r;   s       @r   observez%LegacyLogObserverWrapperTests.observe:   sf     "$i46P6P6P6PQQ+N;;Va(((ayr   c                 Z   |                     dt                                 |                     dd           |                     dt          j                   |                     t          |                    }|                                D ]\  }}|                     ||           |S )z
        Send an event to a wrapped legacy observer and verify that its data is
        preserved.

        @param event: an event

        @return: the event as observed by the legacy wrapper
        log_time
log_system-	log_level)
setdefaultr   r   infor>   dictitemsassertIn)r!   r7   observedkeyvalues        r   forwardAndVerifyz.LegacyLogObserverWrapperTests.forwardAndVerifyL   s     	TVV,,,s+++hm444 <<U,,  ++-- 	) 	)JCMM#x((((r   c                 N    |                      t          dd                     dS )ze
        Basic forwarding: event keys as observed by a legacy observer are the
        same.
        r<   r   foobarN)rL   rF   r)   s    r   test_forwardz*LegacyLogObserverWrapperTests.test_forwardc   s+    
 	dqa00011111r   c                     t                      }|                     t          |                    }|                     |d         |           dS )zc
        The new-style C{"log_time"} key is copied to the old-style C{"time"}
        key.
        )r@   r   Nr   rL   rF   r4   r!   stampr7   s      r   	test_timez'LegacyLogObserverWrapperTests.test_timej   sK    
 %%dE&:&:&:;;v.....r   c                     t                      }|                     t          |dz   |                    }|                     |d         |           dS )zr
        The new-style C{"log_time"} key does not step on a pre-existing
        old-style C{"time"} key.
        r<   )r@   r   r   NrS   rT   s      r   test_timeAlreadySetz1LegacyLogObserverWrapperTests.test_timeAlreadySets   sQ    
 %%dEAIE&J&J&JKKv.....r   c                     |                      t          d                    }|                     |d         d           dS )zg
        The new-style C{"log_system"} key is copied to the old-style
        C{"system"} key.
        rO   )rA   systemNrL   rF   r4   r!   r7   s     r   test_systemz)LegacyLogObserverWrapperTests.test_system|   sB    
 %%de&<&<&<==x%00000r   c                     |                      t          dd                    }|                     |d         d           dS )zv
        The new-style C{"log_system"} key does not step on a pre-existing
        old-style C{"system"} key.
        rO   rP   )rA   rZ   rZ   Nr[   r\   s     r   test_systemAlreadySetz3LegacyLogObserverWrapperTests.test_systemAlreadySet   sD    
 %%deE&J&J&JKKx%00000r   c                     t          t                      t          j                  }|                     t          |                    }|                     |d         d           dS )zy
        If the new-style C{"log_system"} key is absent, the old-style
        C{"system"} key is set to C{"-"}.
        )r@   rC   rZ   rB   N)rF   r   r   rE   r>   r4   )r!   r7   rI   s      r   test_noSystemz+LegacyLogObserverWrapperTests.test_noSystem   sT     dff>>><<U,,(+S11111r   c                 v   |                      t          t          j        d                     |                      t          t          j        d                     |                      t          t          j        d                     |                      t          t          j        d                     dS )z
        If explicitly set, the C{isError} key will be preserved when forwarding
        from a new-style logging emitter to a legacy logging observer,
        regardless of log level.
        r<   )rC   isErrorr   N)rL   rF   r   rE   warnerrorcriticalr)   s    r   test_levelNotChangez1LegacyLogObserverWrapperTests.test_levelNotChange   s     	dX]AFFFGGGdX]AFFFGGGdX^QGGGHHHdX->JJJKKKKKr   c                     |                      t          t          j                            }|                     d|           dS )a)  
        The new-style C{"log_level"} key is not translated to the old-style
        C{"logLevel"} key.

        Events are forwarded from the old module from to new module and are
        then seen by old-style observers.
        We don't want to add unexpected keys to old-style events.
        )rC   logLevelN)rL   rF   r   rE   assertNotInr\   s     r   test_pythonLogLevelNotSetz7LegacyLogObserverWrapperTests.test_pythonLogLevelNotSet   s@     %%dX]&C&C&CDDU+++++r   c                     |                      t          d                    }|                     |d         d           dS )a  
        If a stdlib log level was provided as a string (eg. C{"WARNING"}) in
        the legacy "logLevel" key, it does not get converted to a number.
        The documentation suggested that numerical values should be used but
        this was not a requirement.
        WARNINGri   ri   Nr[   r\   s     r   test_stringPythonLogLevelz7LegacyLogObserverWrapperTests.test_stringPythonLogLevel   sQ     %%"  
 

 	z*I66666r   c                     |                      t                                }|                     |d         d           dS )z
        The old-style C{"message"} key is added, even if no new-style
        C{"log_format"} is given, as it is required, but may be empty.
        messager   Nr[   r\   s     r   test_messagez*LegacyLogObserverWrapperTests.test_message   s<    
 %%dff--y)2.....r   c                     |                      t          d                    }|                     |d         d           dS )zV
        The old-style C{"message"} key is not modified if it already exists.
        rN   )rq   rq   Nr[   r\   s     r   test_messageAlreadySetz4LegacyLogObserverWrapperTests.test_messageAlreadySet   sC     %%d>&B&B&BCCy)>:::::r   c                     |                      t          dd                    }|                     t          j        |          d           dS )z
        Formatting is translated such that text is rendered correctly, even
        though old-style logging doesn't use PEP 3101 formatting.
        zHello, {who}!world)
log_formatwhoHello, world!NrL   rF   r4   r   textFromEventDictr\   s     r   test_formatz)LegacyLogObserverWrapperTests.test_format   sK    
 %%do7&S&S&STT4U;;_MMMMMr   c                     |                      t          dd                    }|                     t          j        |          d           dS )zo
        Using the message key, which is special in old-style, works for
        new-style formatting.
        zHello, {message}!rv   )rw   rq   ry   Nrz   r\   s     r   test_formatMessagez0LegacyLogObserverWrapperTests.test_formatMessage   sS    
 %%/AAA
 
 	4U;;_MMMMMr   c                     |                      t          dd                    }|                     t          j        |          d           dS )zd
        Formatting is not altered if the old-style C{"format"} key already
        exists.
        zHello!zHowdy!)rw   formatNrz   r\   s     r   test_formatAlreadySetz3LegacyLogObserverWrapperTests.test_formatAlreadySet   sK    
 %%dhx&P&P&PQQ4U;;XFFFFFr   valuesc                 ~    t          t          d                    }|                     t          d|dd|          S )z
        Create a new-style event with a captured failure.

        @param values: Additional values to include in the event.

        @return: the new event
        znyargh!	oopsie...)log_failurerw   r   )r   RuntimeErrorrL   rF   )r!   r   failures      r   eventWithFailurez.LegacyLogObserverWrapperTests.eventWithFailure   sI     ,y1122$$GWGGGG
 
 	
r   c                     |                                  }|                     |d         |d                    |                     |d                    |                     |d         d           dS )z}
        Captured failures in the new style set the old-style C{"failure"},
        C{"isError"}, and C{"why"} keys.
        r   r   rc   whyr   N)r   assertIs
assertTruer4   r\   s     r   test_failurez*LegacyLogObserverWrapperTests.test_failure   sj    
 %%''eI&m(<===i()))u{33333r   c                     t          t          d                    }|                     |          }|                     |d         |           dS )v
        Captured failures in the new style do not step on a pre-existing
        old-style C{"failure"} key.
        zWeak salsa!)r   r   N)r   r   r   r   )r!   r   r7   s      r   test_failureAlreadySetz4LegacyLogObserverWrapperTests.test_failureAlreadySet   sN    
 ,}5566%%g%66eI&00000r   c                 j    |                      d          }|                     |d         d           dS )zv
        Captured failures in the new style do not step on a pre-existing
        old-style C{"isError"} key.
        r   rc   rc   Nr   r4   r\   s     r   test_isErrorAlreadySetz4LegacyLogObserverWrapperTests.test_isErrorAlreadySet  s;    
 %%a%00y)1-----r   c                 j    |                      d          }|                     |d         d           dS )r   blah)r   r   Nr   r\   s     r   test_whyAlreadySetz0LegacyLogObserverWrapperTests.test_whyAlreadySet  s:    
 %%&%11uv.....r   r   N)r.   r/   r0   __doc__r$   r6   r   r>   rL   rQ   rV   rX   r]   r_   ra   rg   rk   ro   rr   rt   r|   r~   r   objectr   r   r   r   r   r   r   r   r   r      s(        	 	 	 	X X X X"X (    $h 8    .2 2 2 2/ / / // / / /1 1 1 11 1 1 12 2 2 2	L 	L 	L 	L
, 
, 
, 
,7 7 7 7/ / / /; ; ; ;N N N NN N N NG G G G
 
H 
 
 
 
4 4 4 41 1 1 1. . . ./ / / / / /r   r   c                       e Zd ZdZddZdededej        fdZ	ddZ
dd	Zdd
ZddZddZddZddZddZddZddZdS )PublishToNewObserverTestsz,
    Tests for L{publishToNewObserver}.
    r   Nc                 \    g | _         t          t          | j         j                  | _        d S r   )r;   r   r   r:   r#   r)   s    r   setUpzPublishToNewObserverTests.setUp  s#    &(\4;+=>>r   rq   r   c                     t          j        t          j                  pi                                 }|                    |           ||d<   t                      |d<   d|vrd|d<   |S )a  
        Return a basic old-style event as would be created by L{legacyLog.msg}.

        @param message: a message event value in the legacy event format
        @param values: additional event values in the legacy event format

        @return: a legacy event
        rq   r   rc   r   )r	   getr   ILogContextcopyupdater   )r!   rq   r   r7   s       r   legacyEventz%PublishToNewObserverTests.legacyEvent  sj     Y2339r??AAV"ifE!! E)r   c                     t          | j        |                                 t          j                   |                     t          | j                  d           dS )z6
        The observer is called exactly once.
        r<   N)r   r#   r   r   r{   r4   r=   r;   r)   s    r   test_observedz'PublishToNewObserverTests.test_observed/  sV     	M4++--y/J	
 	
 	
 	T[))1-----r   c                     t          | j        |                                 t          j                   |                     | j        d         d         | j        d         d                    dS )zc
        The old-style C{"time"} key is copied to the new-style C{"log_time"}
        key.
        r   r@   r   Nr   r#   r   r   r{   r4   r;   r)   s    r   rV   z#PublishToNewObserverTests.test_time8  sb    
 	M4++--y/J	
 	
 	
 	Q
3T[^F5KLLLLLr   c                     dt           dt          fd}|                     dd          } ||          }t          | j        ||           |                     t          | j        d                   |           dS )z
        A published old-style event should format as text in the same way as
        the given C{textFromEventDict} callable would format it.
        r7   r   c                 x    d                     t          d                     | d                                       S )N  rq   )joinreversed)r7   s    r   r{   zAPublishToNewObserverTests.test_message.<locals>.textFromEventDictH  s-    778CHHU9-=$>$>??@@@r   zHello,zworld!r   N)r   r1   r   r   r#   r4   r   r;   )r!   r{   r7   texts       r   rr   z&PublishToNewObserverTests.test_messageB  s    	AX 	A# 	A 	A 	A 	A   844  ''T]E3DEEET[^44d;;;;;r   c                     t          | j        |                                 t          j                   |                     | j        d         d         t          j                   dS )zL
        Published event should have log level of L{LogLevel.info}.
        r   rC   N)	r   r#   r   r   r{   r4   r;   r   rE   r)   s    r   test_defaultLogLevelz.PublishToNewObserverTests.test_defaultLogLevelQ  sY     	M4++--y/J	
 	
 	
 	Q4hmDDDDDr   c                     t          | j        |                     d          t          j                   |                     | j        d         d         t          j                   dS )z
        If C{"isError"} is set to C{1} (true) on the legacy event, the
        C{"log_level"} key should get set to L{LogLevel.critical}.
        r<   r   r   rC   N)	r   r#   r   r   r{   r4   r;   r   rf   r)   s    r   test_isErrorz&PublishToNewObserverTests.test_isErrorZ  s_    
 	M4++A+66	8S	
 	
 	
 	Q4h6GHHHHHr   c                     t          | j        |                     t          j                  t
          j                   |                     | j        d         d         t          j
                   dS )z
        If the old-style C{"logLevel"} key is set to a standard library logging
        level, using a predefined (L{int}) constant, the new-style
        C{"log_level"} key should get set to the corresponding log level.
        rn   r   rC   N)r   r#   r   
py_loggingrm   r   r{   r4   r;   r   rd   r)   s    r   test_stdlibLogLevelz-PublishToNewObserverTests.test_stdlibLogLeveld  sc     	Mj&899'	
 	
 	

 	Q4hmDDDDDr   c                     t          | j        |                     d          t          j                   |                     | j        d         d         t          j                   dS )z
        If the old-style C{"logLevel"} key is set to a standard library logging
        level, using a string value, the new-style C{"log_level"} key should
        get set to the corresponding log level.
        rm   rn   r   rC   N)	r   r#   r   r   r{   r4   r;   r   rd   r)   s    r   test_stdlibLogLevelWithStringz7PublishToNewObserverTests.test_stdlibLogLevelWithStringq  s`     	Mi00'	
 	
 	

 	Q4hmDDDDDr   c                     t          | j        |                     d          t          j                   |                     d| j        d                    dS )z
        If the old-style C{"logLevel"} key is set to a standard library logging
        level, using an unknown value, the new-style C{"log_level"} key should
        not get set.
        zFoo!!!!!rn   rC   r   N)r   r#   r   r   r{   rj   r;   r)   s    r   test_stdlibLogLevelWithGarbagez8PublishToNewObserverTests.test_stdlibLogLevelWithGarbage~  sY     	Mj11'	
 	
 	

 	dk!n55555r   c                     t          | j        |                                 t          j                   |                     | j        d         d         d           dS )z
        Published event should have a namespace of C{"log_legacy"} to indicate
        that it was forwarded from legacy logging.
        r   log_namespace
log_legacyNr   r)   s    r   test_defaultNamespacez/PublishToNewObserverTests.test_defaultNamespace  sW    
 	M4++--y/J	
 	
 	
 	Q8,GGGGGr   c                     t          | j        |                                 t          j                   |                     | j        d         d         | j        d         d                    dS )zg
        The old-style C{"system"} key is copied to the new-style
        C{"log_system"} key.
        r   rA   rZ   Nr   r)   s    r   r]   z%PublishToNewObserverTests.test_system  sb    
 	M4++--y/J	
 	
 	
 	Q5t{1~h7OPPPPPr   r   )r.   r/   r0   r   r   r1   r   r   r2   r   r   rV   rr   r   r   r   r   r   r   r]   r   r   r   r   r     sD        ? ? ? ?C 6 i>Q    ". . . .M M M M< < < <E E E EI I I IE E E EE E E E6 6 6 6H H H HQ Q Q Q Q Qr   r   )"r   loggingr   r   typingr   r   zope.interfacer   zope.interface.exceptionsr   zope.interface.verifyr   twisted.pythonr	   r
   r   twisted.python.failurer   twisted.trialr   _formatr   _interfacesr   r   _legacyr   r   _levelsr   TestCaser   r   r   r   r   <module>r      s                      & & & & & & @ @ @ @ @ @ . . . . . . 4 4 4 4 4 4 4 4 * * * * * * " " " " " " ! ! ! ! ! ! 0 0 0 0 0 0 0 0 D D D D D D D D      y/ y/ y/ y/ y/H$5 y/ y/ y/xHQ HQ HQ HQ HQ 1 HQ HQ HQ HQ HQr   