U 1ܟj3V@sddlZddlZddlZddlZddlZddlZddlmZmZddZ GdddeZ ee dGdd d e Z ee dGd d d e Z ee dGd d d eZ ee dGddde ZdS)N)skipIfTestCasecCs,z tdWntk r"YdSXdSdS)NZtwistedFT) __import__ ImportErrorrr?/tmp/pip-unpacked-wheel-43vki919/automat/_test/test_discover.pyisTwistedInstalled s  rcs\eZdZdZfddZfddZddZdd Zd d Zd d Z ddZ ddZ Z S)_WritesPythonModuleszG A helper that enables generating Python module test fixtures. csvtt|ddlm}m}ddlm}||_||_||_tt j |_ t j dd|_t|_||jdS)Nr) getModule PythonPath)FilePath)superr setUptwisted.python.modulesr r Ztwisted.python.filepathr setsysmoduleskeysoriginalSysModulespath savedSysPathtempfilemkdtemppathDirmakeImportable)selfr r r  __class__rrrs  z_WritesPythonModules.setUpcsPtt||jtjdd<tj|j}|D] }tj|=q2t |j dSN) r r tearDownrrrrrrshutilrmtreer)rZmodulesToDeletemodulerrrr(s  z_WritesPythonModules.tearDowncCstj|dSr)rrappend)rrrrrr2sz#_WritesPythonModules.makeImportablec CsJ||}||}t|jd}|t|W5QRX||jgS)Nw)r childopenrwritetextwrapdedentr )rsourcer moduleName directoryr"frrrwriteSourceInto5s   z$_WritesPythonModules.writeSourceIntocCs"tj|\}}|||||Sr)osrsplitextr.)rr*rr+ZpythonModuleName_rrr makeModule@sz_WritesPythonModules.makeModulecCsdd|DS)NcSsi|] }|j|qSr)name).0attrrrr Esz9_WritesPythonModules.attributesAsDict..)ZiterAttributes)rZhasIterAttributesrrrattributesAsDictDsz%_WritesPythonModules.attributesAsDictcCs|||Sr)loadr7)rr"rrrloadModuleAsDictGsz%_WritesPythonModules.loadModuleAsDictcCs|||||Sr)r9r2)rr*rr3rrrmakeModuleAsDictKsz%_WritesPythonModules.makeModuleAsDict) __name__ __module__ __qualname____doc__rrrr.r2r7r9r: __classcell__rrrrr s   r zTwisted is not installed.cs8eZdZdZfddZddZddZdd ZZS) OriginalLocationTestsa Tests that L{isOriginalLocation} detects when a L{PythonAttribute}'s FQPN refers to an object inside the module where it was defined. For example: A L{twisted.python.modules.PythonAttribute} with a name of 'foo.bar' that refers to a 'bar' object defined in module 'baz' does *not* refer to bar's original location, while a L{PythonAttribute} with a name of 'baz.bar' does. cs$tt|ddlm}||_dS)N)isOriginalLocation)r r@r _discoverrB)rrBrrrr]s zOriginalLocationTests.setUpcCs,d}|||jd}|||ddS)z L{isOriginalLocation} returns False when the attribute refers to an object whose source module cannot be determined. z~ class Fake(object): pass hasEmptyModule = Fake() hasEmptyModule.__module__ = None zempty_module_attr.pyz empty_module_attr.hasEmptyModuleN)r:r assertFalserB)rr* moduleDictrrrtest_failsWithNoModulecs  z,OriginalLocationTests.test_failsWithNoModulecCs~d}d}|||jd|||jd}|||d|||d|d}||}|d}|||d S) z L{isOriginalLocation} returns False when the attribute refers to an object outside of the module where that object was defined. z class ImportThisClass(object): pass importThisObject = ImportThisClass() importThisNestingObject = ImportThisClass() importThisNestingObject.nestedObject = ImportThisClass() z from original import (ImportThisClass, importThisObject, importThisNestingObject) original.py importing.pyzimporting.ImportThisClasszimporting.importThisObjectz!importing.importThisNestingObjectz.importing.importThisNestingObject.nestedObjectN)r2rr:rDrBr7)roriginalSourceimportingSourceZ importingDict nestingObjectnestingObjectDict nestedObjectrrrtest_failsWithDifferentModuleus(   z3OriginalLocationTests.test_failsWithDifferentModulecCsptd}|||jd}|||d|||d|d}||}|d}|||dS)z L{isOriginalLocation} returns True when the attribute refers to an object inside the module where that object was defined. z class ThisClassWasDefinedHere(object): pass anObject = ThisClassWasDefinedHere() aNestingObject = ThisClassWasDefinedHere() aNestingObject.nestedObject = ThisClassWasDefinedHere() zm.pyzm.ThisClassWasDefinedHerezm.aNestingObjectzm.aNestingObject.nestedObjectN)r(r)r:r assertTruerBr7)rZmSourceZmDictrKrLrMrrrtest_succeedsWithSameModules  z1OriginalLocationTests.test_succeedsWithSameModule) r;r<r=r>rrFrNrPr?rrrrr@Os  &r@csveZdZdZfddZddZdddd Zd d Zd d ZddZ ddZ ddZ ddZ ddZ ddZZS)FindMachinesViaWrapperTestsz L{findMachinesViaWrapper} recursively yields FQPN, L{MethodicalMachine} pairs in and under a given L{twisted.python.modules.PythonModule} or L{twisted.python.modules.PythonAttribute}. cs$tt|ddlm}||_dS)NrA)findMachinesViaWrapper)r rQrrCrR)rrRrrrrs z!FindMachinesViaWrapperTests.setUpcCs>d}|||jd}|d}|d|ft||dS)z When given a L{twisted.python.modules.PythonAttribute} that refers directly to a L{MethodicalMachine}, L{findMachinesViaWrapper} yields that machine and its FQPN. a from automat import MethodicalMachine rootMachine = MethodicalMachine() root.pyroot.rootMachineNr:rassertInr8listrRrr*rE rootMachinerrrtest_yieldsMachines  z.FindMachinesViaWrapperTests.test_yieldsMachineN)returncCs>d}|||jd}|d}|d|ft||dS)z When given a L{twisted.python.modules.PythonAttribute} that refers directly to a L{TypeMachine}, L{findMachinesViaWrapper} yields that machine and its FQPN. ae from automat import TypeMachineBuilder from typing import Protocol, Callable class P(Protocol): def method(self) -> None: ... class C:... def buildBuilder() -> Callable[[C], P]: builder = TypeMachineBuilder(P, C) return builder.build() rootMachine = buildBuilder() rTrUNrVrYrrrtest_yieldsTypeMachines   z2FindMachinesViaWrapperTests.test_yieldsTypeMachinecCs@d}|||jd}|d}|d|jft||dS)z When given a L{twisted.python.modules.PythonAttribute} that refers to a class that contains a L{MethodicalMachine} as a class variable, L{findMachinesViaWrapper} yields that machine and its FQPN. from automat import MethodicalMachine class PythonClass(object): _classMachine = MethodicalMachine() clsmod.pyclsmod.PythonClass clsmod.PythonClass._classMachineN)r:rrWr8 _classMachinerXrRrr*rE PythonClassrrrtest_yieldsMachineInClasss  z5FindMachinesViaWrapperTests.test_yieldsMachineInClasscCsBd}|||jd}|d}|d|jjft||dS)z When given a L{twisted.python.modules.PythonAttribute} that refers to a nested class that contains a L{MethodicalMachine} as a class variable, L{findMachinesViaWrapper} yields that machine and its FQPN. from automat import MethodicalMachine class PythonClass(object): class NestedClass(object): _classMachine = MethodicalMachine() nestedcls.pynestedcls.PythonClass/nestedcls.PythonClass.NestedClass._classMachineN)r:rrWr8 NestedClassrbrXrRrcrrrtest_yieldsMachineInNestedClasss  z;FindMachinesViaWrapperTests.test_yieldsMachineInNestedClasscCsDd}|||jd}||d}|d|ft||dS)z When given a L{twisted.python.modules.PythonModule} that refers to a module that contains a L{MethodicalMachine}, L{findMachinesViaWrapper} yields that machine and its FQPN. rSrTrUN)r2rr9r8rWrXrR)rr*r"rZrrrtest_yieldsMachineInModules z6FindMachinesViaWrapperTests.test_yieldsMachineInModulecCsFd}|||jd}||d}|d|jft||dS)z When given a L{twisted.python.modules.PythonModule} that refers to the original module of a class containing a L{MethodicalMachine}, L{findMachinesViaWrapper} yields that machine and its FQPN. r^r_r`raN)r2rr9r8rWrbrXrRrr*r"rdrrr!test_yieldsMachineInClassInModule-s z=FindMachinesViaWrapperTests.test_yieldsMachineInClassInModulecCsHd}|||jd}||d}|d|jjft||dS)z When given a L{twisted.python.modules.PythonModule} that refers to the original module of a nested class containing a L{MethodicalMachine}, L{findMachinesViaWrapper} yields that machine and its FQPN. rfrgrhriN) r2rr9r8rWrjrbrXrRrmrrr'test_yieldsMachineInNestedClassInModuleAs zCFindMachinesViaWrapperTests.test_yieldsMachineInNestedClassInModulecCs@d}d}|||jd|||jd}|t||dS)aM When given a L{twisted.python.modules.PythonAttribute} that refers to a class imported from another module, any L{MethodicalMachine}s on that class are ignored. This behavior ensures that a machine is only discovered on a class when visiting the module where that class was defined. z from automat import MethodicalMachine class PythonClass(object): _classMachine = MethodicalMachine() z2 from original import PythonClass rGrHNr2rrDrXrR)rrIrJZimportingModulerrrtest_ignoresImportedClassZs z5FindMachinesViaWrapperTests.test_ignoresImportedClassc Cs||jg}||jd}||dd}|||jd|d}t| |t dd}| |d}|d }|d  }td|fd |jfgt dd} || |d S) z` L{findMachinesViaWrapper} descends into packages to discover machines. test_package __init__.pyz from automat import MethodicalMachine class PythonClass(object): _classMachine = MethodicalMachine() rootMachine = MethodicalMachine() module.pyrkeyr"ztest_package.module.rootMachineztest_package.module.PythonClassz-test_package.module.PythonClass._classMachineN)r rr r%makedirstouchr2rsortedrRoperator itemgetterr9r8rb assertEqual) r pythonPathpackager*rrmachinesrErZrdexpectedMachinesrrrtest_descendsIntoPackagesss.    z5FindMachinesViaWrapperTests.test_descendsIntoPackagescCs,d}|||jd}|t||dS)z L{findMachinesViaWrapper} ignores infinite loops. Note this test can't fail - it can only run forever! zh class InfiniteLoop(object): pass InfiniteLoop.loop = InfiniteLoop zloop.pyNrp)rr*r"rrrtest_infiniteLoopsz-FindMachinesViaWrapperTests.test_infiniteLoop)r;r<r=r>rr[r]rerkrlrnrorqrrr?rrrrrQs ,rQc@sxeZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZdS) WrapFQPNTestsz Tests that ensure L{wrapFQPN} loads the L{twisted.python.modules.PythonModule} or L{twisted.python.modules.PythonAttribute} for a given FQPN. cCsPddlm}m}ddlm}m}m}m}||_||_||_||_||_||_dS)Nr) PythonModulePythonAttributerA)wrapFQPN InvalidFQPNNoModuleNoObject)rrrrCrrrr)rrrrrrrrrrrszWrapFQPNTests.setUpcCs2|||j||j|j|||dS)zt Assert that a L{twisted.python.modules.PythonModule} refers to a particular Python module. N)assertIsInstancerr|r3r;assertIsr8)r moduleWrapperr"rrrassertModuleWrapperRefersTosz)WrapFQPNTests.assertModuleWrapperRefersTocCs0|||j||j||||dS)zw Assert that a L{twisted.python.modules.PythonAttribute} refers to a particular Python object. N)rrr|r3rr8)rZattributeWrapperfqpnobjrrrassertAttributeWrapperRefersTosz,WrapFQPNTests.assertAttributeWrapperRefersToc Cs&||j|dW5QRXdS)zO L{wrapFQPN} raises L{InvalidFQPN} when given an empty string. N assertRaisesrrrrrrtest_failsWithEmptyFQPNsz%WrapFQPNTests.test_failsWithEmptyFQPNc Cs0dD]&}||j||W5QRXqdS)zl " L{wrapFQPN} raises L{InvalidFQPN} when given a badly-dotted FQPN. (e.g., x..y). )z.failszfails.z this..failsNrrbadrrrtest_failsWithBadDottingsz&WrapFQPNTests.test_failsWithBadDottingcCs4ddl}|d}|||j|||dS)z L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the single module a dotless FQPN describes. rNr/)r/rrrrr8)rr/rrrrtest_singleModules zWrapFQPNTests.test_singleModulec Cs&||j|dW5QRXdS)z~ L{wrapFQPN} raises L{NoModule} when given a dotless FQPN that does not refer to a module or package. zthis is not an acceptable name!N)rrrrrrr*test_failsWithMissingSingleModuleOrPackagesz8WrapFQPNTests.test_failsWithMissingSingleModuleOrPackagecCsddl}||d|dS)z L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the single package a dotless FQPN describes. rNxml)rrrrrrrrtest_singlePackagesz WrapFQPNTests.test_singlePackagecCs ddl}||d|jdS)z L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the deepest package described by dotted FQPN. rNz xml.etree)Z xml.etreerretreerrrrtest_multiplePackagessz#WrapFQPNTests.test_multiplePackagescCs"ddl}||d|jjdS)z L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the deepest module described by dotted FQPN. rNzxml.etree.ElementTree)xml.etree.ElementTreerrr ElementTreerrrr test_multiplePackagesFinalModule s z.WrapFQPNTests.test_multiplePackagesFinalModulecCs"ddl}||dd|jdS)z L{wrapFQPN} returns a L{twisted.python.modules.PythonAttribute} referring to the deepest object an FQPN names, traversing one module. rNzos.path)r/rrr)rr/rrrtest_singleModuleObjects z%WrapFQPNTests.test_singleModuleObjectcCsLddl}ddl}d|jjjfd|jjffD]\}}|||||q*dS)z L{wrapFQPN} returns a L{twisted.python.modules.PythonAttribute} referring to the deepest object described by an FQPN, descending through several packages. rNz xml.etree.ElementTree.fromstringz!automat.MethodicalMachine.__doc__) rautomatrr fromstringZMethodicalMachiner>rr)rrrrrrrrtest_multiplePackagesObject s   z)WrapFQPNTests.test_multiplePackagesObjectc Cs0dD]&}||j||W5QRXqdS)z L{wrapFQPN} raises L{NoObject} when given an FQPN that contains a missing attribute, module, or package. )zxml.etree.nope!z*xml.etree.nope!.but.the.rest.is.believableN)rrrrrrr4test_failsWithMultiplePackagesMissingModuleOrPackage/szBWrapFQPNTests.test_failsWithMultiplePackagesMissingModuleOrPackageN)r;r<r=r>rrrrrrrrrrrrrrrrrrs         rcs,eZdZdZdZfddZddZZS)FindMachinesIntegrationTestszs Integration tests to check that L{findMachines} yields all machines discoverable at or below an FQPN. z from automat import MethodicalMachine class PythonClass(object): _machine = MethodicalMachine() ignored = "i am ignored" rootLevel = MethodicalMachine() ignored = "i am ignored" cstt|ddlm}||_||jd}|| |jg|_ | |j |j d|d}||d||j |j d||j d|_||j ddd|_dS)NrA) findMachinesrrrsZ subpackagertr")r rrrCrr rr%rwr r}r.SOURCErrxr2r9 packageDictrE)rrZ packageDirZ subPackageDirrrrrLs  z"FindMachinesIntegrationTests.setUpc Cst|dtdd}|jd}|jd}|jd}|}|jd}|}td|fd|jfd|fd |jfgtdd}|||d S) z Given a top-level package FQPN, L{findMachines} discovers all L{MethodicalMachine} instances in and below it. rrrruztest_package.rootLevelztest_package.PythonClassz(test_package.subpackage.module.rootLevelz*test_package.subpackage.module.PythonClassz!test_package.PythonClass._machinez3test_package.subpackage.module.PythonClass._machineN) ryrrzr{rr8rEZ_machiner|) rrZ tpRootLevelZ tpPythonClassZmRLAttrZ mRootLevelZmPCAttrZ mPythonClassrrrrtest_discoverAllbs$    z-FindMachinesIntegrationTests.test_discoverAll)r;r<r=r>rrrr?rrrrr9s r)rzr/r rr(rZunittestrrrr r@rQrrrrrrs$ < d {