~bBUHddlZddlZddlZddlZddlZddlZddlmZmZdZ GddeZ ee dGdde Z ee dGd d e Z ee dGd d eZ ee dGd de Zy)N)skipIfTestCasec: tdy#t$rYywxYw)NtwistedTF) __import__ ImportError=/usr/lib/python3/dist-packages/automat/_test/test_discover.pyisTwistedInstalledr s(9 s  cPeZdZdZfdZfdZdZdZdZdZ dZ d Z xZ S) _WritesPythonModuleszG A helper that enables generating Python module test fixtures. c`tt| ddlm}m}ddlm}||_||_||_ttjj|_ tjdd|_tj |_|j%|j"y)Nr) getModule PythonPath)FilePath)superrsetUptwisted.python.modulesrrtwisted.python.filepathrsetsysmoduleskeysoriginalSysModulespath savedSysPathtempfilemkdtemppathDirmakeImportable)selfrrr __class__s r rz_WritesPythonModules.setUpsx "D/1@4"$  "%ckk&6&6&8"9HHQK'')  DLL)r c(tt| |jtj ddtj j|jz }|D]}tj |=tj|jyN) rrtearDownrrrrrrshutilrmtreer )r"modulesToDeletemoduler#s r r&z_WritesPythonModules.tearDown'sn "D24'' ++**,t/F/FF% $F F# $  dll#r cBtjj|yr%)rrappend)r"rs r r!z#_WritesPythonModules.makeImportable1s r c|j|}|j|}t|jd5}|j t j |ddd|j|jgS#1swY%xYw)Nw)rchildopenrwritetextwrapdedentr)r"sourcer moduleName directoryr*fs r writeSourceIntoz$_WritesPythonModules.writeSourceInto4srMM$' ,&++s # -q GGHOOF+ , - /00 - -s %BB crtjj|\}}|j||||Sr%)osrsplitextr8)r"r4rr5pythonModuleName_s r makeModulez_WritesPythonModules.makeModule?s7 gg..z:!##FD*=>NOOr c^|jDcic]}|j|c}Scc}wr%)iterAttributesname)r"hasIterAttributesattrs r attributesAsDictz%_WritesPythonModules.attributesAsDictCs',=,L,L,NOD 4OOOs*cD|j|j|Sr%)loadrD)r"r*s r loadModuleAsDictz%_WritesPythonModules.loadModuleAsDictFs $$V,,r cF|j|j|||Sr%)rGr>)r"r4rrAs r makeModuleAsDictz%_WritesPythonModules.makeModuleAsDictJs $$T__VT4%HIIr ) __name__ __module__ __qualname____doc__rr&r!r8r>rDrGrI __classcell__r#s@r rrs3* $ 1PP-Jr rzTwisted is not installed.c4eZdZdZfdZdZdZdZxZS)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. cDtt| ddlm}||_y)N)isOriginalLocation)rrQr _discoverrT)r"rTr#s r rzOriginalLocationTests.setUp[s #T022"4r cd}|j||jd}|j|j|dy)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)rIr assertFalserT)r"r4 moduleDicts r test_failsWithNoModulez,OriginalLocationTests.test_failsWithNoModule`sN  **6+/<<+AC  00 9 :< =r cd}d}|j||jd|j||jd}|j|j |d|j|j |d|d}|j |}|d}|j|j |y ) 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)r>r rIrWrTrD)r"originalSourceimportingSource importingDict nestingObjectnestingObjectDict nestedObjects r test_failsWithDifferentModulez3OriginalLocationTests.test_failsWithDifferentModuless     mD--o.2ll.<>    # #9: < =   # #:; = >&&IJ  11-@( <>  00>?r cjtjd}|j||jd}|j |j |d|j |j |d|d}|j |}|d}|j |j |y)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)r2r3rIr assertTruerTrD)r"mSourcemDictr`rarbs r test_succeedsWithSameModulez1OriginalLocationTests.test_succeedsWithSameModules //#  %%gt||VD // - .0 1 //6H0IJK01  11-@()HI  // =>r ) rJrKrLrMrrYrcrhrNrOs@r rQrQNs 5 =&#@J?r rQc\eZdZdZdZfdZdZdZdZdZ dZ d Z d Z d Z d ZxZS) 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." cDtt| ddlm}||_y)NrS)findMachinesViaWrapper)rrjrrUrl)r"rlr#s r rz!FindMachinesViaWrapperTests.setUps )4686&<#r cd}|j||jd}|d}|jd|jft |j |y)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)rIr assertInrFlistrl)r"r4rX rootMachines r test_yieldsMachinez.FindMachinesViaWrapperTests.test_yieldsMachines_   **64<<K  !34  );+;+;+=>466{CD Fr cd}|j||jd}|d}|jd|jjft |j |y)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)rIr rqrF _classMachinerrrlr"r4rX PythonClasss r test_yieldsMachineInClassz5FindMachinesViaWrapperTests.test_yieldsMachineInClasssh  **64<<M  !56  9"'')779466{CD Fr cd}|j||jd}|d}|jd|jjj ft |j|y)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)rIr rqrF NestedClassrzrrrlr{s r test_yieldsMachineInNestedClassz;FindMachinesViaWrapperTests.test_yieldsMachineInNestedClasssu **6+/<<+9; !!89  H"'')55CCE466{CD Fr cd}|j||jd}|j|dj}|j d|ft |j |y)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. rnrorpN)r>r rGrFrqrrrl)r"r4r*rss r test_yieldsMachineInModulez6FindMachinesViaWrapperTests.test_yieldsMachineInModule sh   yA++F34FGLLN  );7466v>? Ar cd}|j||jd}|j|dj}|j d|j ft |j|y)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. rvrwrxryN)r>r rGrFrqrzrrrlr"r4r*r|s r !test_yieldsMachineInClassInModulez=FindMachinesViaWrapperTests.test_yieldsMachineInClassInModulesw  {C++ (**.$&  9"002466v>? Ar cd}|j||jd}|j|dj}|j d|j j ft|j|y)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. rrrrN) r>r rGrFrqrrzrrrlrs r 'test_yieldsMachineInNestedClassInModulezCFindMachinesViaWrapperTests.test_yieldsMachineInNestedClassInModule0s ~F++ +--1TV  H"..<<>466v>? Ar cd}d}|j||jd|j||jd}|jt|j |y)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 r[r\Nr>r rWrrrl)r"r]r^importingModules r test_ignoresImportedClassz5FindMachinesViaWrapperTests.test_ignoresImportedClassFs`    mD///*.,,*8: d99/JKLr c|j|jg}|j|jjd}|j |jdj d}|j ||jd|d}t|j|tjd}|j|d}|dj}|d j}td|fd |jfgtjd} |j| |y ) 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)rr rr/makedirstouchr>rsortedrloperator itemgetterrGrFrz assertEqual) r" pythonPathpackager4rmachinesrXrsr|expectedMachiness r test_descendsIntoPackagesz5FindMachinesViaWrapperTests.test_descendsIntoPackagesas1 __dll^4 -- -33NC m$**,    k:!.1 $55lC&11!46**<+AB  !BCHHJ  !BCHHJ !/='') *08/B/B1/E G )84r cd}|j||jd}|jt|j |y)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.pyNr)r"r4r*s r test_infiniteLoopz-FindMachinesViaWrapperTests.test_infiniteLoops?   yA d99&ABCr )rJrKrLrMTEST_MODULE_SOURCErrtr}rrrrrrrrNrOs@r rjrjsK (= F"F&F.A A(A,M6$5L Dr rjc^eZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZy) WrapFQPNTestsz Tests that ensure L{wrapFQPN} loads the L{twisted.python.modules.PythonModule} or L{twisted.python.modules.PythonAttribute} for a given FQPN. cddlm}m}ddlm}m}m}m}||_||_||_||_||_||_y)Nr) PythonModulePythonAttributerS)wrapFQPN InvalidFQPNNoModuleNoObject)rrrrUrrrr)r"rrrrrrs r rzWrapFQPNTests.setUps8HII(.  &    r c|j||j|j|j|j|j |j |y)zt Assert that a L{twisted.python.modules.PythonModule} refers to a particular Python module. N)assertIsInstancerrrArJassertIsrF)r" moduleWrapperr*s r assertModuleWrapperRefersToz)WrapFQPNTests.assertModuleWrapperRefersTosK mT->->? ++V__= m((*F3r c|j||j|j|j||j |j |y)zw Assert that a L{twisted.python.modules.PythonAttribute} refers to a particular Python object. N)rrrrArrF)r"attributeWrapperfqpnobjs r assertAttributeWrapperRefersToz,WrapFQPNTests.assertAttributeWrapperRefersTosJ .0D0DE )..5 &++-s3r c|j|j5|jddddy#1swYyxYw)zO L{wrapFQPN} raises L{InvalidFQPN} when given an empty string. N assertRaisesrrr"s r test_failsWithEmptyFQPNz%WrapFQPNTests.test_failsWithEmptyFQPNs9  t// 0  MM"     7AcdD]7}|j|j5|j|ddd9y#1swYDxYw)zk" L{wrapFQPN} raises L{InvalidFQPN} when given a badly-dotted FQPN. (e.g., x..y). )z.failszfails.z this..failsNrr"bads r test_failsWithBadDottingz&WrapFQPNTests.test_failsWithBadDottingsM 7 #C""4#3#34 # c" # # # # # >A cddl}|jd}|j||j|j |j |y)z L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the single module a dotless FQPN describes. rNr:)r:rrrrrF)r"r:rs r test_singleModulezWrapFQPNTests.test_singleModulesB  d+  mT->->? m((*B/r c|j|j5|jddddy#1swYyxYw)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)rrrrs r *test_failsWithMissingSingleModuleOrPackagez8WrapFQPNTests.test_failsWithMissingSingleModuleOrPackages8   t}} - = MM; < = = =rcNddl}|j|jd|y)z L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the single package a dotless FQPN describes. rNxml)rrrr"rs r test_singlePackagez WrapFQPNTests.test_singlePackages  ((u)=sCr cbddl}|j|jd|jy)z L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the deepest package described by dotted FQPN. rNz xml.etree) xml.etreerretreers r test_multiplePackagesz#WrapFQPNTests.test_multiplePackagess$  (({)CSYYOr cvddl}|j|jd|jjy)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 ElementTreers r test_multiplePackagesFinalModulez.WrapFQPNTests.test_multiplePackagesFinalModules/ % (( MM1 2CII4I4I Kr cdddl}|j|jdd|jy)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)r"r:s r test_singleModuleObjectz%WrapFQPNTests.test_singleModuleObjects)  ++ MM) $i :r cddl}ddl}d|jjjfd|j j ffD]'\}}|j|j|||)y)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 fromstringMethodicalMachinerMrr)r"rrrrs r test_multiplePackagesObjectz)WrapFQPNTests.test_multiplePackagesObjectsq %=9900;;=>"44<<>? 0ID#  / / d#T3 0  0r cdD]7}|j|j5|j|ddd9y#1swYDxYw)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)rrrrs r 4test_failsWithMultiplePackagesMissingModuleOrPackagezBWrapFQPNTests.test_failsWithMultiplePackagesMissingModuleOrPackagesL B #C""4==1 # c" # # # # #rN)rJrKrLrMrrrrrrrrrrrrrr r r rrsK !44# 0=DPK:0 #r rc,eZdZdZdZfdZdZxZS)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" ctt| ddlm}||_|j |j jd}|j|j|j g|_ |j|j|jd|jd}|j|jdj|j|j|jd|j!|jd|_|j!|jddd|_y)NrS) findMachinesrr subpackagerr*)rrrrUrrr r/rrrr8SOURCErrr>rG packageDictrX)r"r packageDir subPackageDirr#s r rz"FindMachinesIntegrationTests.setUp0s  *D79,(]]4<<066~F //4<<.9 T[[*//=I"((6  M*002  ]%7%7E00 OON +-// OON +L 9( CEr ct|jdtjd}|jdj }|jdj }|j d}|j }|j d}|j }td|fd|jfd|fd |jfgtjd}|j||y ) z Given a top-level package FQPN, L{findMachines} discovers all L{MethodicalMachine} instances in and below it. rrrztest_package.rootLevelztest_package.PythonClassz(test_package.subpackage.module.rootLevelz*test_package.subpackage.module.PythonClassz!test_package.PythonClass._machinez3test_package.subpackage.module.PythonClass._machineN) rrrrrrFrX_machiner) r"r tpRootLevel tpPythonClassmRLAttr mRootLevelmPCAttr mPythonClassrs r test_discoverAllz-FindMachinesIntegrationTests.test_discoverAllFs $++N;&11!46&&'?@EEG (()CDIIK //"LM\\^ //"NO||~ !& 41=3I3I J8* EC##% & ##A& ( )84r )rJrKrLrMrrrrNrOs@r rrs FE,5r r)rr:r'rr2runittestrrr rrQrjrrr r r rs %9J89Jx   "=>^?0^??^?B   "=>cD"6cD?cDL   "=>B#HB#?B#J   "=>@5#7@5?@5r