o q+WZVU@sddlZddlZddlZddlZddlZddlZddlmZmZddl Z ddZ GdddeZ ee dGdd d e Z ee dGd d d e Z ee dGd d d eZee dGddde ZdS)N)skipIfTestCasecCs$ztdWdStyYdSw)NtwistedFT) __import__ ImportErrorrr=/usr/lib/python3/dist-packages/automat/_test/test_discover.pyisTwistedInstalled s   r cs\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 twisted.python.filepathr setsysmoduleskeysoriginalSysModulespath savedSysPathtempfilemkdtemppathDirmakeImportable)selfr r r  __class__rrrs  z_WritesPythonModules.setUpcsRtt||jtjdd<ttj|j }|D]}tj|=qt |j dSN) rr tearDownrrrsixviewkeysrrshutilrmtreer)rmodulesToDeletemodulerrrr!*s  z_WritesPythonModules.tearDowncCstj|dSr )rrappend)rrrrrr4sz#_WritesPythonModules.makeImportablecCs^||}||}t|jd}|t|Wdn1s#wY||jgS)Nw)r childopenrwritetextwrapdedentr )rsourcer moduleName directoryr'frrrwriteSourceInto7s  z$_WritesPythonModules.writeSourceIntocCs"tj|\}}|||||Sr )osrsplitextr3)rr/rr0pythonModuleName_rrr makeModuleBsz_WritesPythonModules.makeModulecCsdd|DS)NcSsi|]}|j|qSr)name).0attrrrr Gsz9_WritesPythonModules.attributesAsDict..)iterAttributes)rhasIterAttributesrrrattributesAsDictFsz%_WritesPythonModules.attributesAsDictcCs|||Sr )loadr?)rr'rrrloadModuleAsDictIs z%_WritesPythonModules.loadModuleAsDictcCs|||||Sr )rAr8)rr/rr9rrrmakeModuleAsDictMsz%_WritesPythonModules.makeModuleAsDict) __name__ __module__ __qualname____doc__rr!rr3r8r?rArB __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. c$tt|ddlm}||_dS)N)isOriginalLocation)rrHr _discoverrK)rrKrrrr^  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)rBr assertFalserK)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)r8rrBrNrKr?)roriginalSourceimportingSource importingDict nestingObjectnestingObjectDict nestedObjectrrrtest_failsWithDifferentModulevs. 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.rBr assertTruerKr?)rmSourcemDictrVrWrXrrrtest_succeedsWithSameModules  z1OriginalLocationTests.test_succeedsWithSameModule) rCrDrErFrrPrYr]rGrrrrrHQs  %rHcsleZdZdZdZfddZddZddZd d Zd d Z d dZ 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}. 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." crI)NrJ)findMachinesViaWrapper)rr^rrLr_)rr_rrrrrMz!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.rootMachineN)rBrassertInr@listr_)rr/rO rootMachinerrrtest_yieldsMachines  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.pyclsmod.PythonClass clsmod.PythonClass._classMachineN)rBrrcr@ _classMachinerdr_rr/rO 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)rBrrcr@ NestedClassrkrdr_rlrrrtest_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. r`rarbN)r8rrAr@rcrdr_)rr/r'rerrrtest_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. rgrhrirjN)r8rrAr@rcrkrdr_rr/r'rmrrr!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. rorprqrrN) r8rrAr@rcrsrkrdr_rvrrr'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 rQrRNr8rrNrdr_)rrSrTimportingModulerrrtest_ignoresImportedClassIs 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*makedirstouchr8rsortedr_operator itemgetterrAr@rk assertEqual) r pythonPathpackager/r|machinesrOrermexpectedMachinesrrrtest_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.pyNry)rr/r'rrrtest_infiniteLoopsz-FindMachinesViaWrapperTests.test_infiniteLoop)rCrDrErFTEST_MODULE_SOURCErrfrnrtrurwrxr{rrrGrrrrr^s &r^c@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) PythonModulePythonAttributerJ)wrapFQPN InvalidFQPNNoModuleNoObject)rrrrLrrrr)rrrrrrrrrrrs zWrapFQPNTests.setUpcCs2|||j||j|j|||dS)zt Assert that a L{twisted.python.modules.PythonModule} refers to a particular Python module. N)assertIsInstancerrr9rCassertIsr@)r moduleWrapperr'rrrassertModuleWrapperRefersTosz)WrapFQPNTests.assertModuleWrapperRefersTocCs0|||j||j||||dS)zw Assert that a L{twisted.python.modules.PythonAttribute} refers to a particular Python object. N)rrrr9rr@)rattributeWrapperfqpnobjrrrassertAttributeWrapperRefersTosz,WrapFQPNTests.assertAttributeWrapperRefersTocC<||j|dWddS1swYdS)zO L{wrapFQPN} raises L{InvalidFQPN} when given an empty string. N assertRaisesrrrrrrtest_failsWithEmptyFQPNs "z%WrapFQPNTests.test_failsWithEmptyFQPNc CDdD]}||j ||Wdn1swYqdS)zk" L{wrapFQPN} raises L{InvalidFQPN} when given a badly-dotted FQPN. (e.g., x..y). )z.failszfails.z this..failsNrrbadrrrtest_failsWithBadDottings  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. rNr4)r4rrrrr@)rr4rrrrtest_singleModules 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)rrrrrrr*test_failsWithMissingSingleModuleOrPackages "z8WrapFQPNTests.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) 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_multiplePackagesFinalModulez.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)r4rrr)rr4rrrtest_singleModuleObjectrz%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__) rautomatrr fromstringMethodicalMachinerFrr)rrrrrrrrtest_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)rrrrrrr4test_failsWithMultiplePackagesMissingModuleOrPackages  zBWrapFQPNTests.test_failsWithMultiplePackagesMissingModuleOrPackageN)rCrDrErFrrrrrrrrrrrrrrrrrrs       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)NrJ) findMachinesr|r} subpackager~r')rrrrLrr rr*rr rr3SOURCErrr8rA packageDictrO)rr packageDir subPackageDirrrrr3s"   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. r|rrztest_package.rootLevelztest_package.PythonClassz(test_package.subpackage.module.rootLevelz*test_package.subpackage.module.PythonClassz!test_package.PythonClass._machinez3test_package.subpackage.module.PythonClass._machineN) rrrrrr@rO_machiner) rr tpRootLevel tpPythonClassmRLAttr mRootLevelmPCAttr mPythonClassrrrrtest_discoverAllIs(   z-FindMachinesIntegrationTests.test_discoverAll)rCrDrErFrrrrGrrrrr s  r)rr4r$rr-runittestrrr"r r rHr^rrrrrrs( < a g