
    Vh)                         d Z ddlmZmZmZmZ ddlmZ ddlm	Z	 ddl
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      Z G d d      Z G d dej8                        Zy)z+
Test cases for L{twisted.logger._logger}.
    )ListOptionalTypecast)implementer)NamedConstant)Failure)unittest   )formatEvent)globalLogPublisher)ILogObserverLogEvent)InvalidLogLevelErrorLogLevelLoggerc            	       2    e Zd ZdZ	 ddedee   deddfdZy)	
TestLoggerz^
    L{Logger} with an overridden C{emit} method that keeps track of received
    events.
    Nlevelformatkwargsreturnc                     t        t              dt        dd f fd       }t        j                  |       	 t        j                   ||fi | t        j                  |       |||d _        y # t        j                  |       w xY w)Neventr   c                     | _         y N)r   r   selfs    O/home/dcms/DCMS/lib/python3.12/site-packages/twisted/logger/test/test_logger.pyobserverz!TestLogger.emit.<locals>.observer    s
    DJ    )r   r   r   )	r   r   r   r   addObserverr   emitremoveObserveremitted)r   r   r   r   r!   s   `    r    r$   zTestLogger.emit   s     
\	"	H 	 	 
#	 	&&x0	8KKeV6v6--h7 
 --h7s   A1 1Br   )	__name__
__module____qualname____doc__r   r   strobjectr$    r"   r    r   r      s6     =A
"
,4SM
LR
	
r"   r   c                   B    e Zd ZdZ e       Zddee   ddfdZdefdZ	y)LogComposedObjectz3
    A regular object, with a logger attached.
    Nstater   c                     || _         y r   r0   )r   r0   s     r    __init__zLogComposedObject.__init__8   s	    
r"   c                 "    d| j                    dS )Nz<LogComposedObject >r2   )r   s    r    __str__zLogComposedObject.__str__;   s    $TZZL22r"   r   )
r'   r(   r)   r*   r   logr   r+   r3   r6   r-   r"   r    r/   r/   1   s3     ,Chsm t 3 3r"   r/   c                       e Zd Z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dZddZy)LoggerTestsz
    Tests for L{Logger}.
    Nc                 n    d}t        |      }| j                  t        |      dt        |       d       y)z"
        repr() on Logger
        blearghz<Logger r5   N)r   assertEqualrepr)r   	namespacer7   s      r    	test_reprzLoggerTests.test_reprD   s5     	YchtI.?q$ABr"   c                 X    t               }| j                  |j                  t               y)z3
        Default namespace is module name.
        N)r   r<   r>   r'   r   r7   s     r    test_namespaceDefaultz!LoggerTests.test_namespaceDefaultL   s     h1r"   c                     g }t        dt        t              t                      | j	                  |d   j
                  d       y)z
        Default namespace is C{"<unknown>"} when a logger is created from a
        context in which is can't be determined automatically and no namespace
        was specified.
        zresult.append(Logger())r   r   z	<unknown>N)execdictr   localsr<   r>   )r   results     r    test_namespaceOMGItsTooHardz'LoggerTests.test_namespaceOMGItsTooHardS   s=      "%H	

 	,,k:r"   c                    t               }dj                  |j                  |j                  j                        }| j                  t        t        |j                        j                  |       | j                  t        t        t           t         j                        j                  |       | j                  t        t        t           t         j                        j                  t                | j                  t        t        |j                        j                  |       | j                  t               j                         y)z
        Default namespace for classes using L{Logger} as a descriptor is the
        class name they were retrieved from.
        z{}.{}N)r/   r   r(   	__class__r'   r<   r   r   r7   r>   r   assertIssourceassertIsNoner   )r   objexpectedNamespaces      r    test_namespaceAttributez#LoggerTests.test_namespaceAttributea   s    
  !#NNNNMM""

 	j#''2<<>OPj!#4#8#89CCEV	
 	j!#4#8#89@@BS	
 	d:sww/66<&(//*r"   c                     g  G fdd      }|j                   j                  d       | j                  t              d       | j                  d   d   d       y)zH
        When used as a descriptor, the observer is propagated.
        c                   D    e Zd Z e eeW  j                              Zy)5LoggerTests.test_descriptorObserver.<locals>.MyObjectr!   N)r'   r(   r)   r   r   r   appendr7   )observeds   r    MyObjectrS   }   s    $|X__"EFCr"   rW   hello   r   
log_formatN)r7   infor<   len)r   rW   rV   s     @r    test_descriptorObserverz#LoggerTests.test_descriptorObserverw   sW     $&	G 	G 	'"X*!\2G<r"   c                 4   t        d      }t        t        |j                        }|j	                  d       | j                  d|j                         | j                  |j                  d   |       t        |j                        }| j                  d|       y)z
        On instances that have a L{Logger} class attribute, the C{log_source}
        key is available to format strings.
        rX   zHello, {log_source}.
log_sourcez!Hello, <LogComposedObject hello>.N)	r/   r   r   r7   errorassertInr   r<   r   )r   rN   r7   stuffs       r    !test_sourceAvailableForFormattingz-LoggerTests.test_sourceAvailableForFormatting   ss    
  (:sww'		()lCII.<0#6CII&95Ar"   c                 ^   t               }t        j                         D ]  }d}|j                  |j                        }t        ||j                        } ||||j                         | j                  |j                  d   |       | j                  |j                  d   |       | j                  |j                  d   d   |       | j                  t        |d      d	       | j                  |j                  d
   |       | j                  |j                  d   |       | j                  |j                  d   t               | j                  |j                  d          | j                  |j                  d   |       | j                  t        |j                        |        y)z]
        Test that log levels and messages are emitted correctly for
        Logger.
        zThis is a {level_name} message)
level_name)junkre   r   r   r   rf   r   zNo event observed.rZ   	log_levellog_namespacer_   N)r   r   iterconstantsr   namegetattrr<   r&   
assertTruehasattrr   r'   rM   r   )r   r7   r   r   message	logMethods         r    test_basicLoggerzLoggerTests.test_basicLogger   sX   
 l++- 	>E5Fmmuzzm:GUZZ0If7uzzB S[[159S[[2F;S[[26:GDOOGC13GHSYY|4f=SYY{3U;SYY7Bcii56SYYv.8[3W=)	>r"   c                      t        t              dt        ddf fd        G fdd      t        t        j
                        j                          y)z>
        C{log_source} event key refers to the class.
        r   r   Nc                 0    j                  | d          y Nr_   r<   )r   Thingor   s    r    r!   z0LoggerTests.test_sourceOnClass.<locals>.observer       U<0&9r"   c                   "    e Zd Z eW        Zy).LoggerTests.test_sourceOnClass.<locals>.ThingorT   Nr'   r(   r)   r   r7   rT   s   r    ru   rx          h/Cr"   ru   r   r   r   r   r   r7   r[   )r   ru   r!   s   `@@r    test_sourceOnClasszLoggerTests.test_sourceOnClass   sM    
 
