o q+WZVUć@sÜddlZddlZddlZddlZddlZddlZddlmZmZddl Z dd„Z Gdd„deƒZ ee ƒ dƒGdd „d e ƒƒZ ee ƒ dƒGd d „d e ƒƒZ ee ƒ dƒGd d „d eƒƒZee ƒ dƒGdd„de ƒƒZdS)éN)ŚskipIfŚTestCasecCs$ztdƒWdStyYdSw)NZtwistedFT)Ś __import__Ś ImportError©rrś=/usr/lib/python3/dist-packages/automat/_test/test_discover.pyŚisTwistedInstalled s   ż’rcs\eZdZdZ‡fdd„Z‡fdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z ‡Z S)Ś_WritesPythonModuleszG A helper that enables generating Python module test fixtures. csvtt|ƒ ”ddlm}m}ddlm}||_||_||_tt j   ”ƒ|_ t j dd…|_t ”|_| |j”dS)Nr)Ś getModuleŚ PythonPath)ŚFilePath)Śsuperr ŚsetUpŚtwisted.python.modulesr r Ztwisted.python.filepathr ŚsetŚsysŚmodulesŚkeysŚoriginalSysModulesŚpathŚ savedSysPathŚtempfileZmkdtempŚpathDirŚmakeImportable)Śselfr r r ©Ś __class__rrrs  z_WritesPythonModules.setUpcsRtt|ƒ ”|jtjdd…<t tj”|j }|D]}tj|=qt   |j ”dS©N) r r ŚtearDownrrrŚsixZviewkeysrrŚshutilŚrmtreer)rZmodulesToDeleteŚmodulerrrr*s  z_WritesPythonModules.tearDowncCstj |”dSr)rrŚappend)rrrrrr4sz#_WritesPythonModules.makeImportablecCs^| |”}| |”}t|jdƒ}| t |””Wdƒn1s#wY| |jg”S)NŚw)r ŚchildŚopenrŚwriteŚtextwrapŚdedentr )rŚsourcerŚ moduleNameZ directoryr"ŚfrrrŚwriteSourceInto7s  ’z$_WritesPythonModules.writeSourceIntocCs"tj |”\}}| |||”|Sr)ŚosrŚsplitextr-)rr*rr+ZpythonModuleNameŚ_rrrŚ makeModuleBsz_WritesPythonModules.makeModulecCsdd„| ”DƒS)NcSsi|]}|j|“qSr)Śname)Ś.0ŚattrrrrŚ Gsz9_WritesPythonModules.attributesAsDict..)ZiterAttributes)rZhasIterAttributesrrrŚattributesAsDictFsz%_WritesPythonModules.attributesAsDictcCs| ”| |”Sr)Śloadr6)rr"rrrŚloadModuleAsDictIs z%_WritesPythonModules.loadModuleAsDictcCs| | |||””Sr)r8r1)rr*rr2rrrŚmakeModuleAsDictMsz%_WritesPythonModules.makeModuleAsDict) Ś__name__Ś __module__Ś __qualname__Ś__doc__rrrr-r1r6r8r9Ś __classcell__rrrrr s    r zTwisted is not installed.cs8eZdZdZ‡fdd„Zdd„Zdd„Zdd „Z‡ZS) Ś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. có$tt|ƒ ”ddlm}||_dS)Né)ŚisOriginalLocation)r r?rŚ _discoverrB)rrBrrrr^ó  zOriginalLocationTests.setUpcCs,d}| ||jd”}| | |d””dS)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)r9rŚ assertFalserB)rr*Ś moduleDictrrrŚtest_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)r1rr9rErBr6)rŚoriginalSourceŚimportingSourceZ importingDictŚ nestingObjectŚnestingObjectDictŚ nestedObjectrrrŚtest_failsWithDifferentModulevs.ž’’’’ ’z3OriginalLocationTests.test_failsWithDifferentModulecCspt d”}| ||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)r9rZ assertTruerBr6)rZmSourceZmDictrLrMrNrrrŚtest_succeedsWithSameModule›s ’ z1OriginalLocationTests.test_succeedsWithSameModule) r:r;r<r=rrGrOrPr>rrrrr?Qs  %r?csleZdZdZdZ‡fdd„Zdd„Zdd„Zd d „Zd d „Z d d„Z dd„Z dd„Z dd„Z dd„Z‡ZS)Ś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}. aŹ from automat import MethodicalMachine class PythonClass(object): _classMachine = MethodicalMachine() class NestedClass(object): _nestedClassMachine = MethodicalMachine() ignoredAttribute = "I am ignored." def ignoredMethod(self): "I am also ignored." rootLevelMachine = MethodicalMachine() ignoredPythonObject = PythonClass() anotherIgnoredPythonObject = "I am ignored." cr@)NrA)ŚfindMachinesViaWrapper)r rQrrCrR)rrRrrrrĻrDz!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.pyśroot.rootMachineN)r9rŚassertInr7ŚlistrR)rr*rFŚ rootMachinerrrŚtest_yieldsMachineŌs  ’z.FindMachinesViaWrapperTests.test_yieldsMachinecCs@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.pyśclsmod.PythonClassś clsmod.PythonClass._classMachineN)r9rrVr7Ś _classMachinerWrR©rr*rFŚ PythonClassrrrŚtest_yieldsMachineInClassås’ ž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.pyśnestedcls.PythonClassś/nestedcls.PythonClass.NestedClass._classMachineN)r9rrVr7Ś NestedClassr^rWrRr_rrrŚtest_yieldsMachineInNestedClassųsž ’ ž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)r1rr8r7rVrWrR)rr*r"rXrrrŚtest_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. rZr[r\r]N)r1rr8r7rVr^rWrR©rr*r"r`rrrŚ!test_yieldsMachineInClassInModules’’’’ ž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. rbrcrdreN) r1rr8r7rVrfr^rWrRrirrrŚ'test_yieldsMachineInNestedClassInModule3s’’’’ ž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 rHrIN©r1rrErWrR)rrJrKZimportingModulerrrŚtest_ignoresImportedClassIs žz5FindMachinesViaWrapperTests.test_ignoresImportedClassc CsĄ| |jg”}| |j” d”}| ”| d” ”d}| ||jd”|d}t|  |”t   d”d}|  |d”}|d  ”}|d   ”}td|fd |jfgt   d”d} | | |”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.pyr©Śkeyr"ztest_package.module.rootMachineztest_package.module.PythonClassz-test_package.module.PythonClass._classMachineN)r rr r%ŚmakedirsŚtouchr1rŚsortedrRŚoperatorŚ itemgetterr8r7r^Ś assertEqual) rŚ pythonPathŚpackager*rnŚmachinesrFrXr`ŚexpectedMachinesrrrŚtest_descendsIntoPackagesds0  ’  ’’žü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.pyNrl)rr*r"rrrŚtest_infiniteLoopŠsz-FindMachinesViaWrapperTests.test_infiniteLoop)r:r;r<r=ZTEST_MODULE_SOURCErrYrargrhrjrkrmr}r~r>rrrrrQ³s &rQc@sxeZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„ZdS)Ś 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)Ś PythonModuleŚPythonAttributerA)ŚwrapFQPNŚ InvalidFQPNŚNoModuleŚNoObject)rr€rrCr‚rƒr„r…)rr€rr‚rƒr„r…rrrr¢s zWrapFQPNTests.setUpcCs2| ||j”| |j|j”| | ”|”dS)zt Assert that a L{twisted.python.modules.PythonModule} refers to a particular Python module. N)ŚassertIsInstancer€rxr2r:ŚassertIsr7)rŚ moduleWrapperr"rrrŚassertModuleWrapperRefersTo­sz)WrapFQPNTests.assertModuleWrapperRefersTocCs0| ||j”| |j|”| | ”|”dS)zw Assert that a L{twisted.python.modules.PythonAttribute} refers to a particular Python object. N)r†rrxr2r‡r7)rZattributeWrapperŚfqpnŚobjrrrŚassertAttributeWrapperRefersTo¶sz,WrapFQPNTests.assertAttributeWrapperRefersTocCó<| |j”| d”WdƒdS1swYdS)zO L{wrapFQPN} raises L{InvalidFQPN} when given an empty string. ŚN©Ś assertRaisesrƒr‚©rrrrŚtest_failsWithEmptyFQPNæs "’z%WrapFQPNTests.test_failsWithEmptyFQPNc CóDdD]}| |j” | |”Wdƒn1swYqdS)zk" L{wrapFQPN} raises L{InvalidFQPN} when given a badly-dotted FQPN. (e.g., x..y). )z.failszfails.z this..failsNr©rZbadrrrŚtest_failsWithBadDottingĘs  ’€’z&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.r‚r†r€r‡r7)rr.rˆrrrŚtest_singleModuleĻs zWrapFQPNTests.test_singleModulecCr)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)rr„r‚r‘rrrŚ*test_failsWithMissingSingleModuleOrPackageŪs "’z8WrapFQPNTests.test_failsWithMissingSingleModuleOrPackagecCsddl}| | d”|”dS)z L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the single package a dotless FQPN describes. rNŚxml)r˜r‰r‚©rr˜rrrŚtest_singlePackagećsz WrapFQPNTests.test_singlePackagecCs ddl}| | d”|j”dS)z‘ L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the deepest package described by dotted FQPN. rNz xml.etree)Z xml.etreer‰r‚Śetreer™rrrŚtest_multiplePackagesėsz#WrapFQPNTests.test_multiplePackagescCs"ddl}| | d”|jj”dS)z L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the deepest module described by dotted FQPN. rNzxml.etree.ElementTree)Śxml.etree.ElementTreer‰r‚r›Ś ElementTreer™rrrŚ test_multiplePackagesFinalModuleóó’z.WrapFQPNTests.test_multiplePackagesFinalModulecCs"ddl}| | d”d|j”dS)zŸ L{wrapFQPN} returns a L{twisted.python.modules.PythonAttribute} referring to the deepest object an FQPN names, traversing one module. rNzos.path)r.rŒr‚r)rr.rrrŚtest_singleModuleObjectür z%WrapFQPNTests.test_singleModuleObjectcCsLddl}ddl}d|jjjfd|jjffD]\}}| | |”||”qdS)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__) rŚautomatr›ržZ fromstringZMethodicalMachiner=rŒr‚)rr˜r¢rŠr‹rrrŚtest_multiplePackagesObjects’’ ž ’üz)WrapFQPNTests.test_multiplePackagesObjectc Cr“)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)rr…r‚r”rrrŚ4test_failsWithMultiplePackagesMissingModuleOrPackages  ’€žzBWrapFQPNTests.test_failsWithMultiplePackagesMissingModuleOrPackageN)r:r;r<r=rr‰rŒr’r•r–r—ršrœrŸr”r£r¤rrrrršs       rcs,eZdZdZdZ‡fdd„Zdd„Z‡ZS)Ś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" cs¾tt|ƒ ”ddlm}||_| |j” d”}| ”|  |jg”|_ |  |j |j d”| d”}| ”| d” ”| |j |j d”| |j d”|_| |j ddd”|_dS)NrA)Ś findMachinesrnroZ subpackagerpr")r r„rrCr¦r rr%rsr ryr-ŚSOURCErrtr1r8Ś packageDictrF)rr¦Z packageDirZ subPackageDirrrrr3s"  ’ ’z"FindMachinesIntegrationTests.setUpc Cs–t| d”t d”d}|jd ”}|jd ”}|jd}| ”}|jd}| ”}td|fd|jfd|fd |jfgt d”d}| ||”d S) z‡ Given a top-level package FQPN, L{findMachines} discovers all L{MethodicalMachine} instances in and below it. rnrrqztest_package.rootLevelztest_package.PythonClassz(test_package.subpackage.module.rootLevelz*test_package.subpackage.module.PythonClassz!test_package.PythonClass._machinez3test_package.subpackage.module.PythonClass._machineN) rur¦rvrwrØr7rFZ_machinerx) rr{Z tpRootLevelZ tpPythonClassZmRLAttrZ mRootLevelZmPCAttrZ mPythonClassr|rrrŚtest_discoverAllIs( ’  ’żśz-FindMachinesIntegrationTests.test_discoverAll)r:r;r<r=r§rr©r>rrrrr„ s  r„)rvr.r rr(rZunittestrrrrr r?rQrr„rrrrŚs( < a g