Vh3VHddlZddlZddlZddlZddlZddlZddlmZmZdZ GddeZ ee dGdde Z ee dGd d e Z ee dGd d eZ ee dGd de Zy)N)skipIfTestCasec: tdy#t$rYywxYw)NtwistedTF) __import__ ImportErrorK/home/dcms/DCMS/lib/python3.12/site-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.makeImportable2s r c|j|}|j|}t|jd5}|j t j |ddd|j|jgS#1swY%xYw)Nw)rchildopenrwritetextwrapdedentr)r"sourcer moduleName directoryr*fs r writeSourceIntoz$_WritesPythonModules.writeSourceInto5srMM$' ,&++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.attributesAsDictDs',=,L,L,NOD 4OOOs*cD|j|j|Sr%)loadrD)r"r*s r loadModuleAsDictz%_WritesPythonModules.loadModuleAsDictGs $$V,,r cF|j|j|||Sr%)rGr>)r"r4rrAs r makeModuleAsDictz%_WritesPythonModules.makeModuleAsDictKs $$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_failsWithNoModulecsF  **64<r rIrWrTrD)r"originalSourceimportingSource importingDict nestingObjectnestingObjectDict nestedObjects r test_failsWithDifferentModulez3OriginalLocationTests.test_failsWithDifferentModuleus     mD-- T\\>    # #M2M$N O    # #M2N$O P &&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 //6Q0RST //6H0IJK01  11-@()HI  // =>r ) rJrKrLrMrrYrcrhrNrOs@r rQrQOs 5  $$@L?r rQc`eZdZdZfdZdZd dZdZdZdZ 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}. 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.rootMachineNrIr assertInrFlistrlr"r4rX rootMachines r test_yieldsMachinez.FindMachinesViaWrapperTests.test_yieldsMachines^   **64<<K  !34  !1!1!3 4 ,,[9 : r cd}|j||jd}|d}|jd|jft |j |y)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() rorpNrqrts r test_yieldsTypeMachinez2FindMachinesViaWrapperTests.test_yieldsTypeMachines^  **64<<K  !34  !1!1!3 4 ,,[9 : r 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 rrrF _classMachinersrlr"r4rX PythonClasss r test_yieldsMachineInClassz5FindMachinesViaWrapperTests.test_yieldsMachineInClasssd  **64<<M  !56  /1A1A1C1Q1Q R ,,[9 : r 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 rrrF NestedClassr~rsrlrs r test_yieldsMachineInNestedClassz;FindMachinesViaWrapperTests.test_yieldsMachineInNestedClassso **64<<P  !89  A  "..<<  ,,[9 :  r 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 rGrFrrrsrl)r"r4r*rus r test_yieldsMachineInModulez6FindMachinesViaWrapperTests.test_yieldsMachineInModulesg   yA++F34FGLLN   -tD4O4OPV4W/X r 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. rzr{r|r}N)r>r rGrFrrr~rsrlr"r4r*rs r !test_yieldsMachineInClassInModulez=FindMachinesViaWrapperTests.test_yieldsMachineInClassInModule-sm  {C++F34HINNP  /1J1J K ,,V4 5 r 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 rGrFrrrr~rsrlrs r 'test_yieldsMachineInNestedClassInModulezCFindMachinesViaWrapperTests.test_yieldsMachineInNestedClassInModuleAsx ~F++F34KLQQS  A''55  ,,V4 5  r 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 rWrsrl)r"r]r^importingModules r test_ignoresImportedClassz5FindMachinesViaWrapperTests.test_ignoresImportedClassZsZ    mD///4<<X 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 itemgetterrGrFr~ assertEqual) r" pythonPathpackager4rmachinesrXrurexpectedMachiness r test_descendsIntoPackagesz5FindMachinesViaWrapperTests.test_descendsIntoPackagesss- __dll^4 -- -33NC m$**,    k:!.1   ' ' 58;N;Nq;Q **<+AB  !BCHHJ  !BCHHJ !2K@C-- ##A&   )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 )returnN)rJrKrLrMrrvrxrrrrrrrrrNrOs@r rjrjsB=  & 2 ( 2 " ( 2M2*5X 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)zl " 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_multiplePackagesFinalModule s. % (( MM1 2CII4I4I r 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_multiplePackagesObject sl %01F1F1Q1Q R 0'2K2K2S2S T  PID#  / / d0CT3 O  Pr 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_failsWithMultiplePackagesMissingModuleOrPackage/sL U #C""4==1 # c" # # # # #rN)rJrKrLrMrrrrrrrrrrrrrr r r rrsK !44# 0=DP     P#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.setUpLs *D79,(]]4<<066~F //4<<.9 T[[*//=I"((6  M*002  ]%7%7E001PQ// OON +L 9( C r 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_discoverAllbs $++N;ATATUVAWX&&'?@EEG (()CDIIK //"LM\\^ //"NO||~ !);74m6L6LM;ZHI ))  ##A&   )84r )rJrKrLrMrrrrNrOs@r rr9s F ,5r r)rr:r'rr2runittestrrr rrQrjrrr r r rs %9J89Jx   "=>a?0a??a?H   "=>wD"6wD?wDt   "=>F#HF#?F#R   "=>D5#7D5?D5r