U  W[;8@sdZddlmZddlZddlmZmZddlmZddl m Z ddl m Z ddl mZd d lmZd d lmZd d lmZd d lmZd dlmZGdddejZGdddejZdS)z+ Test cases for L{twisted.logger._legacy}. )timeN) verifyObjectBrokenMethodImplementation)unittest)context)log)Failure)LogLevel) ILogObserver) formatEvent)LegacyLogObserverWrapper)publishToNewObserverc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0S)1LegacyLogObserverWrapperTestsz0 Tests for L{LegacyLogObserverWrapper}. c CsPdd}t|}ztt|Wn,tk rJ}z||W5d}~XYnXdS)zD L{LegacyLogObserverWrapper} is an L{ILogObserver}. cSsdSNerrA/usr/lib/python3/dist-packages/twisted/logger/test/test_legacy.py$z>LegacyLogObserverWrapperTests.test_interface..N)r rr rZfail)selflegacyObserverobserverrrrrtest_interface s z,LegacyLogObserverWrapperTests.test_interfacecCs.Gdddt}t|}|t|ddS)zJ L{LegacyLogObserverWrapper} returns the expected string. c@seZdZddZddZdS)z?LegacyLogObserverWrapperTests.test_repr..LegacyObservercSsdS)Nzrrrrr__repr__1szHLegacyLogObserverWrapperTests.test_repr..LegacyObserver.__repr__cSsdSrrrrrr__call__4szHLegacyLogObserverWrapperTests.test_repr..LegacyObserver.__call__N)__name__ __module__ __qualname__rrrrrrLegacyObserver0sr!z+LegacyLogObserverWrapper()N)objectr assertEqualrepr)rr!rrrr test_repr,s  z'LegacyLogObserverWrapperTests.test_reprcs8gfdd}t|}|||tddS)z Send an event to a wrapped legacy observer and capture the event as seen by that observer. @param event: an event @type event: L{dict} @return: the event as observed by the legacy wrapper cs |Sr)appendreventsrrrKrz7LegacyLogObserverWrapperTests.observe..r)r r#len)reventrrrr'robserve?s  z%LegacyLogObserverWrapperTests.observecCsX|dt|dd|dtj|t|}|D]\}}|||q>|S)z Send an event to a wrapped legacy observer and verify that its data is preserved. @param event: an event @type event: L{dict} @return: the event as observed by the legacy wrapper log_time log_system- log_level) setdefaultrr infor,dictitemsZassertIn)rr+observedkeyvaluerrrforwardAndVerifySs  z.LegacyLogObserverWrapperTests.forwardAndVerifycCs|tddddS)ze Basic forwarding: event keys as observed by a legacy observer are the same. r)r foobarN)r8r3rrrr test_forwardlsz*LegacyLogObserverWrapperTests.test_forwardcCs*t}|t|d}||d|dS)zc The new-style C{"log_time"} key is copied to the old-style C{"time"} key. )r-rNrr8r3r#rZstampr+rrr test_timetsz'LegacyLogObserverWrapperTests.test_timecCs0t}|t|d|d}||d|dS)zr The new-style C{"log_time"} key does not step on a pre-existing old-style C{"time"} key. r))r-rrNr=r>rrrtest_timeAlreadySet~sz1LegacyLogObserverWrapperTests.test_timeAlreadySetcCs$|tdd}||dddS)zg The new-style C{"log_system"} key is copied to the old-style C{"system"} key. r:)r.systemNr8r3r#rr+rrr test_systemsz)LegacyLogObserverWrapperTests.test_systemcCs&|tddd}||dddS)zv The new-style C{"log_system"} key does not step on a pre-existing old-style C{"system"} key. r:r;)r.rArANrBrCrrrtest_systemAlreadySetsz3LegacyLogObserverWrapperTests.test_systemAlreadySetcCs2tttjd}|t|}||dddS)zy If the new-style C{"log_system"} key is absent, the old-style C{"system"} key is set to C{"-"}. )r-r0rAr/N)r3rr r2r,r#)rr+r5rrr test_noSystemsz+LegacyLogObserverWrapperTests.test_noSystemcCsT|ttjdd|ttjdd|ttjdd|ttjdddS)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))r0isErrorrN)r8r3r r2warnerrorcriticalrrrrtest_levelNotChangesz1LegacyLogObserverWrapperTests.test_levelNotChangecCs"|ttjd}|d|dS)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. )r0logLevelN)r8r3r r2 assertNotInrCrrrtest_pythonLogLevelNotSets z7LegacyLogObserverWrapperTests.test_pythonLogLevelNotSetcCs$|tdd}||dddS)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. WARNINGrLrLNrBrCrrrtest_stringPythonLogLevelsz7LegacyLogObserverWrapperTests.test_stringPythonLogLevelcCs |t}||dddS)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. messagerNrBrCrrr test_messages z*LegacyLogObserverWrapperTests.test_messagecCs$|tdd}||dddS)zV The old-style C{"message"} key is not modified if it already exists. r9)rRrRNrBrCrrrtest_messageAlreadySetsz4LegacyLogObserverWrapperTests.test_messageAlreadySetcCs(|tddd}|t|ddS)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_formatZwho Hello, world!Nr8r3r# legacyLogtextFromEventDictrCrrr test_formats z)LegacyLogObserverWrapperTests.test_formatcCs(|tddd}|t|ddS)zo Using the message key, which is special in old-style, works for new-style formatting. zHello, {message}!rU)rVrRrWNrXrCrrrtest_formatMessages z0LegacyLogObserverWrapperTests.test_formatMessagecCs(|tddd}|t|ddS)zd Formatting is not altered if the old-style C{"format"} key already exists. zHello!zHowdy!)rVformatNrXrCrrrtest_formatAlreadySets z3LegacyLogObserverWrapperTests.test_formatAlreadySetcKs&ttd}|tf|dd|S)z Create a new-style event with a captured failure. @param values: Additional values to include in the event. @type values: L{dict} @return: the new event @rtype: L{dict} znyargh! oopsie...) log_failurerV)r RuntimeErrorr8r3)rvaluesfailurerrreventWithFailures z.LegacyLogObserverWrapperTests.eventWithFailurecCs>|}||d|d||d||dddS)z} Captured failures in the new style set the old-style C{"failure"}, C{"isError"}, and C{"why"} keys. rcr`rGwhyr_N)rdassertIsZ assertTruer#rCrrr test_failuresz*LegacyLogObserverWrapperTests.test_failurecCs,ttd}|j|d}||d|dS)v Captured failures in the new style do not step on a pre-existing old-style C{"failure"} key. z Weak salsa!)rcrcN)rrardrf)rrcr+rrrtest_failureAlreadySet s  z4LegacyLogObserverWrapperTests.test_failureAlreadySetcCs |jdd}||dddS)zv Captured failures in the new style do not step on a pre-existing old-style C{"isError"} key. rrGrGNrdr#rCrrrtest_isErrorAlreadySet*s z4LegacyLogObserverWrapperTests.test_isErrorAlreadySetcCs |jdd}||dddS)rhZblah)rereNrkrCrrrtest_whyAlreadySet3s z0LegacyLogObserverWrapperTests.test_whyAlreadySetN)rrr __doc__rr%r,r8r<r?r@rDrErFrKrNrQrSrTr[r\r^rdrgrirlrmrrrrrs0              rc@speZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZdS)PublishToNewObserverTestsz, Tests for L{publishToNewObserver}. cCsg|_|jj|_dSr)r(r&rrrrrsetUpBszPublishToNewObserverTests.setUpcOsDttjpi}||||d<t|d<d|kr@d|d<|S)aX 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 @type message: L{tuple} of L{bytes} @param values: additional event values in the legacy event format @type event: L{dict} @return: a legacy event rRrrGr)rgetrYZ ILogContextcopyupdater)rrRrbr+rrr legacyEventGs   z%PublishToNewObserverTests.legacyEventcCs*t|j|tj|t|jddS)z6 The observer is called exactly once. r)N)rrrtrYrZr#r*r(rrrr test_observed\s z'PublishToNewObserverTests.test_observedcCs8t|j|tj||jdd|jdddS)zc The old-style C{"time"} key is copied to the new-style C{"log_time"} key. rr-rNrrrtrYrZr#r(rrrrr?fs z#PublishToNewObserverTests.test_timecCsDdd}|dd}||}t|j|||t|jd|dS)z A published old-style event should format as text in the same way as the given C{textFromEventDict} callable would format it. cSsdtd|dS)N rR)joinreversed)r+rrrrZxszAPublishToNewObserverTests.test_message..textFromEventDictzHello,zworld!rN)rtrrr#r r()rrZr+textrrrrSss  z&PublishToNewObserverTests.test_messagecCs0t|j|tj||jddtjdS)zL Published event should have log level of L{LogLevel.info}. rr0N) rrrtrYrZr#r(r r2rrrrtest_defaultLogLevels z.PublishToNewObserverTests.test_defaultLogLevelcCs4t|j|jddtj||jddtjdS)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)rjrr0N) rrrtrYrZr#r(r rJrrrr test_isErrors  z&PublishToNewObserverTests.test_isErrorcCs6t|j|jtjdtj||jddt j dS)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. rPrr0N) rrrt py_loggingrOrYrZr#r(r rHrrrrtest_stdlibLogLevels  z-PublishToNewObserverTests.test_stdlibLogLevelcCs4t|j|jddtj||jddtjdS)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. rOrPrr0N) rrrtrYrZr#r(r rHrrrrtest_stdlibLogLevelWithStrings  z7PublishToNewObserverTests.test_stdlibLogLevelWithStringcCs.t|j|jddtj|d|jddS)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. zFoo!!!!!rPr0rN)rrrtrYrZrMr(rrrrtest_stdlibLogLevelWithGarbages  z8PublishToNewObserverTests.test_stdlibLogLevelWithGarbagecCs.t|j|tj||jddddS)z Published event should have a namespace of C{"log_legacy"} to indicate that it was forwarded from legacy logging. rZ log_namespaceZ log_legacyNrvrrrrtest_defaultNamespaces z/PublishToNewObserverTests.test_defaultNamespacecCs8t|j|tj||jdd|jdddS)zg The old-style C{"system"} key is copied to the new-style C{"log_system"} key. rr.rANrvrrrrrDs z%PublishToNewObserverTests.test_systemN)rrr rnrprtrur?rSr|r}rrrrrDrrrrro=s     ro)rnrZloggingr~Zzope.interface.verifyrrZ twisted.trialrZtwisted.pythonrrrYZtwisted.python.failurerZ_levelsr Z _observerr Z_formatr Z_legacyr rZTestCaserrorrrrs           $