o Ńó·i3Vć@sŌddlZddlZddlZddlZddlZddlZddlmZmZdd„Z Gdd„deƒZ ee ƒ dƒGdd „d e ƒƒZ ee ƒ dƒGd d „d e ƒƒZ ee ƒ dƒGd d „d eƒƒZ ee ƒ dƒGdd„de ƒƒZdS)éN)ŚskipIfŚTestCasecCs$ztdƒWdStyYdSw)NZtwistedFT)Ś __import__Ś ImportError©rrśaC:\Users\psant\Downloads\PAF backend\school\venv\Lib\site-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ŚtempfileŚmkdtempŚpathDirŚmakeImportable)Śselfr r r ©Ś __class__rrrs  z_WritesPythonModules.setUpcsPtt|ƒ ”|jtjdd…<tj ”|j}|D]}tj|=qt   |j ”dS©N) r r ŚtearDownrrrrrrŚshutilŚrmtreer)rZmodulesToDeleteŚmodulerrrr(s  z_WritesPythonModules.tearDowncCstj |”dSr)rrŚappend)rrrrrr2sz#_WritesPythonModules.makeImportablecCs^| |”}| |”}t|jdƒ}| t |””Wdƒn1s#wY| |jg”S)NŚw)r ŚchildŚopenrŚwriteŚtextwrapŚdedentr )rŚsourcerŚ moduleNameŚ directoryr"ŚfrrrŚwriteSourceInto5s  ’z$_WritesPythonModules.writeSourceIntocCs"tj |”\}}| |||”|Sr)ŚosrŚsplitextr.)rr*rr+ZpythonModuleNameŚ_rrrŚ makeModule@sz_WritesPythonModules.makeModulecCsdd„| ”DƒS)NcSsi|]}|j|“qSr)Śname)Ś.0ŚattrrrrŚ Esz9_WritesPythonModules.attributesAsDict..)ZiterAttributes)rZhasIterAttributesrrrŚattributesAsDictDsz%_WritesPythonModules.attributesAsDictcCs| ”| |”Sr)Śloadr7)rr"rrrŚloadModuleAsDictGs z%_WritesPythonModules.loadModuleAsDictcCs| | |||””Sr)r9r2)rr*rr3rrrŚmakeModuleAsDictKsz%_WritesPythonModules.makeModuleAsDict) Ś__name__Ś __module__Ś __qualname__Ś__doc__rrrr.r2r7r9r:Ś __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Ś _discoverrC)rrCrrrr]ó  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)r:rŚ assertFalserC)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)r2rr:rFrCr7)rŚoriginalSourceŚimportingSourceZ importingDictŚ nestingObjectŚnestingObjectDictŚ nestedObjectrrrŚtest_failsWithDifferentModuleus$’ ’ ’ ’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)r:rŚ assertTruerCr7)rZmSourceZmDictrMrNrOrrrŚtest_succeedsWithSameModule›s’  z1OriginalLocationTests.test_succeedsWithSameModule) r;r<r=r>rrHrPrRr?rrrrr@Os  &r@csreZdZdZ‡fdd„Zdd„Zddd „Zd d „Zd d „Zdd„Z dd„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}. crA)NrB)ŚfindMachinesViaWrapper)r rSrrDrT)rrTrrrr½rEz!FindMachinesViaWrapperTests.setUpcCó>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©r:rŚassertInr8ŚlistrT©rr*rGŚ rootMachinerrrŚtest_yieldsMachineĆs  žz.FindMachinesViaWrapperTests.test_yieldsMachineŚreturnNcCrU)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() rWrXNrYr\rrrŚtest_yieldsTypeMachineÖs   žz2FindMachinesViaWrapperTests.test_yieldsTypeMachinecCs@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)r:rrZr8Ś _classMachiner[rT©rr*rGŚ 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)r:rrZr8Ś NestedClassrer[rTrfrrrŚtest_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. rVrWrXN)r2rr9r8rZr[rT)rr*r"r]rrrŚ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. rarbrcrdN)r2rr9r8rZrer[rT©rr*r"rgrrrŚ!test_yieldsMachineInClassInModule-s ž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. rirjrkrlN) r2rr9r8rZrmrer[rTrprrrŚ'test_yieldsMachineInNestedClassInModuleAsž ū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 rIrJN©r2rrFr[rT)rrKrLZimportingModulerrrŚtest_ignoresImportedClassZs  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Śtouchr2rŚsortedrTŚoperatorŚ itemgetterr9r8reŚ assertEqual) rŚ pythonPathŚpackager*ruŚmachinesrGr]rgŚexpectedMachinesrrrŚtest_descendsIntoPackagesss, ’  žžų 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.pyNrs)rr*r"rrrŚtest_infiniteLoopŸsz-FindMachinesViaWrapperTests.test_infiniteLoop)r_N)r;r<r=r>rr^r`rhrnrorqrrrtr„r…r?rrrrrS“s  ,rSc@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ŚPythonAttributerB)ŚwrapFQPNŚ InvalidFQPNŚNoModuleŚNoObject)rr‡rˆrDr‰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‡rr3r;ŚassertIsr8)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ˆrr3rŽr8)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ƒq1swYqdS)zl " L{wrapFQPN} raises L{InvalidFQPN} when given a badly-dotted FQPN. (e.g., x..y). )z.failszfails.z this..failsNr–©rŚbadrrrŚtest_failsWithBadDottingŪó  ’’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Žr8)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_multiplePackagessz#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_singleModuleObjectr©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§Ś fromstringZMethodicalMachiner>r“r‰)rr”r«r‘r’rrrŚtest_multiplePackagesObject s   žü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_failsWithMultiplePackagesMissingModuleOrPackage/ržzBWrapFQPNTests.test_failsWithMultiplePackagesMissingModuleOrPackageN)r;r<r=r>rrr“r™rrŸr r£r„rØrŖr­r®rrrrr†Æs         r†cs,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)NrB)Ś findMachinesrurvZ subpackagerwr")r rÆrrDr°r rr%rzr r€r.ŚSOURCErr{r2r9Ś packageDictrG)rr°Z packageDirZ subPackageDirrrrrLs   ’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. rurrxztest_package.rootLevelztest_package.PythonClassz(test_package.subpackage.module.rootLevelz*test_package.subpackage.module.PythonClassz!test_package.PythonClass._machinez3test_package.subpackage.module.PythonClass._machineN) r|r°r}r~r²r8rGZ_machiner) rr‚Z tpRootLevelZ tpPythonClassZmRLAttrZ mRootLevelZmPCAttrZ mPythonClassrƒrrrŚtest_discoverAllbs$  žü ö z-FindMachinesIntegrationTests.test_discoverAll)r;r<r=r>r±rr³r?rrrrrÆ9s  rÆ)r}r/r rr(rZunittestrrrr r@rSr†rÆrrrrŚs& < d {