o id@sdZddlmZddlmZmZmZddlmZddl m Z ddl m Z m Z ddlmZmZmZddlmZGd d d e jZGd d d eZGd ddeZeeGddde jZeeGddde jZGddde jZGdddeZGdddeZGdddeZGdddeZGdddeZ Gdd d eZ!eee e!Gd!d"d"e jZ"eeGd#d$d$Z#Gd%d&d&Z$Gd'd(d(ej%e$Z&Gd)d*d*ej%Z'Gd+d,d,eZ(ee(Gd-d.d.e jZ)ee(Gd/d0d0e jZ*Gd1d2d2Z+Gd3d4d4e jZ,ee(Gd5d6d6e jZ-Gd7d8d8eZ.Gd9d:d:eZ/ee.Gd;d<d<Z0e Gd=d>d>Z1Gd?d@d@e$ej%Z2GdAdBdBe$ej%Z3GdCdDdDeZ4GdEdFdFe4Z5ee4GdGdHdHZ6ee5GdIdJdJZ7GdKdLdLeZ8GdMdNdNZ9GdOdPdPej%Z:dQS)Rz0 Test cases for Twisted component architecture. )wraps) Attribute Interface implementer)AdapterRegistry) components)cmp comparable)_addHook _removeHookproxyForInterface)unittestc@eZdZdZddZdS)ComporcCs|jd|_|jSNnumselfriC:\Users\psant\Downloads\PAF backend\school\venv\Lib\site-packages\twisted/python/test/test_components.pyincs z Compo.incN)__name__ __module__ __qualname__rrrrrrr rc@eZdZddZdS)IAdeptcCstN)NotImplementedErrorrrrr adaptorFuncszIAdept.adaptorFuncN)rrrr!rrrrr rc@r)IElapsedcCdS)z 1! Nrrrrr elapsedFunc#zIElapsed.elapsedFuncNrrrr%rrrrr#"r"r#c@seZdZddZddZdS)AdeptcCs||_d|_dSNroriginalrrorigrrr__init__+ zAdept.__init__cCs|jd|_|j|jfSr)rr+rrrrrr!/s zAdept.adaptorFuncN)rrrr.r!rrrrr()s r(c@r)ElapsedcCr$rrrrrrr%6zElapsed.elapsedFuncNr'rrrrr04 r0c@ eZdZdS)ACompNrrrrrrrr4:r4c@r3)BCompNr5rrrrr7>r6r7c@r3)CCompNr5rrrrr8Br6r8c@r3)ITestNr5rrrrr9Fr6r9c@r3)ITest2Nr5rrrrr:Jr6r:c@r3)ITest3Nr5rrrrr;Nr6r;c@r3)ITest4Nr5rrrrr<Rr6r<c@r)TestcCdSrrr,rrrr.Xr1z Test.__init__Nrrrr.rrrrr=Vr2r=c@r)Test2rcCr>rrr,rrrr.`r1zTest2.__init__N)rrrZtemporaryAdapterr.rrrrr@\s r@c@r)RegistryUsingMixinzH Mixin for test cases which modify the global registry somehow. cCs,t}|td|t|}|t|dS)z Configure L{twisted.python.components.registerAdapter} to mutate an alternate registry to improve test isolation. ZglobalRegistryN)rpatchrr Z addCleanupr )rZscratchRegistryhookrrrsetUpiszRegistryUsingMixin.setUpN)rrr__doc__rDrrrrrAd rAc@s`eZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ dS)ComponentizedTestsz8 Simple test case for caching in Componentized. cCs8t|tttttttttttt dSr) rArDrregisterAdapterr=r4r9r;r@r:rrrrrD~s zComponentizedTests.setUpcCsjttttttttt}|tdksJ|tdks'Jtt| dks3JdS)N)rr)rIr) rrHr(rrr0r# getComponentr!r%rcrrrtestComponentizeds z$ComponentizedTests.testComponentizedcCst}|t}|t}|t}|t}||usJ||us#J|||t}|t}||us8J||us>JdSr)r8rJr9r:ZremoveComponent)rrLco1Zco2co3co4Zco5Zco6rrrtestInheritanceAdaptations          z,ComponentizedTests.testInheritanceAdaptationcCs>t}|t}|t}|t}|||||dSr)r8rJr9r;r< assertIsNoneassertIs)rrLrNrOrPrrrtestMultiAdapters     z#ComponentizedTests.testMultiAdaptercCsNt}t}||t||||jt|d|||tddS)z Test that a default value specified to Componentized.getComponent if there is no component for the requested interface. )defaultN)r ComponentizedobjectrSrJr9)r componentizedrUrrrtest_getComponentDefaultss z,ComponentizedTests.test_getComponentDefaultscCs<t}|tt|t}||j|||tdS)z C{Componentized.setAdapter} sets a component for an interface by wrapping the instance with the given adapter class. N) rrVZ setAdapterrr(rJ assertEqualr+assertIsInstancerrX componentrrrtest_setAdapters   z"ComponentizedTests.test_setAdaptercCs>t}|jtdd|t}||j|||tdS)z C{Componentized.setAdapter} adapts the instance by wrapping it with given adapter class, then stores it using C{addComponent}. T)Z ignoreClassN) rrVZ addAdapterr(rJrrZr+r[r\rrrtest_addAdapters  z"ComponentizedTests.test_addAdaptercCs0t}t}|t|||t|dS)zx C{Componentized.setComponent} stores the given component using the given interface as the key. N)rrVrW setComponentr9rSrJrrXobjrrrtest_setComponents z$ComponentizedTests.test_setComponentcCs8t}t}|t||t||tdS)zm C{Componentized.setComponent} removes the cached component for the given interface. N)rrVrWr`r9ZunsetComponentrRrJrarrrtest_unsetComponents   z&ComponentizedTests.test_unsetComponentcCs8t}|tdt|}|d||d|dS)zR C{ReprableComponentized} has a C{__repr__} that lists its cache. hellor9N)rZReprableComponentizedr`r9reprZassertIn)rrcresultrrrtest_reprableComponentizeds   z-ComponentizedTests.test_reprableComponentizedN)rrrrErDrMrQrTrYr^r_rcrdrirrrrrGys     rGc@r) AdapterTestszTest adapters.cCs2t}t|}|tjt||t|ddSr)rWr( assertRaisesrZ CannotAdaptr9rR)roarrrtestAdapterGetComponentsz$AdapterTests.testAdapterGetComponentN)rrrrErnrrrrrjrrjc@r3)IMetaNr5rrrrror6roc@r) MetaAddercCs |jj|Srr*rrrrradd z MetaAdder.addNrrrrrrrrrrpr2rpc@r)BackwardsAddercCs |jj|Srr*rqrrrrrrszBackwardsAdder.addNrtrrrrrur2ruc@r) MetaNumberz9 Integer wrapper for Interface adaptation tests. cC ||_dSrrrqrrrr. zMetaNumber.__init__N)rrrrEr.rrrrrvrFrvc@r)ComponentNumbercCsd|_tj|dSr))rrrVr.rrrrr. szComponentNumber.__init__Nr?rrrrryr"ryc@ eZdZdZddZddZdS)ComponentAdderz0 Adder for componentized adapter tests. cCstj|||jj|_dSr)rAdapterr.r+rrr+rrrr.szComponentAdder.__init__cCs|j|7_|jSrrrqrrrrrszComponentAdder.addN)rrrrEr.rrrrrrr{s r{c@r)IAttrXz= Base interface for test of adapter with C{__cmp__}. cCr$)z! Return a value. Nrrrrrx"r&zIAttrX.xNrrrrErrrrrr~rFr~c@r)IAttrXXz@ Adapted interface for test of adapter with C{__cmp__}. cCr$)z+ Return a tuple of values. Nrrrrrxx-r&z IAttrXX.xxN)rrrrErrrrrr(rFrc@r)XcellentzG L{IAttrX} implementation for test of adapter with C{__cmp__}. cCr$)z; Return a value. @return: a value x!Nrrrrrr9sz Xcellent.xNrrrrrr3s rc@s,eZdZdZdZddZddZddZd S) DoubleXAdapterz Adapter with __cmp__. *cCrwr)r+r}rrrr.JrxzDoubleXAdapter.__init__cCs|j|jfSr)r+rrrrrrMszDoubleXAdapter.xxcCst|j|jSr)rr)rotherrrr__cmp__PszDoubleXAdapter.__cmp__N)rrrrErr.rrrrrrrBs  rc@s$eZdZddZddZddZdS)MetaInterfaceTestscCs0tttttd}|t|dddS)zS Registered adapters can be used to adapt classes to an interface. rrIN)rrHrprvrorZrr)rnrrr test_basicUszMetaInterfaceTests.test_basiccCsJttttt}t|dt|d|t|dddS)Nr)rrHr{ryrorrrZrKrrrtestComponentizedInteraction]s z/MetaInterfaceTests.testComponentizedInteractioncCs,tttttt}|d|dS)N)rr)rrHrr~rrrZr)rrrrrtestAdapterWithCmpds z%MetaInterfaceTests.testAdapterWithCmpN)rrrrrrrrrrrTs rc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd S)!RegistrationTestsz) Tests for adapter registration. cCs0dd}t||t|t|td|dS)z Register an adapter with L{components.registerAdapter} for the given class or interface and verify that the adapter can be looked up with L{components.getAdapterFactory}. cSr>rrrlrrrvr&zGRegistrationTests._registerAdapterForClassOrInterface..NrrHr9rSgetAdapterFactoryrr+adapterrrr#_registerAdapterForClassOrInterfacepsz5RegistrationTests._registerAdapterForClassOrInterfacecCGddd}||S)za Test that an adapter from a class can be registered and then looked up. c@r3)zCRegistrationTests.test_registerAdapterForClass..TheOriginalNr5rrrr TheOriginalr6rN)rrrrrrtest_registerAdapterForClassz z.RegistrationTests.test_registerAdapterForClasscC |tS)zf Test that an adapter from an interface can be registered and then looked up. N)rr:rrrr test_registerAdapterForInterface z2RegistrationTests.test_registerAdapterForInterfacecCsLdd}dd}t||t|ttj||t|t|td|dS)z Verify that L{components.registerAdapter} raises L{ValueError} if the from-type/interface and to-interface pair is not unique. cSr$NFrrrrrrr&zHRegistrationTests._duplicateAdapterForClassOrInterface..cSr$NTrrrrrrr&N)rrHr9rk ValueErrorrSr)rr+ firstAdapter secondAdapterrrr$_duplicateAdapterForClassOrInterfaces z6RegistrationTests._duplicateAdapterForClassOrInterfacecCr)zz Test that attempting to register a second adapter from a class raises the appropriate exception. c@r3)zDRegistrationTests.test_duplicateAdapterForClass..TheOriginalNr5rrrrrr6rN)rrrrrtest_duplicateAdapterForClassrz/RegistrationTests.test_duplicateAdapterForClasscCr)z Test that attempting to register a second adapter from an interface raises the appropriate exception. N)rr:rrrr!test_duplicateAdapterForInterfacerz3RegistrationTests.test_duplicateAdapterForInterfacecCsdd}dd}Gdddt}t|||dt_zt||||t||d|Wdt_ndt_w|ttj||||t||d|dS) z Verify that when C{components.ALLOW_DUPLICATES} is set to C{True}, new adapter registrations for a particular from-type/interface and to-interface pair replace older registrations. cSr$rrrrrrrr&zORegistrationTests._duplicateAdapterForClassOrInterfaceAllowed..cSr$rrrrrrrr&c@r3)zSRegistrationTests._duplicateAdapterForClassOrInterfaceAllowed..TheInterfaceNr5rrrr TheInterfacer6rTNF)rrrHZALLOW_DUPLICATESrSrrkr)rr+rrrrrr+_duplicateAdapterForClassOrInterfaceAlloweds$  z=RegistrationTests._duplicateAdapterForClassOrInterfaceAllowedcCr)z Test that when L{components.ALLOW_DUPLICATES} is set to a true value, duplicate registrations from classes are allowed to override the original registration. c@r3)zKRegistrationTests.test_duplicateAdapterForClassAllowed..TheOriginalNr5rrrrrr6rN)rrrrr$test_duplicateAdapterForClassAlloweds z6RegistrationTests.test_duplicateAdapterForClassAllowedcCsGdddt}||S)z Test that when L{components.ALLOW_DUPLICATES} is set to a true value, duplicate registrations from interfaces are allowed to override the original registration. c@r3)zORegistrationTests.test_duplicateAdapterForInterfaceAllowed..TheOriginalNr5rrrrrr6rN)rrrrrr(test_duplicateAdapterForInterfaceAlloweds z:RegistrationTests.test_duplicateAdapterForInterfaceAllowedcCsHdd}t||tt|t|td||t|td|dS)zh Verify that an adapter can be registered for multiple to-interfaces at a time. cSr>rrrrrrrr&zJRegistrationTests._multipleInterfacesForClassOrInterface..N)rrHr9r:rSrrrrr&_multipleInterfacesForClassOrInterfacesz8RegistrationTests._multipleInterfacesForClassOrInterfacecCr)zi Test the registration of an adapter from a class to several interfaces at once. c@r3)zFRegistrationTests.test_multipleInterfacesForClass..TheOriginalNr5rrrrrr6rN)rrrrrtest_multipleInterfacesForClassrz1RegistrationTests.test_multipleInterfacesForClasscCr)zn Test the registration of an adapter from an interface to several interfaces at once. N)rr;rrrr#test_multipleInterfacesForInterfacerz5RegistrationTests.test_multipleInterfacesForInterfacecCsldd}dd}Gddd|}t||tt||t|t|td||t|td|dS)a  Verify that a new adapter can be registered for a particular to-interface from a subclass of a type or interface which already has an adapter registered to that interface and that the subclass adapter takes precedence over the base class adapter. cSr$rrrrrrrr&zSRegistrationTests._subclassAdapterRegistrationForClassOrInterface..cSr$rrrrrrrr&c@r3)zVRegistrationTests._subclassAdapterRegistrationForClassOrInterface..TheSubclassNr5rrrr TheSubclass r6rNr)rr+rrrrrr/_subclassAdapterRegistrationForClassOrInterfaceszARegistrationTests._subclassAdapterRegistrationForClassOrInterfacecCr)z~ Test that an adapter to a particular interface can be registered from both a class and its subclass. c@r3)zORegistrationTests.test_subclassAdapterRegistrationForClass..TheOriginalNr5rrrrrr6rN)rrrrr(test_subclassAdapterRegistrationForClassrz:RegistrationTests.test_subclassAdapterRegistrationForClasscCr)z Test that an adapter to a particular interface can be registered from both an interface and its subclass. N)rr:rrrr,test_subclassAdapterRegistrationForInterfacerz>RegistrationTests.test_subclassAdapterRegistrationForInterfaceN)rrrrErrrrrrrrrrrrrrrrrrrrks"         rc@s eZdZdZedZddZdS)IProxiedInterfacez= An interface class for use by L{proxyForInterface}. z@ An example declared attribute, which should be proxied.cOr$)z: A sample method which should be proxied. Nr)rmkwrrryay1r&zIProxiedInterface.yayN)rrrrErifaceAttributerrrrrr's  rc@r)IProxiedSubInterfacezS An interface that derives from another for use with L{proxyForInterface}. cCr$)zD A different sample method which should be proxied. Nrrrrrboo<r&zIProxiedSubInterface.booNrrrrErrrrrr7rFrc@rz)Yayablez A provider of L{IProxiedInterface} which increments a counter for every call to C{yay}. @ivar yays: The number of times C{yay} has been called. cCsd|_g|_dSr))yaysyayArgsrrrrr.Mr/zYayable.__init__cOs$|jd7_|j||f|jS)z) Increment C{self.yays}. rN)rrappendrrmrrrrrQsz Yayable.yayN)rrrrEr.rrrrrrBs rc@s(eZdZdZdZdZddZddZdS)Booablez3 An implementation of IProxiedSubInterface FcO d|_dS)z; Mark the fact that 'yay' has been called. TN)yayedrrrrre z Booable.yaycCr)z< Mark the fact that 'boo' has been called.1 TN)booedrrrrrkrz Booable.booN)rrrrErrrrrrrrrZs  rc@rz)IMultipleMethodsz- An interface with multiple methods. cCr$)z4 The first method. Should return 1. Nrrrrr methodOnewr&zIMultipleMethods.methodOnecCr$)z5 The second method. Should return 2. Nrrrrr methodTwo|r&zIMultipleMethods.methodTwoNrrrrErrrrrrrrs rc@rz)MultipleMethodImplementorz: A precise implementation of L{IMultipleMethods}. cCr$)z @return: 1 rNrrrrrrz#MultipleMethodImplementor.methodOnecCr$)z @return: 2 rINrrrrrrrz#MultipleMethodImplementor.methodTwoNrrrrrrs rc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZdS)ProxyForInterfaceTestsz) Tests for L{proxyForInterface}. cCs$t}tt|}||j|dS)z Proxy objects should have an C{original} attribute which refers to the original object passed to the constructor. N)rWr rrSr+)rr+proxyrrr test_originals z$ProxyForInterfaceTests.test_originalcCs@tt}t}||}|||d||jddS)z The class created from L{proxyForInterface} passes methods on an interface to the object which is passed to its constructor. rINr rrrrZr)rklassyayablerrrrtest_proxyMethods z'ProxyForInterfaceTests.test_proxyMethodcsDttGfddd}t}||}||d|jdS)z Methods of the class created from L{proxyForInterface} can be used with the decorator-helper L{functools.wraps}. cs"eZdZejfddZdS)z?ProxyForInterfaceTests.test_decoratedProxyMethod..klasscs|jjd7_|Sr)r+rrrbaserrrs zCProxyForInterfaceTests.test_decoratedProxyMethod..klass.yayN)rrrrrrrrrrsrrINr)rrr+rrrrtest_decoratedProxyMethods z0ProxyForInterfaceTests.test_decoratedProxyMethodcsBt}t|_tt||j|j|tfdddS)zc Proxy objects should proxy declared attributes, but not other attributes. csjSr)rrrrrrsz.N)rrWrr rrSrkAttributeError)rrrrrtest_proxyAttributes  z*ProxyForInterfaceTests.test_proxyAttributecCs0t}tt|}t}||_||j|dS)zv The attributes that proxy objects proxy should be assignable and affect the original object. N)rr rrWrrSrrrZthingyrrrtest_proxySetAttributes  z-ProxyForInterfaceTests.test_proxySetAttributecCs0t}d|_tt|}|`|t|ddS)zu The attributes that proxy objects proxy should be deletable and affect the original object. Nr)rrr r assertFalsehasattr)rrrrrrtest_proxyDeleteAttributes  z0ProxyForInterfaceTests.test_proxyDeleteAttributecCs6t}tt|}||d||ddS)z [Regression test] The proxy should send its method calls to the correct method, not the incorrect one. rrIN)rr rrZrr)rZmultirrrrtest_multipleMethodss z+ProxyForInterfaceTests.test_multipleMethodscCsJGdddtt}t}||}||jd|||jddS)zP It is possible to subclass the result of L{proxyForInterface}. c@r)zAProxyForInterfaceTests.test_subclassing..SpecializedProxyzU A specialized proxy which can decrement the number of yays. cSs|jjd8_dS)z? Decrement the number of yays. rN)r+rrrrrrszEProxyForInterfaceTests.test_subclassing..SpecializedProxy.booNrrrrrSpecializedProxyrFrrN)r rrrZrr)rrrZspecialrrrtest_subclassings  z'ProxyForInterfaceTests.test_subclassingcCstt}||jddS)zQ The name of a proxy class indicates which interface it proxies. zA(Proxy for twisted.python.test.test_components.IProxiedInterface)N)r rrZrrrrrrtest_proxyNames z%ProxyForInterfaceTests.test_proxyNamecCstt}|t|dS)zO The resulting proxy implements the interface that it proxies. N)r r assertTrueZ implementedByrrrrtest_implements sz&ProxyForInterfaceTests.test_implementscCsbGddd}|}|}||_tdd}||||j|d}||||jdS)a\ _ProxyDescriptor's __get__ method should return the appropriate attribute of its argument's 'original' attribute if it is invoked with an object. If it is invoked with None, it should return a false class-method emulator instead. For some reason, Python's documentation recommends to define descriptors' __get__ methods with the 'type' parameter as optional, despite the fact that Python itself never actually calls the descriptor that way. This is probably do to support 'foo.__get__(bar)' as an idiom. Let's make sure that the behavior is correct. Since we don't actually use the 'type' argument at all, this test calls it the idiomatic way to ensure that signature works; test_proxyInheritance verifies the how-Python-actually-calls-it signature. c@r)z>ProxyForInterfaceTests.test_proxyDescriptorGet..SampleFcSs d|_dSr)calledrrrrre&rxzDProxyForInterfaceTests.test_proxyDescriptorGet..Sample.helloN)rrrrrerrrrSample#rrrer+N)r+rZ_ProxyDescriptorrZ__get__rerr)rrZ fakeProxyZ testObjectpdZfakeClassMethodrrrtest_proxyDescriptorGets  z.ProxyForInterfaceTests.test_proxyDescriptorGetcspGdddttGfddd}t}||}||jddddd d ||jd tddd fgd S) z Subclasses of the class returned from L{proxyForInterface} should be able to upcall methods by reference to their superclass, as any normal Python class can. c@seZdZdZdS)zDProxyForInterfaceTests.test_proxyInheritance..YayableWrapperzI This class does not override any functionality. N)rrrrErrrrYayableWrapper9srcs eZdZdZdZfddZdS)zEProxyForInterfaceTests.test_proxyInheritance..EnhancedWrapperz@ This class overrides the 'yay' method. rcs*|jd7_j|g|Ri|dS)Nr) wrappedYaysr)rrmkrrrrEszIProxyForInterfaceTests.test_proxyInheritance..EnhancedWrapper.yayN)rrrrErrrrrrEnhancedWrapper>srr)ry)rrN)r rrrZrrdict)rrrwrapperrrrtest_proxyInheritance2s   z,ProxyForInterfaceTests.test_proxyInheritancecCsBtt}t}||}||||j||jdS)z Proxies of subinterfaces generated with proxyForInterface should allow access to attributes of both the child and the base interfaces. N)r rrrrrrr)rZ proxyClassZbooablerrrrtest_interfaceInheritanceNs z0ProxyForInterfaceTests.test_interfaceInheritancecCs~t}t|_ttdd|}||j|||d||j|jt}||_||j||`| t |ddS)a The original attribute name can be customized via the C{originalAttribute} argument of L{proxyForInterface}: the attribute should change, but the methods of the original object should still be callable, and the attributes still accessible. foo)ZoriginalAttributerrN) rrWrr rrSrrZrrrrrrrtest_attributeCustomization[sz2ProxyForInterfaceTests.test_attributeCustomizationN)rrrrErrrrrrrrrrrrrrrrrrrs          rN);rE functoolsrZzope.interfacerrrZzope.interface.adapterrZtwisted.pythonrZtwisted.python.compatrr Ztwisted.python.componentsr r r Z twisted.trialr rVrrr#r|r(r0r4r7r8r9r:r;r<r=r@rAZSynchronousTestCaserGrjrorprurvryr{r~rrrrrrrrrrrrrrrrsp      l    =