XfBUddlZddlZddlZddlZddlZddlZddlmZmZdZ GddeZ ee dGdde Z ee dGd d e Z ee dGd d eZ ee dGd de ZdS)N)skipIfTestCasecH tddS#t$rYdSwxYw)NtwistedTF) __import__ ImportErrorM/var/www/html/env/lib/python3.11/site-packages/automat/_test/test_discover.pyisTwistedInstalledr s@9t uus  !!cPeZdZdZfdZfdZdZdZdZdZ dZ d Z xZ S) _WritesPythonModuleszG A helper that enables generating Python module test fixtures. ctt|ddlm}m}ddlm}||_||_||_ttj |_ tj dd|_tj|_||jdS)Nr) getModule PythonPath)FilePath)superrsetUptwisted.python.modulesrrtwisted.python.filepathrsetsysmoduleskeysoriginalSysModulespath savedSysPathtempfilemkdtemppathDirmakeImportable)selfrrr __class__s r rz_WritesPythonModules.setUps "D))//111@@@@@@@@444444"$  "%ck&6&6&8&8"9"9HQQQK'))  DL)))))r c$tt||jtjdd<tj|jz }|D]}tj|=tj |j dSN) rrtearDownrrrrrrshutilrmtreer )r"modulesToDeletemoduler#s r r&z_WritesPythonModules.tearDown's "D))22444' +**,,t/FF% $ $F F## dl#####r cDtj|dSr%)rrappend)r"rs r r!z#_WritesPythonModules.makeImportable1s r c4||}||}t|jd5}|t j|dddn #1swxYwY||jgS)Nw)rchildopenrwritetextwrapdedentr)r"sourcer moduleName directoryr*fs r writeSourceIntoz$_WritesPythonModules.writeSourceInto4sMM$'' ,,&+s # # -q GGHOF++ , , , - - - - - - - - - - - - - - - /000s(A44A8;A8ctj|\}}|||||Sr%)osrsplitextr8)r"r4rr5pythonModuleName_s r makeModulez_WritesPythonModules.makeModule?s; g..z::!##FD*==>NOOr c>d|DS)Nci|] }|j| Sr )name).0attrs r z9_WritesPythonModules.attributesAsDict..DsOOOD 4OOOr )iterAttributes)r"hasIterAttributess r attributesAsDictz%_WritesPythonModules.attributesAsDictCs#OO,=,L,L,N,NOOOOr cT|||Sr%)loadrG)r"r*s r loadModuleAsDictz%_WritesPythonModules.loadModuleAsDictFs# $$V,,,r cV|||||Sr%)rJr>)r"r4rrAs r makeModuleAsDictz%_WritesPythonModules.makeModuleAsDictJs&$$T__VT4%H%HIIIr ) __name__ __module__ __qualname____doc__rr&r!r8r>rGrJrL __classcell__r#s@r rrs***** $$$$$ 1 1 1PPPPPP---JJJJJJJr 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. cptt|ddlm}||_dS)N)isOriginalLocation)rrTr _discoverrW)r"rWr#s r rzOriginalLocationTests.setUp[s@ #T**00222222222"4r cd}|||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)rLr assertFalserW)r"r4 moduleDicts r test_failsWithNoModulez,OriginalLocationTests.test_failsWithNoModule`sk  **6+/<+ACC  00 9 :<< = = = = =r cd}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)r>r rLrZrWrG)r"originalSourceimportingSource importingDict nestingObjectnestingObjectDict nestedObjects r test_failsWithDifferentModulez3OriginalLocationTests.test_failsWithDifferentModuless      mDDD--o.2l.<>>    # #9: < < = = =   # #:; = = > > >&&IJ  11-@@( <>  00>>?????r ctjd}|||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)r2r3rLr assertTruerWrG)r"mSourcemDictrcrdres r test_succeedsWithSameModulez1OriginalLocationTests.test_succeedsWithSameModules /#   %%gt|VDD // - .00 1 1 1 //6H0IJJKKK01  11-@@()HI  // ==>>>>>r ) rMrNrOrPrr\rfrkrQrRs@r rTrTNss  55555 ===&#@#@#@J???????r rTc\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." cptt|ddlm}||_dS)NrV)findMachinesViaWrapper)rrmrrXro)r"ror#s r rz!FindMachinesViaWrapperTests.setUps@ )40066888666666&<###r cd}|||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)rLr assertInrIlistro)r"r4r[ rootMachines r test_yieldsMachinez.FindMachinesViaWrapperTests.test_yieldsMachines   **64<KK  !34  );+;+;+=+=>466{CCDD F F F F Fr cd}|||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)rLr rtrI _classMachineruror"r4r[ PythonClasss r test_yieldsMachineInClassz5FindMachinesViaWrapperTests.test_yieldsMachineInClasss  **64<MM  !56  9"''))79466{CCDD F F F F Fr cd}|||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)rLr rtrI NestedClassr}ruror~s r test_yieldsMachineInNestedClassz;FindMachinesViaWrapperTests.test_yieldsMachineInNestedClasss **6+/<+9;; !!89  H"''))5CE466{CCDD F F F F Fr c d}|||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. rqrrrsN)r>r rJrIrtruro)r"r4r*rvs r test_yieldsMachineInModulez6FindMachinesViaWrapperTests.test_yieldsMachineInModule s   yAA++F334FGLLNN  );7466v>>?? A A A A Ar cd}|||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. ryrzr{r|N)r>r rJrIrtr}ruror"r4r*rs r !test_yieldsMachineInClassInModulez=FindMachinesViaWrapperTests.test_yieldsMachineInClassInModules  {CC++ (**.$&&  9"02466v>>?? A A A A Ar c d}|||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. rrrrN) r>r rJrIrtrr}rurors r 'test_yieldsMachineInNestedClassInModulezCFindMachinesViaWrapperTests.test_yieldsMachineInNestedClassInModule0s ~FF++ +--1TVV  H".<>466v>>?? A A A A Ar cd}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 r^r_Nr>r rZruro)r"r`raimportingModules r test_ignoresImportedClassz5FindMachinesViaWrapperTests.test_ignoresImportedClassFsy    mDDD///*.,*8:: d99/JJKKLLLLLr c||jg}||jd}||dd}|||jd|d}t| |tj d}| |d}|d }|d  }td|fd |jfgtj 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.pyrkeyr*ztest_package.module.rootMachineztest_package.module.PythonClassz-test_package.module.PythonClass._classMachineN)rr rr/makedirstouchr>rsortedrooperator itemgetterrJrIr} assertEqual) r" pythonPathpackager4rmachinesr[rvrexpectedMachiness r test_descendsIntoPackagesz5FindMachinesViaWrapperTests.test_descendsIntoPackagesast __dl^44 -- --33NCC m$$**,,,    k:::!.1 $55lCC&1!44666**<+ABB  !BCHHJJ  !BCHHJJ !/=') *08/B1/E/E GGG )844444r cd}|||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.pyNr)r"r4r*s r test_infiniteLoopz-FindMachinesViaWrapperTests.test_infiniteLoopsR   yAA d99&AABBCCCCCr )rMrNrOrPTEST_MODULE_SOURCErrwrrrrrrrrrQrRs@r rmrms (===== FFF"FFF&FFF.AAA AAA(AAA,MMM6$5$5$5L D D D D D D Dr rmc`eZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdS) 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}||_||_||_||_||_||_dS)Nr) PythonModulePythonAttributerV)wrapFQPN InvalidFQPNNoModuleNoObject)rrrrXrrrr)r"rrrrrrs r rzWrapFQPNTests.setUpsoHHHHHHHHIIIIIIIIIIII(.  &    r c|||j||j|j|||dS)zt Assert that a L{twisted.python.modules.PythonModule} refers to a particular Python module. N)assertIsInstancerrrArMassertIsrI)r" moduleWrapperr*s r assertModuleWrapperRefersToz)WrapFQPNTests.assertModuleWrapperRefersTos^ mT->??? +V_=== m((**F33333r c|||j||j||||dS)zw Assert that a L{twisted.python.modules.PythonAttribute} refers to a particular Python object. N)rrrrArrI)r"attributeWrapperfqpnobjs r assertAttributeWrapperRefersToz,WrapFQPNTests.assertAttributeWrapperRefersTos_ .0DEEE ).555 &++--s33333r c||j5|dddddS#1swxYwYdS)zO L{wrapFQPN} raises L{InvalidFQPN} when given an empty string. N assertRaisesrrr"s r test_failsWithEmptyFQPNz%WrapFQPNTests.test_failsWithEmptyFQPNs  t/ 0 0   MM"                     >AAcdD]I}||j5||dddn #1swxYwYJdS)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_failsWithBadDottings 7 # #C""4#344 # # c""" # # # # # # # # # # # # # # # # #AA A cddl}|d}|||j|||dS)z L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the single module a dotless FQPN describes. rNr:)r:rrrrrI)r"r:rs r test_singleModulezWrapFQPNTests.test_singleModules]   d++  mT->??? m((**B/////r c||j5|dddddS#1swxYwYdS)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_failsWithMissingSingleModuleOrPackages   t} - - = = MM; < < < = = = = = = = = = = = = = = = = = =rc`ddl}||d|dS)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_singlePackages5   ((u)=)=sCCCCCr cjddl}||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.etreerretreers r test_multiplePackagesz#WrapFQPNTests.test_multiplePackagess:  (({)C)CSYOOOOOr ctddl}||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 ElementTreers r test_multiplePackagesFinalModulez.WrapFQPNTests.test_multiplePackagesFinalModulesN %$$$ (( MM1 2 2CI4I K K K K Kr clddl}||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)r"r:s r test_singleModuleObjectz%WrapFQPNTests.test_singleModuleObjectsD   ++ MM) $ $i : : : : :r cddl}ddl}d|jjjfd|jjffD]/\}}|||||0dS)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 fromstringMethodicalMachinerPrr)r"rrrrs r test_multiplePackagesObjectz)WrapFQPNTests.test_multiplePackagesObjects %$$$=90;=>"4<>? 0 0ID#  / / d##T3 0 0 0 0  0 0r cdD]I}||j5||dddn #1swxYwYJdS)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_failsWithMultiplePackagesMissingModuleOrPackages B # #C""4=11 # # c""" # # # # # # # # # # # # # # # # #rN)rMrNrOrPrrrrrrrrrrrrrr r r rrs ! ! !444444### 0 0 0===DDDPPPKKK:::000 #####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}||_||jd}|| |jg|_ | |j |j d|d}||d||j |j d||j d|_||j ddd|_dS)NrV) findMachinesrr subpackagerr*)rrrrXrrr r/rrrr8SOURCErrr>rJ packageDictr[)r"r packageDir subPackageDirr#s r rz"FindMachinesIntegrationTests.setUp0sS *D1177999,,,,,,(]]4<0066~FF //4<.99 T[*/=III"((66    M**00222  ]%7EEE00 ON +--// ON +L 9( CEEr ct|dtjd}|jd}|jd}|jd}|}|jd}|}td|fd|jfd|fd |jfgtjd}|||d S) 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) rrrrrrIr[_machiner) r"r tpRootLevel tpPythonClassmRLAttr mRootLevelmPCAttr mPythonClassrs r test_discoverAllz-FindMachinesIntegrationTests.test_discoverAllFs $++N;;&1!44666&'?@EEGG ()CDIIKK /"LM\\^^ /"NO||~~ !& 41=3I J8* EC#% & #A&& ((( )844444r )rMrNrOrPrrrrQrRs@r rrs] FEEEEE,5555555r r)rr:r'rr2runittestrrr rrTrmrrr r r rs %%%%%%%%9J9J9J9J9J89J9J9Jx    "=>>^?^?^?^?^?0^?^??>^?B    "=>>cDcDcDcDcD"6cDcD?>cDL    "=>>B#B#B#B#B#HB#B#?>B#J    "=>>@5@5@5@5@5#7@5@5?>@5@5@5r