\	"	:H 	: 	: 
#	:	0 	0 	Z$))+r"   c                      t        t              dt        ddf fd        G fdd      } |       t        t        j
                        j                          y)zA
        C{log_source} event key refers to the instance.
        r   r   Nc                 0    j                  | d          y rs   rt   )r   r   thingos    r    r!   z3LoggerTests.test_sourceOnInstance.<locals>.observer   rv   r"   c                   "    e Zd Z eW        Zy)1LoggerTests.test_sourceOnInstance.<locals>.ThingorT   Nry   rT   s   r    ru   r      rz   r"   ru   r{   )r   ru   r!   r   s   ` @@r    test_sourceOnInstancez!LoggerTests.test_sourceOnInstance   sT    
 
\	"	:H 	: 	: 
#	:	0 	0 Z$))+r"   c                 ~     t        t              dt        ddf fd       }t        |      }|j	                          y)z5
        C{log_source} event key is L{None}.
        r   r   Nc                 .    j                  | d          y rs   )rM   r   s    r    r!   z0LoggerTests.test_sourceUnbound.<locals>.observer   s    eL12r"   rT   r   r   r   r   r[   )r   r!   r7   s   `  r    test_sourceUnboundzLoggerTests.test_sourceUnbound   s?    
 
\	"	3H 	3 	3 
#	3 (+
r"   c                 h   t               }	 t        d      # t        $ r |j                  d       Y nw xY w| j                  t              }| j	                  t        |      d       | j	                  |j                  d   t        j                         | j	                  |j                  d   d       y)z?
        Test that log.failure() emits the right data.
        zbaloney!WhoopsrY   r   r   N)	r   RuntimeErrorfailureflushLoggedErrorsr<   r\   r&   r   criticalr   r7   errorss      r    test_defaultFailurezLoggerTests.test_defaultFailure   s     l	"z** 	"KK!	" ''5Va(W-x/@/@AX.9s    44c                    t               }|j                  ddt        j                  dd       | j	                  |j
                  d   d       | j	                  |j
                  d   t        j                         | j	                  |j
                  d   |j                         | j                  |j
                  d	          y
)zQ
        Make sure that kwargs conflicting with args don't pass through.
        *#z*namespace*z*source*)rZ   rg   rh   r_   rZ   rg   rh   r_   N)r   warnr   r`   r<   r   r>   rM   rA   s     r    test_conflictingKwargsz"LoggerTests.test_conflictingKwargs   s     lnn'! 	 	
 	<0#6;/??3S]]C#))L12r"   c                     t               }|j                  d       | j                  t              }| j	                  t        |      d       y)zA
        Test passing in a bogus log level to C{emit()}.
        z*bogus*rY   N)r   r$   r   r   r<   r\   r   s      r    test_logInvalidLogLevelz#LoggerTests.test_logInvalidLogLevel   s<     l''(<=Va(r"   c                      t        t              dt        ddffd       t        t              dt        ddf fd       t              j	                  dg        y)	zE
        Tracing keeps track of forwarding to the publisher.
        r   r   Nc                      |        y r   r-   )r   r!   s    r    	publisherz)LoggerTests.test_trace.<locals>.publisher  s
    UOr"   c                 6    j                  | d   fg       y )N	log_tracert   )r   r7   r   r   s    r    r!   z(LoggerTests.test_trace.<locals>.observer  s     U;/3	2B1CDr"   rT   zHello.)r   r   )r   r7   r!   r   s   `@@@r    
test_tracezLoggerTests.test_trace  sq    
 
\	"	X 	$ 	 
#	 
\	"	EH 	E 	E 
#	E ),R(r"   c                    g t        t              dt        ddffd       }t        |      }d G fdd      }|j	                  d	 |       
      5 }ddz   ddd       | j                  j                  d       | j                  |j                  d       | j                  t              d       \  }g dd |d   }| j                  d       | j                  t        |      d       | j                  d       | j                  |j                  t               |j	                  d |       
      5 }| j                  |j                  d       | j                  |j                  d       ddd       | j                  d       | j                  j                  d       | j                  |j                  d       y# 1 sw Y   nxY w# 1 sw Y   axY w)z
        The L{Logger.failuresHandled} context manager catches any
        L{BaseException} and converts it into a logged L{Failure}.
        r   r   Nc                 (    j                  |        y r   rU   r   eventss    r    loggedz0LoggerTests.test_failuresHandled.<locals>.logged      MM% r"   rT   r   c                       e Zd Zdef fdZy)2LoggerTests.test_failuresHandled.<locals>.Reprabler   c                     dz  d dS )NrY   z<repr r5   r-   )r   reprds    r    __repr__z;LoggerTests.test_failuresHandled.<locals>.Reprable.__repr__&  s    
wa((r"   N)r'   r(   r)   r+   r   )r   s   r    Reprabler   %  s    )# )r"   r   z*while testing failure handling for {value})valuerY   FTlog_failurez+while testing failure handling for <repr 1>zsucceeding for {value})r   r   r   r   failuresHandledr<   	succeededfailedr\   r   typeZeroDivisionError)	r   r   r7   r   	operationfop2r   r   s	          @@r    test_failuresHandledz LoggerTests.test_failuresHandled  s   
 	\	"	!( 	!t 	! 
#	! &)	) 	)   8
 ! 
 	E	 	,,e4))40Va(q	M*"!N	
 	"!23  !9 L 	0PSS]]E2SZZ/	0 	"-U++	 	 	0 	0s   G	=9G	GGc                    g t        t              dt        ddffd       }t        |      }|j	                  d      }d}|5 }d}ddd       | j                  d       | j                  |d       | j                  g        d}dd	}|5 } |        ddd       | j                  t              d
       \  }|d   }| j                  |j                  t               y# 1 sw Y   xY w# 1 sw Y   ZxY w)z
        The L{Logger.failureHandler} context manager can safely be shared
        amongst multiple invocations and converts L{BaseException} into logged
        L{Failure}s.
        r   r   Nc                 (    j                  |        y r   r   r   s    r    r   z/LoggerTests.test_failureHandler.<locals>.loggedJ  r   r"   rT   rX   FTc                      t               r   )KeyboardInterruptr-   r"   r    	raisebasez2LoggerTests.test_failureHandler.<locals>.raisebaseY  s    #%%r"   rY   r   r   N)
r   r   r   r   failureHandlerrK   r<   r\   r   r   )	r   r   r7   r   successfhr   r   r   s	           @r    test_failureHandlerzLoggerTests.test_failureHandlerB  s    	\	"	!( 	!t 	! 
#	! &)++G4 	rG	b$$'$	&  	rK	 	Va(=!!23!	 		 	s   C#C/#C,/C8r   )r'   r(   r)   r*   r?   rB   rH   rP   r]   rc   rp   r|   r   r   r   r   r   r   r   r   r-   r"   r    r9   r9   ?   sZ    C2;+,=B>:,,
: 3&	)) ),V 4r"   r9   N)r*   typingr   r   r   r   zope.interfacer   
constantlyr   twisted.python.failurer	   twisted.trialr
   _formatr   _globalr   _interfacesr   r   _levelsr   r   _loggerr   r   r/   TestCaser9   r-   r"   r    <module>r      sW    . - & $ * " ! ( 0 4 
 
43 3c4(## c4r"   