o i 9@sdZddlZddlmZddlmZmZddlmZddl m Z ddl m Z ddl mZmZdd lmZdd lmZd d lmZd d lmZmZd dlmZmZd dlmZGdddejZ GdddejZ!dS)z+ Test cases for L{twisted.logger._legacy}. N)time)Listcast) implementer)BrokenMethodImplementation) verifyObject)contextlog)Failure)unittest) formatEvent) ILogObserverLogEvent)LegacyLogObserverWrapperpublishToNewObserver)LogLevelc@seZdZdZd4ddZd4ddZdedefd d Zdedefd d Zd4d dZ d4ddZ d4ddZ d4ddZ d4ddZ d4ddZd4ddZd4ddZd4ddZd4dd Zd4d!d"Zd4d#d$Zd4d%d&Zd4d'd(Zd)edefd*d+Zd4d,d-Zd4d.d/Zd4d0d1Zd4d2d3ZdS)5LegacyLogObserverWrapperTestsz0 Tests for L{LegacyLogObserverWrapper}. returnNc CsZttjdd}t|}ztt|WdSty,}z ||WYd}~dSd}~ww)zD L{LegacyLogObserverWrapper} is an L{ILogObserver}. cSdSNerreC:\Users\psant\Downloads\PAF backend\school\venv\Lib\site-packages\twisted/logger/test/test_legacy.py"sz>LegacyLogObserverWrapperTests.test_interface..N)r legacyLogrrrrZfail)selflegacyObserverobserverrrrrtest_interfacesz,LegacyLogObserverWrapperTests.test_interfacecCs6ttjGddd}t|}|t|ddS)zJ L{LegacyLogObserverWrapper} returns the expected string. c@s.eZdZdefddZdejddfddZdS)z?LegacyLogObserverWrapperTests.test_repr..LegacyObserverrcSsdS)Nzrrrrr__repr__0zHLegacyLogObserverWrapperTests.test_repr..LegacyObserver.__repr__ eventDictNcSrrr)rr$rrr__call__3r#zHLegacyLogObserverWrapperTests.test_repr..LegacyObserver.__call__)__name__ __module__ __qualname__strr"r EventDictr%rrrrLegacyObserver.sr+z+LegacyLogObserverWrapper()N)rrrr assertEqualrepr)rr+rrrr test_repr)s z'LegacyLogObserverWrapperTests.test_repreventcs@gttjfdd}t|}|||tddS)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 cs |Sr)appendreventsrrrEs z7LegacyLogObserverWrapperTests.observe..rN)rrrrr,len)rr/rrrr1robserve: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 @return: the event as observed by the legacy wrapper log_time log_system- log_levelN) setdefaultrrinfor5dictitemsZassertIn)rr/observedkeyvaluerrrforwardAndVerifyLs z.LegacyLogObserverWrapperTests.forwardAndVerifycCs|tddddS)ze Basic forwarding: event keys as observed by a legacy observer are the same. r3r foobarN)rAr<r!rrr test_forwardcsz*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. )r6rNrrAr<r,rZstampr/rrr test_timejsz'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. r3)r6rrNrFrGrrrtest_timeAlreadySetssz1LegacyLogObserverWrapperTests.test_timeAlreadySetcC$|tdd}||dddS)zg The new-style C{"log_system"} key is copied to the old-style C{"system"} key. rC)r7systemNrAr<r,rr/rrr test_system|sz)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. rCrD)r7rKrKNrLrMrrrtest_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{"-"}. )r6r9rKr8N)r<rrr;r5r,)rr/r>rrr 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. r3)r9isErrorrN)rAr<rr;warnerrorcriticalr!rrrtest_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. )r9logLevelN)rAr<rr; assertNotInrMrrrtest_pythonLogLevelNotSets z7LegacyLogObserverWrapperTests.test_pythonLogLevelNotSetcCrJ)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. WARNINGrVrVNrLrMrrrtest_stringPythonLogLevels z7LegacyLogObserverWrapperTests.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. messagerNrLrMrrr test_message z*LegacyLogObserverWrapperTests.test_messagecCrJ)zV The old-style C{"message"} key is not modified if it already exists. rB)r\r\NrLrMrrrtest_messageAlreadySetsz4LegacyLogObserverWrapperTests.test_messageAlreadySetcC(|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!NrAr<r,rtextFromEventDictrMrrr test_formatz)LegacyLogObserverWrapperTests.test_formatcCr`)zo Using the message key, which is special in old-style, works for new-style formatting. zHello, {message}!ra)rbr\rcNrdrMrrrtest_formatMessages z0LegacyLogObserverWrapperTests.test_formatMessagecCs(|tddd}|t|ddS)zd Formatting is not altered if the old-style C{"format"} key already exists. zHello!zHowdy!)rbformatNrdrMrrrtest_formatAlreadySetrgz3LegacyLogObserverWrapperTests.test_formatAlreadySetvaluescKs&ttd}|td|dd|S)z Create a new-style event with a captured failure. @param values: Additional values to include in the event. @return: the new event znyargh! oopsie...) log_failurerbNr)r RuntimeErrorrAr<)rrkfailurerrreventWithFailures 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. rormrQwhyrlN)rpassertIs assertTruer,rMrrr 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!)roroN)r rnrprr)rror/rrrtest_failureAlreadySets  z4LegacyLogObserverWrapperTests.test_failureAlreadySetcC |jdd}||dddS)zv Captured failures in the new style do not step on a pre-existing old-style C{"isError"} key. rrQrQNrpr,rMrrrtest_isErrorAlreadySetr^z4LegacyLogObserverWrapperTests.test_isErrorAlreadySetcCrw)ruZblah)rqrqNryrMrrrtest_whyAlreadySet r^z0LegacyLogObserverWrapperTests.test_whyAlreadySetrN)r&r'r(__doc__r r.rr5rArErHrIrNrOrPrUrXr[r]r_rfrhrjobjectrprtrvrzr{rrrrrs2            rc@seZdZdZdddZdededejfdd Z dd d Z dd d Z dddZ dddZ dddZdddZdddZdddZdddZdddZdS)PublishToNewObserverTestsz, Tests for L{publishToNewObserver}. rNcCsg|_tt|jj|_dSr)r2rrr0rr!rrrsetUpszPublishToNewObserverTests.setUpr\rkcOsDttjpi}||||d<t|d<d|vr 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 r\rrQrN)rgetrZ ILogContextcopyupdater)rr\rkr/rrr legacyEvents  z%PublishToNewObserverTests.legacyEventcCs*t|j|tj|t|jddS)z6 The observer is called exactly once. r3N)rrrrrer,r4r2r!rrr test_observed/sz'PublishToNewObserverTests.test_observedcC8t|j|tj||jdd|jdddS)zc The old-style C{"time"} key is copied to the new-style C{"log_time"} key. rr6rNrrrrrer,r2r!rrrrH8$z#PublishToNewObserverTests.test_timecCsNdtdtfdd}|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. r/rcSsdtd|dS)N r\)joinreversed)r/rrrreHszAPublishToNewObserverTests.test_message..textFromEventDictzHello,zworld!rN)rr)rrrr,r r2)rrer/textrrrr]Bs  z&PublishToNewObserverTests.test_messagecCs0t|j|tj||jddtjdS)zL Published event should have log level of L{LogLevel.info}. rr9N) rrrrrer,r2rr;r!rrrtest_defaultLogLevelQsz.PublishToNewObserverTests.test_defaultLogLevelcC4t|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}. r3rxrr9N) rrrrrer,r2rrTr!rrr test_isErrorZsz&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. rZrr9N) rrr py_loggingrYrrer,r2rrRr!rrrtest_stdlibLogLevelds  z-PublishToNewObserverTests.test_stdlibLogLevelcCr)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. rYrZrr9N) rrrrrer,r2rrRr!rrrtest_stdlibLogLevelWithStringqs  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!!!!!rZr9rN)rrrrrerWr2r!rrrtest_stdlibLogLevelWithGarbage~s  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_legacyNrr!rrrtest_defaultNamespacesz/PublishToNewObserverTests.test_defaultNamespacecCr)zg The old-style C{"system"} key is copied to the new-style C{"log_system"} key. rr7rKNrr!rrrrNrz%PublishToNewObserverTests.test_systemr|)r&r'r(r}rr)r~rr*rrrHr]rrrrrrrNrrrrrs     r)"r}loggingrrtypingrrZzope.interfacerZzope.interface.exceptionsrZzope.interface.verifyrZtwisted.pythonrr rZtwisted.python.failurer Z twisted.trialr _formatr Z _interfacesrrZ_legacyrrZ_levelsrZTestCaserrrrrrs"        }