o bd@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|_|jSNnumselfrE/usr/lib/python3/dist-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)rrrtemporaryAdapterr.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. globalRegistryN)rpatchrr addCleanupr )rscratchRegistryhookrrrsetUpiszRegistryUsingMixin.setUpN)rrr__doc__rHrrrrrBd rBc@s`eZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ dS)ComponentizedTestsz8 Simple test case for caching in Componentized. cCs8t|tttttttttttt dSr) rBrHrregisterAdapterr=r4r9r;r@r:rrrrrH~s zComponentizedTests.setUpcCsjttttttttt}|tdksJ|tdks'Jtt| dks3JdS)N)rr)rMr) rrLr(rrr0r# getComponentr!r%rcrrrtestComponentizeds z$ComponentizedTests.testComponentizedcCst}|t}|t}|t}|t}||usJ||us#J|||t}|t}||us8J||us>JdSr)r8rNr9r:removeComponent)rrPco1co2co3co4co5co6rrrtestInheritanceAdaptations          z,ComponentizedTests.testInheritanceAdaptationcCs>t}|t}|t}|t}|||||dSr)r8rNr9r;r< assertIsNoneassertIs)rrPrSrUrVrrrtestMultiAdapters     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 Componentizedobjectr[rNr9)r componentizedr]rrrtest_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) rr^ setAdapterrr(rN assertEqualr+assertIsInstancerr` 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) ignoreClassN) rr^ addAdapterr(rNrrcr+rdrerrrtest_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)rr^r_ setComponentr9r[rNrr`objrrrtest_setComponents z$ComponentizedTests.test_setComponentcCs8t}t}|t||t||tdS)zm C{Componentized.setComponent} removes the cached component for the given interface. N)rr^r_rkr9unsetComponentrZrNrlrrrtest_unsetComponents   z&ComponentizedTests.test_unsetComponentcCs8t}|tdt|}|d||d|dS)zR C{ReprableComponentized} has a C{__repr__} that lists its cache. hellor9N)rReprableComponentizedrkr9reprassertIn)rrcresultrrrtest_reprableComponentizeds   z-ComponentizedTests.test_reprableComponentizedN)rrrrIrHrQrYr\rargrjrnrprwrrrrrKys     rKc@r) AdapterTestszTest adapters.cCs2t}t|}|tjt||t|ddSr)r_r( assertRaisesr CannotAdaptr9rZ)roarrrtestAdapterGetComponentsz$AdapterTests.testAdapterGetComponentN)rrrrIr}rrrrrxrrxc@r3)IMetaNr5rrrrr~r6r~c@r) MetaAddercCs |jj|Srr*rrrrradd z MetaAdder.addNrrrrrrrrrr2rc@r)BackwardsAddercCs |jj|Srr*rrrrrrzBackwardsAdder.addNrrrrrrr2rc@r) MetaNumberz9 Integer wrapper for Interface adaptation tests. cC ||_dSrrrrrrr. zMetaNumber.__init__N)rrrrIr.rrrrrrJrc@r)ComponentNumbercCsd|_tj|dSr))rrr^r.rrrrr. szComponentNumber.__init__Nr?rrrrrr"rc@ eZdZdZddZddZdS)ComponentAdderz0 Adder for componentized adapter tests. cCstj|||jj|_dSr)rAdapterr.r+rrr+rrrr.szComponentAdder.__init__cCs|j|7_|jSrrrrrrrszComponentAdder.addN)rrrrIr.rrrrrrs rc@r)IAttrXz= Base interface for test of adapter with C{__cmp__}. cCr$)z! Return a value. Nrrrrrx"r&zIAttrX.xNrrrrIrrrrrrrJrc@r)IAttrXXz@ Adapted interface for test of adapter with C{__cmp__}. cCr$)z+ Return a tuple of values. Nrrrrrxx-r&z IAttrXX.xxN)rrrrIrrrrrr(rJrc@r)XcellentzG L{IAttrX} implementation for test of adapter with C{__cmp__}. cCr$)z; Return a value. @return: a value x!rrrrrr9sz Xcellent.xNrrrrrr3s rc@s,eZdZdZdZddZddZddZd S) DoubleXAdapterz Adapter with __cmp__. *cCrr)r+rrrrr.JrzDoubleXAdapter.__init__cCs|j|jfSr)r+rrrrrrMszDoubleXAdapter.xxcCst|j|jSr)rr)rotherrrr__cmp__PszDoubleXAdapter.__cmp__N)rrrrIrr.rrrrrrrBs  rc@s$eZdZddZddZddZdS)MetaInterfaceTestscCs0tttttd}|t|dddS)zS Registered adapters can be used to adapt classes to an interface. rrMN)rrLrrr~rcr)rnrrr test_basicUszMetaInterfaceTests.test_basiccCsJttttt}t|dt|d|t|dddS)Nr)rrLrrr~rrcrOrrrtestComponentizedInteraction]s z/MetaInterfaceTests.testComponentizedInteractioncCs,tttttt}|d|dS)N)rr)rrLrrrrrcr)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>rrr{rrrvr&zGRegistrationTests._registerAdapterForClassOrInterface..NrrLr9r[getAdapterFactoryrr+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 TheOriginalr6r)rrrrrrtest_registerAdapterForClassz z.RegistrationTests.test_registerAdapterForClasscC |tS)zf Test that an adapter from an interface can be registered and then looked up. )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)rrLr9ry ValueErrorr[r)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..TheOriginalNr5rrrrrr6r)rrrrrtest_duplicateAdapterForClassrz/RegistrationTests.test_duplicateAdapterForClasscCr)z Test that attempting to register a second adapter from an interface raises the appropriate exception. )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)rrrLALLOW_DUPLICATESr[rryr)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..TheOriginalNr5rrrrrr6r)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..TheOriginalNr5rrrrrr6r)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)rrLr9r:r[rrrrr&_multipleInterfacesForClassOrInterfacesz8RegistrationTests._multipleInterfacesForClassOrInterfacecCr)zi Test the registration of an adapter from a class to several interfaces at once. c@r3)zFRegistrationTests.test_multipleInterfacesForClass..TheOriginalNr5rrrrrr6r)rrrrrtest_multipleInterfacesForClassrz1RegistrationTests.test_multipleInterfacesForClasscCr)zn Test the registration of an adapter from an interface to several interfaces at once. )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..TheOriginalNr5rrrrrr6r)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. )rr:rrrr,test_subclassAdapterRegistrationForInterfacerz>RegistrationTests.test_subclassAdapterRegistrationForInterfaceN)rrrrIrrrrrrrrrrrrrrrrrrrrks"         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)r|kwrrryay1r&zIProxiedInterface.yayN)rrrrIrifaceAttributerrrrrr'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.booNrrrrIrrrrrr7rJrc@r)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}. r)rrappendrr|rrrrrQsz Yayable.yayN)rrrrIr.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)rrrrIrrrrrrrrrZs  rc@r)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.methodTwoNrrrrIrrrrrrrrs rc@r)MultipleMethodImplementorz: A precise implementation of L{IMultipleMethods}. cCr$)z @return: 1 rrrrrrrz#MultipleMethodImplementor.methodOnecCr$)z @return: 2 rMrrrrrrrz#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)r_r rr[r+)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. rMNr rrrrcr)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)rrrrrrrrrrsrrMNr)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)rr_rr rr[ryAttributeError)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 rr_rr[rrrthingyrrrtest_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. rrMN)rr rrcrr)rmultirrrrtest_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.booNrrrrrSpecializedProxyrJrrN)r rrrcrr)rrrspecialrrrtest_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 rrcrrrrrrtest_proxyNames z%ProxyForInterfaceTests.test_proxyNamecCstt}|t|dS)zO The resulting proxy implements the interface that it proxies. N)r r assertTrue 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)calledrrrrrq&rzDProxyForInterfaceTests.test_proxyDescriptorGet..Sample.helloN)rrrrrqrrrrSample#rrrqr+N)r+r_ProxyDescriptorrc__get__rqrr)rr fakeProxy testObjectpdfakeClassMethodrrrtest_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)rrrrIrrrrYayableWrapper9srcs eZdZdZdZfddZdS)zEProxyForInterfaceTests.test_proxyInheritance..EnhancedWrapperz@ This class overrides the 'yay' method. rcs*|jd7_j|g|Ri|dS)Nr) wrappedYaysr)rr|krrrrEszIProxyForInterfaceTests.test_proxyInheritance..EnhancedWrapper.yayN)rrrrIrrrrrrEnhancedWrapper>srr)ry)rrN)r rrrcrrdict)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)r proxyClassbooablerrrrtest_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)originalAttributerrN) rr_rr rr[rrcrrrrrrrtest_attributeCustomization[sz2ProxyForInterfaceTests.test_attributeCustomizationN)rrrrIrrrrrrrrrrrr rrrrrrrs          rN);rI functoolsrzope.interfacerrrzope.interface.adapterrtwisted.pythonrtwisted.python.compatrr twisted.python.componentsr r r twisted.trialr r^rrr#rr(r0r4r7r8r9r:r;r<r=r@rBSynchronousTestCaserKrxr~rrrrrrrrrrrrrrrrrrrrrrsp      l    =