File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/_test.tar
Back
test_core.py 0000644 00000005421 15030211240 0007073 0 ustar 00 from .._core import Automaton, NoTransition from unittest import TestCase class CoreTests(TestCase): """ Tests for Automat's (currently private, implementation detail) core. """ def test_NoTransition(self): """ A L{NoTransition} exception describes the state and input symbol that caused it. """ # NoTransition requires two arguments with self.assertRaises(TypeError): NoTransition() state = "current-state" symbol = "transitionless-symbol" noTransitionException = NoTransition(state=state, symbol=symbol) self.assertIs(noTransitionException.symbol, symbol) self.assertIn(state, str(noTransitionException)) self.assertIn(symbol, str(noTransitionException)) def test_noOutputForInput(self): """ L{Automaton.outputForInput} raises L{NoTransition} if no transition for that input is defined. """ a = Automaton() self.assertRaises(NoTransition, a.outputForInput, "no-state", "no-symbol") def test_oneTransition(self): """ L{Automaton.addTransition} adds its input symbol to L{Automaton.inputAlphabet}, all its outputs to L{Automaton.outputAlphabet}, and causes L{Automaton.outputForInput} to start returning the new state and output symbols. """ a = Automaton() a.addTransition("beginning", "begin", "ending", ["end"]) self.assertEqual(a.inputAlphabet(), {"begin"}) self.assertEqual(a.outputAlphabet(), {"end"}) self.assertEqual(a.outputForInput("beginning", "begin"), ("ending", ["end"])) self.assertEqual(a.states(), {"beginning", "ending"}) def test_oneTransition_nonIterableOutputs(self): """ L{Automaton.addTransition} raises a TypeError when given outputs that aren't iterable and doesn't add any transitions. """ a = Automaton() nonIterableOutputs = 1 self.assertRaises( TypeError, a.addTransition, "fromState", "viaSymbol", "toState", nonIterableOutputs) self.assertFalse(a.inputAlphabet()) self.assertFalse(a.outputAlphabet()) self.assertFalse(a.states()) self.assertFalse(a.allTransitions()) def test_initialState(self): """ L{Automaton.initialState} is a descriptor that sets the initial state if it's not yet set, and raises L{ValueError} if it is. """ a = Automaton() a.initialState = "a state" self.assertEqual(a.initialState, "a state") with self.assertRaises(ValueError): a.initialState = "another state" # FIXME: addTransition for transition that's been added before __pycache__/__init__.cpython-310.pyc 0000644 00000000225 15030211240 0013177 0 ustar 00 o q+WZ � @ s d S )N� r r r �8/usr/lib/python3/dist-packages/automat/_test/__init__.py�<module> s __pycache__/test_discover.cpython-310.pyc 0000644 00000051334 15030211240 0014324 0 ustar 00 o q+WZVU � @ s� d dl Z d dlZd dlZd dlZd dlZd dlZd dlmZmZ d dl Z dd� Z G dd� de�Z ee � d�G dd � d e ��Z ee � d�G d d � d e ��Z ee � d�G d d � d e��Zee � d�G dd� de ��ZdS )� N)�skipIf�TestCasec C s$ zt d� W dS ty Y dS w )N�twistedFT)� __import__� ImportError� r r �=/usr/lib/python3/dist-packages/automat/_test/test_discover.py�isTwistedInstalled s ��r c s\ e Zd ZdZ� 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. c sv t t| ��� ddlm}m} ddlm} || _|| _|| _tt j � � �| _ t j d d � | _t�� | _| �| j� d S )Nr )� getModule� PythonPath)�FilePath)�superr �setUp�twisted.python.modulesr r �twisted.python.filepathr �set�sys�modules�keys�originalSysModules�path� savedSysPath�tempfile�mkdtemp�pathDir�makeImportable)�selfr r r �� __class__r r r s z_WritesPythonModules.setUpc sR t t| ��� | jtjd d �< t�tj�| j }|D ]}tj|= qt � | j � d S �N) r r �tearDownr r r �six�viewkeysr r �shutil�rmtreer )r �modulesToDelete�moduler r r r! * s z _WritesPythonModules.tearDownc C s t j�|� d S r )r r �append)r r r r r r 4 s z#_WritesPythonModules.makeImportablec C s^ | � |�}|�|�}t|jd��}|�t�|�� W d � n1 s#w Y | �|jg�S )N�w)r �child�openr �write�textwrap�dedentr )r �sourcer � moduleName� directoryr' �fr r r �writeSourceInto7 s �z$_WritesPythonModules.writeSourceIntoc C s" t j�|�\}}| �|||�| S r )�osr �splitextr3 )r r/ r r0 �pythonModuleName�_r r r � makeModuleB s z _WritesPythonModules.makeModulec C s dd� |� � D �S )Nc S s i | ]}|j |�qS r )�name)�.0�attrr r r � <dictcomp>G s z9_WritesPythonModules.attributesAsDict.<locals>.<dictcomp>)�iterAttributes)r �hasIterAttributesr r r �attributesAsDictF s z%_WritesPythonModules.attributesAsDictc C s |� � | �|�S r )�loadr? )r r' r r r �loadModuleAsDictI s z%_WritesPythonModules.loadModuleAsDictc C s | � | �|||��S r )rA r8 )r r/ r r9 r r r �makeModuleAsDictM s z%_WritesPythonModules.makeModuleAsDict) �__name__� __module__� __qualname__�__doc__r r! r r3 r8 r? rA rB � __classcell__r r r r r s r zTwisted is not installed.c s8 e Zd ZdZ� 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 �$ t t| ��� ddlm} || _d S )N� )�isOriginalLocation)r rH r � _discoverrK )r rK r r r r ^ � zOriginalLocationTests.setUpc C s, 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)rB r � assertFalserK )r r/ � moduleDictr r r �test_failsWithNoModulec s � �z,OriginalLocationTests.test_failsWithNoModulec C s~ 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)r8 r rB rN rK r? )r �originalSource�importingSource� importingDict� nestingObject�nestingObjectDict� nestedObjectr r r � test_failsWithDifferentModulev s. ����� �z3OriginalLocationTests.test_failsWithDifferentModulec C sp t �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.aNestingObjectz m.aNestingObject.nestedObjectN)r- r. rB r � assertTruerK r? )r �mSource�mDictrV rW rX r r r �test_succeedsWithSameModule� s � z1OriginalLocationTests.test_succeedsWithSameModule) rC rD rE rF r rP rY r] rG r r r r rH Q s %rH c sl e Zd ZdZdZ� fdd�Zdd� Zdd� Zd d � Zd d � Z d d� 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}. 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." c rI )NrJ )�findMachinesViaWrapper)r r^ r rL r_ )r r_ r r r r � rM z!FindMachinesViaWrapperTests.setUpc C s> 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)rB r �assertInr@ �listr_ )r r/ rO � rootMachiner r r �test_yieldsMachine� s �z.FindMachinesViaWrapperTests.test_yieldsMachinec C s@ 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)rB r rc r@ � _classMachinerd r_ �r r/ rO � PythonClassr r r �test_yieldsMachineInClass� s � �z5FindMachinesViaWrapperTests.test_yieldsMachineInClassc C sB d}| � || 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)rB r rc r@ � NestedClassrk rd r_ rl r r r � test_yieldsMachineInNestedClass� s � � �z;FindMachinesViaWrapperTests.test_yieldsMachineInNestedClassc C sD 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. r` ra rb N)r8 r rA r@ rc rd r_ )r r/ r' re r r r �test_yieldsMachineInModule s �z6FindMachinesViaWrapperTests.test_yieldsMachineInModulec C sF d}| � || 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. rg rh ri rj N)r8 r rA r@ rc rk rd r_ �r r/ r' rm r r r �!test_yieldsMachineInClassInModule s ���� �z=FindMachinesViaWrapperTests.test_yieldsMachineInClassInModulec C sH 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. ro rp rq rr N) r8 r rA r@ rc rs rk rd r_ rv r r r �'test_yieldsMachineInNestedClassInModule3 s ���� �zCFindMachinesViaWrapperTests.test_yieldsMachineInNestedClassInModulec C s@ 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 rQ rR N�r8 r rN rd r_ )r rS rT �importingModuler r r �test_ignoresImportedClassI s �z5FindMachinesViaWrapperTests.test_ignoresImportedClassc C s� | � | 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' z test_package.module.rootMachinez test_package.module.PythonClassz-test_package.module.PythonClass._classMachineN)r r r r* �makedirs�touchr8 r �sortedr_ �operator� itemgetterrA r@ rk � assertEqual) r � pythonPath�packager/ r| �machinesrO re rm �expectedMachinesr r r �test_descendsIntoPackagesd s0 � ����z5FindMachinesViaWrapperTests.test_descendsIntoPackagesc C s, 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 )r r/ r' r r r �test_infiniteLoop� s z-FindMachinesViaWrapperTests.test_infiniteLoop)rC rD rE rF �TEST_MODULE_SOURCEr rf rn rt ru rw rx r{ r� r� rG r r r r r^ � s &r^ c @ sx e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd S ) � WrapFQPNTestsz� Tests that ensure L{wrapFQPN} loads the L{twisted.python.modules.PythonModule} or L{twisted.python.modules.PythonAttribute} for a given FQPN. c C sP ddl m}m} ddlm}m}m}m} || _|| _|| _|| _|| _|| _d S )Nr )� PythonModule�PythonAttributerJ )�wrapFQPN� InvalidFQPN�NoModule�NoObject)r r� r� rL r� r� r� r� )r r� r� r� r� r� r� r r r r � s zWrapFQPNTests.setUpc C s2 | � || j� | �|j|j� | �|�� |� dS )zt Assert that a L{twisted.python.modules.PythonModule} refers to a particular Python module. N)�assertIsInstancer� r� r9 rC �assertIsr@ )r � moduleWrapperr' r r r �assertModuleWrapperRefersTo� s z)WrapFQPNTests.assertModuleWrapperRefersToc C s0 | � || j� | �|j|� | �|�� |� dS )zw Assert that a L{twisted.python.modules.PythonAttribute} refers to a particular Python object. N)r� r� r� r9 r� r@ )r �attributeWrapper�fqpn�objr r r � assertAttributeWrapperRefersTo� s z,WrapFQPNTests.assertAttributeWrapperRefersToc C �< | � | j�� | �d� W d � dS 1 sw Y dS )zO L{wrapFQPN} raises L{InvalidFQPN} when given an empty string. � N�� assertRaisesr� r� �r r r r �test_failsWithEmptyFQPN� s "�z%WrapFQPNTests.test_failsWithEmptyFQPNc C �D dD ] }| � | j�� | �|� W d � n1 sw Y qdS )zk" L{wrapFQPN} raises L{InvalidFQPN} when given a badly-dotted FQPN. (e.g., x..y). )z.failszfails.z this..failsNr� �r �badr r r �test_failsWithBadDotting� s ���z&WrapFQPNTests.test_failsWithBadDottingc C s4 ddl }| �d�}| �|| j� | �|�� |� dS )z� L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the single module a dotless FQPN describes. r Nr4 )r4 r� r� r� r� r@ )r r4 r� r r r �test_singleModule� s z WrapFQPNTests.test_singleModulec C r� )z~ L{wrapFQPN} raises L{NoModule} when given a dotless FQPN that does not refer to a module or package. z this is not an acceptable name!N)r� r� r� r� r r r �*test_failsWithMissingSingleModuleOrPackage� s "�z8WrapFQPNTests.test_failsWithMissingSingleModuleOrPackagec C s ddl }| �| �d�|� dS )z� L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the single package a dotless FQPN describes. r N�xml)r� r� r� �r r� r r r �test_singlePackage� s z WrapFQPNTests.test_singlePackagec C s ddl }| �| �d�|j� dS )z� L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the deepest package described by dotted FQPN. r Nz xml.etree)� xml.etreer� r� �etreer� r r r �test_multiplePackages� s z#WrapFQPNTests.test_multiplePackagesc C s" ddl }| �| �d�|jj� dS )z� L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the deepest module described by dotted FQPN. r Nzxml.etree.ElementTree)�xml.etree.ElementTreer� r� r� � ElementTreer� r r r � test_multiplePackagesFinalModule� � �z.WrapFQPNTests.test_multiplePackagesFinalModulec C s" 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. r Nzos.path)r4 r� r� r )r r4 r r r �test_singleModuleObject� r� z%WrapFQPNTests.test_singleModuleObjectc C sL ddl }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. r Nz xml.etree.ElementTree.fromstringz!automat.MethodicalMachine.__doc__) r� �automatr� r� � fromstring�MethodicalMachinerF r� r� )r r� r� r� r� r r r �test_multiplePackagesObject s �� � ��z)WrapFQPNTests.test_multiplePackagesObjectc C r� )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� r r r �4test_failsWithMultiplePackagesMissingModuleOrPackage s ���zBWrapFQPNTests.test_failsWithMultiplePackagesMissingModuleOrPackageN)rC rD rE rF r r� r� r� r� r� r� r� r� r� r� r� r� r r r r r� � s r� c s, e Zd ZdZdZ� 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" c s� t t| ��� ddlm} || _| �| j��d�}|�� | � | jg�| _ | � | j |j d� |�d�}|�� |�d��� | �| j |j d� | �| j d �| _| �| j d d d �| _d S )NrJ )� findMachinesr| r} � subpackager~ r' )r r� r rL r� r r r* r� r r� r3 �SOURCEr r� r8 rA � packageDictrO )r r� � packageDir� subPackageDirr r r r 3 s" � �z"FindMachinesIntegrationTests.setUpc C s� t | �d�t�d�d�}| jd �� }| jd �� }| jd }|�� }| jd }|�� }t d|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. r| r r ztest_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� r@ rO �_machiner� ) r r� � tpRootLevel� tpPythonClass�mRLAttr� mRootLevel�mPCAttr� mPythonClassr� r r r �test_discoverAllI s( � ���z-FindMachinesIntegrationTests.test_discoverAll)rC rD rE rF r� r r� rG r r r r r� s r� )r� r4 r$ r r- r �unittestr r r" r r rH r^ r� r� r r r r �<module> s( < a g __pycache__/test_visualize.cpython-310.pyc 0000644 00000036237 15030211240 0014526 0 ustar 00 o q+WZ�5 � @ s� d dl mZ d dlZd dlZd dlZd dlmZmZ d dlZddl m Z ddl m Z dd � Z d d � Zd d � Zee � d�G dd� de��ZejG dd� de��Zdd� Zdd� Zee � d�G dd� de��Zee � d�ee� d�G dd� de���Zee � d�G d d � d e��ZG d d � d e�ZG d d!� d!e�ZG d"d#� d#e�Zee � d�ee� d�ee � d$�G d%d&� d&e����Z dS )'� )�print_functionN)�TestCase�skipIf� )�MethodicalMachine� )�isTwistedInstalledc C s$ zt d� W dS ty Y dS w )z2 Is the graphviz Python module installed? �graphvizFT)� __import__� ImportError� r r �>/usr/lib/python3/dist-packages/automat/_test/test_visualize.py�isGraphvizModuleInstalled s ��r c C sB t �� \} }t �|� ztjd| dd� W t �| � S t �| � w )z+ Are the graphviz tools installed? �dotT)�stdin�shell)�os�pipe�close� subprocess�call)�r�wr r r �isGraphvizInstalled s r c s, t � � G � fdd�dt�} | � }|�� � S )zG Create a sample L{MethodicalMachine} with some sample states. c s` e Zd Z� jdd�dd� �Z� �� dd� �Z� �� dd� �Z� �� d d � �Z e� eee g� d S ) z#sampleMachine.<locals>.SampleObjectT)�initialc S � dS )z initial stateNr ��selfr r r �begin. � z)sampleMachine.<locals>.SampleObject.beginc S r )z end stateNr r r r r �end1 r z'sampleMachine.<locals>.SampleObject.endc S r )z sample inputNr r r r r �go4 r z&sampleMachine.<locals>.SampleObject.goc S r )z sample outputNr r r r r �out7 r z'sampleMachine.<locals>.SampleObject.outN) �__name__� __module__� __qualname__�stater r �inputr! �outputr" �uponr ��mmr r � SampleObject- s r, )r �objectr! )r, �sor r* r � sampleMachine( s r/ z!Graphviz module is not installed.c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �ElementMakerTestszL L{elementMaker} generates HTML representing the specified element. c C s ddl m} || _d S )Nr )� elementMaker)� _visualizer1 )r r1 r r r �setUpF s zElementMakerTests.setUpc C �" d}| � || jddddd�� dS )zK L{elementMaker} orders HTML attributes lexicographically. z <div a="1" b="2" c="3"></div>�div�2�1�3��b�a�cN�� assertEqualr1 �r �expectedr r r �test_sortsAttrsJ s ��z!ElementMakerTests.test_sortsAttrsc C r4 )z� L{elementMaker} quotes HTML attributes according to DOT's quoting rule. See U{http://www.graphviz.org/doc/info/lang.html}, footnote 1. z-<div a="1" b="a \" quote" c="a string"></div>r5 z a " quoter za stringr9 Nr= r? r r r �test_quotesAttrsU s ��z"ElementMakerTests.test_quotesAttrsc C s d}| � || �d�� dS )zN L{elementMaker} should render an element with no attributes. z <div ></div>r5 Nr= r? r r r � test_noAttrsb s z ElementMakerTests.test_noAttrsN)r# r$ r% �__doc__r3 rA rB rC r r r r r0 @ s r0 c @ s( e Zd ZdZe�� Ze�� Ze�� ZdS )� HTMLElementz2Holds an HTML element, as created by elementMaker.N) r# r$ r% rD �attr�ib�name�children� attributesr r r r rE j s rE c s. � | �r| gS t | �r g S � fdd�| jD �S )zk Recursively collect all elements in an L{HTMLElement} tree that match the optional predicate. c s g | ] }t |� �D ]}|�q qS r )� findElements)�.0�child�result�� predicater r � <listcomp>| s � �z findElements.<locals>.<listcomp>)�isLeafrI )�elementrP r rO r rK r s �rK c C s t | t� S )z2 This HTML element is actually leaf node. )� isinstancerE �rS r r r rR � s rR c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �TableMakerTestsz� Tests that ensure L{tableMaker} generates HTML tables usable as labels in DOT graphs. For more information, read the "HTML-Like Labels" section of U{http://www.graphviz.org/doc/info/shapes.html}. c O s t |||d�S )N)rH rI rJ )rE )r rH rI rJ r r r �fakeElementMaker� s z TableMakerTests.fakeElementMakerc C s. ddl m} d| _d| _tj|| jd�| _d S )Nr )� tableMaker� input labelzthe port)�_E)r2 rX � inputLabel�port� functools�partialrW )r rX r r r r3 � s �zTableMakerTests.setUpc s� � fdd�}g dgfD ];}� j � j|� jd�}� �t|j�d� |jd }t||�}� �t|�d� � �|d jd� � �t|t �� jg� q dS ) z� The table returned by L{tableMaker} always contains the input symbol label in its first row, and that row contains one cell with a port attribute set to the provided port. c s t | � o | j�d�� jkS )Nr\ )rR rJ �getr\ rU r r r �hasPort� s �z3TableMakerTests.test_inputLabelRow.<locals>.hasPortzan output label�r\ r r �tdN) rX r[ r\ � assertGreater�lenrI rK r> rH rR )r r` � outputLabels�table� inputLabelRow�portCandidatesr r r �test_inputLabelRow� s � ��z"TableMakerTests.test_inputLabelRowc C s> | j dd| jd�}| �t|j�d� |j\}| �d|j� dS )z� L{tableMaker} does not add a colspan attribute to the input label's cell or a second row if there no output labels. rY r ra r �colspanN)rX r\ r> rd rI � assertNotInrJ )r rf rg r r r �test_noOutputLabels� s z#TableMakerTests.test_noOutputLabelsc C sh | j | jd| jd�}| �t|j�d� |j\}}dd� }| �tt||��d� | �t|t�ddg� d S ) z� L{tableMaker} adds a colspan attribute to the input label's cell equal to the number of output labels and a second row that contains the output labels. )�output label 1�output label 2ra r c S s$ t | � o| jdko| j�d�dkS )Nrb rj r6 )rR rH rJ r_ rU r r r �hasCorrectColspan� s ��z@TableMakerTests.test_withOutputLabels.<locals>.hasCorrectColspanr rm rn N)rX r[ r\ r> rd rI rK rR )r rf �inputRow� outputRowro r r r �test_withOutputLabels� s � � �z%TableMakerTests.test_withOutputLabelsN) r# r$ r% rD rW r3 ri rl rr r r r r rV � s rV z!Graphviz tools are not installed.c @ � e Zd ZdZdd� ZdS )�IntegrationTestsz[ Tests which make sure Graphviz can understand the output produced by Automat. c C sF t jdt jt jd�}|�d�t� �� ��d��\}}| �|j d� dS )z8 L{graphviz} emits valid graphviz data. r )r �stdout� zutf-8r N) r �Popen�PIPE� communicate�joinr/ � asDigraph�encoder> � returncode)r �pr" �errr r r �test_validGraphviz� s ��z#IntegrationTests.test_validGraphvizN)r# r$ r% rD r� r r r r rt � s rt c @ rs )� SpotCheckszj Tests to make sure that the output contains salient features of the machine being generated. c C sD d� t� �� �}| �d|� | �d|� | �d|� | �d|� dS )z� The output of L{graphviz} should contain the names of the states, inputs, outputs in the state machine. rv r r r! r" N)rz r/ r{ �assertIn)r �gvoutr r r � test_containsMachineFeatures� s z'SpotChecks.test_containsMachineFeaturesN)r# r$ r% rD r� r r r r r� � s r� c @ � e Zd ZdZdd� Zdd� ZdS )�RecordsDigraphActionsz/ Records calls made to L{FakeDigraph}. c C s | � � d S �N)�resetr r r r �__init__ s z RecordsDigraphActions.__init__c C s g | _ g | _d S r� )� renderCalls� saveCallsr r r r r� s zRecordsDigraphActions.resetN)r# r$ r% rD r� r� r r r r r� � � r� c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � FakeDigraphzZ A fake L{graphviz.Digraph}. Instantiate it with a L{RecordsDigraphActions}. c C � || _ d S r� )� _recorder)r �recorderr r r r� � zFakeDigraph.__init__c K � | j j�|� d S r� )r� r� �append�r �kwargsr r r �render � zFakeDigraph.renderc K r� r� )r� r� r� r� r r r �save r� zFakeDigraph.saveN)r# r$ r% rD r� r� r� r r r r r� s r� c @ r� )�FakeMethodicalMachinezL A fake L{MethodicalMachine}. Instantiate it with a L{FakeDigraph} c C r� r� ��_digraph)r �digraphr r r r� r� z FakeMethodicalMachine.__init__c C s | j S r� r� r r r r r{ " s z FakeMethodicalMachine.asDigraphN)r# r$ r% rD r� r{ r r r r r� r� r� zTwisted is not installed.c @ sh e Zd Zdd� Zdd� Zdd� Z ddd �Zd d � Zd d � Zdd� Z dd� Z dd� Z dd� Z dS )�VisualizeToolTestsc C s2 t � | _t| j�| _d| _dg| _g | _d| _d S )Nz tool-test�ignoredz fake.fqpn)r� �digraphRecorderr� � fakeDigraph� fakeProgname� fakeSysPath�collectedOutput�fakeFQPNr r r r r3 + s zVisualizeToolTests.setUpc G s | j �d�|�� d S )N� )r� r� rz )r �argsr r r � collectPrints4 s z VisualizeToolTests.collectPrintsc c s � |t | j�fV d S r� )r� r� )r �fqpnr r r �fakeFindMachines7 s �z#VisualizeToolTests.fakeFindMachinesNc C s> ddl m} ||p | j|p| jg|p| j|p| j|p | jd�S )Nr )�tool)� _progname�_argv�_syspath� _findMachines�_print)r2 r� r� r� r� r� r� )r �progname�argv�syspath� findMachines�printr� r r r r� : s �zVisualizeToolTests.toolc C s& | j | jgd� | �| jd d� dS )z� L{tool} adds '' to sys.path to ensure L{automat._discover.findMachines} searches the current directory. �r� r rv N)r� r� r> r� r r r r �test_checksCurrentDirectoryH s z.VisualizeToolTests.test_checksCurrentDirectoryc C s@ | j | jdgd� | �| j� | j | jdgd� | �| j� dS )z6 Passing -q/--quiet hides all output. z--quietr� z-qN)r� r� � assertFalser� r r r r �test_quietHidesOutputQ s z(VisualizeToolTests.test_quietHidesOutputc C s� dD ]C}| j �� g | _| j| j|dgd� | �tdd� | jD ��� | �t| j j �d� | j j \}| �d� | j�|d � | �| j j � qd S ) ze Passing an empty string for --image-directory/-i disables rendering images. )�--image-directoryz-irv r� c s � � | ]}d |v V qdS ��imageNr �rL �liner r r � <genexpr>d � � �z6VisualizeToolTests.test_onlySaveDot.<locals>.<genexpr>r �{}.dot�filenameN) r� r� r� r� r� r� �anyr> rd r� �formatr� �r �argr r r r �test_onlySaveDotZ s � ��z#VisualizeToolTests.test_onlySaveDotc C s� dD ]J}| j �� g | _| j| j|dgd� | �tdd� | jD ��� | �t| j j �d� | j j \}| �d� | j�|d � | � |d � | �| j j � qd S ) zc Passing an empty string for --dot-directory/-d disables saving dot files. )�--dot-directoryz-drv r� c s r� �r Nr r� r r r r� x r� z8VisualizeToolTests.test_saveOnlyImage.<locals>.<genexpr>r r� r� �cleanupN) r� r� r� r� r� r� r� r> rd r� r� � assertTruer� r� r r r �test_saveOnlyImagen s � ��z%VisualizeToolTests.test_saveOnlyImagec C s� d}d}| j | jd|d|gd� | �tdd� | jD ��� | �tdd� | jD ��� | �t| jj�d � | jj\}| �|d |� | �|d � | �t| jj �d � | jj \}| �|d |� d S ) z� Passing different directories to --image-directory and --dot-directory writes images and dot files to those directories. r� r r� r� r� c s r� r� r r� r r r r� � r� zQVisualizeToolTests.test_saveDotAndImagesInDifferentDirectories.<locals>.<genexpr>c s r� r� r r� r r r r� � r� r � directoryr� N) r� r� r� r� r� r> rd r� r� r� )r �imageDirectory� dotDirectory� renderCall�saveCallr r r �+test_saveDotAndImagesInDifferentDirectories� s& � � � z>VisualizeToolTests.test_saveDotAndImagesInDifferentDirectoriesc C s� d}| j | jd|d|gd� | �tdd� | jD ��� | �t| jj�d� | jj\}| �|d |� | � |d � | � t| jj �� d S ) z� Passing the same directory to --image-directory and --dot-directory writes images and dot files to that one directory. � imagesAndDotr� r� r� c s r� )z image and dotNr r� r r r r� � r� zJVisualizeToolTests.test_saveDotAndImagesInSameDirectory.<locals>.<genexpr>r r� r� N) r� r� r� r� r� r> rd r� r� r� r� )r r� r� r r r �$test_saveDotAndImagesInSameDirectory� s � � z7VisualizeToolTests.test_saveDotAndImagesInSameDirectory)NNNNN) r# r$ r% r3 r� r� r� r� r� r� r� r� r� r r r r r� & s � r� ) � __future__r r] r r �unittestr r rF � _methodicalr � test_discoverr r r r/ r0 �sr- rE rK rR rV rt r� r� r� r� r� r r r r �<module> s> ) N __pycache__/test_core.cpython-310.pyc 0000644 00000005674 15030211240 0013444 0 ustar 00 o ��P] � @ s0 d dl mZmZ ddlmZ G dd� de�ZdS )� )� Automaton� NoTransition� )�TestCasec @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) � CoreTestszN Tests for Automat's (currently private, implementation detail) core. c C sv | � t�� t� W d � n1 sw Y d}d}t||d�}| �|j|� | �|t|�� | �|t|�� dS )zj A L{NoTransition} exception describes the state and input symbol that caused it. Nz current-stateztransitionless-symbol)�state�symbol)� assertRaises� TypeErrorr �assertIsr �assertIn�str)�selfr r �noTransitionException� r �9/usr/lib/python3/dist-packages/automat/_test/test_core.py�test_NoTransition s � zCoreTests.test_NoTransitionc C s t � }| �t|jdd� dS )zx L{Automaton.outputForInput} raises L{NoTransition} if no transition for that input is defined. zno-statez no-symbolN)r r r �outputForInput�r �ar r r �test_noOutputForInput s �z CoreTests.test_noOutputForInputc C sn t � }|�ddddg� | �|�� dh� | �|�� dh� | �|�dd�ddgf� | �|�� ddh� dS )a L{Automaton.addTransition} adds its input symbol to L{Automaton.inputAlphabet}, all its outputs to L{Automaton.outputAlphabet}, and causes L{Automaton.outputForInput} to start returning the new state and output symbols. � beginning�begin�ending�endN)r � addTransition� assertEqual� inputAlphabet�outputAlphabetr �statesr r r r �test_oneTransition( s �z CoreTests.test_oneTransitionc C s\ t � }d}| �t|jddd|� | �|�� � | �|�� � | �|�� � | �|�� � dS )z� L{Automaton.addTransition} raises a TypeError when given outputs that aren't iterable and doesn't add any transitions. � � fromState� viaSymbol�toStateN) r r r r � assertFalser r r �allTransitions)r r �nonIterableOutputsr r r �%test_oneTransition_nonIterableOutputs8 s �z/CoreTests.test_oneTransition_nonIterableOutputsc C sP t � }d|_| �|jd� | �t�� d|_W d � dS 1 s!w Y dS )z� L{Automaton.initialState} is a descriptor that sets the initial state if it's not yet set, and raises L{ValueError} if it is. za statez another stateN)r � initialStater r � ValueErrorr r r r �test_initialStateI s "�zCoreTests.test_initialStateN) �__name__� __module__� __qualname__�__doc__r r r r( r+ r r r r r s r N)�_corer r �unittestr r r r r r �<module> s __pycache__/test_trace.cpython-310.pyc 0000644 00000005652 15030211240 0013606 0 ustar 00 o q+WZ� � @ s< d dl mZ ddlmZ G dd� de�ZG dd� de�ZdS ) � )�TestCase� )�MethodicalMachinec @ s� e Zd Ze� Zejdd�dd� �Ze�� dd� �Ze�� dd� �Ze� � d d � �Z e� � d d � �Z e� � d d� �Z e� � dd� �ZejZe�e eeg� e�e eeg� e�e eg � e�e eg � dS )� SampleObjectT)�initialc C � dS )z initial stateN� ��selfr r �:/usr/lib/python3/dist-packages/automat/_test/test_trace.py�begin � zSampleObject.beginc C r )z middle stateNr r r r r �middle r zSampleObject.middlec C r )z end stateNr r r r r �end r zSampleObject.endc C r �z sample inputNr r r r r �go1 r zSampleObject.go1c C r r r r r r r �go2 r zSampleObject.go2c C r r r r r r r �back r zSampleObject.backc C r )z sample outputNr r r r r �out r zSampleObject.outN)�__name__� __module__� __qualname__r �mm�stater r r �inputr r r �outputr � _setTrace�setTrace�uponr r r r r s* r c @ s e Zd Zdd� Zdd� ZdS )� TraceTestsc s� g � � fdd�}t � }|�|� |�� | �� dg� |�� | �� ddg� |�d � |�� | �� ddg� |�� | �� ddg� d S )Nc s � � | ||f� d S �N��append)� old_stater � new_state��tracesr r �tracer) s z+TraceTests.test_only_inputs.<locals>.tracer)r r r )r r r �r r r � assertEqualr r �r r' �sr r% r �test_only_inputs' s& � � �zTraceTests.test_only_inputsc s� g � � fdd�}t � }|�|� |�� | �� ddg� |�� | �� g d�� |�d � |�� | �� g d�� |�� | �� g d�� d S )Nc s( �� �� �d f� � ���fdd�}|S )Nc s �� �� �| f� d S r r! )r )r r$ r# r& r r � trace_outputsE s zITraceTests.test_inputs_and_outputs.<locals>.tracer.<locals>.trace_outputsr! )r# r r$ r- r% )r r$ r# r r' C s z2TraceTests.test_inputs_and_outputs.<locals>.tracer�r r r N�r r r r )r. r/ )r r r N)r r r r r( r* r r% r �test_inputs_and_outputsA s � z"TraceTests.test_inputs_and_outputsN)r r r r, r0 r r r r r & s r N)�unittestr � _methodicalr �objectr r r r r r �<module> s " __pycache__/test_methodical.cpython-310.pyc 0000644 00000063307 15030211240 0014622 0 ustar 00 o ��[�I � @ sd d Z ddlmZ ddlmZ ddlmZmZmZm Z ddl m Z m Z ddl m Z G dd � d e�Zd S ) z, Tests for the public interface of Automat. � )�reduce)�TestCase)�ArgSpec� _getArgNames� _getArgSpec� _filterArgs� )�MethodicalMachine� NoTransition)� _methodicalc @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$S )%�MethodicalTestsz) Tests for L{MethodicalMachine}. c C s> G dd� dt �}|� }| �|�� dg� | �|�� dg� dS )a! L{MethodicalMachine} provides a way for you to declare a state machine with inputs, outputs, and states as methods. When you have declared an input, an output, and a state, calling the input method in that state will produce the specified output. c @ s� e Zd Ze� Ze�� dd� �Ze�� dd� �Ze�� dd� �Z ej dd�d d � �Z e� � d d � �Z e j ee egd � e j ee e gd � dS )z7MethodicalTests.test_oneTransition.<locals>.Machinationc S � dS �zan inputN� ��selfr r �?/usr/lib/python3/dist-packages/automat/_test/test_methodical.py�anInput � z?MethodicalTests.test_oneTransition.<locals>.Machination.anInputc S r )z an output�an-output-valuer r r r r �anOutput! � z@MethodicalTests.test_oneTransition.<locals>.Machination.anOutputc S r )zanother output�another-output-valuer r r r r � anotherOutput& r zEMethodicalTests.test_oneTransition.<locals>.Machination.anotherOutputT��initialc S r �za stateNr r r r r �anState+ r z?MethodicalTests.test_oneTransition.<locals>.Machination.anStatec S r )z another stateNr r r r r � anotherState/ r zDMethodicalTests.test_oneTransition.<locals>.Machination.anotherState��enter�outputsN)�__name__� __module__� __qualname__r �machine�inputr �outputr r �stater r �uponr r r r � Machination s �r* r r N)�object� assertEqualr )r r* �mr r r �test_oneTransition s z"MethodicalTests.test_oneTransitionc st t � � G � fdd�dt�}|� }| �t�� }|j W d � n1 s#w Y | �dt|j�� | �|j� � dS )a4 L{MethodicalMachine} is an implementation detail. If you attempt to access it on an instance of your class, you will get an exception. However, since tools may need to access it for the purposes of, for example, visualization, you may access it on the class itself. c s e Zd Z� ZdS )z@MethodicalTests.test_machineItselfIsPrivate.<locals>.MachinationN)r" r# r$ r% r ��expectedMachiner r r* D s r* Nz-MethodicalMachine is an implementation detail) r r+ � assertRaises�AttributeErrorr% �assertIn�str� exception�assertIs)r r* � machination�cmr r/ r �test_machineItselfIsPrivate< s ��z+MethodicalTests.test_machineItselfIsPrivatec C s� G dd� dt �}|� }|�� | �|jd� |� }| �t�� }|j W d � n1 s,w Y | �|jd� | �dt|j �� dS )au One of the benefits of using a state machine is that your output method implementations don't need to take invalid state transitions into account - the methods simply won't be called. This property would be broken if client code called output methods directly, so output methods are not directly visible under their names. c @ s\ e Zd Ze� ZdZe�� dd� �Ze�� dd� �Z ej dd�dd � �Z e j ee e gd � d S ) z;MethodicalTests.test_outputsArePrivate.<locals>.Machinationr c S r r r r r r r r Y r zCMethodicalTests.test_outputsArePrivate.<locals>.Machination.anInputc S s | j d7 _ d S �N� )�counterr r r r r \ s zDMethodicalTests.test_outputsArePrivate.<locals>.Machination.anOutputTr c S r )za machine stateNr r r r r r( _ r zAMethodicalTests.test_outputsArePrivate.<locals>.Machination.stater N) r" r# r$ r r% r< r& r r' r r( r) r r r r r* V s r* r; Nr zlMachination.anOutput is a state-machine output method; to produce this output, call an input method instead.) r+ r r, r< r1 r2 r r3 r4 r5 )r r* �mach1�mach2r8 r r r �test_outputsArePrivateN s ��z&MethodicalTests.test_outputsArePrivatec C s> G dd� dt �}|� }| �|�� dg� | �|�� dg� dS )zw Two machines may co-exist happily on the same instance; they don't interfere with each other. c @ s� e Zd Ze� Ze� Ze�� dd� �Ze�� dd� �Zej dd�dd� �Z ej dd�d d � �Z e� � d d � �Z e� � d d� �Ze �ee e g� e �ee eg� dS )z8MethodicalTests.test_multipleMachines.<locals>.MultiMachc S r )zinput ANr r r r r �inputA{ r z?MethodicalTests.test_multipleMachines.<locals>.MultiMach.inputAc S r )zinput BNr r r r r �inputB~ r z?MethodicalTests.test_multipleMachines.<locals>.MultiMach.inputBTr c S r )z initial ANr r r r r �initialA� r zAMethodicalTests.test_multipleMachines.<locals>.MultiMach.initialAc S r )z initial BNr r r r r �initialB� r zAMethodicalTests.test_multipleMachines.<locals>.MultiMach.initialBc S r �N�Ar r r r r �outputA� � z@MethodicalTests.test_multipleMachines.<locals>.MultiMach.outputAc S r �N�Br r r r r �outputB� rG z@MethodicalTests.test_multipleMachines.<locals>.MultiMach.outputBN)r" r# r$ r �a�br& r@ rA r( rB rC r' rF rJ r) r r r r � MultiMachw s" rM rE rI N)r+ r, r@ rA )r rM �mmr r r �test_multipleMachinesr s z%MethodicalTests.test_multipleMachinesc s6 ddl � G � fdd�dt�}|� }| �|�� d� dS )zR Outputs can be combined with the "collector" argument to "upon". r Nc st e Zd Ze� Ze�� dd� �Ze�� dd� �Ze�� dd� �Zej dd�d d � �Z e j ee eeg� fd d �d � dS )z4MethodicalTests.test_collectOutputs.<locals>.Machinec S r r r r r r r r& � r z:MethodicalTests.test_collectOutputs.<locals>.Machine.inputc S r rD r r r r r rF � rG z<MethodicalTests.test_collectOutputs.<locals>.Machine.outputAc S r rH r r r r r rJ � rG z<MethodicalTests.test_collectOutputs.<locals>.Machine.outputBTr c S r r r r r r r r( � r z:MethodicalTests.test_collectOutputs.<locals>.Machine.statec s t � j| �S �N)r �add��x��operatorr r �<lambda>� � z=MethodicalTests.test_collectOutputs.<locals>.Machine.<lambda>�� collectorN) r" r# r$ r r- r& r' rF rJ r( r) r rT r r �Machine� s �rZ �AB)rU r+ r, r& )r rZ r- r rT r �test_collectOutputs� s z#MethodicalTests.test_collectOutputsc C sd G dd� dt �}|� }| �t��}|�ddd� W d � n1 s"w Y | �dt|j�� dS )z> Input methods preserve their declared names. c @ s6 e Zd Ze� Ze�� dd� �Zejdd�dd� �ZdS )z-MethodicalTests.test_methodName.<locals>.Mechc S r r r r r r r �declaredInputName� r z?MethodicalTests.test_methodName.<locals>.Mech.declaredInputNameTr c S r )r( Nr r r r r �aState� r z4MethodicalTests.test_methodName.<locals>.Mech.aStateN) r" r# r$ r r- r& r] r( r^ r r r r �Mech� s r_ �too�many� argumentsNr] )r+ r1 � TypeErrorr] r3 r4 r5 )r r_ r- r8 r r r �test_methodName� s �z MethodicalTests.test_methodNamec C s< G dd� dt �}|� }| �|�d�dg� | �|jd� dS )zW If an input takes an argument, it will pass that along to its output. c @ sZ e Zd Ze� Ze�� d dd��Zejdd�dd� �Ze�� d dd ��Ze�eeeg� d S ) z:MethodicalTests.test_inputWithArguments.<locals>.Mechanismr; c S r r r �r rS �yr r r r& � r z@MethodicalTests.test_inputWithArguments.<locals>.Mechanism.inputTr c S r r r r r r r r( � r z@MethodicalTests.test_inputWithArguments.<locals>.Mechanism.statec S s || _ || S rP ��_xre r r r r' � s zAMethodicalTests.test_inputWithArguments.<locals>.Mechanism.outputN�r; ) r" r# r$ r r- r& r( r' r) r r r r � Mechanism� s rj � � N)r+ r, r& rh �r rj r- r r r �test_inputWithArguments� s z'MethodicalTests.test_inputWithArgumentsc C s� G dd� dt �}|� }| �|�d�g d�� | �|jd� | �|jd� | �|jdd�g d�� | �|jd� | �|jd� | �|�d d�g d �� | �|jd � | �|jd� | �|jd d d �g d�� | �|jd � | �|jd � dS )z@ Inputs pass arguments that output will accept. c @ s| e Zd Ze� Ze�� ddd��Zejdd�dd� �Ze�� dd � �Ze�� d d � �Z e�� d d � �Z e� eeee e g� dS )zCMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanismr; c S r r r re r r r r& � r zIMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanism.inputTr c S r r r r r r r r( � r zIMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanism.statec S � || _ |S rP rg )r rS r r r �outputX� � zKMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanism.outputXc S ro rP )�_y)r rf r r r �outputY� rq zKMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanism.outputYc S � d S rP r r r r r � outputNoArgs� rG zPMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanism.outputNoArgsNri ) r" r# r$ r r- r& r( r' rp rs ru r) r r r r rj � s rj rk )rk r; Nr; rl rR )rl r; N� )rv rk N� r )rf )rw r NN)r+ r, r& rh rr rm r r r � test_outputWithSubsetOfArguments� s z0MethodicalTests.test_outputWithSubsetOfArgumentsc s� t �� t �� G � fdd�dt�}G dd� dt�}|� �� G dd� dt�}|� �� G dd� dt�}|� �� G d d � d t�}|� �� G d d � d t�}|� �� d S )zE The wrapped input function must have an empty body. c s^ e Zd Ze� Z� �e��Ze�� dd� �ZW d � n1 s w Y � � e ej �d� dS )zAMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.Mechanismc S s t � dS r ��listr r r r r& s zGMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.Mechanism.inputNzfunction body must be empty) r" r# r$ r r- r1 � ValueErrorr8 r& r, r4 r5 r r r r rj s �rj c @ �F e Zd Ze� Ze�� dd� �Zejdd�dd� �Zejeeg d� dS ) zNMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringc S r r r r r r r r& r zTMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstring.inputTr c S r �zstarting stateNr r r r r �start" r zTMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstring.startr N� r" r# r$ r r- r& r( r~ r) r r r r �MechanismWithDocstring � r� c @ r| ) zIMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithPassc S rt rP r r r r r r& * rG zOMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithPass.inputTr c S r r} r r r r r r~ - r zOMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithPass.startr Nr r r r r �MechanismWithPass( r� r� c @ r| ) zUMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndPassc S r r r r r r r r& 5 r z[MethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndPass.inputTr c S r r} r r r r r r~ 9 r z[MethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndPass.startr Nr r r r r � MechanismWithDocstringAndPass3 � r� c @ r| ) zLMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismReturnsNonec S rt rP r r r r r r& A rG zRMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismReturnsNone.inputTr c S r r} r r r r r r~ D r zRMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismReturnsNone.startr Nr r r r r �MechanismReturnsNone? r� r� c @ r| ) z\MethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndReturnsNonec S r r r r r r r r& L r zbMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndReturnsNone.inputTr c S r r} r r r r r r~ P r zbMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndReturnsNone.startr Nr r r r r �$MechanismWithDocstringAndReturnsNoneJ r� r� N)r �_empty� _docstringr+ r& )r rj r� r� r� r� r� r r r � test_inputFunctionsMustBeEmpty s z.MethodicalTests.test_inputFunctionsMustBeEmptyc � G � fdd�dt �}dS )z� All the argument lists of the outputs for a given input must match; if one does not the call to C{upon} will raise a C{TypeError}. c s� e Zd Ze� Ze�� dd� �Ze�� dd� �Ze�� dd� �Z e� � dd� �Z � � e ��Z e �ee ee g� W d � n1 s@w Y � �d ee j�� � �d ee j�� d S ) z;MethodicalTests.test_inputOutputMismatch.<locals>.Mechanismc S r r r �r rK r r r � nameOfInput^ r zGMethodicalTests.test_inputOutputMismatch.<locals>.Mechanism.nameOfInputc S r )zan output that matchesNr r� r r r �outputThatMatchesa r zMMethodicalTests.test_inputOutputMismatch.<locals>.Mechanism.outputThatMatchesc S r )z an output that doesn't matchNr )r rL r r r �outputThatDoesntMatchd r zQMethodicalTests.test_inputOutputMismatch.<locals>.Mechanism.outputThatDoesntMatchc S r r r r r r r r( g r zAMethodicalTests.test_inputOutputMismatch.<locals>.Mechanism.stateNr� r� )r" r# r$ r r- r& r� r' r� r� r( r1 rc r8 r) r3 r4 r5 r r r r rj \ s" � �rj N�r+ �r rj r r r �test_inputOutputMismatchW � z(MethodicalTests.test_inputOutputMismatchc C sF t dddddddtfdtffd�}| �t|�dddtfdtfh� dS )zC Type annotations should be included in the set of )rK rL Nr rK rL )�args�varargs�varkw�defaults� kwonlyargs�kwonlydefaults� annotations)r �intr4 r, r )r �specr r r �test_getArgNamesq s � �z MethodicalTests.test_getArgNamesc C s> t dd� �}t dd� �}d}t|i ||�\}}| �||� dS )zl filterArgs() should not filter the `args` parameter if outputSpec accepts `*args`. c _ rt rP r �r� �kwargsr r r rV � r z1MethodicalTests.test_filterArgs.<locals>.<lambda>c _ rt rP r r� r r r rV � r r N)r r r6 )r � inputSpec� outputSpec�argsIn�argsOut�_r r r �test_filterArgs� s z MethodicalTests.test_filterArgsc r� )zI A L{MethodicalMachine} can only have one initial state. c sf e Zd Ze� Zejdd�dd� �Z� �e�� ejdd�dd� �Z W d � dS 1 s,w Y dS )zCMethodicalTests.test_multipleInitialStatesFailure.<locals>.WillFailTr c S r )z&The first initial state -- this is OK.Nr r r r r �firstInitialState� r zUMethodicalTests.test_multipleInitialStatesFailure.<locals>.WillFail.firstInitialStatec S r )z4The second initial state -- results in a ValueError.Nr r r r r �secondInitialState� r zVMethodicalTests.test_multipleInitialStatesFailure.<locals>.WillFail.secondInitialStateN) r" r# r$ r r- r( r� r1 r{ r� r r r r �WillFail� s "�r� Nr� �r r� r r r �!test_multipleInitialStatesFailure� r� z1MethodicalTests.test_multipleInitialStatesFailurec r� )zc A L{MethodicalMachine} can only have one transition per start/event pair. c s� e Zd Ze� Zejdd�dd� �Ze�� dd� �Ze�� dd� �Z ej e eg d � � � e �� ej e eg d � W d � d S 1 sBw Y d S ) zAMethodicalTests.test_multipleTransitionsFailure.<locals>.WillFailTr c S r )zWe start here.Nr r r r r r~ � r zGMethodicalTests.test_multipleTransitionsFailure.<locals>.WillFail.startc S r )z Rainbows end.Nr r r r r �end� r zEMethodicalTests.test_multipleTransitionsFailure.<locals>.WillFail.endc S r )z An event.Nr r r r r �event� r zGMethodicalTests.test_multipleTransitionsFailure.<locals>.WillFail.eventr N) r" r# r$ r r- r( r~ r� r& r� r) r1 r{ r r r r r� � s "�r� Nr� r� r r r � test_multipleTransitionsFailure� s z/MethodicalTests.test_multipleTransitionsFailurec C s� G dd� dt �}|� }| �t�� }|�� W d � n1 s w Y | �dt|j�� | �dt|j�� |�� | �t�� }|�� W d � n1 sNw Y | �dt|j�� | �dt|j�� dS )z� Calling any input method that lacks a transition for the machine's current state raises an informative L{NoTransition}. c @ sd e Zd Ze� Zejdd�dd� �Ze�� dd� �Ze�� dd� �Z e�� d d � �Z e� e eg � d S ) zFMethodicalTests.test_badTransitionForCurrentState.<locals>.OnlyOnePathTr c S r )z Start state.Nr r r r r r~ � r zLMethodicalTests.test_badTransitionForCurrentState.<locals>.OnlyOnePath.startc S r )z End state.Nr r r r r r� � r zJMethodicalTests.test_badTransitionForCurrentState.<locals>.OnlyOnePath.endc S r )zMove from start to end.Nr r r r r �advance� r zNMethodicalTests.test_badTransitionForCurrentState.<locals>.OnlyOnePath.advancec S r )z%A transition from nowhere to nowhere.Nr r r r r �deadEnd� r zNMethodicalTests.test_badTransitionForCurrentState.<locals>.OnlyOnePath.deadEndN) r" r# r$ r r- r( r~ r� r& r� r� r) r r r r � OnlyOnePath� s r� Nr� r~ r� )r+ r1 r r� r3 r4 r5 r� )r r� r% r8 r r r �!test_badTransitionForCurrentState� s � �z1MethodicalTests.test_badTransitionForCurrentStatec C s, G dd� dt �}| �|� �� ddd�� dS )a L{MethodicalMachine.serializer} is a decorator that modifies its decoratee's signature to take a "state" object as its first argument, which is the "serialized" argument to the L{MethodicalMachine.state} decorator. c @ sT e Zd Ze� Zdd� Zejddd�dd� �Zejdd �d d � �Ze� � d d � �Z dS )z1MethodicalTests.test_saveState.<locals>.Mechanismc S s d| _ d S r: ��valuer r r r �__init__� s z:MethodicalTests.test_saveState.<locals>.Mechanism.__init__� first-stateT�� serializedr c S r �z First state.Nr r r r r �first� r z7MethodicalTests.test_saveState.<locals>.Mechanism.first� second-state�r� c S r �z Second state.Nr r r r r �second� r z8MethodicalTests.test_saveState.<locals>.Mechanism.secondc S � || j d�S �N�� machine-state� some-valuer� �r r( r r r �save� � �z6MethodicalTests.test_saveState.<locals>.Mechanism.saveN) r" r# r$ r r- r� r( r� r� � serializerr� r r r r rj � s rj r� r; r� N)r+ r, r� r� r r r �test_saveState� s ��z MethodicalTests.test_saveStatec C sh G dd� dt �}|� }|�� |�� }|�|�}| �|jd� | �|�� d� | �|�� ddd�� dS )a/ L{MethodicalMachine.unserializer} decorates a function that becomes a machine-state unserializer; its return value is mapped to the C{serialized} parameter to C{state}, and the L{MethodicalMachine} associated with that instance's state is updated to that state. c @ s� e Zd Ze� Zdd� Zejddd�dd� �Zejdd �d d � �Ze� � d d � �Z e� � dd� �Z e� � dd� �Z ej e ee gdd� d� ej e ee gdd� d� e� � dd� �Ze�� dd� �Zedd� �Zd S ) z4MethodicalTests.test_restoreState.<locals>.Mechanismc S s d| _ d| _d S )Nr; F�r� � ranOutputr r r r r� s z=MethodicalTests.test_restoreState.<locals>.Mechanism.__init__r� Tr� c S r r� r r r r r r� r z:MethodicalTests.test_restoreState.<locals>.Mechanism.firstr� r� c S r r� r r r r r r� r z;MethodicalTests.test_restoreState.<locals>.Mechanism.secondc S r r r r r r r r& r z:MethodicalTests.test_restoreState.<locals>.Mechanism.inputc S s d| _ d| _dS )Nr Tr; r� r r r r r' s z;MethodicalTests.test_restoreState.<locals>.Mechanism.outputc S r )Nr r r r r r �output2 rG z<MethodicalTests.test_restoreState.<locals>.Mechanism.output2c S � t | �d S �Nr ry rR r r r rV rW z=MethodicalTests.test_restoreState.<locals>.Mechanism.<lambda>rX c S r� r� ry rR r r r rV rW c S r� r� r� r� r r r r� r� z9MethodicalTests.test_restoreState.<locals>.Mechanism.savec S s |d | _ |d S )Nr� r� r� )r �blobr r r �_restore' s z=MethodicalTests.test_restoreState.<locals>.Mechanism._restorec S s | � }|� |� |S rP )r� )�clsr� r r r r �fromBlob, s z=MethodicalTests.test_restoreState.<locals>.Mechanism.fromBlobN)r" r# r$ r r- r� r( r� r� r& r' r� r) r� r� � unserializerr� � classmethodr� r r r r rj s2 � � rj Fr r� r� N)r+ r& r� r� r, r� )r rj �m1r� �m2r r r �test_restoreState� s , ��z!MethodicalTests.test_restoreStateN)r" r# r$ �__doc__r. r9 r? rO r\ rd rn rx r� r� r� r� r� r� r� r� r� r r r r r s& )$#0P " "r N)r� � functoolsr �unittestr �automat._methodicalr r r r � r r r r r r r r �<module> s test_trace.py 0000644 00000006317 15030211240 0007246 0 ustar 00 from unittest import TestCase from .._methodical import MethodicalMachine class SampleObject(object): mm = MethodicalMachine() @mm.state(initial=True) def begin(self): "initial state" @mm.state() def middle(self): "middle state" @mm.state() def end(self): "end state" @mm.input() def go1(self): "sample input" @mm.input() def go2(self): "sample input" @mm.input() def back(self): "sample input" @mm.output() def out(self): "sample output" setTrace = mm._setTrace begin.upon(go1, middle, [out]) middle.upon(go2, end, [out]) end.upon(back, middle, []) middle.upon(back, begin, []) class TraceTests(TestCase): def test_only_inputs(self): traces = [] def tracer(old_state, input, new_state): traces.append((old_state, input, new_state)) return None # "I only care about inputs, not outputs" s = SampleObject() s.setTrace(tracer) s.go1() self.assertEqual(traces, [("begin", "go1", "middle"), ]) s.go2() self.assertEqual(traces, [("begin", "go1", "middle"), ("middle", "go2", "end"), ]) s.setTrace(None) s.back() self.assertEqual(traces, [("begin", "go1", "middle"), ("middle", "go2", "end"), ]) s.go2() self.assertEqual(traces, [("begin", "go1", "middle"), ("middle", "go2", "end"), ]) def test_inputs_and_outputs(self): traces = [] def tracer(old_state, input, new_state): traces.append((old_state, input, new_state, None)) def trace_outputs(output): traces.append((old_state, input, new_state, output)) return trace_outputs # "I care about outputs too" s = SampleObject() s.setTrace(tracer) s.go1() self.assertEqual(traces, [("begin", "go1", "middle", None), ("begin", "go1", "middle", "out"), ]) s.go2() self.assertEqual(traces, [("begin", "go1", "middle", None), ("begin", "go1", "middle", "out"), ("middle", "go2", "end", None), ("middle", "go2", "end", "out"), ]) s.setTrace(None) s.back() self.assertEqual(traces, [("begin", "go1", "middle", None), ("begin", "go1", "middle", "out"), ("middle", "go2", "end", None), ("middle", "go2", "end", "out"), ]) s.go2() self.assertEqual(traces, [("begin", "go1", "middle", None), ("begin", "go1", "middle", "out"), ("middle", "go2", "end", None), ("middle", "go2", "end", "out"), ]) test_visualize.py 0000644 00000032660 15030211240 0010163 0 ustar 00 from __future__ import print_function import functools import os import subprocess from unittest import TestCase, skipIf import attr from .._methodical import MethodicalMachine from .test_discover import isTwistedInstalled def isGraphvizModuleInstalled(): """ Is the graphviz Python module installed? """ try: __import__("graphviz") except ImportError: return False else: return True def isGraphvizInstalled(): """ Are the graphviz tools installed? """ r, w = os.pipe() os.close(w) try: return not subprocess.call("dot", stdin=r, shell=True) finally: os.close(r) def sampleMachine(): """ Create a sample L{MethodicalMachine} with some sample states. """ mm = MethodicalMachine() class SampleObject(object): @mm.state(initial=True) def begin(self): "initial state" @mm.state() def end(self): "end state" @mm.input() def go(self): "sample input" @mm.output() def out(self): "sample output" begin.upon(go, end, [out]) so = SampleObject() so.go() return mm @skipIf(not isGraphvizModuleInstalled(), "Graphviz module is not installed.") class ElementMakerTests(TestCase): """ L{elementMaker} generates HTML representing the specified element. """ def setUp(self): from .._visualize import elementMaker self.elementMaker = elementMaker def test_sortsAttrs(self): """ L{elementMaker} orders HTML attributes lexicographically. """ expected = r'<div a="1" b="2" c="3"></div>' self.assertEqual(expected, self.elementMaker("div", b='2', a='1', c='3')) def test_quotesAttrs(self): """ L{elementMaker} quotes HTML attributes according to DOT's quoting rule. See U{http://www.graphviz.org/doc/info/lang.html}, footnote 1. """ expected = r'<div a="1" b="a \" quote" c="a string"></div>' self.assertEqual(expected, self.elementMaker("div", b='a " quote', a=1, c="a string")) def test_noAttrs(self): """ L{elementMaker} should render an element with no attributes. """ expected = r'<div ></div>' self.assertEqual(expected, self.elementMaker("div")) @attr.s class HTMLElement(object): """Holds an HTML element, as created by elementMaker.""" name = attr.ib() children = attr.ib() attributes = attr.ib() def findElements(element, predicate): """ Recursively collect all elements in an L{HTMLElement} tree that match the optional predicate. """ if predicate(element): return [element] elif isLeaf(element): return [] return [result for child in element.children for result in findElements(child, predicate)] def isLeaf(element): """ This HTML element is actually leaf node. """ return not isinstance(element, HTMLElement) @skipIf(not isGraphvizModuleInstalled(), "Graphviz module is not installed.") class TableMakerTests(TestCase): """ Tests that ensure L{tableMaker} generates HTML tables usable as labels in DOT graphs. For more information, read the "HTML-Like Labels" section of U{http://www.graphviz.org/doc/info/shapes.html}. """ def fakeElementMaker(self, name, *children, **attributes): return HTMLElement(name=name, children=children, attributes=attributes) def setUp(self): from .._visualize import tableMaker self.inputLabel = "input label" self.port = "the port" self.tableMaker = functools.partial(tableMaker, _E=self.fakeElementMaker) def test_inputLabelRow(self): """ The table returned by L{tableMaker} always contains the input symbol label in its first row, and that row contains one cell with a port attribute set to the provided port. """ def hasPort(element): return (not isLeaf(element) and element.attributes.get("port") == self.port) for outputLabels in ([], ["an output label"]): table = self.tableMaker(self.inputLabel, outputLabels, port=self.port) self.assertGreater(len(table.children), 0) inputLabelRow = table.children[0] portCandidates = findElements(table, hasPort) self.assertEqual(len(portCandidates), 1) self.assertEqual(portCandidates[0].name, "td") self.assertEqual(findElements(inputLabelRow, isLeaf), [self.inputLabel]) def test_noOutputLabels(self): """ L{tableMaker} does not add a colspan attribute to the input label's cell or a second row if there no output labels. """ table = self.tableMaker("input label", (), port=self.port) self.assertEqual(len(table.children), 1) (inputLabelRow,) = table.children self.assertNotIn("colspan", inputLabelRow.attributes) def test_withOutputLabels(self): """ L{tableMaker} adds a colspan attribute to the input label's cell equal to the number of output labels and a second row that contains the output labels. """ table = self.tableMaker(self.inputLabel, ("output label 1", "output label 2"), port=self.port) self.assertEqual(len(table.children), 2) inputRow, outputRow = table.children def hasCorrectColspan(element): return (not isLeaf(element) and element.name == "td" and element.attributes.get('colspan') == "2") self.assertEqual(len(findElements(inputRow, hasCorrectColspan)), 1) self.assertEqual(findElements(outputRow, isLeaf), ["output label 1", "output label 2"]) @skipIf(not isGraphvizModuleInstalled(), "Graphviz module is not installed.") @skipIf(not isGraphvizInstalled(), "Graphviz tools are not installed.") class IntegrationTests(TestCase): """ Tests which make sure Graphviz can understand the output produced by Automat. """ def test_validGraphviz(self): """ L{graphviz} emits valid graphviz data. """ p = subprocess.Popen("dot", stdin=subprocess.PIPE, stdout=subprocess.PIPE) out, err = p.communicate("".join(sampleMachine().asDigraph()) .encode("utf-8")) self.assertEqual(p.returncode, 0) @skipIf(not isGraphvizModuleInstalled(), "Graphviz module is not installed.") class SpotChecks(TestCase): """ Tests to make sure that the output contains salient features of the machine being generated. """ def test_containsMachineFeatures(self): """ The output of L{graphviz} should contain the names of the states, inputs, outputs in the state machine. """ gvout = "".join(sampleMachine().asDigraph()) self.assertIn("begin", gvout) self.assertIn("end", gvout) self.assertIn("go", gvout) self.assertIn("out", gvout) class RecordsDigraphActions(object): """ Records calls made to L{FakeDigraph}. """ def __init__(self): self.reset() def reset(self): self.renderCalls = [] self.saveCalls = [] class FakeDigraph(object): """ A fake L{graphviz.Digraph}. Instantiate it with a L{RecordsDigraphActions}. """ def __init__(self, recorder): self._recorder = recorder def render(self, **kwargs): self._recorder.renderCalls.append(kwargs) def save(self, **kwargs): self._recorder.saveCalls.append(kwargs) class FakeMethodicalMachine(object): """ A fake L{MethodicalMachine}. Instantiate it with a L{FakeDigraph} """ def __init__(self, digraph): self._digraph = digraph def asDigraph(self): return self._digraph @skipIf(not isGraphvizModuleInstalled(), "Graphviz module is not installed.") @skipIf(not isGraphvizInstalled(), "Graphviz tools are not installed.") @skipIf(not isTwistedInstalled(), "Twisted is not installed.") class VisualizeToolTests(TestCase): def setUp(self): self.digraphRecorder = RecordsDigraphActions() self.fakeDigraph = FakeDigraph(self.digraphRecorder) self.fakeProgname = 'tool-test' self.fakeSysPath = ['ignored'] self.collectedOutput = [] self.fakeFQPN = 'fake.fqpn' def collectPrints(self, *args): self.collectedOutput.append(' '.join(args)) def fakeFindMachines(self, fqpn): yield fqpn, FakeMethodicalMachine(self.fakeDigraph) def tool(self, progname=None, argv=None, syspath=None, findMachines=None, print=None): from .._visualize import tool return tool( _progname=progname or self.fakeProgname, _argv=argv or [self.fakeFQPN], _syspath=syspath or self.fakeSysPath, _findMachines=findMachines or self.fakeFindMachines, _print=print or self.collectPrints) def test_checksCurrentDirectory(self): """ L{tool} adds '' to sys.path to ensure L{automat._discover.findMachines} searches the current directory. """ self.tool(argv=[self.fakeFQPN]) self.assertEqual(self.fakeSysPath[0], '') def test_quietHidesOutput(self): """ Passing -q/--quiet hides all output. """ self.tool(argv=[self.fakeFQPN, '--quiet']) self.assertFalse(self.collectedOutput) self.tool(argv=[self.fakeFQPN, '-q']) self.assertFalse(self.collectedOutput) def test_onlySaveDot(self): """ Passing an empty string for --image-directory/-i disables rendering images. """ for arg in ('--image-directory', '-i'): self.digraphRecorder.reset() self.collectedOutput = [] self.tool(argv=[self.fakeFQPN, arg, '']) self.assertFalse(any("image" in line for line in self.collectedOutput)) self.assertEqual(len(self.digraphRecorder.saveCalls), 1) (call,) = self.digraphRecorder.saveCalls self.assertEqual("{}.dot".format(self.fakeFQPN), call['filename']) self.assertFalse(self.digraphRecorder.renderCalls) def test_saveOnlyImage(self): """ Passing an empty string for --dot-directory/-d disables saving dot files. """ for arg in ('--dot-directory', '-d'): self.digraphRecorder.reset() self.collectedOutput = [] self.tool(argv=[self.fakeFQPN, arg, '']) self.assertFalse(any("dot" in line for line in self.collectedOutput)) self.assertEqual(len(self.digraphRecorder.renderCalls), 1) (call,) = self.digraphRecorder.renderCalls self.assertEqual("{}.dot".format(self.fakeFQPN), call['filename']) self.assertTrue(call['cleanup']) self.assertFalse(self.digraphRecorder.saveCalls) def test_saveDotAndImagesInDifferentDirectories(self): """ Passing different directories to --image-directory and --dot-directory writes images and dot files to those directories. """ imageDirectory = 'image' dotDirectory = 'dot' self.tool(argv=[self.fakeFQPN, '--image-directory', imageDirectory, '--dot-directory', dotDirectory]) self.assertTrue(any("image" in line for line in self.collectedOutput)) self.assertTrue(any("dot" in line for line in self.collectedOutput)) self.assertEqual(len(self.digraphRecorder.renderCalls), 1) (renderCall,) = self.digraphRecorder.renderCalls self.assertEqual(renderCall["directory"], imageDirectory) self.assertTrue(renderCall['cleanup']) self.assertEqual(len(self.digraphRecorder.saveCalls), 1) (saveCall,) = self.digraphRecorder.saveCalls self.assertEqual(saveCall["directory"], dotDirectory) def test_saveDotAndImagesInSameDirectory(self): """ Passing the same directory to --image-directory and --dot-directory writes images and dot files to that one directory. """ directory = 'imagesAndDot' self.tool(argv=[self.fakeFQPN, '--image-directory', directory, '--dot-directory', directory]) self.assertTrue(any("image and dot" in line for line in self.collectedOutput)) self.assertEqual(len(self.digraphRecorder.renderCalls), 1) (renderCall,) = self.digraphRecorder.renderCalls self.assertEqual(renderCall["directory"], directory) self.assertFalse(renderCall['cleanup']) self.assertFalse(len(self.digraphRecorder.saveCalls)) test_methodical.py 0000644 00000044650 15030211240 0010263 0 ustar 00 """ Tests for the public interface of Automat. """ from functools import reduce from unittest import TestCase from automat._methodical import ArgSpec, _getArgNames, _getArgSpec, _filterArgs from .. import MethodicalMachine, NoTransition from .. import _methodical class MethodicalTests(TestCase): """ Tests for L{MethodicalMachine}. """ def test_oneTransition(self): """ L{MethodicalMachine} provides a way for you to declare a state machine with inputs, outputs, and states as methods. When you have declared an input, an output, and a state, calling the input method in that state will produce the specified output. """ class Machination(object): machine = MethodicalMachine() @machine.input() def anInput(self): "an input" @machine.output() def anOutput(self): "an output" return "an-output-value" @machine.output() def anotherOutput(self): "another output" return "another-output-value" @machine.state(initial=True) def anState(self): "a state" @machine.state() def anotherState(self): "another state" anState.upon(anInput, enter=anotherState, outputs=[anOutput]) anotherState.upon(anInput, enter=anotherState, outputs=[anotherOutput]) m = Machination() self.assertEqual(m.anInput(), ["an-output-value"]) self.assertEqual(m.anInput(), ["another-output-value"]) def test_machineItselfIsPrivate(self): """ L{MethodicalMachine} is an implementation detail. If you attempt to access it on an instance of your class, you will get an exception. However, since tools may need to access it for the purposes of, for example, visualization, you may access it on the class itself. """ expectedMachine = MethodicalMachine() class Machination(object): machine = expectedMachine machination = Machination() with self.assertRaises(AttributeError) as cm: machination.machine self.assertIn("MethodicalMachine is an implementation detail", str(cm.exception)) self.assertIs(Machination.machine, expectedMachine) def test_outputsArePrivate(self): """ One of the benefits of using a state machine is that your output method implementations don't need to take invalid state transitions into account - the methods simply won't be called. This property would be broken if client code called output methods directly, so output methods are not directly visible under their names. """ class Machination(object): machine = MethodicalMachine() counter = 0 @machine.input() def anInput(self): "an input" @machine.output() def anOutput(self): self.counter += 1 @machine.state(initial=True) def state(self): "a machine state" state.upon(anInput, enter=state, outputs=[anOutput]) mach1 = Machination() mach1.anInput() self.assertEqual(mach1.counter, 1) mach2 = Machination() with self.assertRaises(AttributeError) as cm: mach2.anOutput self.assertEqual(mach2.counter, 0) self.assertIn( "Machination.anOutput is a state-machine output method; to " "produce this output, call an input method instead.", str(cm.exception) ) def test_multipleMachines(self): """ Two machines may co-exist happily on the same instance; they don't interfere with each other. """ class MultiMach(object): a = MethodicalMachine() b = MethodicalMachine() @a.input() def inputA(self): "input A" @b.input() def inputB(self): "input B" @a.state(initial=True) def initialA(self): "initial A" @b.state(initial=True) def initialB(self): "initial B" @a.output() def outputA(self): return "A" @b.output() def outputB(self): return "B" initialA.upon(inputA, initialA, [outputA]) initialB.upon(inputB, initialB, [outputB]) mm = MultiMach() self.assertEqual(mm.inputA(), ["A"]) self.assertEqual(mm.inputB(), ["B"]) def test_collectOutputs(self): """ Outputs can be combined with the "collector" argument to "upon". """ import operator class Machine(object): m = MethodicalMachine() @m.input() def input(self): "an input" @m.output() def outputA(self): return "A" @m.output() def outputB(self): return "B" @m.state(initial=True) def state(self): "a state" state.upon(input, state, [outputA, outputB], collector=lambda x: reduce(operator.add, x)) m = Machine() self.assertEqual(m.input(), "AB") def test_methodName(self): """ Input methods preserve their declared names. """ class Mech(object): m = MethodicalMachine() @m.input() def declaredInputName(self): "an input" @m.state(initial=True) def aState(self): "state" m = Mech() with self.assertRaises(TypeError) as cm: m.declaredInputName("too", "many", "arguments") self.assertIn("declaredInputName", str(cm.exception)) def test_inputWithArguments(self): """ If an input takes an argument, it will pass that along to its output. """ class Mechanism(object): m = MethodicalMachine() @m.input() def input(self, x, y=1): "an input" @m.state(initial=True) def state(self): "a state" @m.output() def output(self, x, y=1): self._x = x return x + y state.upon(input, state, [output]) m = Mechanism() self.assertEqual(m.input(3), [4]) self.assertEqual(m._x, 3) def test_outputWithSubsetOfArguments(self): """ Inputs pass arguments that output will accept. """ class Mechanism(object): m = MethodicalMachine() @m.input() def input(self, x, y=1): "an input" @m.state(initial=True) def state(self): "a state" @m.output() def outputX(self, x): self._x = x return x @m.output() def outputY(self, y): self._y = y return y @m.output() def outputNoArgs(self): return None state.upon(input, state, [outputX, outputY, outputNoArgs]) m = Mechanism() # Pass x as positional argument. self.assertEqual(m.input(3), [3, 1, None]) self.assertEqual(m._x, 3) self.assertEqual(m._y, 1) # Pass x as key word argument. self.assertEqual(m.input(x=4), [4, 1, None]) self.assertEqual(m._x, 4) self.assertEqual(m._y, 1) # Pass y as positional argument. self.assertEqual(m.input(6, 3), [6, 3, None]) self.assertEqual(m._x, 6) self.assertEqual(m._y, 3) # Pass y as key word argument. self.assertEqual(m.input(5, y=2), [5, 2, None]) self.assertEqual(m._x, 5) self.assertEqual(m._y, 2) def test_inputFunctionsMustBeEmpty(self): """ The wrapped input function must have an empty body. """ # input functions are executed to assert that the signature matches, # but their body must be empty _methodical._empty() # chase coverage _methodical._docstring() class Mechanism(object): m = MethodicalMachine() with self.assertRaises(ValueError) as cm: @m.input() def input(self): "an input" list() # pragma: no cover self.assertEqual(str(cm.exception), "function body must be empty") # all three of these cases should be valid. Functions/methods with # docstrings produce slightly different bytecode than ones without. class MechanismWithDocstring(object): m = MethodicalMachine() @m.input() def input(self): "an input" @m.state(initial=True) def start(self): "starting state" start.upon(input, enter=start, outputs=[]) MechanismWithDocstring().input() class MechanismWithPass(object): m = MethodicalMachine() @m.input() def input(self): pass @m.state(initial=True) def start(self): "starting state" start.upon(input, enter=start, outputs=[]) MechanismWithPass().input() class MechanismWithDocstringAndPass(object): m = MethodicalMachine() @m.input() def input(self): "an input" pass @m.state(initial=True) def start(self): "starting state" start.upon(input, enter=start, outputs=[]) MechanismWithDocstringAndPass().input() class MechanismReturnsNone(object): m = MethodicalMachine() @m.input() def input(self): return None @m.state(initial=True) def start(self): "starting state" start.upon(input, enter=start, outputs=[]) MechanismReturnsNone().input() class MechanismWithDocstringAndReturnsNone(object): m = MethodicalMachine() @m.input() def input(self): "an input" return None @m.state(initial=True) def start(self): "starting state" start.upon(input, enter=start, outputs=[]) MechanismWithDocstringAndReturnsNone().input() def test_inputOutputMismatch(self): """ All the argument lists of the outputs for a given input must match; if one does not the call to C{upon} will raise a C{TypeError}. """ class Mechanism(object): m = MethodicalMachine() @m.input() def nameOfInput(self, a): "an input" @m.output() def outputThatMatches(self, a): "an output that matches" @m.output() def outputThatDoesntMatch(self, b): "an output that doesn't match" @m.state() def state(self): "a state" with self.assertRaises(TypeError) as cm: state.upon(nameOfInput, state, [outputThatMatches, outputThatDoesntMatch]) self.assertIn("nameOfInput", str(cm.exception)) self.assertIn("outputThatDoesntMatch", str(cm.exception)) def test_getArgNames(self): """ Type annotations should be included in the set of """ spec = ArgSpec( args=('a', 'b'), varargs=None, varkw=None, defaults=None, kwonlyargs=(), kwonlydefaults=None, annotations=(('a', int), ('b', str)), ) self.assertEqual( _getArgNames(spec), {'a', 'b', ('a', int), ('b', str)}, ) def test_filterArgs(self): """ filterArgs() should not filter the `args` parameter if outputSpec accepts `*args`. """ inputSpec = _getArgSpec(lambda *args, **kwargs: None) outputSpec = _getArgSpec(lambda *args, **kwargs: None) argsIn = () argsOut, _ = _filterArgs(argsIn, {}, inputSpec, outputSpec) self.assertIs(argsIn, argsOut) def test_multipleInitialStatesFailure(self): """ A L{MethodicalMachine} can only have one initial state. """ class WillFail(object): m = MethodicalMachine() @m.state(initial=True) def firstInitialState(self): "The first initial state -- this is OK." with self.assertRaises(ValueError): @m.state(initial=True) def secondInitialState(self): "The second initial state -- results in a ValueError." def test_multipleTransitionsFailure(self): """ A L{MethodicalMachine} can only have one transition per start/event pair. """ class WillFail(object): m = MethodicalMachine() @m.state(initial=True) def start(self): "We start here." @m.state() def end(self): "Rainbows end." @m.input() def event(self): "An event." start.upon(event, enter=end, outputs=[]) with self.assertRaises(ValueError): start.upon(event, enter=end, outputs=[]) def test_badTransitionForCurrentState(self): """ Calling any input method that lacks a transition for the machine's current state raises an informative L{NoTransition}. """ class OnlyOnePath(object): m = MethodicalMachine() @m.state(initial=True) def start(self): "Start state." @m.state() def end(self): "End state." @m.input() def advance(self): "Move from start to end." @m.input() def deadEnd(self): "A transition from nowhere to nowhere." start.upon(advance, end, []) machine = OnlyOnePath() with self.assertRaises(NoTransition) as cm: machine.deadEnd() self.assertIn("deadEnd", str(cm.exception)) self.assertIn("start", str(cm.exception)) machine.advance() with self.assertRaises(NoTransition) as cm: machine.deadEnd() self.assertIn("deadEnd", str(cm.exception)) self.assertIn("end", str(cm.exception)) def test_saveState(self): """ L{MethodicalMachine.serializer} is a decorator that modifies its decoratee's signature to take a "state" object as its first argument, which is the "serialized" argument to the L{MethodicalMachine.state} decorator. """ class Mechanism(object): m = MethodicalMachine() def __init__(self): self.value = 1 @m.state(serialized="first-state", initial=True) def first(self): "First state." @m.state(serialized="second-state") def second(self): "Second state." @m.serializer() def save(self, state): return { 'machine-state': state, 'some-value': self.value, } self.assertEqual( Mechanism().save(), { "machine-state": "first-state", "some-value": 1, } ) def test_restoreState(self): """ L{MethodicalMachine.unserializer} decorates a function that becomes a machine-state unserializer; its return value is mapped to the C{serialized} parameter to C{state}, and the L{MethodicalMachine} associated with that instance's state is updated to that state. """ class Mechanism(object): m = MethodicalMachine() def __init__(self): self.value = 1 self.ranOutput = False @m.state(serialized="first-state", initial=True) def first(self): "First state." @m.state(serialized="second-state") def second(self): "Second state." @m.input() def input(self): "an input" @m.output() def output(self): self.value = 2 self.ranOutput = True return 1 @m.output() def output2(self): return 2 first.upon(input, second, [output], collector=lambda x: list(x)[0]) second.upon(input, second, [output2], collector=lambda x: list(x)[0]) @m.serializer() def save(self, state): return { 'machine-state': state, 'some-value': self.value, } @m.unserializer() def _restore(self, blob): self.value = blob['some-value'] return blob['machine-state'] @classmethod def fromBlob(cls, blob): self = cls() self._restore(blob) return self m1 = Mechanism() m1.input() blob = m1.save() m2 = Mechanism.fromBlob(blob) self.assertEqual(m2.ranOutput, False) self.assertEqual(m2.input(), 2) self.assertEqual( m2.save(), { 'machine-state': 'second-state', 'some-value': 2, } ) # FIXME: error for wrong types on any call to _oneTransition # FIXME: better public API for .upon; maybe a context manager? # FIXME: when transitions are defined, validate that we can always get to # terminal? do we care about this? # FIXME: implementation (and use-case/example) for passing args from in to out # FIXME: possibly these need some kind of support from core # FIXME: wildcard state (in all states, when input X, emit Y and go to Z) # FIXME: wildcard input (in state X, when any input, emit Y and go to Z) # FIXME: combined wildcards (in any state for any input, emit Y go to Z) __init__.py 0000644 00000000000 15030211240 0006627 0 ustar 00 test_discover.py 0000644 00000052526 15030211240 0007771 0 ustar 00 import operator import os import shutil import sys import textwrap import tempfile from unittest import skipIf, TestCase import six def isTwistedInstalled(): try: __import__('twisted') except ImportError: return False else: return True class _WritesPythonModules(TestCase): """ A helper that enables generating Python module test fixtures. """ def setUp(self): super(_WritesPythonModules, self).setUp() from twisted.python.modules import getModule, PythonPath from twisted.python.filepath import FilePath self.getModule = getModule self.PythonPath = PythonPath self.FilePath = FilePath self.originalSysModules = set(sys.modules.keys()) self.savedSysPath = sys.path[:] self.pathDir = tempfile.mkdtemp() self.makeImportable(self.pathDir) def tearDown(self): super(_WritesPythonModules, self).tearDown() sys.path[:] = self.savedSysPath modulesToDelete = six.viewkeys(sys.modules) - self.originalSysModules for module in modulesToDelete: del sys.modules[module] shutil.rmtree(self.pathDir) def makeImportable(self, path): sys.path.append(path) def writeSourceInto(self, source, path, moduleName): directory = self.FilePath(path) module = directory.child(moduleName) # FilePath always opens a file in binary mode - but that will # break on Python 3 with open(module.path, 'w') as f: f.write(textwrap.dedent(source)) return self.PythonPath([directory.path]) def makeModule(self, source, path, moduleName): pythonModuleName, _ = os.path.splitext(moduleName) return self.writeSourceInto(source, path, moduleName)[pythonModuleName] def attributesAsDict(self, hasIterAttributes): return {attr.name: attr for attr in hasIterAttributes.iterAttributes()} def loadModuleAsDict(self, module): module.load() return self.attributesAsDict(module) def makeModuleAsDict(self, source, path, name): return self.loadModuleAsDict(self.makeModule(source, path, name)) @skipIf(not isTwistedInstalled(), "Twisted is not installed.") class OriginalLocationTests(_WritesPythonModules): """ 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. """ def setUp(self): super(OriginalLocationTests, self).setUp() from .._discover import isOriginalLocation self.isOriginalLocation = isOriginalLocation def test_failsWithNoModule(self): """ L{isOriginalLocation} returns False when the attribute refers to an object whose source module cannot be determined. """ source = """\ class Fake(object): pass hasEmptyModule = Fake() hasEmptyModule.__module__ = None """ moduleDict = self.makeModuleAsDict(source, self.pathDir, 'empty_module_attr.py') self.assertFalse(self.isOriginalLocation( moduleDict['empty_module_attr.hasEmptyModule'])) def test_failsWithDifferentModule(self): """ L{isOriginalLocation} returns False when the attribute refers to an object outside of the module where that object was defined. """ originalSource = """\ class ImportThisClass(object): pass importThisObject = ImportThisClass() importThisNestingObject = ImportThisClass() importThisNestingObject.nestedObject = ImportThisClass() """ importingSource = """\ from original import (ImportThisClass, importThisObject, importThisNestingObject) """ self.makeModule(originalSource, self.pathDir, 'original.py') importingDict = self.makeModuleAsDict(importingSource, self.pathDir, 'importing.py') self.assertFalse( self.isOriginalLocation( importingDict['importing.ImportThisClass'])) self.assertFalse( self.isOriginalLocation( importingDict['importing.importThisObject'])) nestingObject = importingDict['importing.importThisNestingObject'] nestingObjectDict = self.attributesAsDict(nestingObject) nestedObject = nestingObjectDict[ 'importing.importThisNestingObject.nestedObject'] self.assertFalse(self.isOriginalLocation(nestedObject)) def test_succeedsWithSameModule(self): """ L{isOriginalLocation} returns True when the attribute refers to an object inside the module where that object was defined. """ mSource = textwrap.dedent(""" class ThisClassWasDefinedHere(object): pass anObject = ThisClassWasDefinedHere() aNestingObject = ThisClassWasDefinedHere() aNestingObject.nestedObject = ThisClassWasDefinedHere() """) mDict = self.makeModuleAsDict(mSource, self.pathDir, 'm.py') self.assertTrue(self.isOriginalLocation( mDict['m.ThisClassWasDefinedHere'])) self.assertTrue(self.isOriginalLocation(mDict['m.aNestingObject'])) nestingObject = mDict['m.aNestingObject'] nestingObjectDict = self.attributesAsDict(nestingObject) nestedObject = nestingObjectDict['m.aNestingObject.nestedObject'] self.assertTrue(self.isOriginalLocation(nestedObject)) @skipIf(not isTwistedInstalled(), "Twisted is not installed.") class FindMachinesViaWrapperTests(_WritesPythonModules): """ L{findMachinesViaWrapper} recursively yields FQPN, L{MethodicalMachine} pairs in and under a given L{twisted.python.modules.PythonModule} or L{twisted.python.modules.PythonAttribute}. """ TEST_MODULE_SOURCE = """ 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." """ def setUp(self): super(FindMachinesViaWrapperTests, self).setUp() from .._discover import findMachinesViaWrapper self.findMachinesViaWrapper = findMachinesViaWrapper def test_yieldsMachine(self): """ When given a L{twisted.python.modules.PythonAttribute} that refers directly to a L{MethodicalMachine}, L{findMachinesViaWrapper} yields that machine and its FQPN. """ source = """\ from automat import MethodicalMachine rootMachine = MethodicalMachine() """ moduleDict = self.makeModuleAsDict(source, self.pathDir, 'root.py') rootMachine = moduleDict['root.rootMachine'] self.assertIn(('root.rootMachine', rootMachine.load()), list(self.findMachinesViaWrapper(rootMachine))) def test_yieldsMachineInClass(self): """ 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. """ source = """\ from automat import MethodicalMachine class PythonClass(object): _classMachine = MethodicalMachine() """ moduleDict = self.makeModuleAsDict(source, self.pathDir, 'clsmod.py') PythonClass = moduleDict['clsmod.PythonClass'] self.assertIn(('clsmod.PythonClass._classMachine', PythonClass.load()._classMachine), list(self.findMachinesViaWrapper(PythonClass))) def test_yieldsMachineInNestedClass(self): """ 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. """ source = """\ from automat import MethodicalMachine class PythonClass(object): class NestedClass(object): _classMachine = MethodicalMachine() """ moduleDict = self.makeModuleAsDict(source, self.pathDir, 'nestedcls.py') PythonClass = moduleDict['nestedcls.PythonClass'] self.assertIn(('nestedcls.PythonClass.NestedClass._classMachine', PythonClass.load().NestedClass._classMachine), list(self.findMachinesViaWrapper(PythonClass))) def test_yieldsMachineInModule(self): """ 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. """ source = """\ from automat import MethodicalMachine rootMachine = MethodicalMachine() """ module = self.makeModule(source, self.pathDir, 'root.py') rootMachine = self.loadModuleAsDict(module)['root.rootMachine'].load() self.assertIn(('root.rootMachine', rootMachine), list(self.findMachinesViaWrapper(module))) def test_yieldsMachineInClassInModule(self): """ 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. """ source = """\ from automat import MethodicalMachine class PythonClass(object): _classMachine = MethodicalMachine() """ module = self.makeModule(source, self.pathDir, 'clsmod.py') PythonClass = self.loadModuleAsDict( module)['clsmod.PythonClass'].load() self.assertIn(('clsmod.PythonClass._classMachine', PythonClass._classMachine), list(self.findMachinesViaWrapper(module))) def test_yieldsMachineInNestedClassInModule(self): """ 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. """ source = """\ from automat import MethodicalMachine class PythonClass(object): class NestedClass(object): _classMachine = MethodicalMachine() """ module = self.makeModule(source, self.pathDir, 'nestedcls.py') PythonClass = self.loadModuleAsDict( module)['nestedcls.PythonClass'].load() self.assertIn(('nestedcls.PythonClass.NestedClass._classMachine', PythonClass.NestedClass._classMachine), list(self.findMachinesViaWrapper(module))) def test_ignoresImportedClass(self): """ 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. """ originalSource = """ from automat import MethodicalMachine class PythonClass(object): _classMachine = MethodicalMachine() """ importingSource = """ from original import PythonClass """ self.makeModule(originalSource, self.pathDir, 'original.py') importingModule = self.makeModule(importingSource, self.pathDir, 'importing.py') self.assertFalse(list(self.findMachinesViaWrapper(importingModule))) def test_descendsIntoPackages(self): """ L{findMachinesViaWrapper} descends into packages to discover machines. """ pythonPath = self.PythonPath([self.pathDir]) package = self.FilePath(self.pathDir).child("test_package") package.makedirs() package.child('__init__.py').touch() source = """ from automat import MethodicalMachine class PythonClass(object): _classMachine = MethodicalMachine() rootMachine = MethodicalMachine() """ self.makeModule(source, package.path, 'module.py') test_package = pythonPath['test_package'] machines = sorted(self.findMachinesViaWrapper(test_package), key=operator.itemgetter(0)) moduleDict = self.loadModuleAsDict(test_package['module']) rootMachine = moduleDict['test_package.module.rootMachine'].load() PythonClass = moduleDict['test_package.module.PythonClass'].load() expectedMachines = sorted( [('test_package.module.rootMachine', rootMachine), ('test_package.module.PythonClass._classMachine', PythonClass._classMachine)], key=operator.itemgetter(0)) self.assertEqual(expectedMachines, machines) def test_infiniteLoop(self): """ L{findMachinesViaWrapper} ignores infinite loops. Note this test can't fail - it can only run forever! """ source = """ class InfiniteLoop(object): pass InfiniteLoop.loop = InfiniteLoop """ module = self.makeModule(source, self.pathDir, 'loop.py') self.assertFalse(list(self.findMachinesViaWrapper(module))) @skipIf(not isTwistedInstalled(), "Twisted is not installed.") class WrapFQPNTests(TestCase): """ Tests that ensure L{wrapFQPN} loads the L{twisted.python.modules.PythonModule} or L{twisted.python.modules.PythonAttribute} for a given FQPN. """ def setUp(self): from twisted.python.modules import PythonModule, PythonAttribute from .._discover import wrapFQPN, InvalidFQPN, NoModule, NoObject self.PythonModule = PythonModule self.PythonAttribute = PythonAttribute self.wrapFQPN = wrapFQPN self.InvalidFQPN = InvalidFQPN self.NoModule = NoModule self.NoObject = NoObject def assertModuleWrapperRefersTo(self, moduleWrapper, module): """ Assert that a L{twisted.python.modules.PythonModule} refers to a particular Python module. """ self.assertIsInstance(moduleWrapper, self.PythonModule) self.assertEqual(moduleWrapper.name, module.__name__) self.assertIs(moduleWrapper.load(), module) def assertAttributeWrapperRefersTo(self, attributeWrapper, fqpn, obj): """ Assert that a L{twisted.python.modules.PythonAttribute} refers to a particular Python object. """ self.assertIsInstance(attributeWrapper, self.PythonAttribute) self.assertEqual(attributeWrapper.name, fqpn) self.assertIs(attributeWrapper.load(), obj) def test_failsWithEmptyFQPN(self): """ L{wrapFQPN} raises L{InvalidFQPN} when given an empty string. """ with self.assertRaises(self.InvalidFQPN): self.wrapFQPN('') def test_failsWithBadDotting(self): """" L{wrapFQPN} raises L{InvalidFQPN} when given a badly-dotted FQPN. (e.g., x..y). """ for bad in ('.fails', 'fails.', 'this..fails'): with self.assertRaises(self.InvalidFQPN): self.wrapFQPN(bad) def test_singleModule(self): """ L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the single module a dotless FQPN describes. """ import os moduleWrapper = self.wrapFQPN('os') self.assertIsInstance(moduleWrapper, self.PythonModule) self.assertIs(moduleWrapper.load(), os) def test_failsWithMissingSingleModuleOrPackage(self): """ L{wrapFQPN} raises L{NoModule} when given a dotless FQPN that does not refer to a module or package. """ with self.assertRaises(self.NoModule): self.wrapFQPN("this is not an acceptable name!") def test_singlePackage(self): """ L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the single package a dotless FQPN describes. """ import xml self.assertModuleWrapperRefersTo(self.wrapFQPN('xml'), xml) def test_multiplePackages(self): """ L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the deepest package described by dotted FQPN. """ import xml.etree self.assertModuleWrapperRefersTo(self.wrapFQPN('xml.etree'), xml.etree) def test_multiplePackagesFinalModule(self): """ L{wrapFQPN} returns a L{twisted.python.modules.PythonModule} referring to the deepest module described by dotted FQPN. """ import xml.etree.ElementTree self.assertModuleWrapperRefersTo( self.wrapFQPN('xml.etree.ElementTree'), xml.etree.ElementTree) def test_singleModuleObject(self): """ L{wrapFQPN} returns a L{twisted.python.modules.PythonAttribute} referring to the deepest object an FQPN names, traversing one module. """ import os self.assertAttributeWrapperRefersTo( self.wrapFQPN('os.path'), 'os.path', os.path) def test_multiplePackagesObject(self): """ L{wrapFQPN} returns a L{twisted.python.modules.PythonAttribute} referring to the deepest object described by an FQPN, descending through several packages. """ import xml.etree.ElementTree import automat for fqpn, obj in [('xml.etree.ElementTree.fromstring', xml.etree.ElementTree.fromstring), ('automat.MethodicalMachine.__doc__', automat.MethodicalMachine.__doc__)]: self.assertAttributeWrapperRefersTo( self.wrapFQPN(fqpn), fqpn, obj) def test_failsWithMultiplePackagesMissingModuleOrPackage(self): """ L{wrapFQPN} raises L{NoObject} when given an FQPN that contains a missing attribute, module, or package. """ for bad in ('xml.etree.nope!', 'xml.etree.nope!.but.the.rest.is.believable'): with self.assertRaises(self.NoObject): self.wrapFQPN(bad) @skipIf(not isTwistedInstalled(), "Twisted is not installed.") class FindMachinesIntegrationTests(_WritesPythonModules): """ Integration tests to check that L{findMachines} yields all machines discoverable at or below an FQPN. """ SOURCE = """ from automat import MethodicalMachine class PythonClass(object): _machine = MethodicalMachine() ignored = "i am ignored" rootLevel = MethodicalMachine() ignored = "i am ignored" """ def setUp(self): super(FindMachinesIntegrationTests, self).setUp() from .._discover import findMachines self.findMachines = findMachines packageDir = self.FilePath(self.pathDir).child("test_package") packageDir.makedirs() self.pythonPath = self.PythonPath([self.pathDir]) self.writeSourceInto(self.SOURCE, packageDir.path, '__init__.py') subPackageDir = packageDir.child('subpackage') subPackageDir.makedirs() subPackageDir.child('__init__.py').touch() self.makeModule(self.SOURCE, subPackageDir.path, 'module.py') self.packageDict = self.loadModuleAsDict( self.pythonPath['test_package']) self.moduleDict = self.loadModuleAsDict( self.pythonPath['test_package']['subpackage']['module']) def test_discoverAll(self): """ Given a top-level package FQPN, L{findMachines} discovers all L{MethodicalMachine} instances in and below it. """ machines = sorted(self.findMachines('test_package'), key=operator.itemgetter(0)) tpRootLevel = self.packageDict['test_package.rootLevel'].load() tpPythonClass = self.packageDict['test_package.PythonClass'].load() mRLAttr = self.moduleDict['test_package.subpackage.module.rootLevel'] mRootLevel = mRLAttr.load() mPCAttr = self.moduleDict['test_package.subpackage.module.PythonClass'] mPythonClass = mPCAttr.load() expectedMachines = sorted( [('test_package.rootLevel', tpRootLevel), ('test_package.PythonClass._machine', tpPythonClass._machine), ('test_package.subpackage.module.rootLevel', mRootLevel), ('test_package.subpackage.module.PythonClass._machine', mPythonClass._machine)], key=operator.itemgetter(0)) self.assertEqual(expectedMachines, machines)
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings