File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/trial.zip
Back
PK b�Z��̪�. �. & __pycache__/_asynctest.cpython-310.pycnu �[��� o �b@7 � @ s� U d Z ddlZddlZddlmZ ddlmZ ddlmZm Z ddl m Z ddl m Z mZ ddlmZmZmZ g Zed ed < ee j�G d d � d e��ZdS ) zP Things likely to be used by writers of unit tests. Maintainer: Jonathan Lange � N)�List)� implementer)�defer�utils)�failure)�itrial�util)�FailTest�SkipTest�SynchronousTestCase�_wait_is_runningc s� e Zd ZdZd/� fdd� Zdd� ZeZdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dd� Z dd� Zdd� Zejdd� �Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Z� fd'd(�Zd)d*� Zd+d,� Ze fd-d.�Z � Z S )0�TestCasea= A unit test. The atom of the unit testing universe. This class extends L{SynchronousTestCase} which extends C{unittest.TestCase} from the standard library. The main feature is the ability to return C{Deferred}s from tests and fixture methods and to have the suite wait for those C{Deferred}s to fire. Also provides new assertions such as L{assertFailure}. @ivar timeout: A real number of seconds. If set, the test will raise an error if it takes longer than C{timeout} seconds. If not set, util.DEFAULT_TIMEOUT_DURATION is used. �runTestc s t � �|� dS )a� Construct an asynchronous test case for C{methodName}. @param methodName: The name of a method on C{self}. This method should be a unit test. That is, it should be a short method that calls some of the assert* methods. If C{methodName} is unspecified, L{SynchronousTestCase.runTest} will be used as the test method. This is mostly useful for testing Trial. N)�super�__init__)�self� methodName�� __class__� �:/usr/lib/python3/dist-packages/twisted/trial/_asynctest.pyr - s zTestCase.__init__c s& �fdd�}� �fdd�}|� ||�S )z� Fail if C{deferred} does not errback with one of C{expectedFailures}. Returns the original Deferred with callbacks added. You will need to return this Deferred from your test case. c s � � d| ����)Nz$did not catch an error, instead got )�failureException)�ignore�r r r �_cb@ s �z#TestCase.assertFailure.<locals>._cbc s* | j � � r| jS d�� t| ��}��|��)Nz Expected: {!r} Got: {})�check�value�format�strr )r �output��expectedFailuresr r r �_ebE s � z#TestCase.assertFailure.<locals>._eb)� addCallbacks)r �deferredr! r r" r r r � assertFailure9 s zTestCase.assertFailurec s� ddl m� ��� ������fdd�}t�|tjtd��}t���}t � |�r4t d� |��}t �|�S t �tj��� |�}���||�� |�� fdd�� |S ) Nr ��reactorc s� t ���d� � d�� d��}t�|�}z| �|� W d S t jyJ ��� d�_��� }|d urA|� |�rA�� �||� Y d S �� �|� Y d S w )Nz (z) still running at z secsT) r � TimeoutErrorr �Failure�errback�AlreadyCalledError�crash� _timedOut�getTodo�expected�addExpectedFailure�addError)�d�e�f�todo)r r' �resultr �timeoutr r � onTimeoutW s � �z TestCase._run.<locals>.onTimeout��categoryz9{!r} is a generator function and therefore will never runc s � � � r� �� p | S �N)�active�cancel)�x)�callr r �<lambda>| s z TestCase._run.<locals>.<lambda>)�twisted.internetr' � getTimeoutr �suppressWarningsr �suppress�DeprecationWarning�getattr�inspect�isgeneratorfunction� TypeErrorr r �fail� maybeDeferred�runWithWarningsSuppressed� _getSuppress� callLater�addBoth)r r r6 r8 �method�excr2 r )r? r r' r6 r r7 r �_runR s( � �� �z TestCase._runc O s | j |i |��S r; )�run)r �args�kwargsr r r �__call__ s zTestCase.__call__c C s* | � d|�}|j| j| j|f|fd� |S )N�setUp�� callbackArgs� errbackArgs)rR r# �deferTestMethod� _ebDeferSetUp�r �ignoredr6 r2 r r r � deferSetUp� s �zTestCase.deferSetUpc C sN |� t�r|�| | �| j|j�� n|�| |� |� t�r!|�� | � d |�S r; ) r r �addSkip�_getSkipReasonrW r r1 �KeyboardInterrupt�stop�deferRunCleanups�r r r6 r r r r\ � s zTestCase._ebDeferSetUpc C sH | � | j|�}|j| j| j|f|fd� |�| j|� |�| j|� |S )NrX )rR �_testMethodNamer# �_cbDeferTestMethod�_ebDeferTestMethodrO rd � deferTearDownr] r r r r[ � s �zTestCase.deferTestMethodc C s* | � � d ur|�| | � � � |S d| _|S )NT)r. �addUnexpectedSuccess�_passed)r r^ r6 r r r rg � s �zTestCase._cbDeferTestMethodc C s� | � � }|d ur|�|�r|�| ||� d S |�| jt�r%|�| |� d S |�t�r6|�| |� |� � d S |�t �rL|� | | � t | | j�|j�� d S |�| |� d S r; )r. r/ r0 r r r � addFailurerb r1 rc r r` ra rF rf r )r r4 r6 r5 r r r rh � s �zTestCase._ebDeferTestMethodc C s | � d|�}|�| j|� |S )N�tearDown)rR � addErrback�_ebDeferTearDownr] r r r ri � s zTestCase.deferTearDownc C s( |� | |� |�t�r|�� d| _d S �NF)r1 r rb rc rk re r r r ro � s zTestCase._ebDeferTearDownc c sv � g }| j ddd� D ] \}}}z ||i |��V W q ty* |�t�� � Y q w |D ] }|�| |� d| _q-dS )zf Run any scheduled cleanups and report errors (if any) to the result. object. N���F)� _cleanups� Exception�appendr r) r1 rk )r r^ r6 �failures�funcrT rU r4 r r r rd � s � � �zTestCase.deferRunCleanupsc C s� zt �| |��� }|sd| _W n ty# |�| t�� � d| _Y nw | j� � D ] }|�| |� d| _q)| � � | � � | jrG|� | � d S d S rp ) r �_Janitor�postCaseCleanuprk � BaseExceptionr1 r r) � _observer� getErrors�flushLoggedErrors�_removeObserver� addSuccess)r r6 �clean�errorr r r �_cleanUp� s" � � �zTestCase._cleanUpc C s< z t �| |��� W d S ty |�| t�� � Y d S w r; )r rw �postClassCleanupry r1 r r) )r r6 r r r � _classCleanUp� s �zTestCase._classCleanUpc s � �fdd�}|S )z� Create a method which wraps the reactor method C{name}. The new method issues a deprecation warning and calls the original. c s, t jd� � f dtd� �j� | i |��S )Nz{reactor.%s cannot be used inside unit tests. In the future, using %s will fail the test and may crash or hang the test run.� )� stacklevelr: )�warnings�warnrE �_reactorMethods)�a�kw��namer r r �_� s ��z&TestCase._makeReactorMethod.<locals>._r )r r� r� r r� r �_makeReactorMethod� s zTestCase._makeReactorMethodc C s6 i | _ dD ]}t||�| j |< t||| �|�� qdS )z� Deprecate C{iterate}, C{crash} and C{stop} on C{reactor}. That is, each method is wrapped in a function that issues a deprecation warning, then calls the original. @param reactor: The Twisted reactor. )r, �iteraterc N)r� rF �setattrr� )r r' r� r r r �_deprecateReactor� s �zTestCase._deprecateReactorc C s* | j �� D ] \}}t|||� qi | _ dS )z� Restore the deprecated reactor methods. Undoes what L{_deprecateReactor} did. @param reactor: The Twisted reactor. N)r� �itemsr� )r r' r� rP r r r �_undeprecateReactor s z TestCase._undeprecateReactorc C s� ddl m} | �|� d| _z+| �d|�}z| �|� W | �|� | �|� n | �|� | �|� w W | �|� dS | �|� w )z� Really run C{setUp}, the test method, and C{tearDown}. Any of these may return L{defer.Deferred}s. After they complete, do some reactor cleanup. @param result: A L{TestResult} object. r r& FN) rA r' r� r- r_ �_waitr� r� r� )r r6 r' r2 r r r �_runFixturesAndTest s �z TestCase._runFixturesAndTestc s t � j|g|�R i |��S )a Extend the base cleanup feature with support for cleanup functions which return Deferreds. If the function C{f} returns a Deferred, C{TestCase} will wait until the Deferred has fired before proceeding to the next function. )r � addCleanup)r r4 rT rU r r r r� ) s zTestCase.addCleanupc C s | � � S r; )rM r r r r � getSuppress3 s zTestCase.getSuppressc C sH t �| jdt j�}zt|�W S ttfy# tjdt d� t j Y S w )ae Returns the timeout value set on this test. Checks on the instance first, then the class, then the module, then packages. As soon as it finds something with a C{timeout} attribute, returns that. Returns L{util.DEFAULT_TIMEOUT_DURATION} if it cannot find anything. See L{TestCase} docstring for more details. r7 z)'timeout' attribute needs to be a number.r9 ) r �acquireAttribute�_parents�DEFAULT_TIMEOUT_DURATION�float� ValueErrorrI r� r� rE )r r7 r r r rB 6 s � � �zTestCase.getTimeoutc s� |rt d��ddlm� g ��fdd�}� �fdd�}t�|tjdtd ��}� fd d �}t�|tjdtd ��}|�d � z5|� |� �rMW d �|� � d S |� |� |� _ z� � � W � ` n� ` w �sf| j roW d �|� � d S t� �d �|� � w ) zATake a Deferred that only ever callbacks. Block until it happens.z_wait is not reentrantr r& c s � d ur � � | � d S d S r; )rt )�any)�resultsr r rt V s �z TestCase._wait.<locals>.appendc s �d ur � � � d S d S r; �r, )�ign�r' r� r r r, Z s �z TestCase._wait.<locals>.crashz reactor\.crash cannot be used.*)�messager: c s � � � d S r; r� r r& r r rc e s z TestCase._wait.<locals>.stopN)� RuntimeErrorrA r' r rC r rD rE rt rO �poprc rS r- rb )r r2 �runningrt r, rc r r� r r� M sL �� �� � � zTestCase._wait)r ) �__name__� __module__� __qualname__�__doc__r r% �failUnlessFailurerR rV r_ r\ r[ rg rh ri ro r �inlineCallbacksrd r� r� r� r� r� r� r� r� rB r r� � __classcell__r r r r r s4 - r )r� rG r� �typingr �zope.interfacer rA r r �twisted.pythonr � twisted.trialr r �twisted.trial._synctestr r r r �__annotations__� ITestCaser r r r r �<module> s PK b�Z�h�� " __pycache__/itrial.cpython-310.pycnu �[��� o �b6 � @ s8 d Z ddlmZ G dd� dej�ZG dd� dej�ZdS )z3 Interfaces for Trial. Maintainer: Jonathan Lange � Nc @ sB e Zd ZdZe�d�Zdd� Zdd� Zdd� Z d d � Z d d � Z d S )� ITestCasezU The interface that a test case must implement in order to be used in Trial. z7The exception class that is raised by failed assertionsc C � dS )zQ Run the test. Should always do exactly the same thing as run(). N� ��resultr r �6/usr/lib/python3/dist-packages/twisted/trial/itrial.py�__call__ � zITestCase.__call__c C r )zJ Return the number of tests in this test case. Usually 1. Nr r r r r �countTestCases r zITestCase.countTestCasesc C r )zk Return a unique identifier for the test, usually the fully-qualified Python name. Nr r r r r �id! r z ITestCase.idc C r )zj Run the test, storing the results in C{result}. @param result: A L{TestResult}. Nr r r r r �run' r z ITestCase.runc C r )z9 Return a short description of the test. Nr r r r r �shortDescription. r zITestCase.shortDescriptionN) �__name__� __module__� __qualname__�__doc__�zi� Attribute�failureExceptionr r r r r r r r r r s � r c @ sx e Zd ZdZe�d�Ze�d�Zdd� Zdd� Z dd � Z d d � Z d d � Z ddd�Z ddd�Zdd� Zdd� Zdd� ZdS )� IReporterz6 I report results from a run of a test suite. zHA boolean indicating that this reporter would like the test run to stop.zd The number of tests that seem to have been run according to this reporter. c C r )z� Report the beginning of a run of a single test method. @param method: an object that is adaptable to ITestMethod Nr ��methodr r r � startTestC r zIReporter.startTestc C r )z~ Report the status of a single test method @param method: an object that is adaptable to ITestMethod Nr r r r r �stopTestJ r zIReporter.stopTestc C r )z* Record that test passed. Nr )�testr r r � addSuccessQ r zIReporter.addSuccessc C r )aI Record that a test has raised an unexpected exception. @param test: The test that has raised an error. @param error: The error that the test raised. It will either be a three-tuple in the style of C{sys.exc_info()} or a L{Failure<twisted.python.failure.Failure>} object. Nr )r �errorr r r �addErrorV r zIReporter.addErrorc C r )aH Record that a test has failed with the given failure. @param test: The test that has failed. @param failure: The failure that the test failed with. It will either be a three-tuple in the style of C{sys.exc_info()} or a L{Failure<twisted.python.failure.Failure>} object. Nr )r �failurer r r � addFailure` r zIReporter.addFailureNc C r )a� Record that the given test failed, and was expected to do so. In Twisted 15.5 and prior, C{todo} was a mandatory parameter. @type test: L{unittest.TestCase} @param test: The test which this is about. @type failure: L{failure.Failure} @param failure: The error which this test failed with. @type todo: L{unittest.Todo} @param todo: The reason for the test's TODO status. If L{None}, a generic reason is used. Nr )r r �todor r r �addExpectedFailurej r z IReporter.addExpectedFailurec C r )a� Record that the given test failed, and was expected to do so. In Twisted 15.5 and prior, C{todo} was a mandatory parameter. @type test: L{unittest.TestCase} @param test: The test which this is about. @type todo: L{unittest.Todo} @param todo: The reason for the test's TODO status. If L{None}, a generic reason is used. Nr )r r r r r �addUnexpectedSuccessy r z IReporter.addUnexpectedSuccessc C r )z� Record that a test has been skipped for the given reason. @param test: The test that has been skipped. @param reason: An object that the test case has specified as the reason for skipping the test. Nr )r �reasonr r r �addSkip� r zIReporter.addSkipc C r )z� Return a boolean indicating whether all test results that were reported to this reporter were successful or not. Nr r r r r � wasSuccessful� r zIReporter.wasSuccessfulc C r )a1 Called when the test run is complete. This gives the result object an opportunity to display a summary of information to the user. Once you have called C{done} on an L{IReporter} object, you should assume that the L{IReporter} object is no longer usable. Nr r r r r �done� r zIReporter.done)N)r r r r r r � shouldStop�testsRunr r r r r r! r" r$ r% r& r r r r r 4 s$ �� r )r �zope.interface� interfacer � Interfacer r r r r r �<module> s &PK b�Z$��- �- __pycache__/util.cpython-310.pycnu �[��� o �b�0 � @ s� d Z ddlmZ ddlmZmZ ddlmZ ddlm Z ddl m Z g d�Z e � ZdZG d d � d e�ZG d d � d �Ze � Zefd d�Zdd� Zd"dd�Zdd� ZG dd� de�Zdd� ZG dd� de�Zd d � Zd#d d �Z d!S )$a A collection of utility functions and classes, used internally by Trial. This code is for Trial's internal use. Do NOT use this code if you are writing tests. It is subject to change at the Trial maintainer's whim. There is nothing here in this module for you to use unless you are maintaining Trial. Any non-Trial Twisted code that uses this module will be shot. Maintainer: Jonathan Lange @var DEFAULT_TIMEOUT_DURATION: The default timeout which will be applied to asynchronous (ie, Deferred-returning) test methods, in seconds. � )� randrange)� interfaces�utils)�Failure)�FilePath)�FilesystemLock)�DEFAULT_TIMEOUT_DURATION�excInfoOrFailureToExcInfo�suppress�acquireAttributeg ^@c @ s( e Zd ZdZddd�Zdefdd�ZdS ) �DirtyReactorAggregateErrora7 Passed to L{twisted.trial.itrial.IReporter.addError} when the reactor is left in an unclean state after a test. @ivar delayedCalls: The L{DelayedCall<twisted.internet.base.DelayedCall>} objects which weren't cleaned up. @ivar selectables: The selectables which weren't cleaned up. Nc C s || _ || _d S �N)� delayedCalls� selectables)�selfr r � r �4/usr/lib/python3/dist-packages/twisted/trial/util.py�__init__2 s z#DirtyReactorAggregateError.__init__�returnc C sP d}| j r|d7 }|d�tt| j ��7 }| jr&|d7 }|d�tt| j��7 }|S )zR Return a multi-line message describing all of the unclean state. zReactor was unclean.zM DelayedCalls: (set twisted.internet.base.DelayedCall.debug = True to debug) � z Selectables: )r �join�map�strr )r �msgr r r �__str__6 s �z"DirtyReactorAggregateError.__str__r )�__name__� __module__� __qualname__�__doc__r r r r r r r r ( s r c @ s` e Zd ZdZddd�Zdd� Zdd� Zd d � Zd d � Ze � ed e dd�f�Zdd� Z dd� Z dS )�_Janitorz� The guy that cleans up after you. @ivar test: The L{TestCase} to report errors about. @ivar result: The L{IReporter} to report errors to. @ivar reactor: The reactor to use. If None, the global reactor will be used. Nc C s || _ || _|| _dS )z� @param test: See L{_Janitor.test}. @param result: See L{_Janitor.result}. @param reactor: See L{_Janitor.reactor}. N)�test�result�reactor)r r r! r" r r r r R s z_Janitor.__init__c C s0 | � � }|rt|�}| j�| jt|�� dS dS )z� Called by L{unittest.TestCase} after a test to catch any logged errors or pending L{DelayedCall<twisted.internet.base.DelayedCall>}s. FT)� _cleanPendingr r! �addErrorr r )r �calls� aggregater r r �postCaseCleanup\ s z_Janitor.postCaseCleanupc C sB | � � }| �� }|s |rt||�}| j�| jt|�� | �� dS )a Called by L{unittest.TestCase} after the last test in a C{TestCase} subclass. Ensures the reactor is clean by murdering the threadpool, catching any pending L{DelayedCall<twisted.internet.base.DelayedCall>}s, open sockets etc. N)� _cleanReactorr# r r! r$ r r � _cleanThreads)r r r% r& r r r �postClassCleanuph s z_Janitor.postClassCleanupc C s$ | j dur | j }|S ddlm } |S )zI Get either the passed-in reactor or the global reactor. Nr )r" )r" �twisted.internet�r r" r r r � _getReactorv s �z_Janitor._getReactorc C s^ | � � }|�d� |�d� g }|�� D ]}|�� r#t|�}|�� ntd� |�|� q|S )zS Cancel all pending calls and return their string representations. r z)WEIRDNESS! pending timed call not active!)r- �iterate�getDelayedCalls�activer �cancel�print�append)r r" �delayedCallStrings�p� delayedStringr r r r# � s z_Janitor._cleanPending��ignorez!reactor\.iterate cannot be used.*)�category�messagec C s2 | � � }tj�|�r|jd ur|�� d S d S d S r )r- r �IReactorThreads� providedBy� threadpool�_stopThreadPoolr, r r r r) � s �z_Janitor._cleanThreadsc C sB | � � }g }|�� D ]}tj�|�r|�d� |�t|�� q |S )z� Remove all selectables from the reactor, kill any of them that were processes, and return their string representation. �KILL)r- � removeAllr �IProcessTransportr< � signalProcessr3 �repr)r r" �selectableStrings�selr r r r( � s z_Janitor._cleanReactorr )r r r r r r' r* r- r# r �suppressWarnings�DeprecationWarningr) r( r r r r r H s" ��� r c C sB | D ]}t ||�rt||� S q|tur|S td|�d| ����)z� Go through the list 'objects' sequentially until we find one which has attribute 'attr', then return the value of that attribute. If not found, return 'default' if set, otherwise, raise AttributeError. z attribute z not found in )�hasattr�getattr�_DEFAULT�AttributeError)�objects�attr�default�objr r r r � s �r c C s t | t�r| j| j| �� f} | S )a' Coerce a Failure to an _exc_info, if err is a Failure. @param err: Either a tuple such as returned by L{sys.exc_info} or a L{Failure} object. @return: A tuple like the one returned by L{sys.exc_info}. e.g. C{exception_type, exception_object, traceback_object}. )� isinstancer �type�value�getTracebackObject)�errr r r r � s r r8 c K s | f|fS )a: Sets up the .suppress tuple properly, pass options to this method as you would the stdlib warnings.filterwarnings() So, to use this with a .suppress magic attribute you would do the following: >>> from twisted.trial import unittest, util >>> import warnings >>> >>> class TestFoo(unittest.TestCase): ... def testFooBar(self): ... warnings.warn("i am deprecated", DeprecationWarning) ... testFooBar.suppress = [util.suppress(message='i am deprecated')] ... >>> Note that as with the todo and timeout attributes: the module level attribute acts as a default for the class attribute which acts as a default for the method attribute. The suppress attribute can be overridden at any level by specifying C{.suppress = []} r )�action�kwargr r r r � s r c s � �fdd�}|S )Nc sV dd l }|�� }z|j� g| �R i |��}|��� W n ty$ Y nw |�� |S )Nr )�profile�Profile�runcall� dump_stats� SystemExit� print_stats)�args�kwargsrW �profr! ��f� outputFiler r �_� s �zprofiled.<locals>._r )ra rb rc r r` r �profiled� s rd c @ � e Zd ZdZdS )�_NoTrialMarkerz� No trial marker file could be found. Raised when trial attempts to remove a trial temporary working directory that does not contain a marker file. N�r r r r r r r r rf � rf c C s� | � d��� st| �d���z| �� W dS ty_ } z>td| |j|jf � ztdt t d��� d� �}| � |� W n tyS } z td|j|jf � � d}~ww W Y d}~dS d}~ww ) z� Safely remove a path, recursively. If C{path} does not contain a node named C{_trial_marker}, a L{_NoTrialMarker} exception is raised and the path is not removed. � _trial_markerz5 is not a trial temporary path, refusing to remove itz2could not remove %r, caught OSError [Errno %s]: %ss _trial_temp_oldi��� zutf-8z4could not rename path, caught OSError [Errno %s]: %sN) �child�existsrf �remove�OSErrorr2 �errno�strerrorr r r �encode�moveTo)�path�e�newPathr r r � _removeSafely s: � ��� �������ru c @ re )�_WorkingDirectoryBusyzv A working directory was specified to the runner, but another test run is currently using that directory. Nrg r r r r rv + rh rv c C s� d} |r| � d| �� |f �}n| }t|jd �}|�� r6|�� r&t|� |�� |�d�� d� ||fS | �� dkrA|d7 }nt � �q) a0 Find an unused directory named similarly to C{base}. Once a directory is found, it will be locked and a marker dropped into it to identify it as a trial temporary directory. @param base: A template path for the discovery process. If this path exactly cannot be used, a path which varies only in a suffix of the basename will be used instead. @type base: L{FilePath} @return: A two-tuple. The first element is a L{FilePath} representing the directory which was found and created. The second element is a locked L{FilesystemLock<twisted.python.lockfile.FilesystemLock>}. Another call to C{_unusedTestDirectory} will not be able to reused the same name until the lock is released, either explicitly or by this process exiting. r Tz%s-%dz.lockri � � _trial_temp� ) �sibling�basenamer rr �lockrk ru �makedirsrj � setContentrv )�base�counter�testdir� testDirLockr r r �_unusedTestDirectory2 s �r� �, c C s� t | ttf�s td��| sdS t| �dkrt| d �S t| �dkr3t| d �� d|� dt| d �� �S g }| D ] }|�t|�� q7d�|�|dd � �|||d �S ) ad Produce a string containing each thing in C{things}, separated by a C{delimiter}, with the last couple being separated by C{finalDelimiter} @param things: The elements of the resulting phrase @type things: L{list} or L{tuple} @param finalDelimiter: What to put between the last two things (typically 'and' or 'or') @type finalDelimiter: L{str} @param delimiter: The separator to use between each thing, not including the last two. Should typically include a trailing space. @type delimiter: L{str} @return: The resulting phrase @rtype: L{str} z Things must be a list or a tuple� ry r � � z {}{}{} {}N���) rP �list�tuple� TypeError�lenr r3 �formatr )�things�finalDelimiter� delimiter� strThings�thingr r r � _listToPhrase` s" $�r� Nr7 )r� ) r �randomr r+ r r �twisted.python.failurer �twisted.python.filepathr �twisted.python.lockfiler �__all__�object�DEFAULT_TIMEOUTr � Exceptionr r rJ r r r rd rf ru rv r� r� r r r r �<module> s* o .PK b�Z=���- - $ __pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )a� Twisted Trial: Asynchronous unit testing framework. Trial extends Python's builtin C{unittest} to provide support for asynchronous tests. Trial strives to be compatible with other Python xUnit testing frameworks. "Compatibility" is a difficult things to define. In practice, it means that: - L{twisted.trial.unittest.TestCase} objects should be able to be used by other test runners without those runners requiring special support for Trial tests. - Tests that subclass the standard library C{TestCase} and don't do anything "too weird" should be able to be discoverable and runnable by the Trial test runner without the authors of those tests having to jump through hoops. - Tests that implement the interface provided by the standard library C{TestCase} should be runnable by the Trial runner. - The Trial test runner and Trial L{unittest.TestCase} objects ought to be able to use standard library C{TestResult} objects, and third party C{TestResult} objects based on the standard library. This list is not necessarily exhaustive -- compatibility is hard to define. Contributors who discover more helpful ways of defining compatibility are encouraged to update this document. Examples: B{Timeouts} for tests should be implemented in the runner. If this is done, then timeouts could work for third-party TestCase objects as well as for L{twisted.trial.unittest.TestCase} objects. Further, Twisted C{TestCase} objects will run in other runners without timing out. See U{http://twistedmatrix.com/trac/ticket/2675}. Running tests in a temporary directory should be a feature of the test case, because often tests themselves rely on this behaviour. If the feature is implemented in the runner, then tests will change behaviour (possibly breaking) when run in a different test runner. Further, many tests don't even care about the filesystem. See U{http://twistedmatrix.com/trac/ticket/2916}. N)�__doc__� r r �8/usr/lib/python3/dist-packages/twisted/trial/__init__.py�<module> s PK b�Z4���� � $ __pycache__/reporter.cpython-310.pycnu �[��� o �b�� � @ s d Z ddlZddlZddlZddlZddlZddlmZ ddl m Z ddl m Z m Z ddlmZ ddlmZ ddlmZ dd lmZmZ zdd lmZ W n eyW dZY nw d d � ZG d d� de�Z G dd� d�Z e ej �G dd� dej ��Z e ej �G dd� deej d���Z e ej �G dd� de ��Z!e ej �G dd� de ��Z"G dd� de �Z#e ej �G d d � d e ��Z$G d d � d e$�Z%G d d!� d!e$�Z&G d"d#� d#e$�Z'G d$d%� d%e'�Z(G d&d'� d'�Z)G d(d)� d)�Z*G d*d+� d+�Z+e ej �G d,d-� d-��Z,G d.d/� d/e$�Z-dS )0z3 Defines classes that handle the results of tests. � N)� OrderedDict)� implementer)�log�reflect)�proxyForInterface)�Failure)�untilConcludes)�itrial�util)�TestProtocolClientc C s ddl m} || �S )ad Return a L{Todo} object built from C{value}. This is a synonym for L{twisted.trial.unittest.makeTodo}, but imported locally to avoid circular imports. @param value: A string or a tuple of C{(errors, reason)}, where C{errors} is either a single exception class or an iterable of exception classes. @return: A L{Todo} object. r )�makeTodo)�twisted.trial.unittestr )�valuer � r �8/usr/lib/python3/dist-packages/twisted/trial/reporter.py� _makeTodo! s r c @ � e Zd ZdZdS )�BrokenTestCaseWarningzT Emitted as a warning when an exception occurs in one of setUp or tearDown. N��__name__� __module__� __qualname__�__doc__r r r r r 2 s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � SafeStreamz� Wraps a stream object so that all C{write} calls are wrapped in L{untilConcludes<twisted.python.util.untilConcludes>}. c C � || _ d S �N)�original)�selfr r r r �__init__> � zSafeStream.__init__c C s t | j|�S r )�getattrr )r �namer r r � __getattr__A s zSafeStream.__getattr__c O s t | jjg|�R i |��S r )r r �write)r �a�kwr r r r# D s zSafeStream.writeN)r r r r r r" r# r r r r r 8 s r c s� e Zd ZdZdZ� fdd�Zdefdd�Zdd � Zd d � Z � fd d �Z � fdd�Z dd� Z dd� Z dd� Zd!dd�Zd!dd�Zdd � Zd d � Zd d � Z� ZS )"� TestResultz� Accumulates the results of several L{twisted.trial.unittest.TestCase}s. @ivar successes: count the number of successes achieved by the test run. @type successes: C{int} zTest expected to failc s, t � �� g | _g | _g | _d| _g | _d S )Nr )�superr �skips�expectedFailures�unexpectedSuccesses� successes�_timings�r �� __class__r r r T s zTestResult.__init__�returnc C s> dt �| j�| jt| j�t| j�t| j�t| j�t| j �f S )Nz<<%s run=%d errors=%d failures=%d todos=%d dones=%d skips=%d>) r �qualr/ �testsRun�len�errors�failuresr) r( r* r- r r r �__repr__\ s �zTestResult.__repr__c C s t � � S r )�timer- r r r �_getTimeg s zTestResult._getTimec C s& t |t�rt|d |d |d �S |S )zX Convert a C{sys.exc_info()}-style tuple to a L{Failure}, if necessary. � r � )� isinstance�tupler )r �errorr r r � _getFailurej s zTestResult._getFailurec s t � �|� | �� | _dS )zq This must be called before the given test is commenced. @type test: L{pyunit.TestCase} N)r' � startTestr8 � _testStarted�r �testr. r r r? r s zTestResult.startTestc s t � �|� | �� | j | _dS )zp This must be called after the given test is completed. @type test: L{pyunit.TestCase} N)r' �stopTestr8 r@ � _lastTimerA r. r r rC { s zTestResult.stopTestc C � | j �|| �|�f� dS )z� Report a failed assertion for the given test. @type test: L{pyunit.TestCase} @type fail: L{Failure} or L{tuple} N)r5 �appendr> �r rB �failr r r � addFailure� � zTestResult.addFailurec C rE )z� Report an error that occurred while running the given test. @type test: L{pyunit.TestCase} @type error: L{Failure} or L{tuple} N)r4 rF r> �r rB r= r r r �addError� rJ zTestResult.addErrorc C s | j �||f� dS )a5 Report that the given test was skipped. In Trial, tests can be 'skipped'. Tests are skipped mostly because there is some platform or configuration issue that prevents them from being run correctly. @type test: L{pyunit.TestCase} @type reason: L{str} N)r( rF )r rB �reasonr r r �addSkip� s zTestResult.addSkipNc C s& |du r t | j�}| j�||f� dS )a� Report that the given test succeeded against expectations. In Trial, tests can be marked 'todo'. That is, they are expected to fail. When a test that is expected to fail instead succeeds, it should call this method to report the unexpected success. @type test: L{pyunit.TestCase} @type todo: L{unittest.Todo}, or L{None}, in which case a default todo message is provided. N)r � _DEFAULT_TODOr* rF �r rB �todor r r �addUnexpectedSuccess� s z TestResult.addUnexpectedSuccessc C s( |du r t | j�}| j�|||f� dS )ab Report that the given test failed, and was expected to do so. In Trial, tests can be marked 'todo'. That is, they are expected to fail. @type test: L{pyunit.TestCase} @type error: L{Failure} @type todo: L{unittest.Todo}, or L{None}, in which case a default todo message is provided. N)r rO r) rF )r rB r= rQ r r r �addExpectedFailure� s z TestResult.addExpectedFailurec C s | j d7 _ dS )z_ Report that the given test succeeded. @type test: L{pyunit.TestCase} r9 N)r+ rA r r r � addSuccess� s zTestResult.addSuccessc C s$ t | j�t | j� kodkS S )a� Report whether or not this test suite was successful or not. The behaviour of this method changed in L{pyunit} in Python 3.4 to fail if there are any errors, failures, or unexpected successes. Previous to 3.4, it was only if there were errors or failures. This method implements the old behaviour for backwards compatibility reasons, checking just for errors and failures. @rtype: L{bool} r )r3 r5 r4 r- r r r � wasSuccessful� s $ zTestResult.wasSuccessfulc C � dS )z6 The test suite has finished running. Nr r- r r r �done� � zTestResult.doner )r r r r rO r �strr6 r8 r> r? rC rI rL rN rR rS rT rU rW � __classcell__r r r. r r& H s" r& c @ r )�TestResultDecoratorz� Base class for TestResult decorators. @ivar _originalReporter: The wrapped instance of reporter. @type _originalReporter: A provider of L{itrial.IReporter} Nr r r r r r[ � s r[ �_originalReporterc @ s e Zd ZdZdd� ZdS )� UncleanWarningsReporterWrapperze A wrapper for a reporter that converts L{util.DirtyReactorAggregateError}s to warnings. c C s: t |t�r|�tj�rt�|�� � dS | j� ||� dS )z� If the error is a L{util.DirtyReactorAggregateError}, instead of reporting it as a normal error, throw a warning. N) r; r �checkr �DirtyReactorAggregateError�warnings�warn�getErrorMessager\ rL rK r r r rL � s z'UncleanWarningsReporterWrapper.addErrorN)r r r r rL r r r r r] � s r] c @ � e Zd ZdZdd� Zdd� ZdS )� _ExitWrapperza A wrapper for a reporter that causes the reporter to stop after unsuccessful tests. c O � d| _ | jj|i |��S �NT)� shouldStopr\ rL �r �args�kwargsr r r rL � z_ExitWrapper.addErrorc O re rf )rg r\ rI rh r r r rI rk z_ExitWrapper.addFailureN)r r r r rL rI r r r r rd � s rd c @ sT e Zd ZdZdd� Zdd� Zddd�Zd d � Zd d � Zdd d�Z dd� Z dd� Z dS )�_AdaptedReporterz� TestResult decorator that makes sure that addError only gets tests that have been adapted with a particular test adapter. c C s t �| |� || _dS )z� Construct an L{_AdaptedReporter}. @param original: An {itrial.IReporter}. @param testAdapter: A callable that returns an L{itrial.ITestCase}. N)r[ r � testAdapter)r r rm r r r r s z_AdaptedReporter.__init__c C � | � |�}| j�||�S �z* See L{itrial.IReporter}. )rm r\ rL rK r r r rL � z_AdaptedReporter.addErrorNc C s | j �| �|�||�S )at See L{itrial.IReporter}. @type test: A L{pyunit.TestCase}. @type failure: A L{failure.Failure} or L{AssertionError} @type todo: A L{unittest.Todo} or None When C{todo} is L{None} a generic C{unittest.Todo} is built. L{pyunit.TestCase}'s C{run()} calls this with 3 positional arguments (without C{todo}). )r\ rS rm )r rB �failurerQ r r r rS % s �z#_AdaptedReporter.addExpectedFailurec C rn ro )rm r\ rI )r rB rq r r r rI 6 rp z_AdaptedReporter.addFailurec C rn ro )rm r\ rN )r rB �skipr r r rN = rp z_AdaptedReporter.addSkipc C rn )a3 See L{itrial.IReporter}. @type test: A L{pyunit.TestCase}. @type todo: A L{unittest.Todo} or None When C{todo} is L{None} a generic C{unittest.Todo} is built. L{pyunit.TestCase}'s C{run()} calls this with 2 positional arguments (without C{todo}). )rm r\ rR rP r r r rR D s z%_AdaptedReporter.addUnexpectedSuccessc C � | j �| �|��S ro )r\ r? rm rA r r r r? S � z_AdaptedReporter.startTestc C rs ro )r\ rC rm rA r r r rC Y rt z_AdaptedReporter.stopTestr ) r r r r r rL rS rI rN rR r? rC r r r r rl s rl c s� e Zd ZdZdZdZejdddf� fdd� Zd d � Z � fd d �Z � fd d�Z � fdd�Z dd� Z dd� Zd.� fdd� Z� fdd�Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Z� ZS )/�Reportera� A basic L{TestResult} with support for writing to a stream. @ivar _startTime: The time when the first test was started. It defaults to L{None}, which means that no test was actually launched. @type _startTime: C{float} or L{None} @ivar _warningCache: A C{set} of tuples of warning message (file, line, text, category) which have already been written to the output stream during the currently executing test. This is used to avoid writing duplicates of the same warning to the output stream. @type _warningCache: C{set} @ivar _publisher: The log publisher which will be observed for warning events. @type _publisher: L{twisted.python.log.LogPublisher} zO-------------------------------------------------------------------------------zO===============================================================================�defaultFNc sP t � �� t|�| _|| _|| _d | _t� | _|| _ |d ur&|� | j � d S d S r ) r' r r �_stream�tbformat�realtime� _startTime�set� _warningCache� _publisher� addObserver�_observeWarnings�r �streamrx ry � publisherr. r r r w s �zReporter.__init__c C sd d|v r.|d |d |d � d�d t|d �f}|| jvr0| j�|� | j�d| � dS dS dS ) a| Observe warning events and write them to C{self._stream}. This method is a log observer which will be registered with C{self._publisher.addObserver}. @param event: A C{dict} from the logging system. If it has a C{'warning'} key, a logged warning will be extracted from it and possibly written to C{self.stream}. �warning�filename�lineno�category�.���z%s:%s: %s: %s N)�splitrY r| �addrw r# )r �event�keyr r r r � s � �zReporter._observeWarningsc s, t � �|� | jdu r| �� | _t� | _dS )z� Called when a test begins to run. Records the time when it was first called and resets the warning cache. @param test: L{ITestCase} N)r' r? rz r8 r{ r| rA r. r r r? � s zReporter.startTestc s: t � �||� | jr| jd d }| �| �|�� dS dS )z� Called when a test fails. If C{realtime} is set, then it prints the error to the stream. @param test: L{ITestCase} that failed. @param fail: L{failure.Failure} containing the error. r� r9 N)r' rI ry r5 �_write�_formatFailureTracebackrG r. r r rI � s �zReporter.addFailurec sD | � |�}t� �||� | jr | jd d }| �| �|�� dS dS )z� Called when a test raises an error. If C{realtime} is set, then it prints the error to the stream. @param test: L{ITestCase} that raised the error. @param error: L{failure.Failure} containing the error. r� r9 N)r> r' rL ry r4 r� r� rK r. r r rL � s �zReporter.addErrorc G sH t |�}t|t �s J �|r| j�|| � n| j�|� t| jj� dS )z� Safely write to the reporter's stream. @param format: A format string to write. @param args: The arguments for the format string. N)rY r; rw r# r �flush)r �formatri �sr r r r� � s zReporter._writec G s | j |g|�R � | � d� dS )z� Safely write a line to the reporter's stream. Newline is appended to the format string. @param format: A format string to write. @param args: The arguments for the format string. � N)r� �r r� ri r r r �_writeln� s zReporter._writelnTc sN t � �||||� |r%| �|�}t�|� d�||�}tj|tdd� d S d S )Nz3caught exception in {}, your TestCase is broken {}r: )� stacklevel) r' � upDownErrorr� r �msgr� r` ra r )r �methodr= ra � printStatus�tbStrr� r. r r r� � s ��zReporter.upDownErrorc s* t � �|� t�dd| �|�f t� d S )Nz%s %sz&REACTOR UNCLEAN! traceback(s) follow: )r' � cleanupErrorsr` ra r� r �r �errsr. r r r� � s ���zReporter.cleanupErrorsc C sd t |�}t|�dk r |S |d d }tj�tj�|d d ��d }|d d }tj�tj�|d d ��d }d}d}||f||ff} |D ]"} tj�tj�| d ��d } | dkrh| d dkrh|�|�| �� qF| |krt|dd� }n| |kr|d d� }n ||fd kr�|dd� }|s�|S |d } | d �d �r�tj�tj�| d ��d d kr�|dd � }|S )a) Trim frames to remove internal paths. When a C{SynchronousTestCase} method fails synchronously, the stack looks like this: - [0]: C{SynchronousTestCase._run} - [1]: C{util.runWithWarningsSuppressed} - [2:-2]: code in the test method which failed - [-1]: C{_synctest.fail} When a C{TestCase} method fails synchronously, the stack looks like this: - [0]: C{defer.maybeDeferred} - [1]: C{utils.runWithWarningsSuppressed} - [2]: C{utils.runWithWarningsSuppressed} - [3:-2]: code in the test method which failed - [-1]: C{_synctest.fail} When a method fails inside a C{Deferred} (i.e., when the test method returns a C{Deferred}, and that C{Deferred}'s errback fires), the stack captured inside the resulting C{Failure} looks like this: - [0]: C{defer.Deferred._runCallbacks} - [1:-2]: code in the testmethod which failed - [-1]: C{_synctest.fail} As a result, we want to trim either [maybeDeferred, runWWS, runWWS] or [Deferred._runCallbacks] or [SynchronousTestCase._run, runWWS] from the front, and trim the [unittest.fail] from the end. There is also another case, when the test method is badly defined and contains extra arguments. If it doesn't recognize one of these cases, it just returns the original frames. @param frames: The C{list} of frames from the test failure. @return: The C{list} of frames to display. r: r r9 ))�_run� _synctest)�runWithWarningsSuppressedr ))� maybeDeferred�defer)r� �utils�compat�reraiseN� )� _runCallbacksr� r� rH r� ) �listr3 �os�path�splitext�basename�pop�index� startswith) r �frames� newFrames� firstMethod� firstFile� secondMethod� secondFile�syncCase� asyncCase� twoFrames�frame� frameFile�lastr r r � _trimFrames� s: ( � � zReporter._trimFramesc C sF t |t�r |�� d S | �|j�|j|_}|j| jdd�}||_|S )Nr� T)�detail�elideFrameworkCode)r; rY �rstripr� r� � getTracebackrx )r rH r� �resultr r r r� G s z Reporter._formatFailureTracebackc C sJ t � }|D ]}|d }|dd� }||� }|�|g ��|� qt|�� �S )a Group tests together based on their results. @param results: An iterable of tuples of two or more elements. The first element of each tuple is a test case. The remaining elements describe the outcome of that test case. @param formatter: A callable which turns a test case result into a string. The elements after the first of the tuples in C{results} will be passed as positional arguments to C{formatter}. @return: A C{list} of two-tuples. The first element of each tuple is a unique string describing one result from at least one of the test cases in C{results}. The second element is a list of the test cases which had that result. r r9 N)r � setdefaultrF r� �items)r �results� formatter�groups�content�case�outcomer� r r r � _groupResultsO s zReporter._groupResultsc C s\ | � ||�D ]%\}}| �| j� | �|� | �|� | �d� |D ] }| �|�� � q!qdS )a< Print a group of errors to the stream. @param flavor: A string indicating the kind of error (e.g. 'TODO'). @param errors: A list of errors, often L{failure.Failure}s, but sometimes 'todo' errors. @param formatter: A callable that knows how to format the errors. � N)r� r� �_doubleSeparatorr� �id)r �flavorr4 r� rM �casesr� r r r � _printResultsi s ��zReporter._printResultsc C s d� |j| �|��S )NzReason: {!r} {})r� rM r� )r r= rQ r r r �_printExpectedFailurez s �z Reporter._printExpectedFailurec C s. d|j �d�}|jr|d�d�|j��7 }|S )NzReason: r� zExpected errors: {} �, )rM r4 r� �join)r rQ �retr r r �_printUnexpectedSuccess s z Reporter._printUnexpectedSuccessc C sj | � d� | �d| jdd� � | �d| j| j� | �d| j| j� | �d| j| j� | �d| j| j � d S ) zM Print all of the non-success results to the stream in full. r� � [SKIPPED]c S s d| S )N�%s r )�xr r r �<lambda>� s z'Reporter._printErrors.<locals>.<lambda>�[TODO]�[FAIL]�[ERROR]� [SUCCESS!?!]N) r� r� r( r) r� r5 r� r4 r* r� r- r r r � _printErrors� s �zReporter._printErrorsc C sh g }dD ]}t t| |��}|r|�d||f � q| jr%|�d| jf � |r0dd�|� d p1d}|S )zC Return a formatted count of tests status results. )r( r) r5 r4 r* z%s=%dz successes=%dz (r� �)r� )r3 r rF r+ r� )r � summaries�stat�num�summaryr r r � _getSummary� s �zReporter._getSummaryc C s, | � � }| �� r d}nd}| �d||� dS )zJ Print a line summarising the test results to the stream. �PASSED�FAILEDz%s%s N)r� rU r� )r r� �statusr r r � _printSummary� s zReporter._printSummaryc C sf | j dur | j �| j� | �� | �| j� | jdur(| �d| jt�� | j � | � d� | � � dS )a� Summarize the result of the test run. The summary includes a report of all of the errors, todos, skips and so forth that occurred during the run. It also includes the number of tests that were run and how long it took to run them (not including load time). Expects that C{_printErrors}, C{_writeln}, C{_write}, C{_printSummary} and C{_separator} are all implemented. NzRan %d tests in %.3fsr� ) r} �removeObserverr r� r� � _separatorrz r2 r7 r� r� r- r r r rW � s � z Reporter.done)TT) r r r r r� r� �sys�stdoutr r r? rI rL r� r� r� r� r� r� r� r� r� r� r� r� r� rW rZ r r r. r ru ` s0 � T ru c @ rc )�MinimalReporterz� A minimalist reporter that prints only a summary of the test result, in the form of (timeTaken, #tests, #tests, #errors, #failures, #skips). c C rV )zb Don't print a detailed summary of errors. We only care about the counts. Nr r- r r r r� � rX z MinimalReporter._printErrorsc C s` | j }| jdur| �� | j }nd}|||t| j�t| j�t| j�f}| �d�t t |��� dS )z� Print out a one-line summary of the form: '%(runtime) %(number_of_tests) %(number_of_tests) %(num_errors) %(num_failures) %(num_skips)' Nr � ) r2 rz r8 r3 r4 r5 r( r� r� �maprY )r �numTests�timing�tr r r r� � s �z MinimalReporter._printSummaryN)r r r r r� r� r r r r r� � s r� c s\ e Zd ZdZ� fdd�Z� fdd�Z� fdd�Z� fdd �Z� fd d �Z� fd d �Z � Z S )� TextReporterz� Simple reporter that prints a single character for each test as it runs, along with the standard Trial summary text. c � t � �|� | �d� d S )Nr� �r' rT r� rA r. r r rT � � zTextReporter.addSuccessc � t � j|� | �d� d S )N�E�r' rL r� �r ri r. r r rL � r� zTextReporter.addErrorc r� )N�F�r' rI r� r� r. r r rI � r� zTextReporter.addFailurec r� )N�S�r' rN r� r� r. r r rN � r� zTextReporter.addSkipc r� )N�T�r' rS r� r� r. r r rS r� z TextReporter.addExpectedFailurec r� )N�!�r' rR r� r� r. r r rR r� z!TextReporter.addUnexpectedSuccess) r r r r rT rL rI rN rS rR rZ r r r. r r� � s r� c st e Zd ZdZ� fdd�Z� fdd�Z� fdd�Z� fdd �Z� fd d �Z� fd d �Z � fdd�Z � fdd�Z � Z S )�VerboseTextReporterz� A verbose reporter that prints the name of each test as it is running. Each line is printed with the name of the test, followed by the result of that test. c s | � d|�� � t� �|� d S )Nz%s ... )r� r� r' r? )r �tmr. r r r? s z VerboseTextReporter.startTestc r� �Nz[OK]r� rA r. r r rT r� z VerboseTextReporter.addSuccessc r� �Nr� r� r� r. r r rL r� z VerboseTextReporter.addErrorc r� )Nz [FAILURE]r� r� r. r r rI r� z VerboseTextReporter.addFailurec r� �Nr� r� r� r. r r rN $ r� zVerboseTextReporter.addSkipc r� �Nr� r r� r. r r rS ( r� z&VerboseTextReporter.addExpectedFailurec r� �Nr� r r� r. r r rR , r� z(VerboseTextReporter.addUnexpectedSuccessc r� )Nr� )r' rC r� rA r. r r rC 0 r� z VerboseTextReporter.stopTest) r r r r r? rT rL rI rN rS rR rC rZ r r r. r r s r c s e Zd ZdZ� fdd�Z� ZS )�TimingTextReporterze Prints out each test as it is running, followed by the time taken for each test to run. c s t � �|� | �d| j � dS )zm Mark the test as stopped, and write the time it took to run the test to the stream. z (%.03f secs) N)r' rC r� rD )r r� r. r r rC ; s zTimingTextReporter.stopTest)r r r r rC rZ r r r. r r 5 s r c @ sJ e Zd ZdZedddddddd d �Zd d � Zeej fd d��Z dd� Z dS )�_AnsiColorizerz� A colorizer is an object that loosely wraps around a stream, allowing callers to write text to the stream in a particular color. Colorizer classes must implement C{supported()} and C{write(text, color)}. � � � �! �" �# �$ �% )�black�red�green�yellow�blue�magenta�cyan�whitec C r r �r� �r r� r r r r P r z_AnsiColorizer.__init__c C s� |� � sdS zddl}W n ty Y dS w z z |�d�dkW W S |jy7 |�� |�d�dk Y W S w tyA Y dS w )z� A class method that returns True if the current platform supports coloring terminal output using this method. Returns False otherwise. Fr N�colorsr: )�isatty�curses� ImportError�tigetnumr= � setupterm� BaseException)�clsr� r r r r � supportedS s" �� �z_AnsiColorizer.supportedc C s( | j | }| j�d|� d|� d�� dS )z� Write the given text to the stream in the given color. @param text: Text to be written to the stream. @param color: A string label for a color. e.g. 'red', 'white'. z[z;1mz[0mN)�_colorsr� r# �r �text�colorr r r r# j s z_AnsiColorizer.writeN) r r r r �dictr' r � classmethodr� r� r& r# r r r r r D s � r c @ �2 e Zd ZdZdd� Zeejfdd��Zdd� Z dS ) �_Win32Colorizer�' See _AnsiColorizer docstring. c C s� ddl m}m}m}m}m}m} ||||f\}} } } || _||�| _|| B | B || B | | B | | B || B | B || B | B | | B | B || B | B | B d�| _ d S )Nr )�FOREGROUND_BLUE�FOREGROUND_GREEN�FOREGROUND_INTENSITY�FOREGROUND_RED�STD_OUTPUT_HANDLE� GetStdHandle)�normalr r r r r r r ) � win32consoler0 r1 r2 r3 r4 r5 r� � screenBufferr' ) r r� r0 r1 r2 r3 r4 r5 r r r �boldr r r r { s" � �z_Win32Colorizer.__init__c C sl z dd l }|�|j�}W n ty Y dS w dd l}z|�|j|jB |jB � W dS |j y5 Y dS w )Nr FT) r7 r5 r4 r! � pywintypes�SetConsoleTextAttributer3 r1 r0 r= )r% r� r7 r8 r: r r r r& � s& ������z_Win32Colorizer.supportedc C s8 | j | }| j�|� | j�|� | j�| j d � d S )Nr6 )r' r8 r; r� r# r( r r r r# � s z_Win32Colorizer.writeN� r r r r r r, r� r� r& r# r r r r r. v s r. c @ r- ) �_NullColorizerr/ c C r r r r r r r r � r z_NullColorizer.__init__c C rV rf r )r% r� r r r r& � s z_NullColorizer.supportedc C s | j �|� d S r )r� r# r( r r r r# � s z_NullColorizer.writeNr< r r r r r= � s r= c @ s� e Zd ZdZdZejdddfdd�Zdd� Ze d d � �Z d d � Z d d� Z dd� Z dd� Zdd� Zdd� Zdd� Zdd� Zd dd �Zd d d �ZdS ) �SubunitReporterz� Reports test output via Subunit. @ivar _subunit: The subunit protocol client that we are wrapping. @ivar _successful: An internal variable, used to track whether we have received only successful results. @since: 10.0 Nrv Fc C s$ t du rtd��t |�| _d| _dS )aI Construct a L{SubunitReporter}. @param stream: A file-like object representing the stream to print output to. Defaults to stdout. @param tbformat: The format for tracebacks. Ignored, since subunit always uses Python's standard format. @param realtime: Whether or not to print exceptions in the middle of the test results. Ignored, since subunit always does this. @param publisher: The log publisher which will be preserved for reporting events. Ignored, as it's not relevant to subunit. NzSubunit not availableT)r � Exception�_subunit� _successfulr� r r r r � s zSubunitReporter.__init__c C rV )z� Record that the entire test suite run is finished. We do nothing, since a summary clause is irrelevant to the subunit protocol. Nr r- r r r rW � s zSubunitReporter.donec C s | j jS )zK Whether or not the test runner should stop running tests. )r@ rg r- r r r rg � s zSubunitReporter.shouldStopc C s | j �� S )zH Signal that the test runner should stop running tests. )r@ �stopr- r r r rB � s zSubunitReporter.stopc C s | j S )z� Has the test run been successful so far? @return: C{True} if we have received no reports of errors or failures, C{False} otherwise. )rA r- r r r rU � s z SubunitReporter.wasSuccessfulc C � | j �|�S )z2 Record that C{test} has started. )r@ r? rA r r r r? � zSubunitReporter.startTestc C rC )z4 Record that C{test} has completed. )r@ rC rA r r r rC rD zSubunitReporter.stopTestc C rC )z5 Record that C{test} was successful. )r@ rT rA r r r rT rD zSubunitReporter.addSuccessc C s6 t | jdd�}|du r| �|� dS | j�||� dS )a� Record that C{test} was skipped for C{reason}. Some versions of subunit don't have support for addSkip. In those cases, the skip is reported as a success. @param test: A unittest-compatible C{TestCase}. @param reason: The reason for it being skipped. The C{str()} of this object will be included in the subunit output stream. rN N)r r@ rT rN )r rB rM rN r r r rN s zSubunitReporter.addSkipc C � d| _ | j�|t�|��S )z� Record that C{test} failed with an unexpected error C{err}. Also marks the run as being unsuccessful, causing L{SubunitReporter.wasSuccessful} to return C{False}. F)rA r@ rL r �excInfoOrFailureToExcInfo�r rB �errr r r rL , � zSubunitReporter.addErrorc C rE )z� Record that C{test} failed an assertion with the error C{err}. Also marks the run as being unsuccessful, causing L{SubunitReporter.wasSuccessful} to return C{False}. F)rA r@ rI r rF rG r r r rI 6 rI zSubunitReporter.addFailurec C s< t �|�}t| jdd�}|du r| �|� dS |||� dS )z� Record an expected failure from a test. Some versions of subunit do not implement this. For those versions, we record a success. rS N)r rF r r@ rT )r rB rq rQ rS r r r rS @ s z"SubunitReporter.addExpectedFailurec C s | � |� dS )z� Record an unexpected success. Since subunit has no way of expressing this concept, we record a success on the subunit stream. N)rT rP r r r rR N s z$SubunitReporter.addUnexpectedSuccessr )r r r r r2 r� r� r rW �propertyrg rB rU r? rC rT rN rL rI rS rR r r r r r> � s$ � r> c s� e Zd ZdZdZdZdZdZdZdZ dZ dZ dZ e jf� fdd � Zd d � Z� fd d �Z� fdd�Z� fdd�Z� fdd�Z� fdd�Z� fdd�Z� fdd�Zdd� Zd d � Z� fd d �Z� fd d!�Z� fd"d#�Z � fd$d%�Z d&d'� Z � Z S )(� TreeReporterz� Print out the tests in the form a tree. Tests are indented according to which class and module they belong. Results are printed in ANSI color. r� z �O r r r c sN t � j|g|�R i |�� g | _tttfD ]}|�|�r$||�| _ d S qd S r )r' r � _lastTestr. r r= r& � _colorizer)r r� ri rj � colorizerr. r r r l s ��zTreeReporter.__init__c C s |� � �d�d S )z� Return the name of the method which 'test' represents. This is what gets displayed in the leaves of the tree. e.g. getDescription(TestCase('test_foo')) ==> test_foo r� r� )r� r� rA r r r �getDescriptiont s zTreeReporter.getDescriptionc s t � �|� | �d| j� d S r )r' rT �endLine�SUCCESSrA r. r r rT } � zTreeReporter.addSuccessc � t � j|� | �d| j� d S r )r' rL rQ �ERRORr� r. r r rL � rS zTreeReporter.addErrorc rT )Nr� )r' rI rQ �FAILUREr� r. r r rI � rS zTreeReporter.addFailurec rT r )r' rN rQ �SKIPr� r. r r rN � rS zTreeReporter.addSkipc rT r )r' rS rQ �TODOr� r. r r rS � rS z TreeReporter.addExpectedFailurec rT r )r' rR rQ �TODONEr� r. r r rR � rS z!TreeReporter.addUnexpectedSuccessc s$ |r|| }|| _ t� �| j � d S r )� currentLiner' r� r� r. r r r� � s zTreeReporter._writec C sJ |� d�dd� }t|�dkr|S dd� d�|dd� �|d fD �}|S )z� Return a list of all non-leaf segments to display in the tree. Normally this is the module and class name. r� Nr� r c S s g | ] }t |�d kr|�qS )r )r3 )�.0�segr r r � <listcomp>� s z4TreeReporter._getPreludeSegments.<locals>.<listcomp>)r� r3 r� )r �testID�segmentsr r r �_getPreludeSegments� s �z TreeReporter._getPreludeSegmentsc C s| | � |�}d}|D ]/}|t| j�k r'|| j| kr&| �| j| � |� d�� n | �| j| � |� d�� |d7 }q || _dS )z� Write the name of the test to the stream, indenting it appropriately. If the test is the first test in a new 'branch' of the tree, also write all of the parents in that branch. r r� r9 N)r` r3 rM r� �indent)r r^ r_ � indentLevelr\ r r r � _testPrelude� s � zTreeReporter._testPreludec s. | j �d| j� | �d| j� t� �|� d S )Nz cleanup errorsr� )rN r# rU rQ r' r� r� r. r r r� � s zTreeReporter.cleanupErrorsc s< | j �d| | j� |r| �d| j� t� �||||� d S )Nz %sr� )rN r# rU rQ r' r� )r r� r= ra r� r. r r r� � s zTreeReporter.upDownErrorc sB | � |�� � | �d| jt| j� | �|�f � t� �|� dS )zn Called when C{test} starts. Writes the tests name to the stream using a tree format. z %s%s ... N) rc r� r� ra r3 rM rP r' r? rA r. r r r? � s ��zTreeReporter.startTestc sF d| j t| j� t|� }t� �|� | j�||� t� �d� dS )z� Print 'message' in the given color. @param message: A string message, usually '[OK]' or something similar. @param color: A string color, 'red', 'green' and so forth. r� r� N)�columnsr3 rZ r' r� rN r# )r �messager* �spacesr. r r rQ � s zTreeReporter.endLinec C sD | � � }| �� rd}| j}nd}| j}| j�||� | �d|� dS )zo Print a line summarising the test results to the stream, and color the status result. r� r� r� N)r� rU rR rV rN r# r� )r r� r� r* r r r r� � s zTreeReporter._printSummary) r r r r rZ ra rd rV rU rX rW rY rR r� r� r rP rT rL rI rN rS rR r� r` rc r� r� r? rQ r� rZ r r r. r rK Y s6 rK ).r r� r� r7 �unittest�pyunitr` � collectionsr �zope.interfacer �twisted.pythonr r �twisted.python.componentsr �twisted.python.failurer �twisted.python.utilr � twisted.trialr r �subunitr r! r �Warningr r � IReporterr& r[ r] rd rl ru r� r� r r r r. r= r> rK r r r r �<module> s` � � R j" +2> PK b�Z��,i ,i " __pycache__/runner.cpython-310.pycnu �[��� o �b�| � @ s� d Z g d�ZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z ddlmZ ddlmZmZmZmZmZ ddlmZmZ dd lmZmZ dd l m Z dd l m Z dd l m!Z!m"Z" dd l#m$Z$ e%d�Z&dd� Z'dd� Z(dd� Z)dd� Z*dd� Z+dd� Z,dd � Z-G d d � d e$�Z.d Z/G d d!� d!e$�Z0G d"d#� d#e$�Z1d$d%� Z2d&d'� Z3e e �G d(d)� d)��Z4G d*d+� d+e4�Z5G d,d-� d-�Z6d.d/� Z7G d0d1� d1�Z8dS )2zK A miscellany of code used to run Trial tests. Maintainer: Jonathan Lange )� TestSuite�DestructiveTestSuite� ErrorHolder� LoggedSuite� TestHolder� TestLoader� TrialRunner� TrialSuite�filenameToModule� isPackage�isPackageDirectory� isTestCase�name�samefile� NOT_IN_TEST� N)�SourceFileLoader)� implementer)�defer)�failure�filepath�log�modules�reflect)�unittest�util)� _ForceGarbageCollectionDecorator� _iterateTests)� _logObserver)� ITestCase)� UncleanWarningsReporterWrapper� _ExitWrapper)r r c C s2 t | tj�sdS tj�tj�| j��d }|dkS )z>Given an object return True if the object looks like a packageFr �__init__)� isinstance�types� ModuleType�os�path�splitext�basename�__file__)�moduler( � r+ �6/usr/lib/python3/dist-packages/twisted/trial/runner.pyr 8 s r c C s> dd� }|� D ]}d| }t j�t j�| |��r | S qdS )z� Is the directory at path 'dirname' a Python package directory? Returns the name of the __init__ file (it may have a weird extension) if dirname is a package directory. Otherwise, returns False c S s t j�� S �N)� importlib� machinery� all_suffixesr+ r+ r+ r, � _getSuffixesG � z(isPackageDirectory.<locals>._getSuffixesr! F)r% r& �exists�join)�dirnamer1 �ext�initFiler+ r+ r, r @ s �r c C s t j�| �t j�|�kS )z� A hacky implementation of C{os.path.samefile}. Used by L{filenameToModule} when the platform doesn't provide C{os.path.samefile}. Do not use this. )r% r& �abspath)� filename1� filename2r+ r+ r, r Q s r c C s | }dt j kr dk r n ntj�| �s tj�t�� | �} tj�| �s+t|�d���t � | �}zt � |�}W n tt fyH t | |d� Y S w t|dd�du rWt | |d�S tj�|j�d d }ttjd t�}tj�| �r|| |�st j|j= t | |d�}|S ) aV Given a filename, do whatever possible to return a module object matching that file. If the file in question is a module in Python path, properly import and return that module. Otherwise, load the source manually. @param fn: A filename. @return: A module object. @raise ValueError: If C{fn} does not exist. )� � )r; � z doesn't exist)� moduleNamer) Nr z.pyr )�sys� version_infor% r& �isabsr4 �getcwdr3 � ValueErrorr �filenameToModuleName�namedAny�AttributeError�_importFromFile�getattrr' r) r �isfiler �__name__)�fn�oldFnr> �ret�retFile�samer+ r+ r, r Y s& & � r c C s| t | �} |stj�tj�| �d �d }|tjv r tj| S tj� || �}|s+t | ��tj� |�}|j � |� |tj|< |S )N���r )�_resolveDirectoryr% r& r' �splitr? r r. r �spec_from_file_location� SyntaxError�module_from_spec�loader� exec_module)rK r> �specr* r+ r+ r, rG � s rG c C s< t j�| �r t| �}|rt j�| |�} | S t| �d���| S )Nz is not a package directory)r% r& �isdirr r4 rC )rK r7 r+ r+ r, rQ � s �rQ c C sH t | j| jt� �| kr!t| j�D ]}t | j|t� �| kr | S q| jS )z� Find the attribute name on the method's class which refers to the method. For some methods, notably decorators which have not had __name__ set correctly: getattr(method.im_class, method.__name__) != method )rH �im_classrJ �object�dir)�method�aliasr+ r+ r, �_getMethodNameInClass� s �r_ c @ s e Zd ZdZdd� ZdS )r zQ A test suite which remove the tests once run, to minimize memory usage. c C s0 | j r|jr |S | j �d�}||� | j s|S )zn Almost the same as L{TestSuite.run}, but with C{self._tests} being empty at the end. r )�_tests� shouldStop�pop)�self�result�testr+ r+ r, �run� s ��zDestructiveTestSuite.runN)rJ � __module__� __qualname__�__doc__rf r+ r+ r+ r, r � s r z <not in test>c s e Zd ZdZ� fdd�Z� ZS )r z[ Any errors logged in this suite will be reported to the L{TestResult} object. c sJ t }|�� t� �|� |�� |�� D ] }|�tt�|� q|� � dS )z� Run the suite, storing all errors in C{result}. If an error is logged while no tests are running, then it will be added as an error to C{result}. @param result: A L{TestResult} object. N) r �_add�superrf �_remove� getErrors�addErrorr r � flushErrors)rc rd �observer�error�� __class__r+ r, rf � s zLoggedSuite.run)rJ rg rh ri rf � __classcell__r+ r+ rr r, r � s r c s2 e Zd ZdZd � fdd� Zdd� Zdd � Z� ZS ) r z� Suite to wrap around every single test in a C{trial} run. Used internally by Trial to set up things necessary for Trial tests to work, regardless of what context they are run in. r+ Fc sF |rg }|D ] }t �|t�}|�|� q|}t|�}t� �|g� d S r- )r �decorater �appendr rk r! )rc �tests�forceGarbageCollection�newTestsre �suiterr r+ r, r! � s zTrialSuite.__init__c sH ddl m} t�� � |�dd� fdd�� |�d� t�d��� � d S )Nr )�reactor�after�shutdownc s � � d �S r- )�callbackr+ ��dr+ r, �<lambda>� � z"TrialSuite._bail.<locals>.<lambda>�mktemp) �twisted.internetr{ r �Deferred�addSystemEventTrigger�fireSystemEventr �TestCase�_wait)rc r{ r+ r r, �_bail� s zTrialSuite._bailc C s& z t �| |� W | �� d S | �� w r- )r rf r� �rc rd r+ r+ r, rf � s zTrialSuite.run)r+ F)rJ rg rh ri r! r� rf rt r+ r+ rr r, r � s r c C s@ t | �r t�| �}|S z| �� }W |S ty | j}Y |S w )z� @param thing: an object from modules (instance of PythonModule, PythonAttribute), a TestCase subclass, or an instance of a TestCase. )r r �qual�idrF r )�thing�theNamer+ r+ r, r s � ��r c C s$ zt | tj�W S ty Y dS w )z� @return: C{True} if C{obj} is a class that contains test cases, C{False} otherwise. Used to find all the tests in a module. F)� issubclass�pyunitr� � TypeError)�objr+ r+ r, r s �r c @ sD e Zd ZdZdZdd� Zdd� Zdd� Zd d � Zd d � Z d d� Z dS )r z� Placeholder for a L{TestCase} inside a reporter. As far as a L{TestResult} is concerned, this looks exactly like a unit test. Nc C s || _ dS )zM @param description: A string to be displayed L{TestResult}. N�� description)rc r� r+ r+ r, r! , s zTestHolder.__init__c C s | � |�S r- �rf r� r+ r+ r, �__call__2 r2 zTestHolder.__call__c C � | j S r- r� �rc r+ r+ r, r� 5 � z TestHolder.idc C s dS )Nr r+ r� r+ r+ r, �countTestCases8 s zTestHolder.countTestCasesc C s" |� | � |�| � |�| � dS )z� This test is just a placeholder. Run the test successfully. @param result: The C{TestResult} to store the results in. @type result: L{twisted.trial.itrial.IReporter}. N)� startTest� addSuccess�stopTestr� r+ r+ r, rf ; s zTestHolder.runc C r� r- r� r� r+ r+ r, �shortDescriptionF r� zTestHolder.shortDescription) rJ rg rh ri �failureExceptionr! r� r� r� rf r� r+ r+ r+ r, r # s r c s6 e Zd ZdZ� fdd�Zdefdd�Zdd� Z� ZS ) r a Used to insert arbitrary errors into a test suite run. Provides enough methods to look like a C{TestCase}, however, when it is run, it simply adds an error to the C{TestResult}. The most common use-case is for when a module fails to import. c s t � �|� t�|�| _dS )a+ @param description: A string used by C{TestResult}s to identify this error. Generally, this is the name of a module that failed to import. @param error: The error to be added to the result. Can be an `exc_info` tuple or a L{twisted.python.failure.Failure}. N)rk r! r �excInfoOrFailureToExcInforq )rc r� rq rr r+ r, r! R s zErrorHolder.__init__�returnc C s d� | j| jd �S )Nz)<ErrorHolder description={!r} error={!r}>� )�formatr� rq r� r+ r+ r, �__repr__] s �zErrorHolder.__repr__c C s& |� | � |�| | j� |�| � dS )z� Run the test, reporting the error. @param result: The C{TestResult} to store the results in. @type result: L{twisted.trial.itrial.IReporter}. N)r� rn rq r� r� r+ r+ r, rf c s zErrorHolder.run) rJ rg rh ri r! �strr� rf rt r+ r+ rr r, r J s r c @ s� e Zd ZdZdZdZdd� Zdd� Zdd � Zd&d d �Z d d� Z e Z dd� Z e Z dd� Zdd� Zdd� Zd&dd�Zdd� Zd'd d �Zd&d d �ZeZd&d d!�Zd"d#� Zd&d$d%�ZdS )(r a4 I find tests inside function, modules, files -- whatever -- then return them wrapped inside a Test (either a L{TestSuite} or a L{TestCase}). @ivar methodPrefix: A string prefix. C{TestLoader} will assume that all the methods in a class that begin with C{methodPrefix} are test cases. @ivar modulePrefix: A string prefix. Every module in a package that begins with C{modulePrefix} is considered a module full of tests. @ivar forceGarbageCollection: A flag applied to each C{TestCase} loaded. See L{unittest.TestCase} for more information. @ivar sorter: A key function used to sort C{TestCase}s, test classes, modules and packages. @ivar suiteFactory: A callable which is passed a list of tests (which themselves may be suites of tests). Must return a test suite. re �test_c C s t | _t| _g | _d S r- )r � suiteFactoryr �sorter� _importErrorsr� r+ r+ r, r! � s zTestLoader.__init__c C s t || jd�S )zt Sort the given things using L{sorter}. @param xs: A list of test cases, class or modules. )�key)�sortedr� )rc �xsr+ r+ r, �sort� s zTestLoader.sortc C s4 g }t �|�D ] \}}t|�r|�|� q| �|�S )z-Given a module, return all Trial test classes)�inspect� getmembersr rv r� )rc r* �classesr �valr+ r+ r, �findTestClasses� s � zTestLoader.findTestClassesFc C sb t j|v r!t�|�}zt|� W n ty | j||d� Y S w |}d } }}t|�D ]B\}}z t�|�}|}W n4 tyo t � � d } | j durU| j } | j dusM| j j j} | tjkr`� |dkrmt�d|� d���Y q-w |du r�t�|�}|�d�td�|j��d d� }z|D ] } |t|| �}}q�W n ty� t|� d���w | j||||d �S ) a� Find and load tests, given C{name}. @param _name: The qualified name of the thing to load. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. @return: If C{name} is a filename, return the module. If C{name} is a fully-qualified Python name, return the object it refers to. ��recurseN� � z The module z does not exist.�.r� )�parent�qualNamer� )r% �sepr rD � __import__� ImportError�loadFile�_qualNameWalker� namedModuler? �exc_info�tb_next�tb_frame�f_code� co_filenamer) �ModuleNotFoundrE rR �lenrJ rH rF � loadAnything) rc �_namer� r r� r� � remaining� searchName� remainingName�tb�filenameWhereHappened�partr+ r+ r, � findByName� sN � � �� "� ��zTestLoader.findByNamec C s� t |tj�s t|�d���t|d�r|�� S t|d�r |�� S | �� }| �|�D ] }|� | � |�� q(t|d�s:|S | �� }|j D ] }|� | � |�� qA| �||g�S )a� Return a test suite with all the tests from a module. Included are TestCase subclasses and doctests listed in the module's __doctests__ module. If that's not good for you, put a function named either C{testSuite} or C{test_suite} in your module that returns a TestSuite, and I'll use the results of that instead. If C{testSuite} and C{test_suite} are both present, then I'll use C{testSuite}. z is not a module� testSuite� test_suite� __doctests__) r" r# r$ r� �hasattrr� r� r� r� �addTest� loadClassr� � loadDoctests)rc r* rz � testClass�docSuite�docTestr+ r+ r, � loadModule� s zTestLoader.loadModulec s\ t � t�s t� �d���t� �st� �d������ �}��� �fdd�|D ��}��|�S )z� Given a class which contains test cases, return a list of L{TestCase}s. @param klass: The class to load tests from. z is not a classz is not a test casec s g | ] }�� � �j| ��qS r+ )� _makeCase� methodPrefix)�.0r ��klassrc r+ r, � <listcomp> s z(TestLoader.loadClass.<locals>.<listcomp>)r" �typer� r rC �getTestCaseNamesr� r� )rc r� �namesrw r+ r� r, r� s � zTestLoader.loadClassc C s t �|| j�S )z� Given a class that contains C{TestCase}s, return a list of names of methods that probably contain tests. )r �prefixedMethodNamesr� )rc r� r+ r+ r, r� % s zTestLoader.getTestCaseNamesc C s t d��)NzCan't happen on Py3)�NotImplementedError)rc r] r+ r+ r, � loadMethod, � zTestLoader.loadMethodc C s ||�S r- r+ )rc r� � methodNamer+ r+ r, r� / r� zTestLoader._makeCasec C s� t |�s t|�d���t�|j�}|r|�� }n|�� }g }|D ]}|j�d�d � | j �r3|� |� q | � � }| � |�D ]$}z|�� } W n tyV t|jt�� �} Y nw | �| �} |�| � q=|S )a� Load tests from a module object representing a package, and return a TestSuite containing those tests. Tests are only loaded from modules whose name begins with 'test_' (or whatever C{modulePrefix} is set to). @param package: a types.ModuleType object (or reasonable facsimile obtained by importing) which may contain tests. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. @raise TypeError: If C{package} is not a package. @return: a TestSuite created with my suiteFactory, containing all the tests. z is not a packager� rP )r r� r � getModulerJ � walkModules� iterModulesr rR � startswith� modulePrefixrv r� r� �load� BaseExceptionr r �Failurer� r� ) rc �packager� �pkgobj� discovery� discovered�discorz �modinfor* � thingToAddr+ r+ r, � loadPackage2 s* � � zTestLoader.loadPackagec C sx t |t�r zt�|�}W n ty t|t�� � Y S w t� |�s)t � d� dS i }dd� }||d< t j |fi |��S )z� Return a suite of tests for all the doctests defined in C{module}. @param module: A module object or a module name. z&trial only supports doctesting modulesNc S s t | d| j�| _| j�� | _dS )z� Save C{test.globs} and replace it with a copy so that if necessary, the original will be available for the next test run. � _savedGlobalsN)rH �globsr� �copy)re r+ r+ r, � saveGlobalsm s z,TestLoader.loadDoctests.<locals>.saveGlobals�setUp)r" r� r rE r� r r r� r� �ismodule�warnings�warn�doctest� DocTestSuite)rc r* � extraArgsr� r+ r+ r, r� \ s � zTestLoader.loadDoctestsNc C s� t |tj�rt|�r| j||d�S | �|�S t |t�r&t|tj �r&| � |�S t |tj �rLt |t�rLt|tj �rL|d }||�}t ||j �j|ksJJ �|S t |t�rS|S td|� ���)a� Load absolutely anything (as long as that anything is a module, package, class, or method (with associated parent class and qualname). @param obj: The object to load. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. @param parent: If C{obj} is a method, this is the parent class of the method. C{qualName} is also required. @param qualName: If C{obj} is a method, this a list containing is the qualified name of the method. C{parent} is also required. @return: A C{TestCase} or C{TestSuite}. r� rP z"don't know how to make test from: )r" r# r$ r r� �loadTestsFromModuler� r� r� r� �loadTestsFromTestCase� FunctionTyperH �_testMethodName�__func__r r� )rc r� r� r� r� r �instr+ r+ r, r� y s& �� � zTestLoader.loadAnythingc C sB z | � | j||d�g�W S ty | � t|t�� �g� Y S w )a* Load some tests by name. @param name: The qualified name for the test to load. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. r� )r� r� r� r r r� )rc r r� r+ r+ r, � loadByName� s �zTestLoader.loadByNamec C sj g }g }|D ]!}z |� | j||d�� W q ty' |� t|t�� �� Y qw |�|� | �| �|��S )a+ Load some tests by a list of names. @param names: A L{list} of qualified names. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. r� ) rv r r� r r r� �extendr� � _uniqueTests)rc r� r� �things�errorsr r+ r+ r, � loadByNames� s � zTestLoader.loadByNamesc c sF � t � }|D ]}|j}|D ]}t|�|vr |V |�t|�� q qdS )a Gather unique suite objects from loaded things. This will guarantee uniqueness of inherited methods on TestCases which would otherwise hash to same value and collapse to one test unexpectedly if using simpler means: e.g. set(). N)�setr` r� �add)rc r �seen� testthing� testthingsr� r+ r+ r, r � s � ���zTestLoader._uniqueTestsc C sF t �|�}zt||��� }| j||d�W S ty" t|� d���w )a1 Load a file, and then the tests in that file. @param fileName: The file name to load. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. r� z is not a Python file.)r rD r � load_moduler� �OSErrorrC )rc �fileNamer� r r* r+ r+ r, r� � s �zTestLoader.loadFile�F)FNN)rJ rg rh ri r� r� r! r� r� r� r� r r� r r� r� r� r� r� r� r �loadTestsFromNamer r r� r+ r+ r+ r, r o s. V * 0 r c c sR � | g fV | � d�}tdt|��D ]}d�|d| � �|| d� fV qdS )a3 Given a Python qualified name, this function yields a 2-tuple of the most specific qualified name first, followed by the next-most-specific qualified name, and so on, paired with the remainder of the qualified name. @param qualName: A Python qualified name. @type qualName: L{str} r� r� N)rR �ranger� r4 )r� � qualParts�indexr+ r+ r, r� � s � &�r� c @ s� e Zd ZdZdZdZdd� Zdd� ZeZ dd � Z d d e j d d d d d d d d f dd�Z dd� Zdd� Zdd� Zddd�Zdd� Zd S )r z= A specialised runner that the trial front end uses. �debugzdry-runc C s< | � � t�� }t�| j�}t�|�\}| _t� |j � |S r- ) �_tearDownLogFiler% rB r �FilePath�workingDirectoryr �_unusedTestDirectory� _testDirLock�chdirr& )rc � currentDir�base�testdirr+ r+ r, � _setUpTestdir s zTrialRunner._setUpTestdirc C s t �|� | j�� d S r- )r% r$ r# �unlock)rc �oldDirr+ r+ r, �_tearDownTestdir s z TrialRunner._tearDownTestdirc C s8 | � | j| j| j| j�}| jrt|�}| jrt|�}|S r- ) �reporterFactory�stream�tbformat�rterrors�_log� _exitFirstr �uncleanWarningsr )rc �reporterr+ r+ r, � _makeResult s �zTrialRunner._makeResultNztest.logF�defaultc C st || _ || _|| _|| _|| _|| _|| _d | _| pd| _d | _ d | _ | | _ | | _ | | _ |r8t�| jd�| _d S d S )N� _trial_tempz profile.data)r, �logfile�moder- r. r/ r2 �_resultr! �_logFileObserver�_logFileObject�_forceGarbageCollection�debuggerr1 r �profiledrf ) rc r, r8 r7 r- �profile�tracebackFormat�realTimeErrorsr2 r! rx r= � exitFirstr+ r+ r, r! # s" �zTrialRunner.__init__c C s@ | j d urt�| j j� d | _ | jd ur | j�� d | _d S d S r- )r: r �removeObserver�emitr; �closer� r+ r+ r, r C s �z TrialRunner._tearDownLogFilec C sL | � � | jdkr tj}nt| jd�}|| _t�|�| _t� | jj d� d S )N�-�ar ) r r7 r? �stdout�openr; r �FileLogObserverr: �startLoggingWithObserverrD )rc �logFiler+ r+ r, � _setUpLogFileK s zTrialRunner._setUpLogFilec C s t �|t�}| �|| j�S )zC Run the test or suite and return a result object. )r ru r �_runWithoutDecorationr< )rc re r+ r+ r, rf U s zTrialRunner.runc sF �� � � t|g|��t�� }�j�jkr+t��D ]}� �|� � �|� � �|� qn7�j�j kr:� ��fdd�}n� �fdd�}�� � }z�� � |� W �� � �� |� n �� � �� |� w t�� }t� dd�}|du r�tjdt�� j� tdd� � �� � �� j� � �d � j|| � � �d � � �� � S � �� � S ) zR Private helper that runs the given test but doesn't decorate it. c s �j ��j� �S r- )r= �runcallrf r+ �rd rc rz r+ r, r� m s z3TrialRunner._runWithoutDecoration.<locals>.<lambda>c s �� � �S r- r� r+ )rd rz r+ r, r� o r� �doneNzR%s should implement done() but doesn't. Falling back to printErrors() and friends.r; )�category� stacklevelzRan %d tests in %.3fs� ) r4 r �timer8 �DRY_RUNr r� r� r� �DEBUGr( rM r r+ rH r r r r� rs �DeprecationWarning� printErrors�writeln� separator�testsRun�write� printSummaryrQ ) rc re rx � startTime�singlerf r* �endTimerQ r+ rP r, rN \ sP � � �� � �z!TrialRunner._runWithoutDecorationc C s^ d} |d7 }| j �d|f � |dkr| �|�}n| �|�}|jdkr' |S |�� s. |S q)z8 Repeatedly run C{test} until it fails. r Tr� z Test Pass %d )r- r] rf rN r\ � wasSuccessful)rc re �countrd r+ r+ r, �runUntilFailure� s ��zTrialRunner.runUntilFailurer )rJ rg rh ri rW rV r( r+ r r0 r4 r? rH r! r rM rf rN rd r+ r+ r+ r, r s2 � 1r )9ri �__all__r r. r� r% r? rU r# r �importlib.machineryr �zope.interfacer r� r �twisted.pythonr r r r r � twisted.trialr r �twisted.trial._asyncrunnerr r �twisted.trial._synctestr �twisted.trial.itrialr �twisted.trial.reporterr r �twisted.trial.unittestr r� r� r r r r rG rQ r_ r r r r r r r r r r� r r+ r+ r+ r, �<module> sV 1 $ &% PK b�Z���� � $ __pycache__/unittest.cpython-310.pycnu �[��� o �b� � @ s\ d Z ddlmZmZmZ ddlmZ ddlmZm Z m Z m Z m Z m Z e e_e _g d�ZdS )z4 Things likely to be used by writers of unit tests. � )� TestDecorator� TestSuite�decorate)�TestCase)�FailTest�PyUnitResultAdapter�SkipTest�SynchronousTestCase�Todo�makeTodo) r r r r r r r r r r N)�__doc__�twisted.trial._asyncrunnerr r r �twisted.trial._asynctestr �twisted.trial._synctestr r r r r r �__name__� __module__�__all__� r r �8/usr/lib/python3/dist-packages/twisted/trial/unittest.py�<module> s PK b�Z^�1ͳ � ( __pycache__/_asyncrunner.cpython-310.pycnu �[��� o �b, � @ s d Z ddlZddlZddlZddlmZ ddlmZ ddl m Z m Z ddl m Z G dd� dej�Zee j�G d d � d e�e jd ���Zd d � Zdd� ZG dd� de�ZG dd� de�ZG dd� de�Ze�eeje j� e�eeje j� eedd�Zer�e�eee j� dd� Z dS )z- Infrastructure for test running and suites. � N)� implementer)� components)�itrial�reporter)� _logObserverc @ � e Zd ZdZdd� ZdS )� TestSuitezh Extend the standard library's C{TestSuite} with a consistently overrideable C{run} method. c C s$ | j D ] }|jr |S ||� q|S )z; Call C{run} on every member of the suite. )�_tests� shouldStop)�self�result�test� r �</usr/lib/python3/dist-packages/twisted/trial/_asyncrunner.py�run s �z TestSuite.runN��__name__� __module__� __qualname__�__doc__r r r r r r � r c @ s e Zd ZdZdd� Zdd� ZdS )� TestDecoratorz� Decorator for test cases. @param _originalTest: The wrapped instance of test. @type _originalTest: A provider of L{itrial.ITestCase} c C s | � |�S �zQ Run the unit test. @param result: A TestResult object. )r �r r r r r �__call__3 s zTestDecorator.__call__c C s | j �t�|| j��S r )� _originalTestr r �_AdaptedReporter� __class__r r r r r ; s zTestDecorator.runN)r r r r r r r r r r r & s r r c C s g | _ dS )z� Clear all tests from C{suite}. This messes with the internals of C{suite}. In particular, it assumes that the suite keeps all of its tests in a list in an instance variable called C{_tests}. N)r )�suiter r r � _clearSuiteD s r c C sN zt | �}W n ty || � Y S w t| � |D ] }| �t||�� q| S )a2 Decorate all test cases in C{test} with C{decorator}. C{test} can be a test case or a test suite. If it is a test suite, then the structure of the suite is preserved. L{decorate} tries to preserve the class of the test suites it finds, but assumes the presence of the C{_tests} attribute on the suite. @param test: The C{TestCase} or C{TestSuite} to decorate. @param decorator: A unary callable used to decorate C{TestCase}s. @return: A decorated C{TestCase} or a C{TestSuite} containing decorated C{TestCase}s. )�iter� TypeErrorr �addTest�decorate)r � decorator�tests�caser r r r# O s �r# c @ s e Zd ZdZdS )�_PyUnitTestCaseAdapterz2 Adapt from pyunit.TestCase to ITestCase. N)r r r r r r r r r' n s r' c @ r )�_BrokenIDTestCaseAdapterz� Adapter for pyunit-style C{TestCase} subclasses that have undesirable id() methods. That is C{unittest.FunctionTestCase} and C{unittest.DocTestCase}. c C s | j �� }|dur |S | j �� S )zH Return the fully-qualified Python name of the doctest. N)r �shortDescription�id)r �testIDr r r r* z s z_BrokenIDTestCaseAdapter.idN)r r r r r* r r r r r( t r r( c @ r )� _ForceGarbageCollectionDecoratorz� Forces garbage collection to be run before and after the test. Any errors logged during the post-test collection are added to the test result as errors. c C sR t �� t�| |� t�� t �� t�� D ]}|�| |� qt�� t� � d S )N) �gc�collectr r r �_add� getErrors�addError� flushErrors�_remove)r r �errorr r r r � s z$_ForceGarbageCollectionDecorator.runNr r r r r r, � s r, � DocTestCasec c sF � zt | �}W n ty | V Y dS w |D ] }t|�E dH qdS )zF Iterate through all of the test cases in C{testSuiteOrCase}. N)r r! � _iterateTests)�testSuiteOrCaser r r r r r6 � s � ��r6 ) r �doctestr- �unittest�pyunit�zope.interfacer �twisted.pythonr � twisted.trialr r �twisted.trial._synctestr r � ITestCase�proxyForInterfacer r r# r' r( r, �registerAdapter�TestCase�FunctionTestCase�getattr� _docTestCaser6 r r r r �<module> s8 �� � PK b�Z����; ; $ __pycache__/__main__.cpython-310.pycnu �[��� o �b� � @ s8 e d krddlZddlmZ e�eddd�� � dS dS )�__main__� N)�load_entry_point�Twisted�console_scripts�trial)�__name__�sys� pkg_resourcesr �exit� r r �8/usr/lib/python3/dist-packages/twisted/trial/__main__.py�<module> s �PK b�Z�Q� R� R� % __pycache__/_synctest.cpython-310.pycnu �[��� o �b� � @ sn d Z ddlZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z mZ ddlmZ ddlmZ ddlmZmZmZ ddlmZmZmZmZ dd lm Z dd l m Z dd l m Z m!Z! G d d � d e"�Z#G dd� d�Z$dd� Z%G dd� d�Z&dd� Z'dd� Z(G dd� de)�Z*G dd� d�Z+G d d � d �Z,G d d � d ej-�Z.G d d!� d!�Z/e/� Z0G d"d#� d#e.�Z1dS )$zP Things likely to be used by writers of unit tests. Maintainer: Jonathan Lange � N)�findlinestarts)�Optional�Tuple)�SkipTest)�ensureDeferred)�failure�log�monkey)�DEPRECATION_WARNING_FORMAT�getDeprecationWarningString�getVersionString�warnAboutFunction)�fullyQualifiedName)�runWithWarningsSuppressed)�itrial�utilc @ � e Zd ZdZdS )�FailTestzA Raised to indicate the current test has failed to pass. N��__name__� __module__� __qualname__�__doc__� r r �9/usr/lib/python3/dist-packages/twisted/trial/_synctest.pyr & � r c @ s0 e Zd ZdZd dd�Zdefdd�Zdd � ZdS ) �TodoaK Internal object used to mark a L{TestCase} as 'todo'. Tests marked 'todo' are reported differently in Trial L{TestResult}s. If todo'd tests fail, they do not fail the suite and the errors are reported in a separate category. If todo'd tests succeed, Trial L{TestResult}s will report an unexpected success. Nc C s || _ || _dS )ar @param reason: A string explaining why the test is marked 'todo' @param errors: An iterable of exception types that the test is expected to raise. If one of these errors is raised by the test, it will be trapped. Raising any other kind of error will fail the test. If L{None} is passed, then all errors will be trapped. N��reason�errors)�selfr r r r r �__init__5 s z Todo.__init__�returnc C s d| j �d| j�d�S )Nz <Todo reason=z errors=�>r �r r r r �__repr__A s z Todo.__repr__c C s. | j du rdS | j D ] }|�|�r dS q dS )z� @param failure: A L{twisted.python.failure.Failure}. @return: C{True} if C{failure} is expected, C{False} otherwise. NTF)r �check)r r �errorr r r �expectedD s �z Todo.expected�N)r r r r r! �strr% r( r r r r r , s r c C s\ t | t�r t| d�S t | t�r,| \}}zt|�}W n ty% |g}Y nw t||d�S dS )a� Return a L{Todo} object built from C{value}. If C{value} is a string, return a Todo that expects any exception with C{value} as a reason. If C{value} is a tuple, the second element is used as the reason and the first element as the excepted error(s). @param value: A string or a tuple of C{(errors, reason)}, where C{errors} is either a single exception class or an iterable of exception classes. @return: A L{Todo} object. )r r N)� isinstancer* r �tuple�list� TypeError)�valuer r r r r �makeTodoR s � �r0 c @ s e Zd ZdZdd� ZdS )�_Warninga] A L{_Warning} instance represents one warning emitted through the Python warning system (L{warnings}). This is used to insulate callers of L{_collectWarnings} from changes to the Python warnings system which might otherwise require changes to the warning objects that function passes to the observer object it accepts. @ivar message: The string which was passed as the message parameter to L{warnings.warn}. @ivar category: The L{Warning} subclass which was passed as the category parameter to L{warnings.warn}. @ivar filename: The name of the file containing the definition of the code object which was C{stacklevel} frames above the call to L{warnings.warn}, where C{stacklevel} is the value of the C{stacklevel} parameter passed to L{warnings.warn}. @ivar lineno: The source line associated with the active instruction of the code object object which was C{stacklevel} frames above the call to L{warnings.warn}, where C{stacklevel} is the value of the C{stacklevel} parameter passed to L{warnings.warn}. c C s || _ || _|| _|| _d S r) ��message�category�filename�lineno)r r3 r4 r5 r6 r r r r! � s z_Warning.__init__N)r r r r r! r r r r r1 j s r1 c C s< t | �� �D ]}|durzd|_W q ty Y qw qdS )z� Disable the per-module cache for every module found in C{modules}, typically C{sys.modules}. @param modules: Dictionary of modules, typically sys.module dict N)r- �values�__warningregistry__� BaseException)�modules�vr r r �_setWarningRegistryToNone� s ���r< c s| d� fdd� }t tj� tjdd� }tj}t�d� z|t_||i |��}W |tjdd�< |t_|S |tjdd�< |t_w )aU Call C{f} with C{args} positional arguments and C{kwargs} keyword arguments and collect all warnings which are emitted as a result in a list. @param observeWarning: A callable which will be invoked with a L{_Warning} instance each time a warning is emitted. @return: The return value of C{f(*args, **kwargs)}. Nc s( t | t�sJ �� tt| �|||�� d S r) )r+ �Warningr1 r* )r3 r4 r5 r6 �file�line��observeWarningr r � showWarning� s z%_collectWarnings.<locals>.showWarning�always)NN)r< �sysr: �warnings�filters� showwarning� simplefilter)rA �f�args�kwargsrB � origFilters�origShow�resultr r@ r �_collectWarnings� s �rO c @ r )�UnsupportedTrialFeaturez?A feature of twisted.trial was used that pyunit cannot support.Nr r r r r rP � r rP c @ sr e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z ddd�Z dd� Z dd� Zdd� ZdS ) �PyUnitResultAdapterz� Wrap a C{TestResult} from the standard library's C{unittest} so that it supports the extended result types from Trial, and also supports L{twisted.python.failure.Failure}s being passed to L{addError} and L{addFailure}. c C s || _ dS )zM @param original: A C{TestResult} instance from C{unittest}. N)�original)r rR r r r r! � � z PyUnitResultAdapter.__init__c C s t �|�S r) )r �excInfoOrFailureToExcInfo)r �errr r r � _exc_info� s z PyUnitResultAdapter._exc_infoc C � | j �|� d S r) )rR � startTest�r �methodr r r rX � � z PyUnitResultAdapter.startTestc C rW r) )rR �stopTestrY r r r r\ � r[ z PyUnitResultAdapter.stopTestc C � | j �|| �|�� d S r) )rR � addFailurerV )r �test�failr r r r^ � � z PyUnitResultAdapter.addFailurec C r] r) )rR �addErrorrV �r r_ r' r r r rb � ra z PyUnitResultAdapter.addErrorc C s | j �|tt||�d f� d S r) )rR r^ rP )r r_ �feature�infor r r � _unsupported� s �z PyUnitResultAdapter._unsupportedc C s | j �||� dS )z/ Report the skip as a failure. N)rR �addSkip)r r_ r r r r rg � � zPyUnitResultAdapter.addSkipNc C � | � |d|� dS )z= Report the unexpected success as a failure. zunexpected successN�rf )r r_ �todor r r �addUnexpectedSuccess� rh z(PyUnitResultAdapter.addUnexpectedSuccessc C ri )zG Report the expected failure (i.e. todo) as a failure. zexpected failureNrj rc r r r �addExpectedFailure� rh z&PyUnitResultAdapter.addExpectedFailurec C rW r) )rR � addSuccess)r r_ r r r rn � r[ z PyUnitResultAdapter.addSuccessc C � d S r) r )r rZ r' �warn� printStatusr r r � upDownError� � z PyUnitResultAdapter.upDownErrorr) )r r r r r! rV rX r\ r^ rb rf rg rl rm rn rr r r r r rQ � s rQ c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �_AssertRaisesContexta� A helper for implementing C{assertRaises}. This is a context manager and a helper method to support the non-context manager version of C{assertRaises}. @ivar _testCase: See C{testCase} parameter of C{__init__} @ivar _expected: See C{expected} parameter of C{__init__} @ivar _returnValue: The value returned by the callable being tested (only when not being used as a context manager). @ivar _expectedName: A short string describing the expected exception (usually the name of the exception class). @ivar exception: The exception which was raised by the function being tested (if it raised one). c C sD || _ || _d| _z| jj| _W dS ty! t| j�| _Y dS w )z� @param testCase: The L{TestCase} instance which is used to raise a test-failing exception when that is necessary. @param expected: The exception type expected to be raised. N)� _testCase� _expected� _returnValuer � _expectedName�AttributeErrorr* )r �testCaser( r r r r! s �z _AssertRaisesContext.__init__c C s6 | �}|� | _ W d � |jS 1 sw Y |jS )a, Call the given object using this object as a context manager. @param obj: The object to call and which is expected to raise some exception. @type obj: L{object} @return: Whatever exception is raised by C{obj()}. @rtype: L{BaseException} N)rw � exception)r �obj�contextr r r �_handle s ��z _AssertRaisesContext._handlec C s | S r) r r$ r r r � __enter__. rs z _AssertRaisesContext.__enter__c C s� |du r| j �d�| j| j�� t||�s#t|t�r ||� }n||�}|| _t|| j �sCt � |||�}| j �d�t |�| j|� � �� dS )zB Check exit exception against expected exception. Nz{} not raised ({} returned)z {} raised instead of {}: {}T)ru r` �formatrx rw r+ r, r{ � issubclassrv r �Failurer � getTraceback)r � exceptionType�exceptionValue� tracebackr r r r �__exit__1 s* �� �� z _AssertRaisesContext.__exit__N)r r r r r! r~ r r� r r r r rt � s rt c s` e Zd ZdZd.dd�Zd.� fdd� ZeZeZeZd.� fdd� Z e Z e Z e Z d.d d �Z e Zd.� fd d � ZeZeZeZd.d d�ZeZeZd.dd�ZeZeZd.dd�ZeZeZeZ d.dd�Z e Z d.dd�Z e Z d/dd�Z!e!Z"e!Z#e!Z$d/dd�Z%e%Z&e%Z'd.d d �Z(e(Z)d.d d �Z*e*Z+d.d d!�Z,e,Z-d"d#� Z.e.Z/d.d$d%�Z0e0Z1d&d'� Z2e2Z3d(d)� Z4d*d+� Z5d,d-� Z6� Z7S )0� _Assertionsz� Replaces many of the built-in TestCase assertions. In general, these assertions provide better error messages and are easier to use in callbacks. Nc C s | � |��)z� Absolutely fail the test. Do not pass go, do not collect $200. @param msg: the message that will be displayed as the reason for the failure ��failureException)r �msgr r r r` ` s z_Assertions.failc � t � �||� |S )z� Fail the test if C{condition} evaluates to True. @param condition: any object that defines __nonzero__ )�super� assertFalse�r � conditionr� �� __class__r r r� i � z_Assertions.assertFalsec r� )z� Fail the test if C{condition} evaluates to False. @param condition: any object that defines __nonzero__ )r� � assertTruer� r� r r r� v r� z_Assertions.assertTruec s, t | |�}�du r |S |�� ��fdd��S )a� Fail the test unless calling the function C{f} with the given C{args} and C{kwargs} raises C{exception}. The failure will report the traceback and call stack of the unexpected exception. @param exception: exception type that is to be expected @param f: the function to call @return: If C{f} is L{None}, a context manager which will make an assertion about the exception raised from the suite it manages. If C{f} is not L{None}, the exception raised by C{f}. @raise self.failureException: Raised if the function call does not raise an exception or if it raises an exception of a different type. Nc s �� i ���S r) r r �rJ rI rK r r �<lambda>� s z*_Assertions.assertRaises.<locals>.<lambda>)rt r~ )r r{ rI rJ rK r} r r� r � assertRaises� s z_Assertions.assertRaisesc s t � �|||� |S )z� Fail the test if C{first} and C{second} are not equal. @param msg: A string describing the failure that's included in the exception. )r� � assertEqual�r �first�secondr� r� r r r� � s z_Assertions.assertEqualc C s$ ||ur| � |p|�d|����|S )a Fail the test if C{first} is not C{second}. This is an obect-identity-equality test, not an object equality (i.e. C{__eq__}) test. @param msg: if msg is None, then the failure message will be '%r is not %r' % (first, second) z is not r� r� r r r �assertIs� � z_Assertions.assertIsc C s$ ||u r| � |p|�d|����|S )a Fail the test if C{first} is C{second}. This is an obect-identity-equality test, not an object equality (i.e. C{__eq__}) test. @param msg: if msg is None, then the failure message will be '%r is %r' % (first, second) z is r� r� r r r � assertIsNot� r� z_Assertions.assertIsNotc C s$ ||ks| � |p|�d|����|S )z� Fail the test if C{first} == C{second}. @param msg: if msg is None, then the failure message will be '%r == %r' % (first, second) � == r� r� r r r �assertNotEqual� s z_Assertions.assertNotEqualc C s$ ||vr| � |p|�d|����|S )a� Fail the test if C{containee} is not found in C{container}. @param containee: the value that should be in C{container} @param container: a sequence type, or in the case of a mapping type, will follow semantics of 'if key in dict.keys()' @param msg: if msg is None, then the failure message will be '%r not in %r' % (first, second) z not in r� �r � containee� containerr� r r r �assertIn� � z_Assertions.assertInc C s$ ||v r| � |p|�d|����|S )a� Fail the test if C{containee} is found in C{container}. @param containee: the value that should not be in C{container} @param container: a sequence type, or in the case of a mapping type, will follow semantics of 'if key in dict.keys()' @param msg: if msg is None, then the failure message will be '%r in %r' % (first, second) z in r� r� r r r � assertNotIn� r� z_Assertions.assertNotIn� c C s6 t || |�dkr| �|p|�d|�d|�d���|S )a� Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero. @note: decimal places (from zero) is usually not the same as significant digits (measured from the most significant digit). @note: included for compatibility with PyUnit test cases r r� � within � places��roundr� �r r� r� �placesr� �deltar r r �assertNotAlmostEqual� � �z _Assertions.assertNotAlmostEqualc C s6 t || |�dkr| �|p|�d|�d|�d���|S )a� Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero. @note: decimal places (from zero) is usually not the same as significant digits (measured from the most significant digit). @note: included for compatibility with PyUnit test cases r z != r� r� r� r� r r r �assertAlmostEqual r� z _Assertions.assertAlmostEqualc C s, t || �|kr| �|p|� d|� ���|S )z� Fail if C{first} - C{second} > C{tolerance} @param msg: if msg is None, then the failure message will be '%r ~== %r' % (first, second) z ~== )�absr� )r r� r� � tolerancer� r r r �assertApproximates' s z _Assertions.assertApproximatesc C � | � |||�S )zH Fail if C{substring} does not exist within C{astring}. )� failUnlessIn�r � substring�astringr� r r r �assertSubstring4 � z_Assertions.assertSubstringc C r� )z; Fail if C{astring} contains C{substring}. )�failIfInr� r r r �assertNotSubstring< r� z _Assertions.assertNotSubstringc O s� g }t |j|g|�R i |��}|s| �d� |d } |dd� D ]} | j| jf| j| jfkr3| �d� q | �| j|� | �| j|� | �|�| j �d| j �d|��� |S )a� Fail if the given function doesn't generate the specified warning when called. It calls the function, checks the warning, and forwards the result of the function if everything is fine. @param category: the category of the warning to check. @param message: the output message of the warning to check. @param filename: the filename where the warning should come from. @param f: the function which is supposed to generate the warning. @type f: any callable. @param args: the arguments to C{f}. @param kwargs: the keywords arguments to C{f}. @return: the result of the original function C{f}. zNo warnings emittedr � Nz Can't handle different warningsz Warning in z , expected ) rO �appendr` r3 r4 r� �assertIdenticalr� � startswithr5 ) r r4 r3 r5 rI rJ rK � warningsShownrN r� �otherr r r � assertWarnsD s � � z_Assertions.assertWarnsc C s@ t ||�s |du r d}nd| }| �|�d|� |� �� dS dS )a Fail if C{instance} is not an instance of the given class or of one of the given classes. @param instance: the object to test the type (first argument of the C{isinstance} call). @type instance: any. @param classOrTuple: the class or classes to test against (second argument of the C{isinstance} call). @type classOrTuple: class, type, or tuple. @param message: Custom text to include in the exception text if the assertion fails. N� �: z is not an instance of �r+ r` )r �instance� classOrTupler3 �suffixr r r �assertIsInstancep s �z _Assertions.assertIsInstancec C s& t ||�r| �|�d|� �� dS dS )a� Fail if C{instance} is an instance of the given class or of one of the given classes. @param instance: the object to test the type (first argument of the C{isinstance} call). @type instance: any. @param classOrTuple: the class or classes to test against (second argument of the C{isinstance} call). @type classOrTuple: class, type, or tuple. z is an instance of Nr� )r r� r� r r r �assertNotIsInstance� s �z _Assertions.assertNotIsInstancec C sZ t |�}g }|�|j� |s| �d�|�� |d }t|tj�r+| �d�||�� �� |S )a? Return the current success result of C{deferred} or raise C{self.failureException}. @param deferred: A L{Deferred<twisted.internet.defer.Deferred>} which has a success result. This means L{Deferred.callback<twisted.internet.defer.Deferred.callback>} or L{Deferred.errback<twisted.internet.defer.Deferred.errback>} has been called on it and it has reached the end of its callback chain and the last callback or errback returned a non-L{failure.Failure}. @type deferred: L{Deferred<twisted.internet.defer.Deferred>} @raise SynchronousTestCase.failureException: If the L{Deferred<twisted.internet.defer.Deferred>} has no result or has a failure result. @return: The result of C{deferred}. z8Success result expected on {!r}, found no result insteadr zASuccess result expected on {!r}, found failure result instead: {}) r �addBothr� r` r� r+ r r� r� )r �deferredrN r r r �successResultOf� s$ �� ��z_Assertions.successResultOfc G s� t |�}g }|�|j� |s| �d�|�� |d }t|tj�s)| �d�||�� |rH|j|� sHd� dd� |D ��}| �d�|||j |� � �� |S )a� Return the current failure result of C{deferred} or raise C{self.failureException}. @param deferred: A L{Deferred<twisted.internet.defer.Deferred>} which has a failure result. This means L{Deferred.callback<twisted.internet.defer.Deferred.callback>} or L{Deferred.errback<twisted.internet.defer.Deferred.errback>} has been called on it and it has reached the end of its callback chain and the last callback or errback raised an exception or returned a L{failure.Failure}. @type deferred: L{Deferred<twisted.internet.defer.Deferred>} @param expectedExceptionTypes: Exception types to expect - if provided, and the exception wrapped by the failure result is not one of the types provided, then this test will fail. @raise SynchronousTestCase.failureException: If the L{Deferred<twisted.internet.defer.Deferred>} has no result, has a success result, or has an unexpected failure result. @return: The failure result of C{deferred}. @rtype: L{failure.Failure} z8Failure result expected on {!r}, found no result insteadr zDFailure result expected on {!r}, found success result ({!r}) insteadz or c S s g | ] }d � |j|jf��qS )�.)�joinr r )�.0�tr r r � <listcomp>� s z/_Assertions.failureResultOf.<locals>.<listcomp>zBFailure of type ({}) expected on {!r}, found type {!r} instead: {}) r r� r� r` r� r+ r r� r& r� �typer� )r r� �expectedExceptionTypesrN �expectedStringr r r �failureResultOf� s4 �� � ���z_Assertions.failureResultOfc sR t |�}g � � fdd�}|�|� � r'|�dd� � | �d�|� d �� dS dS )a� Assert that C{deferred} does not have a result at this point. If the assertion succeeds, then the result of C{deferred} is left unchanged. Otherwise, any L{failure.Failure} result is swallowed. @param deferred: A L{Deferred<twisted.internet.defer.Deferred>} without a result. This means that neither L{Deferred.callback<twisted.internet.defer.Deferred.callback>} nor L{Deferred.errback<twisted.internet.defer.Deferred.errback>} has been called, or that the L{Deferred<twisted.internet.defer.Deferred>} is waiting on another L{Deferred<twisted.internet.defer.Deferred>} for a result. @type deferred: L{Deferred<twisted.internet.defer.Deferred>} @raise SynchronousTestCase.failureException: If the L{Deferred<twisted.internet.defer.Deferred>} has a result. c s � � | � | S r) )r� )�res�rN r r �cb s z&_Assertions.assertNoResult.<locals>.cbc S ro r) r )�_r r r r� � z,_Assertions.assertNoResult.<locals>.<lambda>z.No result expected on {!r}, found {!r} insteadr N)r r� � addErrbackr` r� )r r� r� r r� r �assertNoResult� s ���z_Assertions.assertNoResultr) )r� NN)8r r r r r` r� � assertNot�failUnlessFalse�failIfr� �assert_�failUnlessTrue� failUnlessr� �failUnlessRaisesr� �failUnlessEqual�failUnlessEquals� assertEqualsr� �failUnlessIdenticalr� r� �failIfIdentical�assertNotIdenticalr� �assertNotEquals� failIfEquals� failIfEqualr� r� r� r� r� �assertNotAlmostEquals�failIfAlmostEqual�failIfAlmostEqualsr� �assertAlmostEquals�failUnlessAlmostEqualr� �failUnlessApproximatesr� �failUnlessSubstringr� �failIfSubstringr� �failUnlessWarnsr� �failUnlessIsInstancer� �failIfIsInstancer� r� r� � __classcell__r r r� r r� Y sj * *:r� c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )� _LogObservera Observes the Twisted logs and catches any errors. @ivar _errors: A C{list} of L{Failure} instances which were received as error events from the Twisted logging system. @ivar _added: A C{int} giving the number of times C{_add} has been called less the number of times C{_remove} has been called; used to only add this observer to the Twisted logging since once, regardless of the number of calls to the add method. @ivar _ignored: A C{list} of exception types which will not be recorded. c C s g | _ d| _g | _d S )Nr )�_errors�_added�_ignoredr$ r r r r! 3 s z_LogObserver.__init__c C s( | j dkr t�| j� | j d7 _ d S )Nr r� )r� r � addObserver�gotEventr$ r r r �_add8 s z_LogObserver._addc C s, | j d8 _ | j dkrt�| j� d S d S )Nr� r )r� r �removeObserverr r$ r r r �_remove= s �z_LogObserver._removec G s | j �|� dS )zF Do not store any errors with any of the given types. N)r� �extend�r � errorTypesr r r � _ignoreErrorsB s z_LogObserver._ignoreErrorsc C s g | _ dS )zJ Stop ignoring any errors we might currently be ignoring. N)r� r$ r r r � _clearIgnoresH rS z_LogObserver._clearIgnoresc G sR |r!g }g }| j D ]}|j|� r|�|� q |�|� q || _ |S | j }g | _ |S )z� Flush errors from the list of caught errors. If no arguments are specified, remove all errors. If arguments are specified, only remove errors of those types from the stored list. )r� r& r� )r r �flushed� remainderrI r r r � flushErrorsN s �z_LogObserver.flushErrorsc C s | j S )zB Return a list of errors caught by this observer. )r� r$ r r r � getErrorsb s z_LogObserver.getErrorsc C sR |� dd�r#d|v r%|d }t| j�dks|j| j� s'| j�|� dS dS dS dS )z� The actual observer method. Called whenever a message is logged. @param event: A dictionary containing the log message. Actual structure undocumented (see source for L{twisted.python.log}). �isErrorFr r N)�get�lenr� r& r� r� )r �eventrI r r r r h s �z_LogObserver.gotEventN) r r r r r! r r r r r r r r r r r r� $ s r� c s� e Zd ZdZeZd2� fdd� Zdedefdd�Z d d � Z � fd d �Z de ee e f fd d�Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd3d d �Zd3d d �Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Z d*d+� Z d,d-� Z d.d/� Z d0d1� Z � Z!S )4�SynchronousTestCasea A unit test. The atom of the unit testing universe. This class extends C{unittest.TestCase} from the standard library. A number of convenient testing helpers are added, including logging and warning integration, monkey-patching support, and more. To write a unit test, subclass C{SynchronousTestCase} and define a method (say, 'test_foo') on the subclass. To run the test, instantiate your subclass with the name of the method, and call L{run} on the instance, passing a L{TestResult} object. The C{trial} script will automatically find any C{SynchronousTestCase} subclasses defined in modules beginning with 'test_' and construct test cases for all methods beginning with 'test'. If an error is logged during the test run, the test will fail with an error. See L{log.err}. @ivar failureException: An exception class, defaulting to C{FailTest}. If the test method raises this exception, it will be reported as a failure, rather than an exception. All of the assertion methods raise this if the assertion fails. @ivar skip: L{None} or a string explaining why this test is to be skipped. If defined, the test will not be run. Instead, it will be reported to the result object as 'skipped' (if the C{TestResult} supports skipping). @ivar todo: L{None}, a string or a tuple of C{(errors, reason)} where C{errors} is either an exception class or an iterable of exception classes, and C{reason} is a string. See L{Todo} or L{makeTodo} for more information. @ivar suppress: L{None} or a list of tuples of C{(args, kwargs)} to be passed to C{warnings.filterwarnings}. Use these to suppress warnings raised in a test. Useful for testing deprecated code. See also L{util.suppress}. �runTestc sD t � �|� d| _g | _|| _t| |�}|| tj�| j j �g| _ d S )NF) r� r! �_passed� _cleanups�_testMethodName�getattrrD r: r r� r �_parents)r � methodName� testMethodr� r r r! � s z SynchronousTestCase.__init__r� r" c C s t |t�r | |u S tS )a� Override the comparison defined by the base TestCase which considers instances of the same class with the same _testMethodName to be equal. Since trial puts TestCase instances into a set, that definition of comparison makes it impossible to run the same test method twice. Most likely, trial should stop using a set to hold tests, but until it does, this is necessary on Python 2.6. -exarkun )r+ r �NotImplemented)r r� r r r �__eq__� s zSynchronousTestCase.__eq__c C s t | j| jf�S r) )�hashr� r r$ r r r �__hash__� r[ z SynchronousTestCase.__hash__c s t � �� }|d u r | jS |S r) )r� �shortDescriptionr )r �descr� r r r � s z$SynchronousTestCase.shortDescriptionc C sD t �| jdd�}|du}|du r t| dd�}|r t| dd�}||fS )aN Return the skip reason set on this test, if any is set. Checks on the instance first, then the class, then the module, then packages. As soon as it finds something with a C{skip} attribute, returns that in a tuple (L{True}, L{str}). If the C{skip} attribute does not exist, look for C{__unittest_skip__} and C{__unittest_skip_why__} attributes which are set by the standard library L{unittest.skip} function. Returns (L{False}, L{None}) if it cannot find anything. See L{TestCase} docstring for more details. �skipN�__unittest_skip__F�__unittest_skip_why__r� )r �acquireAttributer r )r � skipReason�doSkipr r r �getSkip� s zSynchronousTestCase.getSkipc C s$ t �| jdd�}|du rdS t|�S )aQ Return a L{Todo} object if the test is marked todo. Checks on the instance first, then the class, then the module, then packages. As soon as it finds something with a C{todo} attribute, returns that. Returns L{None} if it cannot find anything. See L{TestCase} docstring for more details. rk N)r r$ r r0 )r rk r r r �getTodo� s zSynchronousTestCase.getTodoc C s dS )z� If no C{methodName} argument is passed to the constructor, L{run} will treat this method as the thing with the actual test inside. Nr r$ r r r r � r� zSynchronousTestCase.runTestc C s� t �d| �� � t�|d�}|du rt|�}n|}|�| � | �� \}}|r4|�| |� |� | � dS d| _ g | _ | � � t | j j| j|� | �� D ] }z tjdi |�� W qK tyh |�| t�� � Y qKw |� | � dS )a� Run the test case, storing the results in C{result}. First runs C{setUp} on self, then runs the test method (defined in the constructor), then runs C{tearDown}. As with the standard library L{unittest.TestCase}, the return value of these methods is disregarded. In particular, returning a L{Deferred<twisted.internet.defer.Deferred>} has no special additional consequences. @param result: A L{TestResult} object. z --> %s <--NFr )r r� �idr � IReporterrQ rX r' rg r\ r � _warnings�_installObserverrO r� �_runFixturesAndTest� flushWarningsrE � warn_explicitr9 rb r r� )r rN � new_resultr& r% �wr r r �run� s, �zSynchronousTestCase.runc O s | j �|||f� dS )as Add the given function to a list of functions to be called after the test has run, but before C{tearDown}. Functions will be run in reverse order of being added. This helps ensure that tear down complements set up. As with all aspects of L{SynchronousTestCase}, Deferreds are not supported in cleanup functions. N)r r� )r rI rJ rK r r r � addCleanup s z SynchronousTestCase.addCleanupc C s( t �|||f�}|�� | �|j� |S )a Monkey patch an object for the duration of the test. The monkey patch will be reverted at the end of the test using the L{addCleanup} mechanism. The L{monkey.MonkeyPatcher} is returned so that users can restore and re-apply the monkey patch within their tests. @param obj: The object to monkey patch. @param attribute: The name of the attribute to change. @param value: The value to set the attribute to. @return: A L{monkey.MonkeyPatcher} object. )r � MonkeyPatcher�patchr3 �restore)r r| � attributer/ � monkeyPatchr r r r5 ! s zSynchronousTestCase.patchc G s | j j|� S )a� Remove stored errors received from the log. C{TestCase} stores each error logged during the run of the test and reports them as errors during the cleanup phase (after C{tearDown}). @param errorTypes: If unspecified, flush all errors. Otherwise, only flush errors that match the given types. @return: A list of failures that have been removed. )� _observerr r r r r �flushLoggedErrors5 s z%SynchronousTestCase.flushLoggedErrorsNc C s� |du r| j dd� }g | j dd�< n[g }| j D ]L}|D ]G}t|tjtjf�s.t|�d���tj|j }t � |�}|t j � |j�krCq dd� t|j�D �}t|�|j kr\t|�ks^n q |�|� qtt| j j|�� dd� |D �S )a� Remove stored warnings from the list of captured warnings and return them. @param offendingFunctions: If L{None}, all warnings issued during the currently running test will be flushed. Otherwise, only warnings which I{point} to a function included in this list will be flushed. All warnings include a filename and source line number; if these parts of a warning point to a source line which is part of a function, then the warning I{points} to that function. @type offendingFunctions: L{None} or L{list} of functions or methods. @raise ValueError: If C{offendingFunctions} is not L{None} and includes an object which is not a L{types.FunctionType} or L{types.MethodType} instance. @return: A C{list}, each element of which is a C{dict} giving information about one warning which was flushed by this call. The keys of each C{dict} are: - C{'message'}: The string which was passed as the I{message} parameter to L{warnings.warn}. - C{'category'}: The warning subclass which was passed as the I{category} parameter to L{warnings.warn}. - C{'filename'}: The name of the file containing the definition of the code object which was C{stacklevel} frames above the call to L{warnings.warn}, where C{stacklevel} is the value of the C{stacklevel} parameter passed to L{warnings.warn}. - C{'lineno'}: The source line associated with the active instruction of the code object object which was C{stacklevel} frames above the call to L{warnings.warn}, where C{stacklevel} is the value of the C{stacklevel} parameter passed to L{warnings.warn}. Nz is not a function or methodc S s g | ]\}}|�qS r r )r� r� � lineNumberr r r r� � s ��z5SynchronousTestCase.flushWarnings.<locals>.<listcomp>c S s" g | ] }|j |j|j|jd ��qS )r2 r2 )r� r1 r r r r� � s ���)r+ r+ �types� FunctionType� MethodType� ValueErrorrD r: r �inspect� getabsfile�os�path�normcaser5 �_findlinestarts�__code__�minr6 �maxr� r- �map�remove)r �offendingFunctions�toFlush�aWarning� aFunction�aModuler5 � lineNumbersr r r r. C s4 & � � ��z!SynchronousTestCase.flushWarningsc C s� |d | }t j| }t||�}| �| jg�}t|�dkr%| �|� d�� |d d } t|t|�d� } |dur>| d | } | � | � | �d| �d | ��� |S ) a� Retrieve a module attribute which should have been deprecated, and assert that we saw the appropriate deprecation warning. @type moduleName: C{str} @param moduleName: Fully-qualified Python name of the module containing the deprecated attribute; if called from the same module as the attributes are being deprecated in, using the C{__name__} global can be helpful @type name: C{str} @param name: Attribute name which we expect to be deprecated @param version: The first L{version<twisted.python.versions.Version>} that the module attribute was deprecated. @type message: C{str} @param message: (optional) The expected deprecation message for the module attribute @return: The given attribute from the named module @raise FailTest: if no warnings were emitted on getattr, or if the L{DeprecationWarning} emitted did not produce the canonical please-use-something-else message that is standard for Twisted deprecations according to the given version and replacement. @since: Twisted 21.2.0 r� r � is not deprecated.r3 )�fqpn�versionNr� z Expected z to start with ) rD r: r r. � getDeprecatedModuleAttributer r` r r r� r� ) r � moduleName�namerS r3 rR �module�attrr� �observedWarning�expectedWarningr r r rT � s$ � �z0SynchronousTestCase.getDeprecatedModuleAttributec O s� ||i |��}| � | jg�}zt|�}W n ty! |}d} Y nw |\}} t|�dkr4| �|�d�� |d d } t||| d�} | �| | � |S )aM Call a function that should have been deprecated at a specific version and in favor of a specific alternative, and assert that it was thusly deprecated. @param version: A 2-sequence of (since, replacement), where C{since} is a the first L{version<incremental.Version>} that C{f} should have been deprecated since, and C{replacement} is a suggested replacement for the deprecated functionality, as described by L{twisted.python.deprecate.deprecated}. If there is no suggested replacement, this parameter may also be simply a L{version<incremental.Version>} by itself. @param f: The deprecated function to call. @param args: The arguments to pass to C{f}. @param kwargs: The keyword arguments to pass to C{f}. @return: Whatever C{f} returns. @raise Exception: Whatever C{f} raises. If any exception is raised by C{f}, though, no assertions will be made about emitted deprecations. @raise FailTest: if no warnings were emitted by C{f}, or if the L{DeprecationWarning} emitted did not produce the canonical please-use-something-else message that is standard for Twisted deprecations according to the given version and replacement. Nr rQ r3 )� replacement)r. �callDeprecatedr- r. r r` r r� ) r rS rI rJ rK rN r� re �sincer[ rY rZ r r r r\ � s � z"SynchronousTestCase.callDeprecatedc C sh d}t j�| jjd|� | jjd|� | jd|� �}t j�|�s&t �|� t � dd|�}t j�|d�S )a Create a new path name which can be used for a new file or directory. The result is a relative path that is guaranteed to be unique within the current working directory. The parent of the path will exist, but the path will not. For a temporary directory call os.mkdir on the path. For a temporary file just create the file (e.g. by opening the path for writing and then closing it). @return: The newly created path @rtype: C{str} � Nr� �temp) rB rC r� r� r r r �exists�makedirs�tempfile�mkdtemp)r � MAX_FILENAME�base�dirnamer r r �mktemp� s � zSynchronousTestCase.mktempc C s t �| jdg �S )ax Returns any warning suppressions set for this test. Checks on the instance first, then the class, then the module, then packages. As soon as it finds something with a C{suppress} attribute, returns that. Returns any empty list (i.e. suppress no warnings) if it cannot find anything. See L{TestCase} docstring for more details. �suppress)r r$ r r$ r r r � _getSuppress s z SynchronousTestCase._getSuppressc C s& t |j�dkr |jd S t|d� |S )z� Return the reason to use for skipping a test method. @param method: The method which produced the skip. @param skip: A L{unittest.SkipTest} instance raised by C{method}. r zSDo not raise unittest.SkipTest with no arguments! Give a reason for skipping tests!)r rJ r )r rZ r! r r r �_getSkipReason" s �z"SynchronousTestCase._getSkipReasonc C s� t �|�rtd�|��}|�| t�|�� dS zt||� W dS ty< } z|� | | � ||�� W Y d}~dS d}~w t yn t�� }|du sO|� |�sd|� | j�rY|j}n|j}|| |� Y dS |�| ||� Y dS w )a� Run a single method, either a test method or fixture. @param suppress: Any warnings to suppress, as defined by the C{suppress} attribute on this method, test case, or the module it is defined in. @param todo: Any expected failure or failures, as defined by the C{todo} attribute on this method, test case, or the module it is defined in. @param method: The method to run. @param result: The TestResult instance to which to report results. @return: C{True} if the method fails and no further method/fixture calls should be made, C{False} otherwise. z9{!r} is a generator function and therefore will never runTNF)r@ �isgeneratorfunctionr. r� rb r r� r r rg rj r9 r( r& r� r^ rm ) r rh rk rZ rN �exc�er � addResultr r r �_run3 s4 �� � � � ��zSynchronousTestCase._runc C s� | � � }z*| �|d| j|�rW | �|� dS | �� }t| | j�}| �||||�}W | �|� n| �|� w |r?|s?|�| |� | �|d| j|�rJd}| j � � D ] }|� | |� d}qO| j � � | � � |sn|sp|�| � dS dS dS )z� Run C{setUp}, a test method, test cleanups, and C{tearDown}. @param result: The TestResult instance to which to report results. NT)ri ro �setUp� _runCleanupsr( r r rl �tearDownr9 r rb r �_removeObserverrn )r rN rh rk rZ �failedr' r r r r- ^ s* � �z'SynchronousTestCase._runFixturesAndTestc C sn t | j�dkr5| j�� \}}}z ||i |�� W n ty+ t�� }|�| |� Y nw t | j�dksdS dS )zG Synchronously run any cleanups which have been added. r N)r r �popr9 r r� rb )r rN rI rJ rK r r r rq ~ s ��z SynchronousTestCase._runCleanupsc C s t | _| j�� d S r) )� _logObserverr9 r r$ r r r r, � s z$SynchronousTestCase._installObserverc C s | j �� d S r) )r9 r r$ r r r rs � s z#SynchronousTestCase._removeObserver)r r) )"r r r r r r� r! �object�boolr r r r r r* r' r( r r2 r3 r5 r: r. rT r\ rg ri rj ro r- rq r, rs r� r r r� r r x s2 ( + W22 + r )2r r@ rB rD rb r< �unittest�pyunitrE �disr rE �typingr r r �twisted.internet.deferr �twisted.pythonr r r �twisted.python.deprecater r r r �twisted.python.reflectr �twisted.python.utilr � twisted.trialr r �AssertionErrorr r r0 r1 r< rO � ExceptionrP rQ rt �TestCaser� r� rv r r r r r �<module> sB & <] NQPK b�Z0X��6 6 itrial.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Interfaces for Trial. Maintainer: Jonathan Lange """ import zope.interface as zi class ITestCase(zi.Interface): """ The interface that a test case must implement in order to be used in Trial. """ failureException = zi.Attribute( "The exception class that is raised by failed assertions" ) def __call__(result): """ Run the test. Should always do exactly the same thing as run(). """ def countTestCases(): """ Return the number of tests in this test case. Usually 1. """ def id(): """ Return a unique identifier for the test, usually the fully-qualified Python name. """ def run(result): """ Run the test, storing the results in C{result}. @param result: A L{TestResult}. """ def shortDescription(): """ Return a short description of the test. """ class IReporter(zi.Interface): """ I report results from a run of a test suite. """ shouldStop = zi.Attribute( "A boolean indicating that this reporter would like the " "test run to stop." ) testsRun = zi.Attribute( """ The number of tests that seem to have been run according to this reporter. """ ) def startTest(method): """ Report the beginning of a run of a single test method. @param method: an object that is adaptable to ITestMethod """ def stopTest(method): """ Report the status of a single test method @param method: an object that is adaptable to ITestMethod """ def addSuccess(test): """ Record that test passed. """ def addError(test, error): """ Record that a test has raised an unexpected exception. @param test: The test that has raised an error. @param error: The error that the test raised. It will either be a three-tuple in the style of C{sys.exc_info()} or a L{Failure<twisted.python.failure.Failure>} object. """ def addFailure(test, failure): """ Record that a test has failed with the given failure. @param test: The test that has failed. @param failure: The failure that the test failed with. It will either be a three-tuple in the style of C{sys.exc_info()} or a L{Failure<twisted.python.failure.Failure>} object. """ def addExpectedFailure(test, failure, todo=None): """ Record that the given test failed, and was expected to do so. In Twisted 15.5 and prior, C{todo} was a mandatory parameter. @type test: L{unittest.TestCase} @param test: The test which this is about. @type failure: L{failure.Failure} @param failure: The error which this test failed with. @type todo: L{unittest.Todo} @param todo: The reason for the test's TODO status. If L{None}, a generic reason is used. """ def addUnexpectedSuccess(test, todo=None): """ Record that the given test failed, and was expected to do so. In Twisted 15.5 and prior, C{todo} was a mandatory parameter. @type test: L{unittest.TestCase} @param test: The test which this is about. @type todo: L{unittest.Todo} @param todo: The reason for the test's TODO status. If L{None}, a generic reason is used. """ def addSkip(test, reason): """ Record that a test has been skipped for the given reason. @param test: The test that has been skipped. @param reason: An object that the test case has specified as the reason for skipping the test. """ def wasSuccessful(): """ Return a boolean indicating whether all test results that were reported to this reporter were successful or not. """ def done(): """ Called when the test run is complete. This gives the result object an opportunity to display a summary of information to the user. Once you have called C{done} on an L{IReporter} object, you should assume that the L{IReporter} object is no longer usable. """ PK b�Z*4G/�� �� test/test_assertions.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for assertions provided by C{SynchronousTestCase} and C{TestCase}, provided by L{twisted.trial.unittest}. L{TestFailureTests} demonstrates that L{SynchronousTestCase.fail} works, so that is the only method on C{twisted.trial.unittest.SynchronousTestCase} that is initially assumed to work. The test classes are arranged so that the methods demonstrated to work earlier in the file are used by those later in the file (even though the runner will probably not run the tests in this order). """ import unittest as pyunit import warnings from incremental import Version, getVersionString from twisted.internet.defer import Deferred, fail, succeed from twisted.python.deprecate import deprecated, deprecatedModuleAttribute from twisted.python.failure import Failure from twisted.python.reflect import ( accumulateMethods, fullyQualifiedName, prefixedMethods, ) from twisted.python.util import FancyEqMixin from twisted.trial import unittest class MockEquality(FancyEqMixin): compareAttributes = ("name",) def __init__(self, name): self.name = name def __repr__(self) -> str: return f"MockEquality({self.name})" class ComparisonError: """ An object which raises exceptions from its comparison methods. """ def _error(self, other): raise ValueError("Comparison is broken") __eq__ = _error __ne__ = _error class TestFailureTests(pyunit.TestCase): """ Tests for the most basic functionality of L{SynchronousTestCase}, for failing tests. This class contains tests to demonstrate that L{SynchronousTestCase.fail} can be used to fail a test, and that that failure is reflected in the test result object. This should be sufficient functionality so that further tests can be built on L{SynchronousTestCase} instead of L{unittest.TestCase}. This depends on L{unittest.TestCase} working. """ class FailingTest(unittest.SynchronousTestCase): def test_fails(self): self.fail("This test fails.") def setUp(self): """ Load a suite of one test which can be used to exercise the failure handling behavior. """ components = [__name__, self.__class__.__name__, self.FailingTest.__name__] self.loader = pyunit.TestLoader() self.suite = self.loader.loadTestsFromName(".".join(components)) self.test = list(self.suite)[0] def test_fail(self): """ L{SynchronousTestCase.fail} raises L{SynchronousTestCase.failureException} with the given argument. """ try: self.test.fail("failed") except self.test.failureException as result: self.assertEqual("failed", str(result)) else: self.fail( "SynchronousTestCase.fail method did not raise " "SynchronousTestCase.failureException" ) def test_failingExceptionFails(self): """ When a test method raises L{SynchronousTestCase.failureException}, the test is marked as having failed on the L{TestResult}. """ result = pyunit.TestResult() self.suite.run(result) self.assertFalse(result.wasSuccessful()) self.assertEqual(result.errors, []) self.assertEqual(len(result.failures), 1) self.assertEqual(result.failures[0][0], self.test) class AssertFalseTests(unittest.SynchronousTestCase): """ Tests for L{SynchronousTestCase}'s C{assertFalse} and C{failIf} assertion methods. This is pretty paranoid. Still, a certain paranoia is healthy if you are testing a unit testing framework. @note: As of 11.2, C{assertFalse} is preferred over C{failIf}. """ def _assertFalseFalse(self, method): """ Perform the positive case test for C{failIf} or C{assertFalse}. @param method: The test method to test. """ for notTrue in [0, 0.0, False, None, (), []]: result = method(notTrue, f"failed on {notTrue!r}") if result != notTrue: self.fail(f"Did not return argument {notTrue!r}") def _assertFalseTrue(self, method): """ Perform the negative case test for C{failIf} or C{assertFalse}. @param method: The test method to test. """ for true in [1, True, "cat", [1, 2], (3, 4)]: try: method(true, f"failed on {true!r}") except self.failureException as e: self.assertIn( f"failed on {true!r}", str(e), f"Raised incorrect exception on {true!r}: {e!r}", ) else: self.fail( "Call to %s(%r) didn't fail" % ( method.__name__, true, ) ) def test_failIfFalse(self): """ L{SynchronousTestCase.failIf} returns its argument if its argument is not considered true. """ self._assertFalseFalse(self.failIf) def test_assertFalseFalse(self): """ L{SynchronousTestCase.assertFalse} returns its argument if its argument is not considered true. """ self._assertFalseFalse(self.assertFalse) def test_failIfTrue(self): """ L{SynchronousTestCase.failIf} raises L{SynchronousTestCase.failureException} if its argument is considered true. """ self._assertFalseTrue(self.failIf) def test_assertFalseTrue(self): """ L{SynchronousTestCase.assertFalse} raises L{SynchronousTestCase.failureException} if its argument is considered true. """ self._assertFalseTrue(self.assertFalse) class AssertTrueTests(unittest.SynchronousTestCase): """ Tests for L{SynchronousTestCase}'s C{assertTrue} and C{failUnless} assertion methods. This is pretty paranoid. Still, a certain paranoia is healthy if you are testing a unit testing framework. @note: As of 11.2, C{assertTrue} is preferred over C{failUnless}. """ def _assertTrueFalse(self, method): """ Perform the negative case test for C{assertTrue} and C{failUnless}. @param method: The test method to test. """ for notTrue in [0, 0.0, False, None, (), []]: try: method(notTrue, f"failed on {notTrue!r}") except self.failureException as e: self.assertIn( f"failed on {notTrue!r}", str(e), f"Raised incorrect exception on {notTrue!r}: {e!r}", ) else: self.fail( "Call to %s(%r) didn't fail" % ( method.__name__, notTrue, ) ) def _assertTrueTrue(self, method): """ Perform the positive case test for C{assertTrue} and C{failUnless}. @param method: The test method to test. """ for true in [1, True, "cat", [1, 2], (3, 4)]: result = method(true, f"failed on {true!r}") if result != true: self.fail(f"Did not return argument {true!r}") def test_assertTrueFalse(self): """ L{SynchronousTestCase.assertTrue} raises L{SynchronousTestCase.failureException} if its argument is not considered true. """ self._assertTrueFalse(self.assertTrue) def test_failUnlessFalse(self): """ L{SynchronousTestCase.failUnless} raises L{SynchronousTestCase.failureException} if its argument is not considered true. """ self._assertTrueFalse(self.failUnless) def test_assertTrueTrue(self): """ L{SynchronousTestCase.assertTrue} returns its argument if its argument is considered true. """ self._assertTrueTrue(self.assertTrue) def test_failUnlessTrue(self): """ L{SynchronousTestCase.failUnless} returns its argument if its argument is considered true. """ self._assertTrueTrue(self.failUnless) class SynchronousAssertionsTests(unittest.SynchronousTestCase): """ Tests for L{SynchronousTestCase}'s assertion methods. That is, failUnless*, failIf*, assert* (not covered by other more specific test classes). Note: As of 11.2, assertEqual is preferred over the failUnlessEqual(s) variants. Tests have been modified to reflect this preference. This is pretty paranoid. Still, a certain paranoia is healthy if you are testing a unit testing framework. """ def _testEqualPair(self, first, second): x = self.assertEqual(first, second) if x != first: self.fail("assertEqual should return first parameter") def _testUnequalPair(self, first, second): """ Assert that when called with unequal arguments, C{assertEqual} raises a failure exception with the same message as the standard library C{assertEqual} would have raised. """ raised = False try: self.assertEqual(first, second) except self.failureException as ourFailure: case = pyunit.TestCase("setUp") try: case.assertEqual(first, second) except case.failureException as theirFailure: raised = True got = str(ourFailure) expected = str(theirFailure) if expected != got: self.fail(f"Expected: {expected!r}; Got: {got!r}") if not raised: self.fail(f"Call to assertEqual({first!r}, {second!r}) didn't fail") def test_assertEqual_basic(self): self._testEqualPair("cat", "cat") self._testUnequalPair("cat", "dog") self._testEqualPair([1], [1]) self._testUnequalPair([1], "orange") def test_assertEqual_custom(self): x = MockEquality("first") y = MockEquality("second") z = MockEquality("first") self._testEqualPair(x, x) self._testEqualPair(x, z) self._testUnequalPair(x, y) self._testUnequalPair(y, z) def test_assertEqualMessage(self): """ When a message is passed to L{assertEqual} it is included in the error message. """ message = "message" exception = self.assertRaises( self.failureException, self.assertEqual, "foo", "bar", message ) self.assertIn(message, str(exception)) def test_assertEqualNoneMessage(self): """ If a message is specified as L{None}, it is not included in the error message of L{assertEqual}. """ exceptionForNone = self.assertRaises( self.failureException, self.assertEqual, "foo", "bar", None ) exceptionWithout = self.assertRaises( self.failureException, self.assertEqual, "foo", "bar" ) self.assertEqual(str(exceptionWithout), str(exceptionForNone)) def test_assertEqual_incomparable(self): apple = ComparisonError() orange = ["orange"] try: self.assertEqual(apple, orange) except self.failureException: self.fail("Fail raised when ValueError ought to have been raised.") except ValueError: # good. error not swallowed pass else: self.fail( "Comparing {!r} and {!r} should have raised an exception".format( apple, orange ) ) def _raiseError(self, error): raise error def test_failUnlessRaises_expected(self): x = self.failUnlessRaises(ValueError, self._raiseError, ValueError) self.assertTrue( isinstance(x, ValueError), "Expect failUnlessRaises to return instance of raised " "exception.", ) def test_failUnlessRaises_unexpected(self): try: self.failUnlessRaises(ValueError, self._raiseError, TypeError) except TypeError: self.fail("failUnlessRaises shouldn't re-raise unexpected " "exceptions") except self.failureException: # what we expect pass else: self.fail("Expected exception wasn't raised. Should have failed") def test_failUnlessRaises_noException(self): returnValue = 3 try: self.failUnlessRaises(ValueError, lambda: returnValue) except self.failureException as e: self.assertEqual(str(e), "ValueError not raised (3 returned)") else: self.fail("Exception not raised. Should have failed") def test_failUnlessRaises_failureException(self): x = self.failUnlessRaises( self.failureException, self._raiseError, self.failureException ) self.assertTrue( isinstance(x, self.failureException), f"Expected {self.failureException!r} instance to be returned", ) try: x = self.failUnlessRaises( self.failureException, self._raiseError, ValueError ) except self.failureException: # what we expect pass else: self.fail("Should have raised exception") def test_assertRaisesContextExpected(self): """ If C{assertRaises} is used to create a context manager and an exception is raised from the body of the C{with} statement then the context manager's C{exception} attribute is set to the exception that was raised. """ exception = ValueError("marker") with self.assertRaises(ValueError) as context: raise exception self.assertIs(exception, context.exception) def test_assertRaisesContextUnexpected(self): """ If C{assertRaises} is used to create a context manager and the wrong exception type is raised from the body of the C{with} statement then the C{with} statement raises C{failureException} describing the mismatch. """ try: with self.assertRaises(ValueError): raise TypeError("marker") except self.failureException as exception: message = str(exception) expected = ("{type} raised instead of ValueError:\n" " Traceback").format( type=fullyQualifiedName(TypeError) ) self.assertTrue( message.startswith(expected), "Exception message did not begin with expected information: " "{}".format(message), ) else: self.fail("Mismatched exception type should have caused test failure.") def test_assertRaisesContextNoException(self): """ If C{assertRaises} is used to create a context manager and no exception is raised from the body of the C{with} statement then the C{with} statement raises C{failureException} describing the lack of exception. """ try: with self.assertRaises(ValueError): # No exception is raised. pass except self.failureException as exception: message = str(exception) # `(None returned)` text is here for backward compatibility and should # be ignored for context manager use case. self.assertEqual(message, "ValueError not raised (None returned)") else: self.fail("Non-exception result should have caused test failure.") def test_brokenName(self): """ If the exception type passed to C{assertRaises} does not have a C{__name__} then the context manager still manages to construct a descriptive string for it. """ try: with self.assertRaises((ValueError, TypeError)): # Just some other kind of exception raise AttributeError() except self.failureException as exception: message = str(exception) valueError = "ValueError" not in message typeError = "TypeError" not in message errors = [] if valueError: errors.append("expected ValueError in exception message") if typeError: errors.append("expected TypeError in exception message") if errors: self.fail("; ".join(errors), f"message = {message}") else: self.fail("Mismatched exception type should have caused test failure.") def test_failIfEqual_basic(self): x, y, z = [1], [2], [1] ret = self.failIfEqual(x, y) self.assertEqual(ret, x, "failIfEqual should return first parameter") self.failUnlessRaises(self.failureException, self.failIfEqual, x, x) self.failUnlessRaises(self.failureException, self.failIfEqual, x, z) def test_failIfEqual_customEq(self): x = MockEquality("first") y = MockEquality("second") z = MockEquality("fecund") ret = self.failIfEqual(x, y) self.assertEqual(ret, x, "failIfEqual should return first parameter") self.failUnlessRaises(self.failureException, self.failIfEqual, x, x) self.failIfEqual(x, z, "__ne__ should make these not equal") def test_failIfIdenticalPositive(self): """ C{failIfIdentical} returns its first argument if its first and second arguments are not the same object. """ x = object() y = object() result = self.failIfIdentical(x, y) self.assertEqual(x, result) def test_failIfIdenticalNegative(self): """ C{failIfIdentical} raises C{failureException} if its first and second arguments are the same object. """ x = object() self.failUnlessRaises(self.failureException, self.failIfIdentical, x, x) def test_failUnlessIdentical(self): x, y, z = [1], [1], [2] ret = self.failUnlessIdentical(x, x) self.assertEqual(ret, x, "failUnlessIdentical should return first " "parameter") self.failUnlessRaises(self.failureException, self.failUnlessIdentical, x, y) self.failUnlessRaises(self.failureException, self.failUnlessIdentical, x, z) def test_failUnlessApproximates(self): x, y, z = 1.0, 1.1, 1.2 self.failUnlessApproximates(x, x, 0.2) ret = self.failUnlessApproximates(x, y, 0.2) self.assertEqual( ret, x, "failUnlessApproximates should return " "first parameter" ) self.failUnlessRaises( self.failureException, self.failUnlessApproximates, x, z, 0.1 ) self.failUnlessRaises( self.failureException, self.failUnlessApproximates, x, y, 0.1 ) def test_failUnlessAlmostEqual(self): precision = 5 x = 8.000001 y = 8.00001 z = 8.000002 self.failUnlessAlmostEqual(x, x, precision) ret = self.failUnlessAlmostEqual(x, z, precision) self.assertEqual( ret, x, "failUnlessAlmostEqual should return " "first parameter (%r, %r)" % (ret, x), ) self.failUnlessRaises( self.failureException, self.failUnlessAlmostEqual, x, y, precision ) def test_failIfAlmostEqual(self): precision = 5 x = 8.000001 y = 8.00001 z = 8.000002 ret = self.failIfAlmostEqual(x, y, precision) self.assertEqual( ret, x, "failIfAlmostEqual should return " "first parameter (%r, %r)" % (ret, x), ) self.failUnlessRaises( self.failureException, self.failIfAlmostEqual, x, x, precision ) self.failUnlessRaises( self.failureException, self.failIfAlmostEqual, x, z, precision ) def test_failUnlessSubstring(self): x = "cat" y = "the dog sat" z = "the cat sat" self.failUnlessSubstring(x, x) ret = self.failUnlessSubstring(x, z) self.assertEqual(ret, x, "should return first parameter") self.failUnlessRaises(self.failureException, self.failUnlessSubstring, x, y) self.failUnlessRaises(self.failureException, self.failUnlessSubstring, z, x) def test_failIfSubstring(self): x = "cat" y = "the dog sat" z = "the cat sat" self.failIfSubstring(z, x) ret = self.failIfSubstring(x, y) self.assertEqual(ret, x, "should return first parameter") self.failUnlessRaises(self.failureException, self.failIfSubstring, x, x) self.failUnlessRaises(self.failureException, self.failIfSubstring, x, z) def test_assertIs(self): """ L{assertIs} passes if two objects are identical. """ a = MockEquality("first") self.assertIs(a, a) def test_assertIsError(self): """ L{assertIs} fails if two objects are not identical. """ a, b = MockEquality("first"), MockEquality("first") self.assertEqual(a, b) self.assertRaises(self.failureException, self.assertIs, a, b) def test_assertIsNot(self): """ L{assertIsNot} passes if two objects are not identical. """ a, b = MockEquality("first"), MockEquality("first") self.assertEqual(a, b) self.assertIsNot(a, b) def test_assertIsNotError(self): """ L{assertIsNot} fails if two objects are identical. """ a = MockEquality("first") self.assertRaises(self.failureException, self.assertIsNot, a, a) def test_assertIsInstance(self): """ Test a true condition of assertIsInstance. """ A = type("A", (object,), {}) a = A() self.assertIsInstance(a, A) def test_assertIsInstanceMultipleClasses(self): """ Test a true condition of assertIsInstance with multiple classes. """ A = type("A", (object,), {}) B = type("B", (object,), {}) a = A() self.assertIsInstance(a, (A, B)) def test_assertIsInstanceError(self): """ Test an error with assertIsInstance. """ A = type("A", (object,), {}) B = type("B", (object,), {}) a = A() self.assertRaises(self.failureException, self.assertIsInstance, a, B) def test_assertIsInstanceErrorMultipleClasses(self): """ Test an error with assertIsInstance and multiple classes. """ A = type("A", (object,), {}) B = type("B", (object,), {}) C = type("C", (object,), {}) a = A() self.assertRaises(self.failureException, self.assertIsInstance, a, (B, C)) def test_assertIsInstanceCustomMessage(self): """ If L{TestCase.assertIsInstance} is passed a custom message as its 3rd argument, the message is included in the failure exception raised when the assertion fails. """ exc = self.assertRaises( self.failureException, self.assertIsInstance, 3, str, "Silly assertion" ) self.assertIn("Silly assertion", str(exc)) def test_assertNotIsInstance(self): """ Test a true condition of assertNotIsInstance. """ A = type("A", (object,), {}) B = type("B", (object,), {}) a = A() self.assertNotIsInstance(a, B) def test_assertNotIsInstanceMultipleClasses(self): """ Test a true condition of assertNotIsInstance and multiple classes. """ A = type("A", (object,), {}) B = type("B", (object,), {}) C = type("C", (object,), {}) a = A() self.assertNotIsInstance(a, (B, C)) def test_assertNotIsInstanceError(self): """ Test an error with assertNotIsInstance. """ A = type("A", (object,), {}) a = A() error = self.assertRaises(self.failureException, self.assertNotIsInstance, a, A) self.assertEqual(str(error), f"{a!r} is an instance of {A}") def test_assertNotIsInstanceErrorMultipleClasses(self): """ Test an error with assertNotIsInstance and multiple classes. """ A = type("A", (object,), {}) B = type("B", (object,), {}) a = A() self.assertRaises(self.failureException, self.assertNotIsInstance, a, (A, B)) def test_assertDictEqual(self): """ L{twisted.trial.unittest.TestCase} supports the C{assertDictEqual} method inherited from the standard library in Python 2.7. """ self.assertDictEqual({"a": 1}, {"a": 1}) if getattr(unittest.SynchronousTestCase, "assertDictEqual", None) is None: test_assertDictEqual.skip = ( # type: ignore[attr-defined] "assertDictEqual is not available on this version of Python" ) class WarningAssertionTests(unittest.SynchronousTestCase): def test_assertWarns(self): """ Test basic assertWarns report. """ def deprecated(a): warnings.warn("Woo deprecated", category=DeprecationWarning) return a r = self.assertWarns( DeprecationWarning, "Woo deprecated", __file__, deprecated, 123 ) self.assertEqual(r, 123) def test_assertWarnsRegistryClean(self): """ Test that assertWarns cleans the warning registry, so the warning is not swallowed the second time. """ def deprecated(a): warnings.warn("Woo deprecated", category=DeprecationWarning) return a r1 = self.assertWarns( DeprecationWarning, "Woo deprecated", __file__, deprecated, 123 ) self.assertEqual(r1, 123) # The warning should be raised again r2 = self.assertWarns( DeprecationWarning, "Woo deprecated", __file__, deprecated, 321 ) self.assertEqual(r2, 321) def test_assertWarnsError(self): """ Test assertWarns failure when no warning is generated. """ def normal(a): return a self.assertRaises( self.failureException, self.assertWarns, DeprecationWarning, "Woo deprecated", __file__, normal, 123, ) def test_assertWarnsWrongCategory(self): """ Test assertWarns failure when the category is wrong. """ def deprecated(a): warnings.warn("Foo deprecated", category=DeprecationWarning) return a self.assertRaises( self.failureException, self.assertWarns, UserWarning, "Foo deprecated", __file__, deprecated, 123, ) def test_assertWarnsWrongMessage(self): """ Test assertWarns failure when the message is wrong. """ def deprecated(a): warnings.warn("Foo deprecated", category=DeprecationWarning) return a self.assertRaises( self.failureException, self.assertWarns, DeprecationWarning, "Bar deprecated", __file__, deprecated, 123, ) def test_assertWarnsWrongFile(self): """ If the warning emitted by a function refers to a different file than is passed to C{assertWarns}, C{failureException} is raised. """ def deprecated(a): # stacklevel=2 points at the direct caller of the function. The # way assertRaises is invoked below, the direct caller will be # something somewhere in trial, not something in this file. In # Python 2.5 and earlier, stacklevel of 0 resulted in a warning # pointing to the warnings module itself. Starting in Python 2.6, # stacklevel of 0 and 1 both result in a warning pointing to *this* # file, presumably due to the fact that the warn function is # implemented in C and has no convenient Python # filename/linenumber. warnings.warn("Foo deprecated", category=DeprecationWarning, stacklevel=2) self.assertRaises( self.failureException, # Since the direct caller isn't in this file, try to assert that # the warning *does* point to this file, so that assertWarns raises # an exception. self.assertWarns, DeprecationWarning, "Foo deprecated", __file__, deprecated, 123, ) def test_assertWarnsOnClass(self): """ Test assertWarns works when creating a class instance. """ class Warn: def __init__(self): warnings.warn("Do not call me", category=RuntimeWarning) r = self.assertWarns(RuntimeWarning, "Do not call me", __file__, Warn) self.assertTrue(isinstance(r, Warn)) r = self.assertWarns(RuntimeWarning, "Do not call me", __file__, Warn) self.assertTrue(isinstance(r, Warn)) def test_assertWarnsOnMethod(self): """ Test assertWarns works when used on an instance method. """ class Warn: def deprecated(self, a): warnings.warn("Bar deprecated", category=DeprecationWarning) return a w = Warn() r = self.assertWarns( DeprecationWarning, "Bar deprecated", __file__, w.deprecated, 321 ) self.assertEqual(r, 321) r = self.assertWarns( DeprecationWarning, "Bar deprecated", __file__, w.deprecated, 321 ) self.assertEqual(r, 321) def test_assertWarnsOnCall(self): """ Test assertWarns works on instance with C{__call__} method. """ class Warn: def __call__(self, a): warnings.warn("Egg deprecated", category=DeprecationWarning) return a w = Warn() r = self.assertWarns(DeprecationWarning, "Egg deprecated", __file__, w, 321) self.assertEqual(r, 321) r = self.assertWarns(DeprecationWarning, "Egg deprecated", __file__, w, 321) self.assertEqual(r, 321) def test_assertWarnsFilter(self): """ Test assertWarns on a warning filtered by default. """ def deprecated(a): warnings.warn("Woo deprecated", category=PendingDeprecationWarning) return a r = self.assertWarns( PendingDeprecationWarning, "Woo deprecated", __file__, deprecated, 123 ) self.assertEqual(r, 123) def test_assertWarnsMultipleWarnings(self): """ C{assertWarns} does not raise an exception if the function it is passed triggers the same warning more than once. """ def deprecated(): warnings.warn("Woo deprecated", category=PendingDeprecationWarning) def f(): deprecated() deprecated() self.assertWarns(PendingDeprecationWarning, "Woo deprecated", __file__, f) def test_assertWarnsDifferentWarnings(self): """ For now, assertWarns is unable to handle multiple different warnings, so it should raise an exception if it's the case. """ def deprecated(a): warnings.warn("Woo deprecated", category=DeprecationWarning) warnings.warn("Another one", category=PendingDeprecationWarning) e = self.assertRaises( self.failureException, self.assertWarns, DeprecationWarning, "Woo deprecated", __file__, deprecated, 123, ) self.assertEqual(str(e), "Can't handle different warnings") def test_assertWarnsAfterUnassertedWarning(self): """ Warnings emitted before L{TestCase.assertWarns} is called do not get flushed and do not alter the behavior of L{TestCase.assertWarns}. """ class TheWarning(Warning): pass def f(message): warnings.warn(message, category=TheWarning) f("foo") self.assertWarns(TheWarning, "bar", __file__, f, "bar") [warning] = self.flushWarnings([f]) self.assertEqual(warning["message"], "foo") class ResultOfAssertionsTests(unittest.SynchronousTestCase): """ Tests for L{SynchronousTestCase.successResultOf}, L{SynchronousTestCase.failureResultOf}, and L{SynchronousTestCase.assertNoResult}. """ result = object() failure = Failure(Exception("Bad times")) def test_withoutResult(self): """ L{SynchronousTestCase.successResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with no current result. """ self.assertRaises(self.failureException, self.successResultOf, Deferred()) def test_successResultOfWithFailure(self): """ L{SynchronousTestCase.successResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with a failure result. """ self.assertRaises( self.failureException, self.successResultOf, fail(self.failure) ) def test_successResultOfWithFailureHasTraceback(self): """ L{SynchronousTestCase.successResultOf} raises a L{SynchronousTestCase.failureException} that has the original failure traceback when called with a L{Deferred} with a failure result. """ try: self.successResultOf(fail(self.failure)) except self.failureException as e: self.assertIn(self.failure.getTraceback(), str(e)) def test_failureResultOfWithoutResult(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with no current result. """ self.assertRaises(self.failureException, self.failureResultOf, Deferred()) def test_failureResultOfWithSuccess(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with a success result. """ self.assertRaises( self.failureException, self.failureResultOf, succeed(self.result) ) def test_failureResultOfWithWrongFailure(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} that fails with an exception type that was not expected. """ self.assertRaises( self.failureException, self.failureResultOf, fail(self.failure), KeyError ) def test_failureResultOfWithWrongFailureOneExpectedFailure(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} that fails with an exception type that was not expected, and the L{SynchronousTestCase.failureException} message contains the expected exception type. """ try: self.failureResultOf(fail(self.failure), KeyError) except self.failureException as e: self.assertIn( "Failure of type ({}.{}) expected on".format( KeyError.__module__, KeyError.__name__ ), str(e), ) def test_failureResultOfWithWrongFailureOneExpectedFailureHasTB(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} that fails with an exception type that was not expected, and the L{SynchronousTestCase.failureException} message contains the original failure traceback. """ try: self.failureResultOf(fail(self.failure), KeyError) except self.failureException as e: self.assertIn(self.failure.getTraceback(), str(e)) def test_failureResultOfWithWrongFailureMultiExpectedFailures(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with an exception type that was not expected, and the L{SynchronousTestCase.failureException} message contains the expected exception types in the error message. """ try: self.failureResultOf(fail(self.failure), KeyError, IOError) except self.failureException as e: self.assertIn( "Failure of type ({}.{} or {}.{}) expected on".format( KeyError.__module__, KeyError.__name__, IOError.__module__, IOError.__name__, ), str(e), ) def test_failureResultOfWithWrongFailureMultiExpectedFailuresHasTB(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with an exception type that was not expected, and the L{SynchronousTestCase.failureException} message contains the original failure traceback in the error message. """ try: self.failureResultOf(fail(self.failure), KeyError, IOError) except self.failureException as e: self.assertIn(self.failure.getTraceback(), str(e)) def test_successResultOfWithSuccessResult(self): """ When passed a L{Deferred} which currently has a result (ie, L{Deferred.addCallback} would cause the added callback to be called before C{addCallback} returns), L{SynchronousTestCase.successResultOf} returns that result. """ self.assertIdentical(self.result, self.successResultOf(succeed(self.result))) def test_failureResultOfWithExpectedFailureResult(self): """ When passed a L{Deferred} which currently has a L{Failure} result (ie, L{Deferred.addErrback} would cause the added errback to be called before C{addErrback} returns), L{SynchronousTestCase.failureResultOf} returns that L{Failure} if its contained exception type is expected. """ self.assertIdentical( self.failure, self.failureResultOf(fail(self.failure), self.failure.type, KeyError), ) def test_failureResultOfWithFailureResult(self): """ When passed a L{Deferred} which currently has a L{Failure} result (ie, L{Deferred.addErrback} would cause the added errback to be called before C{addErrback} returns), L{SynchronousTestCase.failureResultOf} returns that L{Failure}. """ self.assertIdentical(self.failure, self.failureResultOf(fail(self.failure))) def test_assertNoResultSuccess(self): """ When passed a L{Deferred} which currently has a success result (see L{test_withSuccessResult}), L{SynchronousTestCase.assertNoResult} raises L{SynchronousTestCase.failureException}. """ self.assertRaises( self.failureException, self.assertNoResult, succeed(self.result) ) def test_assertNoResultFailure(self): """ When passed a L{Deferred} which currently has a failure result (see L{test_withFailureResult}), L{SynchronousTestCase.assertNoResult} raises L{SynchronousTestCase.failureException}. """ self.assertRaises( self.failureException, self.assertNoResult, fail(self.failure) ) def test_assertNoResult(self): """ When passed a L{Deferred} with no current result, L{SynchronousTestCase.assertNoResult} does not raise an exception. """ self.assertNoResult(Deferred()) def test_assertNoResultPropagatesSuccess(self): """ When passed a L{Deferred} with no current result, which is then fired with a success result, L{SynchronousTestCase.assertNoResult} doesn't modify the result of the L{Deferred}. """ d = Deferred() self.assertNoResult(d) d.callback(self.result) self.assertEqual(self.result, self.successResultOf(d)) def test_assertNoResultPropagatesLaterFailure(self): """ When passed a L{Deferred} with no current result, which is then fired with a L{Failure} result, L{SynchronousTestCase.assertNoResult} doesn't modify the result of the L{Deferred}. """ d = Deferred() self.assertNoResult(d) d.errback(self.failure) self.assertEqual(self.failure, self.failureResultOf(d)) def test_assertNoResultSwallowsImmediateFailure(self): """ When passed a L{Deferred} which currently has a L{Failure} result, L{SynchronousTestCase.assertNoResult} changes the result of the L{Deferred} to a success. """ d = fail(self.failure) try: self.assertNoResult(d) except self.failureException: pass self.assertEqual(None, self.successResultOf(d)) class ResultOfCoroutineAssertionsTests(unittest.SynchronousTestCase): """ Tests for L{SynchronousTestCase.successResultOf}, L{SynchronousTestCase.failureResultOf}, and L{SynchronousTestCase.assertNoResult} when given a coroutine. """ result = object() exception = Exception("Bad times") failure = Failure(exception) async def successResult(self): return self.result async def noCurrentResult(self): await Deferred() async def raisesException(self, exception=None): if exception is None: exception = self.exception raise exception def test_withoutResult(self): """ L{SynchronousTestCase.successResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine with no current result. """ self.assertRaises( self.failureException, self.successResultOf, self.noCurrentResult() ) def test_successResultOfWithException(self): """ L{SynchronousTestCase.successResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception. """ self.assertRaises( self.failureException, self.successResultOf, self.raisesException() ) def test_successResultOfWithFailureHasTraceback(self): """ L{SynchronousTestCase.successResultOf} raises a L{SynchronousTestCase.failureException} that has the original failure traceback when called with a coroutine with a failure result. """ exception = Exception("Bad times") try: self.successResultOf(self.raisesException(exception)) except self.failureException as e: self.assertIn("Success result expected on", str(e)) self.assertIn("builtins.Exception: Bad times", str(e)) def test_failureResultOfWithoutResult(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine with no current result. """ self.assertRaises( self.failureException, self.failureResultOf, self.noCurrentResult() ) def test_failureResultOfWithSuccess(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine with a success result. """ self.assertRaises( self.failureException, self.failureResultOf, self.successResult() ) def test_failureResultOfWithWrongFailure(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception that was not expected. """ self.assertRaises( self.failureException, self.failureResultOf, self.raisesException(), KeyError, ) def test_failureResultOfWithWrongExceptionOneExpectedException(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception with a failure type that was not expected, and the L{SynchronousTestCase.failureException} message contains the expected exception type. """ try: self.failureResultOf(self.raisesException(), KeyError) except self.failureException as e: self.assertIn( "Failure of type ({}.{}) expected on".format( KeyError.__module__, KeyError.__name__ ), str(e), ) def test_failureResultOfWithWrongExceptionOneExpectedExceptionHasTB(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception with a failure type that was not expected, and the L{SynchronousTestCase.failureException} message contains the original exception traceback. """ exception = Exception("Bad times") try: self.failureResultOf(self.raisesException(exception), KeyError) except self.failureException as e: self.assertIn("Failure of type (builtins.KeyError) expected on", str(e)) self.assertIn("builtins.Exception: Bad times", str(e)) def test_failureResultOfWithWrongExceptionMultiExpectedExceptions(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception of a type that was not expected, and the L{SynchronousTestCase.failureException} message contains expected exception types in the error message. """ try: self.failureResultOf(self.raisesException(), KeyError, IOError) except self.failureException as e: self.assertIn( "Failure of type ({}.{} or {}.{}) expected on".format( KeyError.__module__, KeyError.__name__, IOError.__module__, IOError.__name__, ), str(e), ) def test_failureResultOfWithWrongExceptionMultiExpectedExceptionsHasTB(self): """ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception of a type that was not expected, and the L{SynchronousTestCase.failureException} message contains the original exception traceback in the error message. """ exception = Exception("Bad times") try: self.failureResultOf(self.raisesException(exception), KeyError, IOError) except self.failureException as e: self.assertIn( "Failure of type (builtins.KeyError or builtins.OSError) expected on", str(e), ) self.assertIn("builtins.Exception: Bad times", str(e)) def test_successResultOfWithSuccessResult(self): """ When passed a coroutine which currently has a result (ie, if converted into a L{Deferred}, L{Deferred.addCallback} would cause the added callback to be called before C{addCallback} returns), L{SynchronousTestCase.successResultOf} returns that result. """ self.assertIdentical(self.result, self.successResultOf(self.successResult())) def test_failureResultOfWithExpectedException(self): """ When passed a coroutine which currently has an exception result (ie, if converted into a L{Deferred}, L{Deferred.addErrback} would cause the added errback to be called before C{addErrback} returns), L{SynchronousTestCase.failureResultOf} returns a L{Failure} containing that exception, if the exception type is expected. """ self.assertEqual( self.failure.value, self.failureResultOf( self.raisesException(), self.failure.type, KeyError ).value, ) def test_failureResultOfWithException(self): """ When passed a coroutine which currently has an exception result (ie, if converted into a L{Deferred}, L{Deferred.addErrback} would cause the added errback to be called before C{addErrback} returns), L{SynchronousTestCase.failureResultOf} returns returns a L{Failure} containing that exception. """ self.assertEqual( self.failure.value, self.failureResultOf(self.raisesException()).value ) def test_assertNoResultSuccess(self): """ When passed a coroutine which currently has a success result (see L{test_withSuccessResult}), L{SynchronousTestCase.assertNoResult} raises L{SynchronousTestCase.failureException}. """ self.assertRaises( self.failureException, self.assertNoResult, self.successResult() ) def test_assertNoResultFailure(self): """ When passed a coroutine which currently has an exception result (see L{test_withFailureResult}), L{SynchronousTestCase.assertNoResult} raises L{SynchronousTestCase.failureException}. """ self.assertRaises( self.failureException, self.assertNoResult, self.raisesException() ) def test_assertNoResult(self): """ When passed a coroutine with no current result, L{SynchronousTestCase.assertNoResult} does not raise an exception. """ self.assertNoResult(self.noCurrentResult()) def test_assertNoResultPropagatesSuccess(self): """ When passed a coroutine awaiting a L{Deferred} with no current result, which is then fired with a success result, L{SynchronousTestCase.assertNoResult} doesn't modify the result of the L{Deferred}. """ d = Deferred() async def noCurrentResult(): return await d c = noCurrentResult() self.assertNoResult(d) d.callback(self.result) self.assertEqual(self.result, self.successResultOf(c)) def test_assertNoResultPropagatesLaterFailure(self): """ When passed a coroutine awaiting a L{Deferred} with no current result, which is then fired with a L{Failure} result, L{SynchronousTestCase.assertNoResult} doesn't modify the result of the L{Deferred}. """ f = Failure(self.exception) d = Deferred() async def noCurrentResult(): return await d c = noCurrentResult() self.assertNoResult(d) d.errback(f) self.assertEqual(f.value, self.failureResultOf(c).value) def test_assertNoResultSwallowsImmediateFailure(self): """ When passed a L{Deferred} which currently has a L{Failure} result, L{SynchronousTestCase.assertNoResult} changes the result of the L{Deferred} to a success. """ d = fail(self.failure) async def raisesException(): return await d c = raisesException() try: self.assertNoResult(d) except self.failureException: pass self.assertEqual(None, self.successResultOf(c)) class AssertionNamesTests(unittest.SynchronousTestCase): """ Tests for consistency of naming within TestCase assertion methods """ def _getAsserts(self): dct = {} accumulateMethods(self, dct, "assert") return [dct[k] for k in dct if not k.startswith("Not") and k != "_"] def _name(self, x): return x.__name__ def test_failUnlessMatchesAssert(self): """ The C{failUnless*} test methods are a subset of the C{assert*} test methods. This is intended to ensure that methods using the I{failUnless} naming scheme are not added without corresponding methods using the I{assert} naming scheme. The I{assert} naming scheme is preferred, and new I{assert}-prefixed methods may be added without corresponding I{failUnless}-prefixed methods. """ asserts = set(self._getAsserts()) failUnlesses = set(prefixedMethods(self, "failUnless")) self.assertEqual(failUnlesses, asserts.intersection(failUnlesses)) def test_failIf_matches_assertNot(self): asserts = prefixedMethods(unittest.SynchronousTestCase, "assertNot") failIfs = prefixedMethods(unittest.SynchronousTestCase, "failIf") self.assertEqual( sorted(asserts, key=self._name), sorted(failIfs, key=self._name) ) def test_equalSpelling(self): for name, value in vars(self).items(): if not callable(value): continue if name.endswith("Equal"): self.assertTrue(hasattr(self, name + "s"), f"{name} but no {name}s") self.assertEqual(value, getattr(self, name + "s")) if name.endswith("Equals"): self.assertTrue(hasattr(self, name[:-1]), f"{name} but no {name[:-1]}") self.assertEqual(value, getattr(self, name[:-1])) class CallDeprecatedTests(unittest.SynchronousTestCase): """ Test use of the L{SynchronousTestCase.callDeprecated} method with version objects. """ version = Version("Twisted", 8, 0, 0) def test_callDeprecatedSuppressesWarning(self): """ callDeprecated calls a deprecated callable, suppressing the deprecation warning. """ self.callDeprecated(self.version, oldMethod, "foo") self.assertEqual(self.flushWarnings(), [], "No warnings should be shown") def test_callDeprecatedCallsFunction(self): """ L{callDeprecated} actually calls the callable passed to it, and forwards the result. """ result = self.callDeprecated(self.version, oldMethod, "foo") self.assertEqual("foo", result) def test_failsWithoutDeprecation(self): """ L{callDeprecated} raises a test failure if the callable is not deprecated. """ def notDeprecated(): pass exception = self.assertRaises( self.failureException, self.callDeprecated, self.version, notDeprecated ) self.assertEqual("%r is not deprecated." % notDeprecated, str(exception)) def test_failsWithIncorrectDeprecation(self): """ callDeprecated raises a test failure if the callable was deprecated at a different version to the one expected. """ differentVersion = Version("Foo", 1, 2, 3) exception = self.assertRaises( self.failureException, self.callDeprecated, differentVersion, oldMethod, "foo", ) self.assertIn(getVersionString(self.version), str(exception)) self.assertIn(getVersionString(differentVersion), str(exception)) def test_nestedDeprecation(self): """ L{callDeprecated} ignores all deprecations apart from the first. Multiple warnings are generated when a deprecated function calls another deprecated function. The first warning is the one generated by the explicitly called function. That's the warning that we care about. """ differentVersion = Version("Foo", 1, 2, 3) def nestedDeprecation(*args): return oldMethod(*args) nestedDeprecation = deprecated(differentVersion)(nestedDeprecation) self.callDeprecated(differentVersion, nestedDeprecation, 24) # The oldMethod deprecation should have been emitted too, not captured # by callDeprecated. Flush it now to make sure it did happen and to # prevent it from showing up on stdout. warningsShown = self.flushWarnings() self.assertEqual(len(warningsShown), 1, f"Unexpected warnings: {warningsShown}") def test_callDeprecationWithMessage(self): """ L{callDeprecated} can take a message argument used to check the warning emitted. """ self.callDeprecated((self.version, "newMethod"), oldMethodReplaced, 1) def test_callDeprecationWithWrongMessage(self): """ If the message passed to L{callDeprecated} doesn't match, L{callDeprecated} raises a test failure. """ exception = self.assertRaises( self.failureException, self.callDeprecated, (self.version, "something.wrong"), oldMethodReplaced, 1, ) self.assertIn(getVersionString(self.version), str(exception)) self.assertIn("please use newMethod instead", str(exception)) @deprecated(CallDeprecatedTests.version) def oldMethod(x): """ Deprecated method for testing. """ return x @deprecated(CallDeprecatedTests.version, replacement="newMethod") def oldMethodReplaced(x): """ Another deprecated method, which has been deprecated in favor of the mythical 'newMethod'. """ return 2 * x class GetDeprecatedModuleAttributeTests(unittest.SynchronousTestCase): """ Test L{SynchronousTestCase.getDeprecatedModuleAttribute} @ivar version: The version at which L{test_assertions.somethingOld} is marked deprecated. @type version: L{incremental.Version} """ version = Version("Bar", 1, 2, 3) def test_deprecated(self): """ L{getDeprecatedModuleAttribute} returns the specified attribute and consumes the deprecation warning that generates. """ self.assertIs( _somethingOld, self.getDeprecatedModuleAttribute( __name__, "somethingOld", self.version, ), ) self.assertEqual([], self.flushWarnings()) def test_message(self): """ The I{message} argument to L{getDeprecatedModuleAttribute} matches the prefix of the deprecation message. """ self.assertIs( _somethingOld, self.getDeprecatedModuleAttribute( __name__, "somethingOld", self.version, message="It's old", ), ) self.assertEqual([], self.flushWarnings()) def test_messageMismatch(self): """ L{getDeprecatedModuleAttribute} fails the test if the I{message} isn't part of the deprecation message prefix. """ self.assertRaises( self.failureException, self.getDeprecatedModuleAttribute, __name__, "somethingOld", self.version, "It's shiny and new", # Doesn't match. ) self.assertEqual([], self.flushWarnings()) def test_notDeprecated(self): """ L{getDeprecatedModuleAttribute} fails the test when used to get an attribute that isn't actually deprecated. """ self.assertRaises( self.failureException, self.getDeprecatedModuleAttribute, __name__, "somethingNew", self.version, ) def somethingOld(): """ A deprecated module attribute. Used by L{GetDeprecatedModuleAttributeTests.test_deprecated}. """ # A non-deprecated alias of _somethingOld. _somethingOld = somethingOld deprecatedModuleAttribute( GetDeprecatedModuleAttributeTests.version, "It's old and clunky", __name__, "somethingOld", ) def somethingNew(): """ A module attribute that is not deprecated. Used by L{GetDeprecatedModuleAttributeTests.test_notDeprecated}. """ PK b�Z���:� � test/weird.pynu �[��� import unittest from twisted.internet import defer # Used in test_tests.UnhandledDeferredTests class TestBleeding(unittest.TestCase): """This test creates an unhandled Deferred and leaves it in a cycle. The Deferred is left in a cycle so that the garbage collector won't pick it up immediately. We were having some problems where unhandled Deferreds in one test were failing random other tests. (See #1507, #1213) """ def test_unhandledDeferred(self): try: 1 / 0 except ZeroDivisionError: f = defer.fail() # these two lines create the cycle. don't remove them l = [f] l.append(l) PK b�Zy�� test/mockcustomsuite.pynu �[��� # Copyright (c) 2006 Twisted Matrix Laboratories. See LICENSE for details """ Mock test module that contains a C{test_suite} method. L{runner.TestLoader} should load the tests from the C{test_suite}, not from the C{Foo} C{TestCase}. See {twisted.trial.test.test_loader.LoaderTest.test_loadModuleWith_test_suite}. """ from twisted.trial import runner, unittest class Foo(unittest.SynchronousTestCase): def test_foo(self): pass def test_suite(): ts = runner.TestSuite() ts.name = "MyCustomSuite" return ts PK b�Zg�kZ# # test/detests.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for Deferred handling by L{twisted.trial.unittest.TestCase}. """ from twisted.internet import defer, reactor, threads from twisted.python.util import runWithWarningsSuppressed from twisted.trial import unittest from twisted.trial.util import suppress as SUPPRESS class DeferredSetUpOK(unittest.TestCase): def setUp(self): d = defer.succeed("value") d.addCallback(self._cb_setUpCalled) return d def _cb_setUpCalled(self, ignored): self._setUpCalled = True def test_ok(self): self.assertTrue(self._setUpCalled) class DeferredSetUpFail(unittest.TestCase): testCalled = False def setUp(self): return defer.fail(unittest.FailTest("i fail")) def test_ok(self): DeferredSetUpFail.testCalled = True self.fail("I should not get called") class DeferredSetUpCallbackFail(unittest.TestCase): testCalled = False def setUp(self): d = defer.succeed("value") d.addCallback(self._cb_setUpCalled) return d def _cb_setUpCalled(self, ignored): self.fail("deliberate failure") def test_ok(self): DeferredSetUpCallbackFail.testCalled = True class DeferredSetUpError(unittest.TestCase): testCalled = False def setUp(self): return defer.fail(RuntimeError("deliberate error")) def test_ok(self): DeferredSetUpError.testCalled = True class DeferredSetUpNeverFire(unittest.TestCase): testCalled = False def setUp(self): return defer.Deferred() def test_ok(self): DeferredSetUpNeverFire.testCalled = True class DeferredSetUpSkip(unittest.TestCase): testCalled = False def setUp(self): d = defer.succeed("value") d.addCallback(self._cb1) return d def _cb1(self, ignored): raise unittest.SkipTest("skip me") def test_ok(self): DeferredSetUpSkip.testCalled = True class DeferredTests(unittest.TestCase): touched = False def _cb_fail(self, reason): self.fail(reason) def _cb_error(self, reason): raise RuntimeError(reason) def _cb_skip(self, reason): raise unittest.SkipTest(reason) def _touchClass(self, ignored): self.__class__.touched = True def setUp(self): self.__class__.touched = False def test_pass(self): return defer.succeed("success") def test_passGenerated(self): self._touchClass(None) yield None test_passGenerated = runWithWarningsSuppressed( [ SUPPRESS( message="twisted.internet.defer.deferredGenerator was " "deprecated" ) ], defer.deferredGenerator, test_passGenerated, ) @defer.inlineCallbacks def test_passInlineCallbacks(self): """ Test case that is decorated with L{defer.inlineCallbacks}. """ self._touchClass(None) yield None def test_fail(self): return defer.fail(self.failureException("I fail")) def test_failureInCallback(self): d = defer.succeed("fail") d.addCallback(self._cb_fail) return d def test_errorInCallback(self): d = defer.succeed("error") d.addCallback(self._cb_error) return d def test_skip(self): d = defer.succeed("skip") d.addCallback(self._cb_skip) d.addCallback(self._touchClass) return d def test_thread(self): return threads.deferToThread(lambda: None) def test_expectedFailure(self): d = defer.succeed("todo") d.addCallback(self._cb_error) return d test_expectedFailure.todo = "Expected failure" # type: ignore[attr-defined] class TimeoutTests(unittest.TestCase): timedOut = None def test_pass(self): d = defer.Deferred() reactor.callLater(0, d.callback, "hoorj!") return d test_pass.timeout = 2 # type: ignore[attr-defined] def test_passDefault(self): # test default timeout d = defer.Deferred() reactor.callLater(0, d.callback, "hoorj!") return d def test_timeout(self): return defer.Deferred() test_timeout.timeout = 0.1 # type: ignore[attr-defined] def test_timeoutZero(self): return defer.Deferred() test_timeoutZero.timeout = 0 # type: ignore[attr-defined] def test_expectedFailure(self): return defer.Deferred() test_expectedFailure.timeout = 0.1 # type: ignore[attr-defined] test_expectedFailure.todo = "i will get it right, eventually" # type: ignore[attr-defined] def test_skip(self): return defer.Deferred() test_skip.timeout = 0.1 # type: ignore[attr-defined] test_skip.skip = "i will get it right, eventually" # type: ignore[attr-defined] def test_errorPropagation(self): def timedOut(err): self.__class__.timedOut = err return err d = defer.Deferred() d.addErrback(timedOut) return d test_errorPropagation.timeout = 0.1 # type: ignore[attr-defined] def test_calledButNeverCallback(self): d = defer.Deferred() def neverFire(r): return defer.Deferred() d.addCallback(neverFire) d.callback(1) return d test_calledButNeverCallback.timeout = 0.1 # type: ignore[attr-defined] class TestClassTimeoutAttribute(unittest.TestCase): timeout = 0.2 def setUp(self): self.d = defer.Deferred() def testMethod(self): self.methodCalled = True return self.d PK b�Z��ȁ� � test/scripttest.pynu ȯ�� #! /usr/bin/python3 # -*- test-case-name: twisted.trial.test.test_log,twisted.trial.test.test_runner -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # fodder for test_script, which parses files for emacs local variable # declarations. This one is supposed to have: # test-case-name: twisted.trial.test.test_log,twisted.trial.test.test_runner # in the second line # The class declaration is irrelevant class Foo: pass PK b�Z���XW XW test/test_loader.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for loading tests by name. """ import os import sys import unittest as pyunit from hashlib import md5 from twisted.python import filepath, util from twisted.python.modules import getModule from twisted.python.reflect import ModuleNotFound from twisted.trial import reporter, runner, unittest from twisted.trial._asyncrunner import _iterateTests from twisted.trial.itrial import ITestCase from twisted.trial.test import packages def testNames(tests): """ Return the id of each test within the given test suite or case. """ names = [] for test in _iterateTests(tests): names.append(test.id()) return names class FinderPy3Tests(packages.SysPathManglingTest): def setUp(self): super().setUp() self.loader = runner.TestLoader() def test_findNonModule(self): """ findByName, if given something findable up until the last entry, will raise AttributeError (as it cannot tell if 'nonexistent' here is supposed to be a module or a class). """ self.assertRaises( AttributeError, self.loader.findByName, "twisted.trial.test.nonexistent" ) def test_findNonPackage(self): self.assertRaises(ModuleNotFound, self.loader.findByName, "nonextant") def test_findNonFile(self): """ findByName, given a file path that doesn't exist, will raise a ValueError saying that it is not a Python file. """ path = util.sibpath(__file__, "nonexistent.py") self.assertRaises(ValueError, self.loader.findByName, path) def test_findFileWithImportError(self): """ findByName will re-raise ImportErrors inside modules that it has found and imported. """ self.assertRaises( ImportError, self.loader.findByName, "unimportablepackage.test_module" ) class FileTests(packages.SysPathManglingTest): """ Tests for L{runner.filenameToModule}. """ def test_notFile(self): """ L{runner.filenameToModule} raises a C{ValueError} when a non-existing file is passed. """ err = self.assertRaises(ValueError, runner.filenameToModule, "it") self.assertEqual(str(err), "'it' doesn't exist") def test_moduleInPath(self): """ If the file in question is a module on the Python path, then it should properly import and return that module. """ sample1 = runner.filenameToModule(util.sibpath(__file__, "sample.py")) from twisted.trial.test import sample as sample2 self.assertEqual(sample2, sample1) def test_moduleNotInPath(self): """ If passed the path to a file containing the implementation of a module within a package which is not on the import path, L{runner.filenameToModule} returns a module object loosely resembling the module defined by that file anyway. """ self.mangleSysPath(self.oldPath) sample1 = runner.filenameToModule( os.path.join(self.parent, "goodpackage", "test_sample.py") ) self.assertEqual(sample1.__name__, "goodpackage.test_sample") self.cleanUpModules() self.mangleSysPath(self.newPath) from goodpackage import test_sample as sample2 # type: ignore[import] self.assertIsNot(sample1, sample2) self.assertEqual(sample1.__spec__, sample2.__spec__) def test_packageInPath(self): """ If the file in question is a package on the Python path, then it should properly import and return that package. """ package1 = runner.filenameToModule(os.path.join(self.parent, "goodpackage")) self.assertIs(package1, sys.modules["goodpackage"]) def test_packageNotInPath(self): """ If passed the path to a directory which represents a package which is not on the import path, L{runner.filenameToModule} returns a module object loosely resembling the package defined by that directory anyway. """ self.mangleSysPath(self.oldPath) package1 = runner.filenameToModule(os.path.join(self.parent, "goodpackage")) self.assertEqual(package1.__name__, "goodpackage") self.cleanUpModules() self.mangleSysPath(self.newPath) import goodpackage self.assertIsNot(package1, goodpackage) self.assertEqual(package1.__spec__, goodpackage.__spec__) def test_directoryNotPackage(self): """ L{runner.filenameToModule} raises a C{ValueError} when the name of an empty directory is passed that isn't considered a valid Python package because it doesn't contain a C{__init__.py} file. """ emptyDir = filepath.FilePath(self.parent).child("emptyDirectory") emptyDir.createDirectory() err = self.assertRaises(ValueError, runner.filenameToModule, emptyDir.path) self.assertEqual(str(err), f"{emptyDir.path!r} is not a package directory") def test_filenameNotPython(self): """ L{runner.filenameToModule} raises a C{SyntaxError} when a non-Python file is passed. """ filename = filepath.FilePath(self.parent).child("notpython") filename.setContent(b"This isn't python") self.assertRaises(SyntaxError, runner.filenameToModule, filename.path) def test_filenameMatchesPackage(self): """ The C{__file__} attribute of the module should match the package name. """ filename = filepath.FilePath(self.parent).child("goodpackage.py") filename.setContent(packages.testModule.encode("utf8")) try: module = runner.filenameToModule(filename.path) self.assertEqual(filename.path, module.__file__) finally: filename.remove() def test_directory(self): """ Test loader against a filesystem directory containing an empty C{__init__.py} file. It should handle 'path' and 'path/' the same way. """ goodDir = filepath.FilePath(self.parent).child("goodDirectory") goodDir.createDirectory() goodDir.child("__init__.py").setContent(b"") try: module = runner.filenameToModule(goodDir.path) self.assertTrue(module.__name__.endswith("goodDirectory")) module = runner.filenameToModule(goodDir.path + os.path.sep) self.assertTrue(module.__name__.endswith("goodDirectory")) finally: goodDir.remove() class LoaderTests(packages.SysPathManglingTest): """ Tests for L{trial.TestLoader}. """ def setUp(self): self.loader = runner.TestLoader() packages.SysPathManglingTest.setUp(self) def test_sortCases(self): from twisted.trial.test import sample suite = self.loader.loadClass(sample.AlphabetTest) self.assertEqual( ["test_a", "test_b", "test_c"], [test._testMethodName for test in suite._tests], ) newOrder = ["test_b", "test_c", "test_a"] sortDict = dict(zip(newOrder, range(3))) self.loader.sorter = lambda x: sortDict.get(x.shortDescription(), -1) suite = self.loader.loadClass(sample.AlphabetTest) self.assertEqual(newOrder, [test._testMethodName for test in suite._tests]) def test_loadFailure(self): """ Loading a test that fails and getting the result of it ends up with one test ran and one failure. """ suite = self.loader.loadByName( "twisted.trial.test.erroneous.TestRegularFail.test_fail" ) result = reporter.TestResult() suite.run(result) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.failures), 1) def test_loadBadDecorator(self): """ A decorated test method for which the decorator has failed to set the method's __name__ correctly is loaded and its name in the class scope discovered. """ from twisted.trial.test import sample suite = self.loader.loadAnything( sample.DecorationTest.test_badDecorator, parent=sample.DecorationTest, qualName=["sample", "DecorationTest", "test_badDecorator"], ) self.assertEqual(1, suite.countTestCases()) self.assertEqual("test_badDecorator", suite._testMethodName) def test_loadGoodDecorator(self): """ A decorated test method for which the decorator has set the method's __name__ correctly is loaded and the only name by which it goes is used. """ from twisted.trial.test import sample suite = self.loader.loadAnything( sample.DecorationTest.test_goodDecorator, parent=sample.DecorationTest, qualName=["sample", "DecorationTest", "test_goodDecorator"], ) self.assertEqual(1, suite.countTestCases()) self.assertEqual("test_goodDecorator", suite._testMethodName) def test_loadRenamedDecorator(self): """ Load a decorated method which has been copied to a new name inside the class. Thus its __name__ and its key in the class's __dict__ no longer match. """ from twisted.trial.test import sample suite = self.loader.loadAnything( sample.DecorationTest.test_renamedDecorator, parent=sample.DecorationTest, qualName=["sample", "DecorationTest", "test_renamedDecorator"], ) self.assertEqual(1, suite.countTestCases()) self.assertEqual("test_renamedDecorator", suite._testMethodName) def test_loadClass(self): from twisted.trial.test import sample suite = self.loader.loadClass(sample.FooTest) self.assertEqual(2, suite.countTestCases()) self.assertEqual( ["test_bar", "test_foo"], [test._testMethodName for test in suite._tests] ) def test_loadNonClass(self): from twisted.trial.test import sample self.assertRaises(TypeError, self.loader.loadClass, sample) self.assertRaises(TypeError, self.loader.loadClass, sample.FooTest.test_foo) self.assertRaises(TypeError, self.loader.loadClass, "string") self.assertRaises(TypeError, self.loader.loadClass, ("foo", "bar")) def test_loadNonTestCase(self): from twisted.trial.test import sample self.assertRaises(ValueError, self.loader.loadClass, sample.NotATest) def test_loadModule(self): from twisted.trial.test import sample suite = self.loader.loadModule(sample) self.assertEqual(10, suite.countTestCases()) def test_loadNonModule(self): from twisted.trial.test import sample self.assertRaises(TypeError, self.loader.loadModule, sample.FooTest) self.assertRaises(TypeError, self.loader.loadModule, sample.FooTest.test_foo) self.assertRaises(TypeError, self.loader.loadModule, "string") self.assertRaises(TypeError, self.loader.loadModule, ("foo", "bar")) def test_loadPackage(self): import goodpackage suite = self.loader.loadPackage(goodpackage) self.assertEqual(7, suite.countTestCases()) def test_loadNonPackage(self): from twisted.trial.test import sample self.assertRaises(TypeError, self.loader.loadPackage, sample.FooTest) self.assertRaises(TypeError, self.loader.loadPackage, sample.FooTest.test_foo) self.assertRaises(TypeError, self.loader.loadPackage, "string") self.assertRaises(TypeError, self.loader.loadPackage, ("foo", "bar")) def test_loadModuleAsPackage(self): from twisted.trial.test import sample ## XXX -- should this instead raise a ValueError? -- jml self.assertRaises(TypeError, self.loader.loadPackage, sample) def test_loadPackageRecursive(self): import goodpackage suite = self.loader.loadPackage(goodpackage, recurse=True) self.assertEqual(14, suite.countTestCases()) def test_loadAnythingOnModule(self): from twisted.trial.test import sample suite = self.loader.loadAnything(sample) self.assertEqual( sample.__name__, suite._tests[0]._tests[0].__class__.__module__ ) def test_loadAnythingOnClass(self): from twisted.trial.test import sample suite = self.loader.loadAnything(sample.FooTest) self.assertEqual(2, suite.countTestCases()) def test_loadAnythingOnPackage(self): import goodpackage suite = self.loader.loadAnything(goodpackage) self.assertTrue(isinstance(suite, self.loader.suiteFactory)) self.assertEqual(7, suite.countTestCases()) def test_loadAnythingOnPackageRecursive(self): import goodpackage suite = self.loader.loadAnything(goodpackage, recurse=True) self.assertTrue(isinstance(suite, self.loader.suiteFactory)) self.assertEqual(14, suite.countTestCases()) def test_loadAnythingOnString(self): # the important thing about this test is not the string-iness # but the non-handledness. self.assertRaises(TypeError, self.loader.loadAnything, "goodpackage") def test_importErrors(self): import package # type: ignore[import] suite = self.loader.loadPackage(package, recurse=True) result = reporter.Reporter() suite.run(result) self.assertEqual(False, result.wasSuccessful()) self.assertEqual(2, len(result.errors)) errors = [test.id() for test, error in result.errors] errors.sort() self.assertEqual( errors, ["package.test_bad_module", "package.test_import_module"] ) def test_differentInstances(self): """ L{TestLoader.loadClass} returns a suite with each test method represented by a different instances of the L{TestCase} they are defined on. """ class DistinctInstances(pyunit.TestCase): def test_1(self): self.first = "test1Run" def test_2(self): self.assertFalse(hasattr(self, "first")) suite = self.loader.loadClass(DistinctInstances) result = reporter.Reporter() suite.run(result) self.assertTrue(result.wasSuccessful()) def test_loadModuleWith_test_suite(self): """ Check that C{test_suite} is used when present and other L{TestCase}s are not included. """ from twisted.trial.test import mockcustomsuite suite = self.loader.loadModule(mockcustomsuite) self.assertEqual(0, suite.countTestCases()) self.assertEqual("MyCustomSuite", getattr(suite, "name", None)) def test_loadModuleWith_testSuite(self): """ Check that C{testSuite} is used when present and other L{TestCase}s are not included. """ from twisted.trial.test import mockcustomsuite2 suite = self.loader.loadModule(mockcustomsuite2) self.assertEqual(0, suite.countTestCases()) self.assertEqual("MyCustomSuite", getattr(suite, "name", None)) def test_loadModuleWithBothCustom(self): """ Check that if C{testSuite} and C{test_suite} are both present in a module then C{testSuite} gets priority. """ from twisted.trial.test import mockcustomsuite3 suite = self.loader.loadModule(mockcustomsuite3) self.assertEqual("testSuite", getattr(suite, "name", None)) def test_customLoadRaisesAttributeError(self): """ Make sure that any C{AttributeError}s raised by C{testSuite} are not swallowed by L{TestLoader}. """ def testSuite(): raise AttributeError("should be reraised") from twisted.trial.test import mockcustomsuite2 mockcustomsuite2.testSuite, original = (testSuite, mockcustomsuite2.testSuite) try: self.assertRaises(AttributeError, self.loader.loadModule, mockcustomsuite2) finally: mockcustomsuite2.testSuite = original # XXX - duplicated and modified from test_script def assertSuitesEqual(self, test1, test2): names1 = testNames(test1) names2 = testNames(test2) names1.sort() names2.sort() self.assertEqual(names1, names2) def test_loadByNamesDuplicate(self): """ Check that loadByNames ignores duplicate names """ module = "twisted.trial.test.test_log" suite1 = self.loader.loadByNames([module, module], True) suite2 = self.loader.loadByName(module, True) self.assertSuitesEqual(suite1, suite2) def test_loadByNamesPreservesOrder(self): """ L{TestLoader.loadByNames} preserves the order of tests provided to it. """ modules = [ "inheritancepackage.test_x.A.test_foo", "twisted.trial.test.sample", "goodpackage", "twisted.trial.test.test_log", "twisted.trial.test.sample.FooTest", "package.test_module", ] suite1 = self.loader.loadByNames(modules) suite2 = runner.TestSuite(map(self.loader.loadByName, modules)) self.assertEqual(testNames(suite1), testNames(suite2)) def test_loadDifferentNames(self): """ Check that loadByNames loads all the names that it is given """ modules = ["goodpackage", "package.test_module"] suite1 = self.loader.loadByNames(modules) suite2 = runner.TestSuite(map(self.loader.loadByName, modules)) self.assertSuitesEqual(suite1, suite2) def test_loadInheritedMethods(self): """ Check that test methods names which are inherited from are all loaded rather than just one. """ methods = [ "inheritancepackage.test_x.A.test_foo", "inheritancepackage.test_x.B.test_foo", ] suite1 = self.loader.loadByNames(methods) suite2 = runner.TestSuite(map(self.loader.loadByName, methods)) self.assertSuitesEqual(suite1, suite2) class ZipLoadingTests(LoaderTests): def setUp(self): from twisted.python.test.test_zippath import zipit LoaderTests.setUp(self) zipit(self.parent, self.parent + ".zip") self.parent += ".zip" self.mangleSysPath(self.oldPath + [self.parent]) class PackageOrderingTests(packages.SysPathManglingTest): def setUp(self): self.loader = runner.TestLoader() self.topDir = self.mktemp() parent = os.path.join(self.topDir, "uberpackage") os.makedirs(parent) open(os.path.join(parent, "__init__.py"), "wb").close() packages.SysPathManglingTest.setUp(self, parent) self.mangleSysPath(self.oldPath + [self.topDir]) def _trialSortAlgorithm(self, sorter): """ Right now, halfway by accident, trial sorts like this: 1. all modules are grouped together in one list and sorted. 2. within each module, the classes are grouped together in one list and sorted. 3. finally within each class, each test method is grouped together in a list and sorted. This attempts to return a sorted list of testable thingies following those rules, so that we can compare the behavior of loadPackage. The things that show as 'cases' are errors from modules which failed to import, and test methods. Let's gather all those together. """ pkg = getModule("uberpackage") testModules = [] for testModule in pkg.walkModules(): if testModule.name.split(".")[-1].startswith("test_"): testModules.append(testModule) sortedModules = sorted(testModules, key=sorter) # ONE for modinfo in sortedModules: # Now let's find all the classes. module = modinfo.load(None) if module is None: yield modinfo else: testClasses = [] for attrib in modinfo.iterAttributes(): if runner.isTestCase(attrib.load()): testClasses.append(attrib) sortedClasses = sorted(testClasses, key=sorter) # TWO for clsinfo in sortedClasses: testMethods = [] for attr in clsinfo.iterAttributes(): if attr.name.split(".")[-1].startswith("test"): testMethods.append(attr) sortedMethods = sorted(testMethods, key=sorter) # THREE yield from sortedMethods def loadSortedPackages(self, sorter=runner.name): """ Verify that packages are loaded in the correct order. """ import uberpackage # type: ignore[import] self.loader.sorter = sorter suite = self.loader.loadPackage(uberpackage, recurse=True) # XXX: Work around strange, unexplained Zope crap. # jml, 2007-11-15. suite = unittest.decorate(suite, ITestCase) resultingTests = list(_iterateTests(suite)) manifest = list(self._trialSortAlgorithm(sorter)) for number, (manifestTest, actualTest) in enumerate( zip(manifest, resultingTests) ): self.assertEqual( manifestTest.name, actualTest.id(), "#%d: %s != %s" % (number, manifestTest.name, actualTest.id()), ) self.assertEqual(len(manifest), len(resultingTests)) def test_sortPackagesDefaultOrder(self): self.loadSortedPackages() def test_sortPackagesSillyOrder(self): def sillySorter(s): # This has to work on fully-qualified class names and class # objects, which is silly, but it's the "spec", such as it is. # if isinstance(s, type): # return s.__module__+'.'+s.__name__ n = runner.name(s) d = md5(n.encode("utf8")).hexdigest() return d self.loadSortedPackages(sillySorter) PK b�ZP�QI� � test/mockcustomsuite3.pynu �[��� # Copyright (c) 2006 Twisted Matrix Laboratories. See LICENSE for details """ Mock test module that contains both a C{test_suite} and a C{testSuite} method. L{runner.TestLoader} should load the tests from the C{testSuite}, not from the C{Foo} C{TestCase} nor from the C{test_suite} method. See {twisted.trial.test.test_loader.LoaderTest.test_loadModuleWithBothCustom}. """ from twisted.trial import runner, unittest class Foo(unittest.SynchronousTestCase): def test_foo(self): pass def test_suite(): ts = runner.TestSuite() ts.name = "test_suite" return ts def testSuite(): ts = runner.TestSuite() ts.name = "testSuite" return ts PK b�ZV�Ҹ � test/erroneous.pynu �[��� # -*- test-case-name: twisted.trial.test.test_tests -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Definitions of test cases with various interesting error-related behaviors, to be used by test modules to exercise different features of trial's test runner. See the L{twisted.trial.test.test_tests} module docstring for details about how this code is arranged. """ from unittest import skipIf from twisted.internet import defer, protocol, reactor from twisted.trial import unittest, util class FoolishError(Exception): pass class FailureInSetUpMixin: def setUp(self): raise FoolishError("I am a broken setUp method") def test_noop(self): pass class SynchronousTestFailureInSetUp(FailureInSetUpMixin, unittest.SynchronousTestCase): pass class AsynchronousTestFailureInSetUp(FailureInSetUpMixin, unittest.TestCase): pass class FailureInTearDownMixin: def tearDown(self): raise FoolishError("I am a broken tearDown method") def test_noop(self): pass class SynchronousTestFailureInTearDown( FailureInTearDownMixin, unittest.SynchronousTestCase ): pass class AsynchronousTestFailureInTearDown(FailureInTearDownMixin, unittest.TestCase): pass class FailureButTearDownRunsMixin: """ A test fails, but its L{tearDown} still runs. """ tornDown = False def tearDown(self): self.tornDown = True def test_fails(self): """ A test that fails. """ raise FoolishError("I am a broken test") class SynchronousTestFailureButTearDownRuns( FailureButTearDownRunsMixin, unittest.SynchronousTestCase ): pass class AsynchronousTestFailureButTearDownRuns( FailureButTearDownRunsMixin, unittest.TestCase ): pass class TestRegularFail(unittest.SynchronousTestCase): def test_fail(self): self.fail("I fail") def test_subfail(self): self.subroutine() def subroutine(self): self.fail("I fail inside") class TestAsynchronousFail(unittest.TestCase): """ Test failures for L{unittest.TestCase} based classes. """ def test_fail(self): """ A test which fails in the callback of the returned L{defer.Deferred}. """ d = defer.Deferred() d.addCallback(self._later) reactor.callLater(0, d.callback, None) return d def _later(self, res): self.fail("I fail later") def test_exception(self): """ A test which raises an exception synchronously. """ raise Exception("I fail") class ErrorTest(unittest.SynchronousTestCase): """ A test case which has a L{test_foo} which will raise an error. @ivar ran: boolean indicating whether L{test_foo} has been run. """ ran = False def test_foo(self): """ Set C{self.ran} to True and raise a C{ZeroDivisionError} """ self.ran = True 1 / 0 @skipIf(True, "skipping this test") class TestSkipTestCase(unittest.SynchronousTestCase): pass class DelayedCall(unittest.TestCase): hiddenExceptionMsg = "something blew up" def go(self): raise RuntimeError(self.hiddenExceptionMsg) def testHiddenException(self): """ What happens if an error is raised in a DelayedCall and an error is also raised in the test? L{test_reporter.ErrorReportingTests.testHiddenException} checks that both errors get reported. Note that this behaviour is deprecated. A B{real} test would return a Deferred that got triggered by the callLater. This would guarantee the delayed call error gets reported. """ reactor.callLater(0, self.go) reactor.iterate(0.01) self.fail("Deliberate failure to mask the hidden exception") testHiddenException.suppress = [ # type: ignore[attr-defined] util.suppress( message=r"reactor\.iterate cannot be used.*", category=DeprecationWarning ) ] class ReactorCleanupTests(unittest.TestCase): def test_leftoverPendingCalls(self): def _(): print("foo!") reactor.callLater(10000.0, _) class SocketOpenTest(unittest.TestCase): def test_socketsLeftOpen(self): f = protocol.Factory() f.protocol = protocol.Protocol reactor.listenTCP(0, f) class TimingOutDeferred(unittest.TestCase): def test_alpha(self): pass def test_deferredThatNeverFires(self): self.methodCalled = True d = defer.Deferred() return d def test_omega(self): pass def unexpectedException(self): """i will raise an unexpected exception... ... *CAUSE THAT'S THE KINDA GUY I AM* >>> 1/0 """ PK b�Z����7 7 * test/__pycache__/erroneous.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZ ddlmZmZmZ ddlmZmZ G dd� de �Z G dd� d�Z G d d � d e ej �Z G d d � d e ej�ZG d d� d�ZG dd� deej �ZG dd� deej�ZG dd� d�ZG dd� deej �ZG dd� deej�ZG dd� dej �ZG dd � d ej�ZG d d � d ej �Zed d �G d!d"� d"ej ��ZG d#d$� d$ej�ZG d%d&� d&ej�ZG d'd(� d(ej�Z G d)d*� d*ej�Z d+d,� Z d-S ).a Definitions of test cases with various interesting error-related behaviors, to be used by test modules to exercise different features of trial's test runner. See the L{twisted.trial.test.test_tests} module docstring for details about how this code is arranged. � )�skipIf)�defer�protocol�reactor)�unittest�utilc @ � e Zd ZdS )� FoolishErrorN��__name__� __module__� __qualname__� r r �>/usr/lib/python3/dist-packages/twisted/trial/test/erroneous.pyr � r c @ � e Zd Zdd� Zdd� ZdS )�FailureInSetUpMixinc C � t d��)NzI am a broken setUp method�r ��selfr r r �setUp � zFailureInSetUpMixin.setUpc C � d S �Nr r r r r � test_noop � z FailureInSetUpMixin.test_noopN)r r r r r r r r r r � r c @ r )� SynchronousTestFailureInSetUpNr r r r r r r r c @ r )� AsynchronousTestFailureInSetUpNr r r r r r $ r r c @ r )�FailureInTearDownMixinc C r )Nz I am a broken tearDown methodr r r r r �tearDown) r z FailureInTearDownMixin.tearDownc C r r r r r r r r , r z FailureInTearDownMixin.test_noopN)r r r r! r r r r r r ( r r c @ r )� SynchronousTestFailureInTearDownNr r r r r r" 0 � r" c @ r )�!AsynchronousTestFailureInTearDownNr r r r r r$ 6 r r$ c @ s$ e Zd ZdZdZdd� Zdd� ZdS )�FailureButTearDownRunsMixinz7 A test fails, but its L{tearDown} still runs. Fc C s d| _ d S �NT)�tornDownr r r r r! A � z$FailureButTearDownRunsMixin.tearDownc C r )z$ A test that fails. zI am a broken testr r r r r � test_failsD � z&FailureButTearDownRunsMixin.test_failsN)r r r �__doc__r' r! r) r r r r r% : s r% c @ r )�%SynchronousTestFailureButTearDownRunsNr r r r r r, K r# r, c @ r )�&AsynchronousTestFailureButTearDownRunsNr r r r r r- Q r# r- c @ �$ e Zd Zdd� Zdd� Zdd� ZdS )�TestRegularFailc C � | � d� d S )N�I fail��failr r r r � test_failX � zTestRegularFail.test_failc C s | � � d S r )� subroutiner r r r � test_subfail[ � z TestRegularFail.test_subfailc C r0 )Nz I fail insider2 r r r r r6 ^ r5 zTestRegularFail.subroutineN)r r r r4 r7 r6 r r r r r/ W s r/ c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �TestAsynchronousFailz? Test failures for L{unittest.TestCase} based classes. c C s( t �� }|�| j� t�d|jd� |S )zW A test which fails in the callback of the returned L{defer.Deferred}. r N)r �Deferred� addCallback�_laterr � callLater�callback�r �dr r r r4 g s z TestAsynchronousFail.test_failc C r0 )Nz I fail laterr2 )r �resr r r r< p r5 zTestAsynchronousFail._laterc C r )zA A test which raises an exception synchronously. r1 )� Exceptionr r r r �test_exceptions r* z#TestAsynchronousFail.test_exceptionN)r r r r+ r4 r< rC r r r r r9 b s r9 c @ s e Zd ZdZdZdd� ZdS )� ErrorTestz� A test case which has a L{test_foo} which will raise an error. @ivar ran: boolean indicating whether L{test_foo} has been run. Fc C s d| _ dd dS )zJ Set C{self.ran} to True and raise a C{ZeroDivisionError} T� r N)�ranr r r r �test_foo� s zErrorTest.test_fooN)r r r r+ rF rG r r r r rD z s rD Tzskipping this testc @ r )�TestSkipTestCaseNr r r r r rH � s rH c @ s2 e Zd ZdZdd� Zdd� Zejded�ge_dS ) � DelayedCallzsomething blew upc C s t | j��r )� RuntimeError�hiddenExceptionMsgr r r r �go� r( zDelayedCall.goc C s& t �d| j� t �d� | �d� dS )a� What happens if an error is raised in a DelayedCall and an error is also raised in the test? L{test_reporter.ErrorReportingTests.testHiddenException} checks that both errors get reported. Note that this behaviour is deprecated. A B{real} test would return a Deferred that got triggered by the callLater. This would guarantee the delayed call error gets reported. r g{�G�z�?z/Deliberate failure to mask the hidden exceptionN)r r= rL �iterater3 r r r r �testHiddenException� s z DelayedCall.testHiddenExceptionz!reactor\.iterate cannot be used.*)�message�categoryN) r r r rK rL rN r �suppress�DeprecationWarningr r r r rI � s � �rI c @ � e Zd Zdd� ZdS )�ReactorCleanupTestsc C s dd� }t �d|� d S )Nc S s t d� d S )Nzfoo!)�printr r r r �_� r8 z8ReactorCleanupTests.test_leftoverPendingCalls.<locals>._g ��@)r r= )r rV r r r �test_leftoverPendingCalls� s z-ReactorCleanupTests.test_leftoverPendingCallsN)r r r rW r r r r rT � � rT c @ rS )�SocketOpenTestc C s t �� }t j|_ t�d|� d S )Nr )r �Factory�Protocolr � listenTCP)r �fr r r �test_socketsLeftOpen� s z#SocketOpenTest.test_socketsLeftOpenN)r r r r^ r r r r rY � rX rY c @ r. )�TimingOutDeferredc C r r r r r r r � test_alpha� r z TimingOutDeferred.test_alphac C s d| _ t�� }|S r& )� methodCalledr r: r? r r r �test_deferredThatNeverFires� s z-TimingOutDeferred.test_deferredThatNeverFiresc C r r r r r r r � test_omega� r z TimingOutDeferred.test_omegaN)r r r r` rb rc r r r r r_ � s r_ c C s dS )zci will raise an unexpected exception... ... *CAUSE THAT'S THE KINDA GUY I AM* >>> 1/0 Nr r r r r �unexpectedException� s rd N) r+ r r �twisted.internetr r r � twisted.trialr rB r r �SynchronousTestCaser �TestCaser r r" r$ r% r, r- r/ r9 rD rH rI rT rY r_ rd r r r r �<module> s< � � � PK b�Z"�!O� � 1 test/__pycache__/test_suppression.cpython-310.pycnu �[��� o �b � @ sV d Z ddlZddlmZ ddlmZ ddlmZ G dd� d�ZG dd � d eej �Z dS ) z2 Tests for warning suppression features of Trial. � N)�namedAny)�unittest)� suppressionc @ sX e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dS )�SuppressionMixinzj Tests for the warning suppression features of L{twisted.trial.unittest.SynchronousTestCase}. c C s |� t�� � d S )N)�run�pyunit� TestResult)�self�suite� r �E/usr/lib/python3/dist-packages/twisted/trial/test/test_suppression.py�runTests s zSuppressionMixin.runTestsc C s t �||�g�S )z� Return a new L{unittest.TestSuite} with a single test method in it. @param cls: A L{TestCase} subclass defining a test method. @param methodName: The name of the test method from C{cls}. )r � TestSuite)r �cls� methodNamer r r �_load s zSuppressionMixin._loadc C s | � dd� |D �|� dS )a& Assert that a certain number of warnings with certain messages were emitted in a certain order. @param warnings: A list of emitted warnings, as returned by C{flushWarnings}. @param which: A list of strings giving warning messages that should appear in C{warnings}. @raise self.failureException: If the warning messages given by C{which} do not match the messages in the warning information in C{warnings}, or if they do not appear in the same order. c S s g | ]}|d �qS )�messager )�.0�warningr r r � <listcomp>2 s z4SuppressionMixin._assertWarnings.<locals>.<listcomp>N)� assertEqual)r �warnings�whichr r r �_assertWarnings# s z SuppressionMixin._assertWarningsc C �D | � | �| jd�� | �| jjg�}| �|tjtjtjtjg� dS )z� Suppressions defined by the test method being run are applied to any warnings emitted while running the C{setUp} fixture. �testSuppressMethodN) r r �TestSetUpSuppression� flushWarnings�_emitr r �CLASS_WARNING_MSG�MODULE_WARNING_MSG�r � warningsShownr r r �test_setUpSuppression4 � ��z&SuppressionMixin.test_setUpSuppressionc C r )z� Suppressions defined by the test method being run are applied to any warnings emitted while running the C{tearDown} fixture. r N) r r �TestTearDownSuppressionr r r r r r r! r r r �test_tearDownSuppressionE r$ z)SuppressionMixin.test_tearDownSuppressionc C s< | � | �| jd�� | �| jjg�}| �|tjtjg� dS )z� A suppression set on a test method prevents warnings emitted by that test method which the suppression matches from being emitted. r N) r r �TestSuppressionr r r r r r r! r r r �test_suppressMethodV s �z$SuppressionMixin.test_suppressMethodc C sd | � | �| jd�� | �| jjg�}| �|d d tj� | �|d d tj� | �t |�d� dS )z� A suppression set on a L{SynchronousTestCase} subclass prevents warnings emitted by any test methods defined on that class which match the suppression from being emitted. �testSuppressClassr r � � N) r r r' r r r r �METHOD_WARNING_MSGr �lenr! r r r �test_suppressClassb � z#SuppressionMixin.test_suppressClassc C sd | � | �| jd�� | �| jjg�}| �|d d tj� | �|d d tj � | �t |�d� dS )z� A suppression set on a module prevents warnings emitted by any test mewthods defined in that module which match the suppression from being emitted. �testSuppressModuler r r* r+ N) r r �TestSuppression2r r' r r r r, r r- r! r r r �test_suppressModulen r/ z$SuppressionMixin.test_suppressModulec C sz | � | �| jd�� | �| jjg�}| �|d d tj� | �|d d tj� | �|d d tj � | �t |�d� dS )z� The suppression set on a test method completely overrides a suppression with wider scope; if it does not match a warning emitted by that test method, the warning is emitted, even if a wider suppression matches. �testOverrideSuppressClassr r r* r+ � N) r r r' r r r r r, r r r- r! r r r �test_overrideSuppressClassz s z+SuppressionMixin.test_overrideSuppressClassN) �__name__� __module__� __qualname__�__doc__r r r r# r& r( r. r2 r5 r r r r r s r c @ s0 e Zd ZdZed�Zed�Zed�Zed�ZdS )�SynchronousSuppressionTestsz0 @see: L{twisted.trial.test.test_tests} z>twisted.trial.test.suppression.SynchronousTestSetUpSuppressionzAtwisted.trial.test.suppression.SynchronousTestTearDownSuppressionz9twisted.trial.test.suppression.SynchronousTestSuppressionz:twisted.trial.test.suppression.SynchronousTestSuppression2N) r6 r7 r8 r9 r r r% r' r1 r r r r r: � s ����r: ) r9 r r �twisted.python.reflectr � twisted.trial�twisted.trial.testr r �SynchronousTestCaser: r r r r �<module> s xPK b�Z �ſ7 7 1 test/__pycache__/mockcustomsuite3.cpython-310.pycnu �[��� o �b� � @ s: d Z ddlmZmZ G dd� dej�Zdd� Zdd� Zd S ) a% Mock test module that contains both a C{test_suite} and a C{testSuite} method. L{runner.TestLoader} should load the tests from the C{testSuite}, not from the C{Foo} C{TestCase} nor from the C{test_suite} method. See {twisted.trial.test.test_loader.LoaderTest.test_loadModuleWithBothCustom}. � )�runner�unittestc @ s e Zd Zdd� ZdS )�Fooc C s d S )N� )�selfr r �E/usr/lib/python3/dist-packages/twisted/trial/test/mockcustomsuite3.py�test_foo s z Foo.test_fooN)�__name__� __module__� __qualname__r r r r r r s r c C � t �� } d| _| S )N� test_suite�r � TestSuite�name��tsr r r r � r c C r )N� testSuiter r r r r r r r N)�__doc__� twisted.trialr r �SynchronousTestCaser r r r r r r �<module> s PK b�Zy{�� � - test/__pycache__/test_doctest.cpython-310.pycnu �[��� o �b� � @ s> d Z ddlmZmZmZmZ ddlmZ G dd� dej�Z dS )z! Test Twisted's doctest support. � )�itrial�reporter�runner�unittest)� mockdoctestc @ s: e Zd ZdZdd� Zdd� Zdd� Zdd d �Zd d � Zd S )� RunnersTestsz. Tests for Twisted's doctest support. c C s< t �� }|�t�}d}|jD ] }| �|t�|��� � qdS )zq Check that the id() of the doctests' case object contains the FQPN of the actual tests. z&twisted.trial.test.mockdoctest.CounterN) r � TestLoader� loadDoctestsr �_tests�assertInr � ITestCase�id)�self�loader�suite�idPrefix�test� r �A/usr/lib/python3/dist-packages/twisted/trial/test/test_doctest.py�test_id s �zRunnersTests.test_idc C s& t �� }|�t�}| �d|�� � dS )zP L{loadDoctests} loads all of the doctests in the given module. � N)r r r r � assertEqual�countTestCases)r r r r r r �test_basicTrialIntegration s z'RunnersTests.test_basicTrialIntegrationc C s6 t �� }|�|� | �d|j� | �dt|j�� dS )z4 Run C{suite} and check the result. � � N)r � TestResult�runr � successes�len�failures)r r �resultr r r �_testRun% s zRunnersTests._testRun� c C s t �� �t�}| �|� dS )zL Trial can correctly run doctests with its xUnit test APIs. N�r r r r r" )r �countr r r r �test_expectedResults. s z!RunnersTests.test_expectedResultsc C s& t �� �t�}| �|� | �|� dS )z9 Doctests should be runnable repeatably. Nr$ )r r r r r �test_repeatable5 s z RunnersTests.test_repeatableN)r# ) �__name__� __module__� __qualname__�__doc__r r r" r& r' r r r r r s r N) r+ � twisted.trialr r r r �twisted.trial.testr �SynchronousTestCaser r r r r �<module> s PK b�ZwLk{+ + ' test/__pycache__/novars.cpython-310.pycnu �[��� o �b� � @ s G d d� d�Z dS )c @ s e Zd ZdS )�BarN)�__name__� __module__� __qualname__� r r �;/usr/lib/python3/dist-packages/twisted/trial/test/novars.pyr s r N)r r r r r �<module> s PK b�Z����� � ' test/__pycache__/sample.cpython-310.pycnu �[��� o �b$ � @ s� d Z ddlZddlmZ ddlmZ G dd� dej�Zdd� Zd d � Z G d d � d ej�Z G d d� dej �Z G dd� d�Z G dd� dej�ZdS )z�This module is used by test_loader to test the Trial test loading functionality. Do NOT change the number of tests in this module. Do NOT change the names the tests in this module. � N��mergeFunctionMetadata)�unittestc @ � e Zd Zdd� Zdd� ZdS )�FooTestc C � d S �N� ��selfr r �;/usr/lib/python3/dist-packages/twisted/trial/test/sample.py�test_foo � zFooTest.test_fooc C r r r r r r r �test_bar r zFooTest.test_barN��__name__� __module__� __qualname__r r r r r r r � r c s � fdd�}|S )z� Decorate a function without preserving the name of the original function. Always return a function with the same name. c � � | i |��S r r ��args�kwargs��fnr r � nameCollision � z#badDecorator.<locals>.nameCollisionr �r r r r r � badDecorator s r c s � fdd�}t � |�S )z= Decorate a function and preserve the original name. c r r r r r r r r & r z$goodDecorator.<locals>.nameCollisionr r r r r � goodDecorator! s r c @ sD e Zd Zdd� Zee�Zdd� Zee�Zdd� Zee�Zdd� Z d S ) �DecorationTestc C � dS )z� This test method is decorated in a way that gives it a confusing name that collides with another method. Nr r r r r �test_badDecorator- � z DecorationTest.test_badDecoratorc C r! )zQ This test method is decorated in a way that preserves its name. Nr r r r r �test_goodDecorator5 r# z!DecorationTest.test_goodDecoratorc C r! )z~ This is secretly a test method and will be decorated and then renamed so test discovery can find it. Nr r r r r �renamedDecorator< r# z DecorationTest.renamedDecoratorc C r! )zJ This isn't a test, it's just here to collide with tests. Nr r r r r r D r# z DecorationTest.nameCollisionN) r r r r" r r$ r r% �test_renamedDecoratorr r r r r r , s r c @ r )� PyunitTestc C r r r r r r r r K r zPyunitTest.test_fooc C r r r r r r r r N r zPyunitTest.test_barNr r r r r r' J r r' c @ s e Zd Zdd� ZdS )�NotATestc C r r r r r r r r S r zNotATest.test_fooN)r r r r r r r r r( R s r( c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )� AlphabetTestc C r r r r r r r �test_aX r zAlphabetTest.test_ac C r r r r r r r �test_b[ r zAlphabetTest.test_bc C r r r r r r r �test_c^ r zAlphabetTest.test_cN)r r r r* r+ r, r r r r r) W s r) )�__doc__r �pyunit�twisted.python.utilr � twisted.trial�SynchronousTestCaser r r r �TestCaser' r( r) r r r r �<module> s PK b�Z�_:]! ]! . test/__pycache__/test_deferred.cpython-310.pycnu �[��� o �bv" � @ s� d Z ddlZddlmZ ddlmZmZmZ ddlm Z G dd� dej �Z G dd � d ej �Z G d d � d ej �Z G d d � d e �ZG dd� de �Z[ dS )z0 Tests for returning Deferreds from a TestCase. � N)�defer)�reporter�unittest�util)�detestsc @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd S )� SetUpTestsc C �" t �� }t�� }|�|�}||fS �N��pyunit� TestLoaderr � TestResult�loadTestsFromTestCase��self�klass�loader�r�s� r �B/usr/lib/python3/dist-packages/twisted/trial/test/test_deferred.py� _loadSuite � zSetUpTests._loadSuitec C s8 | � tj�\}}||� | �|�� � | �|jd� d S )N� )r r �DeferredSetUpOK� assertTrue� wasSuccessful� assertEqual�testsRun�r �result�suiter r r � test_success s zSetUpTests.test_successc C �x | � tjj� | �tj�\}}||� | � |�� � | �|jd� | �t|j �d� | �t|j �d� | � tjj� d S �Nr r ) � assertFalser �DeferredSetUpFail� testCalledr r r r �len�failures�errorsr r r r � test_fail � zSetUpTests.test_failc C r# r$ ) r% r �DeferredSetUpCallbackFailr' r r r r r( r) r* r r r r �test_callbackFail' r, z SetUpTests.test_callbackFailc C r# r$ ) r% r �DeferredSetUpErrorr' r r r r r( r) r* r r r r � test_error1 r, zSetUpTests.test_errorc C s� | � tjj� | �tj�\}}||� | �|�� � | �|jd� | �t |j �d� | �t |j �d� | �t |j �d� | � tjj� d S r$ ) r% r �DeferredSetUpSkipr' r r r r r r( r) r* �skipsr r r r � test_skip; s zSetUpTests.test_skipN) �__name__� __module__� __qualname__r r" r+ r. r0 r3 r r r r r s r c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �NeverFireTestsc C s t j| _dt _d S )Ng�������?)r �DEFAULT_TIMEOUT_DURATION� _oldTimeout�r r r r �setUpH s zNeverFireTests.setUpc C s | j t_d S r )r9 r r8 r: r r r �tearDownL s zNeverFireTests.tearDownc C r r r r r r r r O r zNeverFireTests._loadSuitec C s� | � tjj� | �tj�\}}||� | � |�� � | �|jd� | �t|j �d� | �t|j �d� | � tjj� | � |j d d � t j�� d S r$ )r% r �DeferredSetUpNeverFirer' r r r r r( r) r* r �checkr � TimeoutErrorr r r r � test_setUpU s zNeverFireTests.test_setUpN)r4 r5 r6 r; r< r r@ r r r r r7 G s r7 c @ s e Zd Zdd� Zdd� ZdS )� TestTesterc C s t d��)Nzmust override me)�NotImplementedError�r �namer r r �getTestb s zTestTester.getTestc C s t �� }| �|��|� |S r )r r rE �run)r rD r r r r �runTeste s zTestTester.runTestN)r4 r5 r6 rE rG r r r r rA a s rA c @ sl e Zd Zdd� Zdd� Zdd� Zejdd�ge_d d � Z d d � Z d d� Z dd� Z dd� Z dd� Zdd� ZdS )� DeferredTestsc C � t �|�S r )r rH rC r r r rE l � zDeferredTests.getTestc C �* | � d�}| �|�� � | �|jd� d S �N� test_passr �rG r r r r �r r r r r rM o � zDeferredTests.test_passc C s8 | � d�}| �|�� � | �|jd� | �tjj� d S )N�test_passGeneratedr �rG r r r r r rH �touchedrO r r r rQ t � z DeferredTests.test_passGeneratedz6twisted.internet.defer.deferredGenerator is deprecated)�messagec C s8 | � d�}| �|�� � | �|jd� | �tjj� dS )zQ The body of a L{defer.inlineCallbacks} decorated test gets run. �test_passInlineCallbacksr NrR rO r r r rV ~ s z&DeferredTests.test_passInlineCallbacksc C �< | � d�}| �|�� � | �|jd� | �t|j�d� d S )Nr+ r �rG r% r r r r( r) rO r r r r+ � � zDeferredTests.test_failc C rW )N�test_failureInCallbackr rX rO r r r rZ � rY z$DeferredTests.test_failureInCallbackc C rW )N�test_errorInCallbackr )rG r% r r r r( r* rO r r r r[ � rY z"DeferredTests.test_errorInCallbackc C sJ | � d�}| �|�� � | �|jd� | �t|j�d� | �tj j � d S �Nr3 r ) rG r r r r r( r2 r% r rH rS rO r r r r3 � s zDeferredTests.test_skipc C s` | � d�}| �|�� � | �|jd� | �t|j�d� | �t|j�d� | �t|j�d� d S �N�test_expectedFailurer r ) rG r r r r r( r* r) �expectedFailuresrO r r r � test_todo� s zDeferredTests.test_todoc C s. | � d�}| �|jd� | �|�� |j� d S )N� test_threadr )rG r r r r r* rO r r r ra � s zDeferredTests.test_threadN)r4 r5 r6 rE rM rQ r �suppress�supressrV r+ rZ r[ r3 r` ra r r r r rH k s � rH c @ sd e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dS )� TimeoutTestsc C rI r )r rd rC r r r rE � rJ zTimeoutTests.getTestc C s | � |�tj�tj� d S r )r r> r r? )r �errorr r r � _wasTimeout� s zTimeoutTests._wasTimeoutc C rK rL rN rO r r r rM � rP zTimeoutTests.test_passc C rK )N�test_passDefaultr rN rO r r r rg � rP z TimeoutTests.test_passDefaultc C �P | � d�}| �|�� � | �|jd� | �t|j�d� | �|jd d � d S )N� test_timeoutr r �rG r% r r r r( r* rf rO r r r ri � � zTimeoutTests.test_timeoutc C rh )N�test_timeoutZeror r rj rO r r r rl � rk z TimeoutTests.test_timeoutZeroc C rW r\ )rG r r r r r( r2 rO r r r r3 � rY zTimeoutTests.test_skipc C rh r] )rG r r r r r( r_ rf rO r r r r` � rk zTimeoutTests.test_todoc C s8 | � d�}| �|�� � | �|jd� | �tjj� d S )N�test_errorPropagationr ) rG r% r r r rf r rd �timedOutrO r r r rm � rT z"TimeoutTests.test_errorPropagationc C sP t �� }|�tj�}t�� }|�|� | �t |j �d� | � |j d d � d S r$ ) r r r r �TestClassTimeoutAttributer r rF r r( r* rf )r r r! r r r r �test_classTimeout� s z TimeoutTests.test_classTimeoutc C sZ ddl m} |�d|j�}| �d�}|�� r|�� | �|�� � | � |j d d � d S )Nr )�reactor� �test_calledButNeverCallbackr ) �twisted.internetrq � callLater�crashrG �active�cancelr% r rf r* )r rq �callr r r r �&test_callbackReturnsNonCallingDeferred� s z3TimeoutTests.test_callbackReturnsNonCallingDeferredN)r4 r5 r6 rE rf rM rg ri rl r3 r` rm rp rz r r r r rd � s rd )�__doc__r r rt r � twisted.trialr r �twisted.trial.testr �TestCaser r7 rA rH rd r r r r �<module> s 7 CHPK b�Zr;)�� � ) test/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dS )z2 Unit tests for the Trial unit-testing framework. N)�__doc__� r r �=/usr/lib/python3/dist-packages/twisted/trial/test/__init__.py�<module> s PK b�Z^��� � . test/__pycache__/test_keyboard.cpython-310.pycnu �[��� o �b� � @ sj d Z ddlmZ ddlmZmZmZ G dd� dej�ZG dd� de�Z G dd � d e�Z G d d � d e�Z d S ) z. Tests for interrupting tests with Control-C. � )�StringIO)�reporter�runner�unittestc @ s e Zd Zdd� ZdS )� TrialTestc C s t � | _t�� | _t�� | _d S �N)r �outputr � TestResultr � TestLoader�loader��self� r �B/usr/lib/python3/dist-packages/twisted/trial/test/test_keyboard.py�setUp s zTrialTest.setUpN)�__name__� __module__� __qualname__r r r r r r s r c s> e Zd ZG dd� dej�Z� fdd�Zdd� Zdd� Z� Z S ) �InterruptInTestTestsc @ �$ e Zd Zdd� Zdd� Zdd� ZdS )z$InterruptInTestTests.InterruptedTestc C s t �r )�KeyboardInterruptr r r r �test_02_raiseInterrupt � z;InterruptInTestTests.InterruptedTest.test_02_raiseInterruptc C s d S r r r r r r �test_01_doNothing r z6InterruptInTestTests.InterruptedTest.test_01_doNothingc C s dt _d S )NT)r �test_03_doNothing_runr r r r �test_03_doNothing s z6InterruptInTestTests.InterruptedTest.test_03_doNothingN)r r r r r r r r r r �InterruptedTest s r c s$ t � �� | j�tj�| _d t_d S r )�superr r � loadClassr r �suiter r �� __class__r r r s zInterruptInTestTests.setUpc C s4 | � d| j�� � | � d| jj� | �| jj� d S )N� r )� assertEqualr �countTestCasesr �testsRun� assertFalse� shouldStopr r r r � test_setUpOK% s z!InterruptInTestTests.test_setUpOKc C �F t �| jg��| j� | �| jj� | �d| jj� | � t j d� d S )N� ztest_03_doNothing ran.) r � TrialSuiter �runr � assertTruer' r# r% r& r r r r r r �test_interruptInTest* s �z)InterruptInTestTests.test_interruptInTest) r r r r �TestCaser r r( r. � __classcell__r r r r r s r c �B e Zd ZdZG dd� dej�Z� fdd�Zdd� Zdd � Z � Z S ) �InterruptInSetUpTestsr c @ r )z%InterruptInSetUpTests.InterruptedTestc C � t jdkrt�d S �Nr )r2 r% r r r r r r 7 � �z+InterruptInSetUpTests.InterruptedTest.setUpc C � t jd7 _d S �N� )r2 r% r r r r �test_01; � z-InterruptInSetUpTests.InterruptedTest.test_01c C � t jd7 _dt _d S �Nr8 T)r2 r% � test_02_runr r r r �test_02> � z-InterruptInSetUpTests.InterruptedTest.test_02N)r r r r r9 r> r r r r r 6 � r c �* t � �� | j�tj�| _dt_dt_d S )NFr ) r r r r r2 r r r= r% r r r r r B � zInterruptInSetUpTests.setUpc C �B | � dtj� | � d| j�� � | � d| jj� | �| jj� d S �Nr r* )r# r2 r% r r$ r r& r' r r r r r( H � z"InterruptInSetUpTests.test_setUpOKc C r) )Nr* � test_02 ran) r r+ r r, r r- r' r# r% r& r2 r= r r r r �test_interruptInSetUpN s z+InterruptInSetUpTests.test_interruptInSetUp) r r r r% r r/ r r r( rG r0 r r r r r2 3 � r2 c r1 ) �InterruptInTearDownTestsr c @ r )z(InterruptInTearDownTests.InterruptedTestc C r3 r4 )rI r% r r r r r �tearDownY r5 z1InterruptInTearDownTests.InterruptedTest.tearDownc C r6 r7 )rI r% r r r r r9 ] r: z0InterruptInTearDownTests.InterruptedTest.test_01c C r; r< )rI r% r= r r r r r> ` r? z0InterruptInTearDownTests.InterruptedTest.test_02N)r r r rJ r9 r> r r r r r X r@ r c rA )Nr F) r r r r rI r r r% r= r r r r r d rB z InterruptInTearDownTests.setUpc C rC rD )r# rI r% r r$ r r& r' r r r r r( j rE z%InterruptInTearDownTests.test_setUpOKc C sF t �| jg��| j� | �d| jj� | �| jj� | � t j d� d S )Nr8 rF ) r r+ r r, r r# r% r- r' r& rI r= r r r r �test_interruptInTearDownp s z1InterruptInTearDownTests.test_interruptInTearDown) r r r r% r r/ r r r( rK r0 r r r r rI U rH rI N) �__doc__�ior � twisted.trialr r r �SynchronousTestCaser r r2 rI r r r r �<module> s "PK b�Z C��� � & test/__pycache__/weird.cpython-310.pycnu �[��� o �b� � @ s* d dl Z d dlmZ G dd� de j�ZdS )� N)�deferc @ s e Zd ZdZdd� ZdS )� TestBleedinga' This test creates an unhandled Deferred and leaves it in a cycle. The Deferred is left in a cycle so that the garbage collector won't pick it up immediately. We were having some problems where unhandled Deferreds in one test were failing random other tests. (See #1507, #1213) c C s< zdd W n t y t�� }Y nw |g}|�|� d S )N� r )�ZeroDivisionErrorr �fail�append)�self�f�l� r �:/usr/lib/python3/dist-packages/twisted/trial/test/weird.py�test_unhandledDeferred s �z#TestBleeding.test_unhandledDeferredN)�__name__� __module__� __qualname__�__doc__r r r r r r s r )�unittest�twisted.internetr �TestCaser r r r r �<module> s PK b�Z�[� (� (� . test/__pycache__/test_reporter.cpython-310.pycnu �[��� o �b�� � @ s� d Z ddlZddlZddlZddlZddlmZ ddlmZm Z ddl m Z ddl m ZmZ ddlmZmZ ddlmZ dd lmZ dd lmZmZmZm Z mZ dd l m Z m Z dd l m Z m!Z! dd l"m#Z#m$Z$m%Z% G dd� d�Z&G dd� de j'�Z(G dd� de j'�Z)G dd� de)�Z*G dd� de(�Z+G dd� de+�Z,G dd� de j'�Z-G d d � d e(�Z.G d d � d e j'�Z/G d d!� d!e j'�Z0G d"d#� d#e j'�Z1G d$d%� d%e j'�Z2G d&d'� d'e2�Z3G d(d)� d)e j'�Z4G d*d+� d+e4�Z5G d,d-� d-�Z6G d.d/� d/e j'�Z7G d0d1� d1e j'�Z8G d2d3� d3e8�Z9G d4d5� d5e j'�Z:G d6d7� d7e8�Z;G d8d9� d9e j'�Z<G d:d;� d;e9�Z=G d<d=� d=ej>�Z?G d>d?� d?e j'�Z@G d@dA� dA�ZAG dBdC� dCe j'�ZBG dDdE� dEe j'�ZCdS )Fz& Tests for L{twisted.trial.reporter}. � N)�getmro)�BytesIO�StringIO)�Type)�TestCase�expectedFailure)�log�reflect)�Failure)�qual)�itrial�reporter�runner�unittest�util)� UncleanWarningsReporterWrapper� _ExitWrapper)� erroneous�sample)�SkipTest�Todo�makeTodoc @ s0 e Zd ZdZdZdZdd� Zdd� Zdd� Zd S ) � BrokenStreamz� Stream-ish object that raises a signal interrupt error. We use this to make sure that Trial still manages to write what it needs to write. Fc C � || _ d S �N)�fObj)�selfr � r �B/usr/lib/python3/dist-packages/twisted/trial/test/test_reporter.py�__init__% � zBrokenStream.__init__c C s$ | j r | j�|�S d| _ ttjd��)NTzInterrupted write)�writtenr �write�OSError�errno�EINTR)r �sr r r r" ( s zBrokenStream.writec C s" | j r| j�� S d| _ ttjd��)NTzInterrupted flush)�flushedr �flushr# r$ r% �r r r r r( . s zBrokenStream.flushN) �__name__� __module__� __qualname__�__doc__r! r' r r" r( r r r r r s r c @ � e Zd Zdd� ZdS )� StringTestc C s� t td |��}| �t|�t|�kdt|�t|�f � tt�d��}tt||��D ]8\}\}}|d u r4q)t |t �rF| � ||d|||f � q)t ||�r[| �|� |�d||j |f � q)td|����d S )Nz2Must have more observed than expectedlines %d < %d� zLine %d: %r not in %rz#Line %d: %r did not match string %rz"don't know what to do with object )�list�filter� assertTrue�len�type�re�compile� enumerate�zip� isinstance�str�assertSubstring�match�pattern� TypeError)r �expect�output�REGEX_PATTERN_TYPE� line_number�exp�outr r r �stringComparison6 s0 �� � ���zStringTest.stringComparisonN)r* r+ r, rF r r r r r/ 5 � r/ c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�TestResultTestsc C s t �� | _d S r )r � TestResult�resultr) r r r �setUpP � zTestResultTests.setUpc C st zt d�� t y! } z|}| j�| t�� � W Y d }~nd }~ww | jjd d }| �||j� | �t |j� d S �N�foor � ) � RuntimeErrorrJ �addError�sys�exc_info�errors� assertEqual�valuer5 �r �e�excValue�failurer r r �test_pyunitAddErrorS s ��z#TestResultTests.test_pyunitAddErrorc C sz z| � d�� | j y# } z|}| j�| t�� � W Y d }~nd }~ww | jjd d }| �||j� | �| j |j� d S rM ) �failureExceptionrJ � addFailurerR rS �failuresrU rV r5 rW r r r �test_pyunitAddFailure^ s ��z%TestResultTests.test_pyunitAddFailureN)r* r+ r, rK r[ r_ r r r r rH O s rH c @ r. )�ReporterRealtimeTestsc C s t � }tj|dd�| _d S )NT)�realtime)r r �ReporterrJ �r rA r r r rK k s zReporterRealtimeTests.setUpN)r* r+ r, rK r r r r r` j rG r` c @ sN e Zd Ze�d�Zdd� Zdd� Zdd� Zdd � Z d d � Z d d � Z dd� Z dS )�ErrorReportingTestsz^=+$c C s$ t �� | _t� | _t�| j�| _d S r )r � TestLoader�loaderr rA r rb rJ r) r r r rK s s zErrorReportingTests.setUpc C s | � |�}|�� | j�� S r )� getResult�donerA �getvalue)r �suiterJ r r r � getOutputx s z ErrorReportingTests.getOutputc C s |� | j� | jS r )�runrJ )r rj r r r rg } s z ErrorReportingTests.getResultc C s` t j}| j�|�}| �|��� }| jddt�d�t�d�d|j � d|j � d�g}| � ||� dS ) z� A test method which runs and has an error recorded against it is reported in the output stream with the I{ERROR} tag along with a summary of what error was reported and the ID of the test. �[ERROR]�"Traceback (most recent call last):z.^\s+File .*erroneous\.py., line \d+, in setUp$z5^\s+raise FoolishError..I am a broken setUp method..$zEtwisted.trial.test.erroneous.FoolishError: I am a broken setUp method�.z .test_noopN) r � SynchronousTestFailureInSetUprf � loadClassrk � splitlines�doubleSeparatorr6 r7 r+ r* rF )r �clsrj rA r= r r r �test_formatErroredMethod� s � z,ErrorReportingTests.test_formatErroredMethodc C sJ | j �d�}| �|��� }| jddt�d�t�d�ddg}| �||� dS )z� A test method which runs and has a failure recorded against it is reported in the output stream with the I{FAIL} tag along with a summary of what failure was reported and the ID of the test. z6twisted.trial.test.erroneous.TestRegularFail.test_fail�[FAIL]rn z2^\s+File .*erroneous\.py., line \d+, in test_fail$z^\s+self\.fail\("I fail"\)$z'twisted.trial.unittest.FailTest: I failN)rf � loadByNamerk rr rs r6 r7 rF )r rj rA r= r r r �test_formatFailedMethod� s �� z+ErrorReportingTests.test_formatFailedMethodc C s� ddl m} t�| j�|�tj�}| �|�}d}ddd|fD ]}| � ||� q | � t � d|�d� | j t �d �g}| �||�� � d S ) z� A problem encountered while running a doctest is reported in the output stream with a I{FAIL} or I{ERROR} tag along with a summary of what problem was encountered and the ID of the test. r )r z0twisted.trial.test.erroneous.unexpectedExceptionz1/0�ZeroDivisionErrorzException raised:zFail(ed|ure in) example:z;Couldn't match 'Failure in example: ' or 'Failed example: 'z\[(ERROR|FAIL)\]N)�twisted.trial.testr r �decoraterf � loadDoctestsr � ITestCaserk r< r3 r6 �searchrs r7 rF rr )r r rj rA �path� substringr@ r r r �test_doctestError� s �z%ErrorReportingTests.test_doctestErrorc C s� ddl m} t�|��d�r| �d��t�d�}| �|�� � }tt �}| j ddt � d�t � d �d d | j d dt � d �t � d�t � d�t � d�|d d g}| �||� dS )a- Check that errors in C{DelayedCall}s get reported, even if the test already has a failure. Only really necessary for testing the deprecated style of tests that use iterate() directly. See L{erroneous.DelayedCall.testHiddenException} for more details. r )�reactorz twisted.internet.asyncioreactorzhThis test does not work on the asyncio reactor, as the traceback comes from inside asyncio, not Twisted.�testHiddenExceptionrv rn z<^\s+File .*erroneous\.py., line \d+, in testHiddenException$zD^\s+self\.fail\("Deliberate failure to mask the hidden exception"\)$zPtwisted.trial.unittest.FailTest: Deliberate failure to mask the hidden exceptionz<twisted.trial.test.erroneous.DelayedCall.testHiddenExceptionrm z ^\s+File .* in runUntilCurrentz^\s+.*z*^\s+File .*erroneous\.py", line \d+, in goz1^\s+raise RuntimeError\(self.hiddenExceptionMsg\)z: something blew upN)�twisted.internetr� r r � startswith�skipTestr � DelayedCallrk rr rP rs r6 r7 rF )r r� �testrA � errorQualr= r r r �test_hiddenException� s< � ���z(ErrorReportingTests.test_hiddenExceptionN) r* r+ r, r6 r7 rs rK rk rg ru rx r� r� r r r r rd p s rd c @ � e Zd ZdZdd� ZdS )�(UncleanWarningWrapperErrorReportingTestsz� Tests that the L{UncleanWarningsReporterWrapper} can sufficiently proxy IReporter failure and error reporting methods to a L{reporter.Reporter}. c C s( t �� | _t� | _tt�| j��| _d S r ) r re rf r rA r r rb rJ r) r r r rK � s z.UncleanWarningWrapperErrorReportingTests.setUpN)r* r+ r, r- rK r r r r r� � s r� c @ sL e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dS )�TracebackHandlingTestsc C s^ t � }t�|�}|�|� |j|j }| �t|�d� | �|d d |� |�|d d j �S )z� Run the given C{test}, make sure it fails and return the trimmed frames. @param test: The test case to run. @return: The C{list} of frames trimmed. rO r ) r r rb rl r^ rT rU r4 � _trimFrames�frames)r r� �streamrJ �badsr r r �getErrorFrames� s z%TracebackHandlingTests.getErrorFramesc C s� t ||�D ]0\}}| �|d |d � tj�|d �d �tj�}|d �d�}| �|t|� d � |� q| �t|�t|�� d S )Nr rO �/)r9 rU �osr �splitext�split�sepr4 )r �observedFrames�expectedFrames�observed�expected� observedSegs� expectedSegsr r r � checkFrames s z"TracebackHandlingTests.checkFramesc C s& t �d�}| �|�}| �|dg� d S )N� test_fail)r� � twisted/trial/test/erroneous�r �TestRegularFailr� r� �r r� r� r r r � test_basic s z!TracebackHandlingTests.test_basicc C s( t �d�}| �|�}| �|ddg� d S )N� test_subfail)r� r� )� subroutiner� r� r� r r r �test_subroutine s ��z&TracebackHandlingTests.test_subroutinec C �& t �d�}| �|�}| �|dg� dS )z� C{_trimFrames} removes traces of C{_runCallbacks} when getting an error in a callback returned by a C{TestCase} based test. r� )�_laterr� N�r �TestAsynchronousFailr� r� r� r r r � test_deferred& s z$TracebackHandlingTests.test_deferredc C s t �d �}| �g |�g �� d S r �r rb rU r� �r rJ r r r � test_noFrames/ s z$TracebackHandlingTests.test_noFramesc C s$ t �d �}| �dg|�dg�� d S )Nz fake framer� r� r r r � test_oneFrame3 s z$TracebackHandlingTests.test_oneFramec C r� )z� C{_trimFrames} removes traces of C{runWithWarningsSuppressed} from C{utils} when a synchronous exception happens in a C{TestCase} based test. �test_exception)r� r� Nr� r� r r r r� 7 s z%TracebackHandlingTests.test_exceptionN) r* r+ r, r� r� r� r� r� r� r� r� r r r r r� � s r� c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �FormatFailuresTestsc C sf zt d�� t y t� | _Y nw ddddgdggddddgd ggg| j_t� | _t�| j�| _d S ) NrN z foo/bar.py� )�xr� )�y�orange�qux� )�a�two)�b�MCMXCIX) rP r �fr� r r� r rb rJ r) r r r rK C s ��zFormatFailuresTests.setUpc C s: | j �| j�}| �ddt�d�dt�d�dg|�� � d S )Nrn z# File "foo/bar.py", line 5, in fooz^\s*$z$ File "foo/bar.py", line 10, in quxzRuntimeError: foo)rJ �_formatFailureTracebackr� rF r6 r7 rr )r �tbr r r �test_formatDefaultO s ��z&FormatFailuresTests.test_formatDefaultc C s$ d}d}| j �|�}| �||� d S )Nz� File "twisted/trial/unittest.py", line 256, in failUnlessSubstring return self.failUnlessIn(substring, astring, msg) exceptions.TypeError: iterable argument required z� File "twisted/trial/unittest.py", line 256, in failUnlessSubstring return self.failUnlessIn(substring, astring, msg) exceptions.TypeError: iterable argument required )rJ r� rU )r r� r� � formattedr r r �test_formatString] s z%FormatFailuresTests.test_formatStringc C s2 | j jd d � }| j�| j � | �| j j|� d S r )r� r� rJ r� rU )r r� r r r � test_mutationl s z!FormatFailuresTests.test_mutationN)r* r+ r, rK r� r� r� r r r r r� B s r� c @ �D e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dS )�PyunitNamesTestsc C � t � | _t�d�| _d S �N�test_foo)r r� r � PyunitTestr� r) r r r rK t � zPyunitNamesTests.setUpc C s2 t �| j�}|�| j� | j�� }| �|d� d S )Nz2twisted.trial.test.sample.PyunitTest.test_foo ... )r �VerboseTextReporterr� � startTestr� ri rU �r rJ rA r r r �test_verboseReporterx s z%PyunitNamesTests.test_verboseReporterc C �N t �| j�}|�| j� | j�� }|�� d �� }| �||� | j�d � d S �N���z ...� r � TreeReporterr� r� r� ri rr �striprU �getDescriptionr� r r r �test_treeReporter~ � z"PyunitNamesTests.test_treeReporterc C �( t �| j�}|�| j�}| �|d� d S r� �r r� r� r� r� rU r� r r r �test_getDescription� � z$PyunitNamesTests.test_getDescriptionc C sP t �| j�}| j�|� |�� | j�� �� �d�}| � |dd� g d�� dS )a� The summary of L{reporter.MinimalReporter} is a simple list of numbers, indicating how many tests ran, how many failed etc. The numbers represents: * the run time of the tests * the number of tests run, printed 2 times for legacy reasons * the number of errors * the number of failures * the number of skips � rO N)�1r� �0r� r� ) r �MinimalReporterr� r� rl � _printSummaryri r� r� rU r� r r r �test_minimalReporter� s z%PyunitNamesTests.test_minimalReporterc sb g d�� t �| j�}� fdd�|_| j�|� |�� | j�� �� � d�}|d }| � |d� dS )zt L{reporter.MinimalReporter} reports the time to run the tests as first data in its output. )g �?g333333�?g �?gffffff�?c s � � d�S �Nr )�popr ��timesr r �<lambda>� s z;PyunitNamesTests.test_minimalReporterTime.<locals>.<lambda>r� r z0.7N) r r� r� �_getTimer� rl r� ri r� r� rU )r rJ rA �timerr r� r �test_minimalReporterTime� s z)PyunitNamesTests.test_minimalReporterTimec C s< t �| j�}|�� | j�� �� �d�}| �|g d�� dS )zv The summary of L{reporter.MinimalReporter} is a list of zeroes when no test is actually run. r� )r� r� r� r� r� r� N)r r� r� r� ri r� r� rU r� r r r �test_emptyMinimalReporter� s z*PyunitNamesTests.test_emptyMinimalReporterN) r* r+ r, rK r� r� r� r� r� r� r r r r r� s s r� c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �DirtyReactorTestsz� The trial script has an option to treat L{DirtyReactorAggregateError}s as warnings, as a migration tool for test authors. It causes a wrapper to be placed around reporters that replaces L{DirtyReactorAggregatErrors} with warnings. c C s, t t�dgdg��| _t� | _td�| _d S )NrN �bar�test_errorByDefault)r r �DirtyReactorAggregateError� dirtyErrorr rA r� r� r) r r r rK � s zDirtyReactorTests.setUpc C sL t j| jd�}|�| j| j� | �t|j�d� | �|jd d | j� dS )zj L{DirtyReactorAggregateError}s are reported as errors with the default Reporter. �r� rO r N) r rb rA rQ r� r� rU r4 rT r� r r r r� � s z%DirtyReactorTests.test_errorByDefaultc C s8 t tj| jd��}| �t| j�� tj|j | j | j� dS )z� L{DirtyReactorAggregateError}s are reported as warnings when using the L{UncleanWarningsReporterWrapper}. r� N) r r rb rA � assertWarns� UserWarningr� �getErrorMessage�__file__rQ r� r� r r r �test_warningsEnabled� s �z&DirtyReactorTests.test_warningsEnabledc C sH t tj| jd��}| �t| j�� tj|j | j | j� | � |j j g � dS )z� L{DirtyReactorAggregateError}s are I{not} reported as errors if the L{UncleanWarningsReporterWrapper} is used. r� N)r r rb rA r� r� r� r� r� rQ r� rU �_originalReporterrT r� r r r �test_warningsMaskErrors� s �z)DirtyReactorTests.test_warningsMaskErrorsc C s� t tj| jd��}|�| j| jj| jjdf� | � t |j j �d� | � |j j d d j| jj� | � |j j d d j| jj� dS )a� Some annoying stuff can pass three-tuples to addError instead of Failures (like PyUnit). The wrapper, of course, handles this case, since it is a part of L{twisted.trial.itrial.IReporter}! But it does not convert L{DirtyReactorAggregateError} to warnings in this case, because nobody should be passing those in the form of three-tuples. r� NrO r ) r r rb rA rQ r� r� r5 rV rU r4 r� rT r� r r r �test_dealsWithThreeTuples� s ��z+DirtyReactorTests.test_dealsWithThreeTuplesN) r* r+ r, r- rK r� r� r� r� r r r r r� � s r� c @ s4 e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd S ) �TrialNamesTestsc C r� r� )r r� r �FooTestr� r) r r r rK � r� zTrialNamesTests.setUpc C s< t �| j�}|�| j� | j�� }| �|| j�� d � d S )Nz ... )r r� r� r� r� ri rU �idr� r r r r� s z$TrialNamesTests.test_verboseReporterc C r� r� r� r� r r r r� r� z!TrialNamesTests.test_treeReporterc C s" t �| j�}| �|�| �d� dS )z A docstring� test_treeReporterWithDocstringsN)r r� r� rU r� r� r r r r� s z/TrialNamesTests.test_treeReporterWithDocstringsc C r� r� r� r� r r r r� r� z#TrialNamesTests.test_getDescriptionN)r* r+ r, rK r� r� r� r� r r r r r� � s r� c @ �P e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )� SkipTestsz= Tests for L{reporter.Reporter}'s handling of skips. c C �& t � | _t�| j�| _t�d�| _d S r� �r r� r rb rJ r r� r� r) r r r rK � zSkipTests.setUpc C s t |j�S )zF Get the number of skips that happened to a reporter. )r4 �skipsr� r r r � _getSkips% s zSkipTests._getSkipsc C s( | j �| jd� | �| �| j �d� d S )N� some reasonrO )rJ �addSkipr� rU r r) r r r �test_accumulation+ s zSkipTests.test_accumulationc C s& | j �| jd� | �d| j �� � d S )Nr T)rJ r r� rU � wasSuccessfulr) r r r � test_success/ s zSkipTests.test_successc C s` | j �| jd� | j �� | j�� �� d }d}| �|�|�� | � |t |�d� � � d� dS )z� The summary of a successful run with skips indicates that the test suite passed and includes the number of skips. r r� �PASSED Nz (skips=1)) rJ r r� rh r� ri rr r3 r� rU r4 r� �r rA �prefixr r r � test_summary3 s zSkipTests.test_summaryc C s@ | j �| jd� | j �� | j�� �� d }| �|�� d� dS )zw The output at the end of a test run with skips includes the reasons for skipping those tests. r � N) rJ r r� rh r� ri rr rU r� rc r r r �test_basicErrors? s zSkipTests.test_basicErrorsc C s< | j �| jd� | j �� | j�� �� d }| �|d� dS )z� Tests can be skipped without specifying a reason by setting the 'skip' attribute to True. When this happens, the test output includes 'True' as the reason. Tr �TrueN)rJ r r� rh r� ri rr rU rc r r r �test_booleanSkipI s zSkipTests.test_booleanSkipc C s� zdd W n t y } z|}W Y d}~nd}~ww | j�| j|� | j�� d�| j�� �� dd� �� � }| � |t |�� dS )z� Skips can be raised as errors. When this happens, the error is included in the summary at the end of the test suite. rO r N� r r� ) � ExceptionrJ r r� rh �joinr� ri rr r� rU r; �r rX �errorrA r r r �test_exceptionSkipT s �� z SkipTests.test_exceptionSkipN) r* r+ r, r- rK r r r r r r r r r r r r� s r� c @ � e Zd ZdZdd� Zdd� ZdS )�UncleanWarningSkipTestszh Tests for skips on a L{reporter.Reporter} wrapped by an L{UncleanWarningsReporterWrapper}. c C � t �| � t| j�| _d S r )r� rK r rJ r) r r r rK i � z UncleanWarningSkipTests.setUpc C s t |jj�S )z} Get the number of skips that happened to a reporter inside of an unclean warnings reporter wrapper. )r4 r� r r� r r r r m s z!UncleanWarningSkipTests._getSkipsN)r* r+ r, r- rK r r r r r r c s r c @ � 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 S ) � TodoTestsz= Tests for L{reporter.Reporter}'s handling of todos. c C r� r� r r) r r r rK z r zTodoTests.setUpc C � |j S )zH Get the expected failures that happened to a reporter. )�expectedFailuresr� r r r � _getTodos � zTodoTests._getTodosc C r )zK Get the unexpected successes that happened to a reporter. )�unexpectedSuccessesr� r r r �_getUnexpectedSuccesses� r z!TodoTests._getUnexpectedSuccessesc C s8 | j �| jtt� �td�� | �t| �| j ��d� dS )zh L{reporter.Reporter} accumulates the expected failures that it is notified of. �todo!rO N) rJ �addExpectedFailurer� r r r rU r4 r r) r r r r � s � zTodoTests.test_accumulationc C sd t t� �}| j�| j|� | �| j�\\}}}| �|| j� | �||� | �t|�ttd��� dS )z� If no C{Todo} is provided to C{addExpectedFailure}, then L{reporter.Reporter} makes up a sensible default. This allows standard Python unittests to use Twisted reporters. �Test expected to failN) r r rJ r$ r� r rU �reprr )r rZ r� r �todor r r �test_noTodoProvided� s z TodoTests.test_noTodoProvidedc C s2 | j �| jtt� �td�� | �d| j �� � dS )zU A test run is still successful even if there are expected failures. r# TN)rJ r$ r� r r r rU r r) r r r r � s �zTodoTests.test_successc C sB | j �| jtd�� | �d| j �� � | �t| �| j ��d� dS )z� A test which is marked as todo but succeeds will have an unexpected success reported to its result. A test run is still successful even when this happens. zHeya!TrO N)rJ �addUnexpectedSuccessr� r rU r r4 r" r) r r r �test_unexpectedSuccess� s z TodoTests.test_unexpectedSuccessc C sJ | j �| j� | �| j �\\}}| �|| j� | �t|�ttd��� dS )aL A test which is marked as todo but succeeds will have an unexpected success reported to its result. A test run is still successful even when this happens. If no C{Todo} is provided, then we make up a sensible default. This allows standard Python unittests to use Twisted reporters. r% N)rJ r) r� r" rU r& r �r r� r' r r r � test_unexpectedSuccessNoTodo� s z&TodoTests.test_unexpectedSuccessNoTodoc C sl | j �| jtt� �td�� | j �� | j�� � � d }d}| � |� |�� | � |t |�d� �� d� dS )z{ The reporter's C{printSummary} method should print the number of expected failures that occurred. r r� r Nz(expectedFailures=1))rJ r$ r� r r r rh r� ri rr r3 r� rU r4 r� r r r r r � s � zTodoTests.test_summaryc C sL | j �| jtt� �td�� | j �� | j�� � � d � � }| � |d� dS )zd The reporter's L{printErrors} method should include the value of the Todo. r r zReason: 'some reason'N) rJ r$ r� r r r rh r� ri rr r� rU rc r r r r � s � zTodoTests.test_basicErrorsc C s, | j �| jtt� �d� | �t| j j� dS )z� Booleans CAN'T be used as the value of a todo. Maybe this sucks. This is a test for current behavior, not a requirement. TN)rJ r$ r� r r � assertRaisesrh r) r r r �test_booleanTodo� s zTodoTests.test_booleanTodoc C s� zdd W n t y } z|}W Y d}~nd}~ww | j�| jt|�td�� | j�� d�| j� � � � dd� �� � }| � t |�|v � dS )zk The exception for expected failures should be shown in the C{printErrors} output. rO r Nr# r r )r rJ r$ r� r r rh r r� ri rr r� r3 r; r r r r �test_exceptionTodo� s �� z TodoTests.test_exceptionTodoc C �@ G dd� dt �}|d�}|�| j� | �t| �| j��d� dS )�t Tests that use the standard library C{expectedFailure} feature worth with Trial reporters. c @ � e Zd Zedd� �ZdS )z@TodoTests.test_standardLibraryCompatibilityFailure.<locals>.Testc S s | � d� d S )NrZ )�failr) r r r r� � s zJTodoTests.test_standardLibraryCompatibilityFailure.<locals>.Test.test_failN)r* r+ r, r r� r r r r �Test� � r4 r� rO N)�StdlibTestCaserl rJ rU r4 r �r r4 r� r r r �(test_standardLibraryCompatibilityFailure� � z2TodoTests.test_standardLibraryCompatibilityFailurec C r0 )r1 c @ r2 )z@TodoTests.test_standardLibraryCompatibilitySuccess.<locals>.Testc S s d S r r r) r r r r s zMTodoTests.test_standardLibraryCompatibilitySuccess.<locals>.Test.test_successN)r* r+ r, r r r r r r r4 r5 r4 r rO N)r6 rl rJ rU r4 r" r7 r r r �(test_standardLibraryCompatibilitySuccess r9 z2TodoTests.test_standardLibraryCompatibilitySuccessN)r* r+ r, r- rK r r" r r( r r* r, r r r. r/ r8 r: r r r r r u s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �UncleanWarningTodoTestszJ Tests for L{UncleanWarningsReporterWrapper}'s handling of todos. c C r r )r rK r rJ r) r r r rK r z UncleanWarningTodoTests.setUpc C � |j jS )zt Get the todos that happened to a reporter inside of an unclean warnings reporter wrapper. )r� r r� r r r r � z!UncleanWarningTodoTests._getTodosc C r< )z� Get the number of unexpected successes that happened to a reporter inside of an unclean warnings reporter wrapper. )r� r! r� r r r r" # r= z/UncleanWarningTodoTests._getUnexpectedSuccessesN)r* r+ r, r- rK r r" r r r r r; s r; c @ r )� MockColorizerzR Used by TreeReporterTests to make sure that output is colored correctly. c C s g | _ d S r )r )r r� r r r r 0 r zMockColorizer.__init__c C s | j �||f� d S r )r �append)r �text�colorr r r r" 3 s zMockColorizer.writeN)r* r+ r, r- r r" r r r r r> + s r> c @ r� )�TreeReporterTestsc C s@ t �d�| _t� | _t�| j�| _t| j�| j_ | jj j | _ d S r� ) r r� r� r r� r r� rJ r> � _colorizerr r) r r r rK 8 s zTreeReporterTests.setUpc C s* zdd W |S t y t� }Y |S w )NrO r )ry r )r r� r r r � makeError? s ��zTreeReporterTests.makeErrorc C sT | j �| j� | j �� | �| jd | j jdf� | �| j�� � � d � � d� dS )zw The summary in case of success should have a good count of successes and be colored properly. rO �PASSEDr� z (successes=1)N) rJ � addSuccessr� rh rU r �SUCCESSr� ri rr r� r) r r r �test_summaryColoredSuccessF s �z,TreeReporterTests.test_summaryColoredSuccessc C st zt d�� t y | j�| t�� � Y nw | j�� | �| jd | jjdf� | �| j � � � � d � � d� dS )zt The summary in case of failure should have a good count of errors and be colored properly. rN rO �FAILEDr� z (errors=1)N) rP rJ rQ rR rS rh rU r �FAILUREr� ri rr r� r) r r r �test_summaryColoredFailureR s � "z,TreeReporterTests.test_summaryColoredFailurec C s^ | � ddg| j�d�� | � ddg| j�d�� | � dg| j�d�� | � g | j�d�� dS )z� The tree needs to get the segments of the test ID that correspond to the module and class that it belongs to. zfoo.bar�bazzfoo.bar.baz.quxrN r� z foo.bar.bazN)rU rJ �_getPreludeSegmentsr) r r r �test_getPrelude_ s �z!TreeReporterTests.test_getPreludec C s� zt d�� t y | j�| t�� � | j�| jt�� � Y nw zt d�� t y< t�d�}| j�|t�� � Y nw | j�� | j� | jj | jj �}| � |d d | | jg� | � |d d |g� dS )z� If two different tests have the same error, L{Reporter._groupResults} includes them together in one of the tuples in the list it returns. rN r� �test_barr rO N) rP rJ rQ rR rS r� r r� rh � _groupResultsrT r� rU )r �extra�groupedr r r �test_groupResultsk s$ � � �z#TreeReporterTests.test_groupResultsc C s| dd� }t �d�}t �d�}t �d�}| j�d|df|df|dfg|� | �| j�� d| jj|� � |� � |� � d � � d S ) z� L{Reporter._printResults} uses the results list and formatter callable passed to it to produce groups of results to write to its output stream. c S s t | �d S )Nr )r; )�nr r r � formatter� s z6TreeReporterTests.test_printResults.<locals>.formatterr� rO �FOOrO � zW%(double separator)s FOO 1 %(first)s %(second)s %(double separator)s FOO 2 %(third)s )zdouble separator�first�second�thirdN) r r� r� rJ � _printResultsrU r� ri �_doubleSeparatorr� )r rU rX rY rZ r r r �test_printResults� s" � ���z#TreeReporterTests.test_printResultsN) r* r+ r, rK rD rH rK rN rS r] r r r r rB 7 s rB c @ s^ e Zd ZU dZejZeej e d< dd� Z dd� Z dd� Z d d � Zd d � Zd d� Zdd� ZdS )�ReporterInterfaceTestsas Tests for the bare interface of a trial reporter. Subclass this test case and provide a different 'resultFactory' to test that a particular reporter implementation will work with the rest of Trial. @cvar resultFactory: A callable that returns a reporter to be tested. The callable must take the same parameters as L{reporter.Reporter}. � resultFactoryc C s6 t �d�| _t� | _t�� | _| j| j| jd�| _ d S )Nr� �� publisher) r r� r� r r� r � LogPublisherra r_ rJ r) r r r rK � s z ReporterInterfaceTests.setUpc C s | � d| jj� dS )z4 shouldStop is False to begin with. FN)rU rJ � shouldStopr) r r r � test_shouldStopInitiallyFalse� s z4ReporterInterfaceTests.test_shouldStopInitiallyFalsec C s | j �� | �d| j j� dS )zG shouldStop becomes True soon as someone calls stop(). TN)rJ �stoprU rc r) r r r � test_shouldStopTrueAfterStop� s z3ReporterInterfaceTests.test_shouldStopTrueAfterStopc C s | � d| j�� � dS )zS wasSuccessful() is True when there have been no results reported. TN)rU rJ r r) r r r � test_wasSuccessfulInitiallyTrue� s z6ReporterInterfaceTests.test_wasSuccessfulInitiallyTruec C s$ | j �| j� | �d| j �� � dS )zg wasSuccessful() is True when there have been only successes, False otherwise. TN)rJ rF r� rU r r) r r r �$test_wasSuccessfulTrueAfterSuccesses� s z;ReporterInterfaceTests.test_wasSuccessfulTrueAfterSuccessesc C sJ zdd W n t y | j�| jt�� � Y nw | �d| j�� � dS )zP wasSuccessful() becomes False after errors have been reported. rO r FN)ry rJ rQ r� rR rS rU r r) r r r �"test_wasSuccessfulFalseAfterErrors� s �z9ReporterInterfaceTests.test_wasSuccessfulFalseAfterErrorsc C sN z| � d� W n | jy | j�| jt�� � Y nw | �d| j�� � dS )zR wasSuccessful() becomes False after failures have been reported. rN FN) r3 r\ rJ r] r� rR rS rU r r) r r r �$test_wasSuccessfulFalseAfterFailures� s �z;ReporterInterfaceTests.test_wasSuccessfulFalseAfterFailuresN)r* r+ r, r- r rb r_ r r � IReporter�__annotations__rK rd rf rg rh ri rj r r r r r^ � s r^ c @ r� )� ReporterTestsz8 Tests for the base L{reporter.Reporter} class. c C s t �| � d| _| j| j_d S r� )r^ rK �_timerr� rJ r) r r r rK � s zReporterTests.setUpc C s | j d7 _ | j S �NrO )rn r) r r r r� � s zReporterTests._getTimec C sT | j �| j� | j �| j� | �| j jdk� | �| j jd� | �| j �� d� d S )Nr rO T) rJ r� r� �stopTestr3 � _lastTimerU �testsRunr r) r r r �test_startStop� s z ReporterTests.test_startStopc C sh | j t| j�d�}|�d� | �| j�� d� | j�d� | j�d� |�dd� | �| j�� d� dS ) zE Test that the reporter safely writes to its stream. r� �HellozHello r z Hello %s!�Worldz Hello World! N)r_ r r� �_writelnrU ri �truncate�seekr� r r r �test_brokenStream s z ReporterTests.test_brokenStreamc C sT t d�}d}d}d}| jj||||d� | �| j�� d|||�d�d |f � d S ) z� L{reporter.Reporter} observes warnings emitted by the Twisted log system and writes them to its output stream. zsome warning text�exceptions.RuntimeWarningzpath/to/some/file.py�G ��warning�category�filename�linenoz%s:%d: %s: %s ro r� N)�RuntimeWarningra �msgrU r� ri r� )r �messager~ r r� r r r � test_warning s ��zReporterTests.test_warningc C s | � � | � � dS )zj A warning emitted twice within a single test is only written to the stream once. N)r� r) r r r � test_duplicateWarningSuppressed s z-ReporterTests.test_duplicateWarningSuppressedc C s� | � d�}| j�|� | j�d� | j�� | �� | j�d� | j�� | j�|� | j�|� | j�d� | j�� | �� dS )zn A warning emitted again after a new test has started is written to the stream again. � test_warningEmittedForNewTestr N)� __class__rJ r� r� rx rw r� rp �r r� r r r r� ( s z+ReporterTests.test_warningEmittedForNewTestc C sN | j �� | j�d� | j�� | jjtd�dddd� | �| j� � d� dS ) zl L{reporter.Reporter} stops observing log events when its C{done} method is called. r z some messagerz z file/name.py� r| r0 N) rJ rh r� rx rw ra r� r� rU ri r) r r r �test_stopObservingH s �z ReporterTests.test_stopObservingN) r* r+ r, r- rK r� rs ry r� r� r� r� r r r r rm � s rm c @ r. )�SafeStreamTestsc C s6 t � }t|�}t�|�}|�d� | �|�� d� dS )z� Test that L{reporter.SafeStream} successfully write to its original stream even if an interrupt happens during the write. rt N)r r r � SafeStreamr" rU ri )r r� �broken�safer r r � test_safeZ s zSafeStreamTests.test_safeN)r* r+ r, r� r r r r r� Y rG r� c @ s� e Zd ZU dZejZeej e d< dd� Z dd� Z dd� Z d d � Zd d � Zd d� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!S )"�SubunitReporterTestszx Tests for the subunit reporter. This just tests that the subunit reporter implements the basic interface. r_ c C sH t jd u r td��t�d�| _t� | _t� � | _ | j | j| j d�| _ d S )Nz2Subunit not installed, cannot test SubunitReporterr� r` ) r �TestProtocolClientr r r� r� r r� r rb ra r_ rJ r) r r r rK o s zSubunitReporterTests.setUpc O sd t � }t�|�}t||�|i |��}|�� }t| j|�|i |��}| �||� | �|| j�� � dS )a� Assert that 'methodName' on L{SubunitReporter} forwards to the equivalent method on subunit. Checks that the return value from subunit is returned from the L{SubunitReporter} and that the reporter writes the same data to its stream as subunit does to its own. Assumes that the method on subunit has the same name as the method on L{SubunitReporter}. N)r r r� �getattrri rJ rU r� ) r � methodName�args�kwargsr� � subunitClient� subunitReturn� subunitOutput�reporterReturnr r r �assertForwardsToSubunitx s z,SubunitReporterTests.assertForwardsToSubunitc C sd t ||d�}|du r dS t|�D ] }zt||� W n ttfy& Y dS w | �t|||� qdS )a� Remove 'methodName' from 'klass'. If 'klass' does not have a method named 'methodName', then 'removeMethod' succeeds silently. If 'klass' does have a method named 'methodName', then it is removed using delattr. Also, methods of the same name are removed from all base classes of 'klass', thus removing the method entirely. @param klass: The class to remove the method from. @param methodName: The name of the method to remove. N)r� r �delattr�AttributeErrorr? � addCleanup�setattr)r �klassr� �method�baser r r � removeMethod� s ��z!SubunitReporterTests.removeMethodc C s� | � tjd� zdd W n ty! | j�| jt�� d� Y nw | j � � }| j � d� | j � d� | j� | j� | j � � }| �||� dS )z� Some versions of subunit don't have "addExpectedFailure". For these versions, we report expected failures as successes. r$ rO r r' N)r� r r� ry rJ r$ r� rR rS r� ri rw rx rF rU )r �expectedFailureOutput� successOutputr r r �.test_subunitWithoutAddExpectedFailureInstalled� s � zCSubunitReporterTests.test_subunitWithoutAddExpectedFailureInstalledc C sh | � tjd� | j�| jd� | j�� }| j�d� | j� d� | j� | j� | j�� }| � ||� dS )zz Some versions of subunit don't have "addSkip". For these versions, we report skips as successes. r �reasonr N) r� r r� rJ r r� r� ri rw rx rF rU )r � skipOutputr� r r r �#test_subunitWithoutAddSkipInstalled� s z8SubunitReporterTests.test_subunitWithoutAddSkipInstalledc sl g � � fdd�}|| j j_zdd W n ty) t�� }| j �| j|d� Y nw | �� | j|fg� dS )z� Some versions of subunit have "addExpectedFailure". For these versions, when we call 'addExpectedFailure' on the test result, we pass the error and test through to the subunit client. c � � � | |f� d S r �r? )r� r ��addExpectedFailureCallsr r r$ � � zUSubunitReporterTests.test_addExpectedFailurePassedThrough.<locals>.addExpectedFailurerO r r' N)rJ �_subunitr$ ry rR rS r� rU )r r$ rS r r� r �$test_addExpectedFailurePassedThrough� s �z9SubunitReporterTests.test_addExpectedFailurePassedThroughc sB g � � fdd�}|| j j_| j �| jd� | �� | jdfg� dS )z� Some versions of subunit have "addSkip". For these versions, when we call 'addSkip' on the test result, we pass the test and reason through to the subunit client. c r� r r� )r� r� �� addSkipCallsr r r � r� zESubunitReporterTests.test_addSkipSendsSubunitAddSkip.<locals>.addSkipr� N)rJ r� r r� rU )r r r r� r � test_addSkipSendsSubunitAddSkip� s z4SubunitReporterTests.test_addSkipSendsSubunitAddSkipc C s | j �� | �d| j�� � dS )z� The subunit reporter doesn't need to print out a summary -- the stream of results is everything. Thus, done() does nothing. � N)rJ rh rU r� ri r) r r r �test_doneDoesNothing� s z)SubunitReporterTests.test_doneDoesNothingc C � | � d| j� dS )zT SubunitReporter.startTest() sends the subunit 'startTest' message. r� N�r� r� r) r r r �#test_startTestSendsSubunitStartTest� � z8SubunitReporterTests.test_startTestSendsSubunitStartTestc C r� )zR SubunitReporter.stopTest() sends the subunit 'stopTest' message. rp Nr� r) r r r �!test_stopTestSendsSubunitStopTest� r� z6SubunitReporterTests.test_stopTestSendsSubunitStopTestc C r� )zV SubunitReporter.addSuccess() sends the subunit 'addSuccess' message. rF Nr� r) r r r �%test_addSuccessSendsSubunitAddSuccess� r� z:SubunitReporterTests.test_addSuccessSendsSubunitAddSuccessc C s< zdd W n t y t�� }Y nw | �d| j|� dS )zR SubunitReporter.addError() sends the subunit 'addError' message. rO r rQ N)ry rR rS r� r� )r r r r r �!test_addErrorSendsSubunitAddError s �z6SubunitReporterTests.test_addErrorSendsSubunitAddErrorc C s@ z| � d� W n | jy t�� }Y nw | �d| j|� dS )zV SubunitReporter.addFailure() sends the subunit 'addFailure' message. �hellor] N)r3 r\ rR rS r� r� )r rZ r r r �%test_addFailureSendsSubunitAddFailure s �z:SubunitReporterTests.test_addFailureSendsSubunitAddFailurec C sH t � }t�|�}|�| j� |�� }| j�| j� | �|| j �� � dS )z� SubunitReporter.addFailure() sends the subunit 'addSuccess' message, since subunit doesn't model unexpected success. N) r r r� rF r� ri rJ r) rU r� )r r� r� r� r r r �/test_addUnexpectedSuccessSendsSubunitAddSuccess s zDSubunitReporterTests.test_addUnexpectedSuccessSendsSubunitAddSuccessc C s4 t �� �d�}|�| j� | j�� }| �d|� dS )zC Load-time errors are reported like normal errors. � doesntexists doesntexistN)r re rw rl rJ r� ri �assertIn)r r� rA r r r �test_loadTimeErrors% s z(SubunitReporterTests.test_loadTimeErrorsN)r* r+ r, r- r �SubunitReporterr_ r r rk rl rK r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r� f s$ r� c @ r� )� SubunitReporterNotInstalledTestszD Test behaviour when the subunit reporter is not installed. c C s8 t � }| �tdd� | �ttj|�}| �dt|�� dS )z� If subunit is not installed, TestProtocolClient will be None, and SubunitReporter will raise an error when you try to construct it. r� NzSubunit not available)r �patchr r- r r� rU r; )r r� rX r r r �test_subunitNotInstalled6 s z9SubunitReporterNotInstalledTests.test_subunitNotInstalledN)r* r+ r, r- r� r r r r r� 1 s r� c @ s" e Zd ZU ejZeej e d< dS )�TimingReporterTestsr_ N) r* r+ r, r �TimingTextReporterr_ r r rk rl r r r r r� A s r� c @ sT e Zd ZdZdd� Zdd� Zddd�Zd d � Zd d � Zdd d�Z dd� Z dd� Z dS )�LoggingReporterzJ Simple reporter that stores the last test that was passed to it. c O s$ t jj| g|�R i |�� d | _d S r )r rb r r� )r r� r� r r r r J s zLoggingReporter.__init__c C r r �r� )r r� r r r r rQ N r zLoggingReporter.addErrorNc C r r r� )r r� rZ r' r r r r$ Q r z"LoggingReporter.addExpectedFailurec C r r r� )r r� rZ r r r r] T r zLoggingReporter.addFailurec C r r r� )r r� �skipr r r r W r zLoggingReporter.addSkipc C r r r� r+ r r r r) Z r z$LoggingReporter.addUnexpectedSuccessc C r r r� r� r r r r� ] r zLoggingReporter.startTestc C r r r� r� r r r rp ` r zLoggingReporter.stopTestr ) r* r+ r, r- r rQ r$ r] r r) r� rp r r r r r� E s r� c @ r ) �AdaptedReporterTestsz� L{reporter._AdaptedReporter} is a reporter wrapper that wraps all of the tests it receives before passing them on to the original reporter. c C s | � � | _d S r )�getWrappedResult� wrappedResultr) r r r rK j rL zAdaptedReporterTests.setUpc C s |� � S r )r� r� r r r � _testAdapterm � z!AdaptedReporterTests._testAdapterc C s | � |jj| �|�� d S r )rU r� r� r� )r r� r� r r r � assertWrappedp s z"AdaptedReporterTests.assertWrappedc C s z|� t y t� Y S w )z� Return a L{Failure} from raising the given exception. @param exceptionInstance: The exception to raise. @return: L{Failure} )� BaseExceptionr )r �exceptionInstancer r r � getFailures s �z AdaptedReporterTests.getFailurec C s t � }t�|| j�S r )r� r �_AdaptedReporterr� r� r r r r� s z%AdaptedReporterTests.getWrappedResultc C �( | j �| | �t� �� | �| j | � dS )zG C{addError} wraps its test with the provided adapter. N)r� rQ r� rP r� r) r r r � test_addError� � z"AdaptedReporterTests.test_addErrorc C r� )zI C{addFailure} wraps its test with the provided adapter. N)r� r] r� �AssertionErrorr� r) r r r �test_addFailure� r� z$AdaptedReporterTests.test_addFailurec C s* | j �| | �td��� | �| j | � dS )zF C{addSkip} wraps its test with the provided adapter. � no reasonN)r� r r� r r� r) r r r � test_addSkip� s z!AdaptedReporterTests.test_addSkipc C � | j �| � | �| j | � dS )zH C{startTest} wraps its test with the provided adapter. N)r� r� r� r) r r r �test_startTest� � z#AdaptedReporterTests.test_startTestc C r� )zG C{stopTest} wraps its test with the provided adapter. N)r� rp r� r) r r r � test_stopTest� r� z"AdaptedReporterTests.test_stopTestc C s. | j �| | �t� �td�� | �| j | � dS )zQ C{addExpectedFailure} wraps its test with the provided adapter. r� N)r� r$ r� rP r r� r) r r r �test_addExpectedFailure� s �z,AdaptedReporterTests.test_addExpectedFailurec C r� )z@ C{addExpectedFailure} works without a C{Todo}. N)r� r$ r� rP r� r) r r r � test_expectedFailureWithoutTodo� r� z4AdaptedReporterTests.test_expectedFailureWithoutTodoc C s$ | j �| td�� | �| j | � dS )zS C{addUnexpectedSuccess} wraps its test with the provided adapter. r� N)r� r) r r� r) r r r �test_addUnexpectedSuccess� s z.AdaptedReporterTests.test_addUnexpectedSuccessc C r� )zB C{addUnexpectedSuccess} works without a C{Todo}. N)r� r) r� r) r r r �!test_unexpectedSuccessWithoutTodo� r� z6AdaptedReporterTests.test_unexpectedSuccessWithoutTodoN)r* r+ r, r- rK r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r� d s r� c @ s" e Zd ZdZddd�Zdd� ZdS ) � FakeStreamz� A fake stream which C{isatty} method returns some predictable. @ivar tty: returned value of C{isatty}. @type tty: C{bool} Tc C r r ��tty)r r� r r r r � r zFakeStream.__init__c C s | j S r r� r) r r r �isatty� � zFakeStream.isattyN)T)r* r+ r, r- r r� r r r r r� � s r� c @ r� )�AnsiColorizerTestsz/ Tests for L{reporter._AnsiColorizer}. c C s t j�� | _d S r )rR �modules�copy� savedModulesr) r r r rK � s zAnsiColorizerTests.setUpc C s t j�� t j�| j� d S r )rR r� �clear�updater� r) r r r �tearDown� s zAnsiColorizerTests.tearDownc C s | � tj�td��� dS )zq L{reporter._AnsiColorizer.supported} returns C{False} if the given stream is not a TTY. FN)� assertFalser �_AnsiColorizer� supportedr� r) r r r �test_supportedStdOutTTY� s z*AnsiColorizerTests.test_supportedStdOutTTYc C s" dt jd< | �tj�t� �� dS )zw L{reporter._AnsiColorizer.supported} returns C{False} if the curses module can't be imported. N�curses�rR r� r� r r� r� r� r) r r r �test_supportedNoCurses� s z)AnsiColorizerTests.test_supportedNoCursesc C sZ G dd� d�}|� t jd< | �tj�t� �� | �tj�t� �� | �t jd jd� dS )a L{reporter._AnsiColorizer.supported} returns C{True} if C{curses.tigetnum} returns more than 2 supported colors. It only tries to call C{curses.setupterm} if C{curses.tigetnum} previously failed with a C{curses.error}. c @ �$ e Zd ZeZdZdd� Zdd� ZdS )z>AnsiColorizerTests.test_supportedSetupTerm.<locals>.fakecursesr c S � | j d7 _ d S ro �rK r) r r r � setupterm� r� zHAnsiColorizerTests.test_supportedSetupTerm.<locals>.fakecurses.setuptermc S s | j rdS | �� �)Nr )rK r �r rV r r r �tigetnum� s zGAnsiColorizerTests.test_supportedSetupTerm.<locals>.fakecurses.tigetnumN�r* r+ r, rP r rK r� r� r r r r � fakecurses� � r� r� rO N) rR r� r3 r r� r� r� rU rK �r r� r r r �test_supportedSetupTerm� s z*AnsiColorizerTests.test_supportedSetupTermc C �2 G dd� d�}|� t jd< | �tj�t� �� dS )z� L{reporter._AnsiColorizer.supported} returns C{False} and doesn't try to call C{curses.setupterm} if C{curses.tigetnum} returns something different than C{curses.error}. c @ � e Zd ZeZdd� ZdS )zGAnsiColorizerTests.test_supportedTigetNumWrongError.<locals>.fakecursesc S s t � �r )� ValueErrorr� r r r r� r� zPAnsiColorizerTests.test_supportedTigetNumWrongError.<locals>.fakecurses.tigetnumN�r* r+ r, rP r r� r r r r r� � r� r� Nr� r r r r � test_supportedTigetNumWrongError s z3AnsiColorizerTests.test_supportedTigetNumWrongErrorc C r )z� L{reporter._AnsiColorizer.supported} returns C{False} if C{curses.tigetnum} returns less than 2 supported colors. c @ r )zKAnsiColorizerTests.test_supportedTigetNumNotEnoughColor.<locals>.fakecursesc S s dS ro r r� r r r r� # s zTAnsiColorizerTests.test_supportedTigetNumNotEnoughColor.<locals>.fakecurses.tigetnumNr r r r r r� r r� r� Nr� r r r r �$test_supportedTigetNumNotEnoughColor s z7AnsiColorizerTests.test_supportedTigetNumNotEnoughColorc C sF G dd� d�}|� t jd< | �tj�t� �� | �t jd jd� dS )z� L{reporter._AnsiColorizer.supported} returns C{False} if C{curses.tigetnum} raises an error, and calls C{curses.setupterm} once. c @ r� )zCAnsiColorizerTests.test_supportedTigetNumErrors.<locals>.fakecursesr c S r� ro r� r) r r r r� 3 r� zMAnsiColorizerTests.test_supportedTigetNumErrors.<locals>.fakecurses.setuptermc S s | � � �r )r r� r r r r� 6 r� zLAnsiColorizerTests.test_supportedTigetNumErrors.<locals>.fakecurses.tigetnumNr� r r r r r� / r� r� r� rO N) rR r� r� r r� r� r� rU rK r r r r � test_supportedTigetNumErrors) s z/AnsiColorizerTests.test_supportedTigetNumErrorsN) r* r+ r, r- rK r� r� r� r r r r r r r r r� � s r� c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �ExitWrapperTestsz- Tests for L{reporter._ExitWrapper}. c C sB t td��| _t�d�| _t�� | _t | j�| _ | � | j j � d S )NzI am a Failurer� ) r r rZ r r� r� r rI rJ r �wrappedr� rc r) r r r rK C s zExitWrapperTests.setUpc C �> | j �| j| j� | �| j j� | �| jj| j| jfg� dS )zm L{reporter._ExitWrapper} causes a wrapped reporter to stop after its first failure. N) r r] r� rZ r3 rc rU rJ r^ r) r r r �test_stopOnFailureJ � z#ExitWrapperTests.test_stopOnFailurec C r )zk L{reporter._ExitWrapper} causes a wrapped reporter to stop after its first error. N) r rQ r� rZ r3 rc rU rJ rT r) r r r �test_stopOnErrorS r z!ExitWrapperTests.test_stopOnErrorc C r )zy L{reporter._ExitWrapper} does not cause a wrapped reporter to stop after an unexpected success. N) r r) r� rZ r� rc rU rJ r! r) r r r �#test_doesNotStopOnUnexpectedSuccess\ r z4ExitWrapperTests.test_doesNotStopOnUnexpectedSuccessN)r* r+ r, r- rK r r r r r r r r > s r )Dr- r$ r� r6 rR �inspectr �ior r �typingr r r r6 r �twisted.pythonr r �twisted.python.failurer �twisted.python.reflectr � twisted.trialr r r r �twisted.trial.reporterr r rz r r �twisted.trial.unittestr r r r �SynchronousTestCaser/ rH r` rd r� r� r� r� r� r� r� r r r; r> rB r^ rm r� r� r� r� rb r� r� r� r� r r r r r �<module> s^ F1BI H pDn L ajPK b�Z��jS S , test/__pycache__/mockdoctest.cpython-310.pycnu �[��� o �bu � @ s G d d� d�Z dS )c @ sb e Zd ZdZdZddd�Zdd� Zded efd d �Z ded efd d �Z dd� Z dd� Z dd� Z dS )�Counterz�a simple counter object for testing trial's doctest support >>> c = Counter() >>> c.value() 0 >>> c += 3 >>> c.value() 3 >>> c.incr() >>> c.value() == 4 True >>> c == 4 True >>> c != 9 True � Nc C s || _ || _d S )N)�_count�maxval)�self� initialValuer � r �@/usr/lib/python3/dist-packages/twisted/trial/test/mockdoctest.py�__init__ s zCounter.__init__c C s4 | j dur| j| | j krtd��| j|7 _| S )z�add other to my value and return self >>> c = Counter(100) >>> c += 333 >>> c == 433 True Nzsorry, counter got too big)r r � ValueError�r �otherr r r �__iadd__! s zCounter.__iadd__r �returnc C s | j |kS )z�equality operator, compare other to my value() >>> c = Counter() >>> c == 0 True >>> c += 10 >>> c.incr() >>> c == 10 # fail this test on purpose True �r r r r r �__eq__/ s zCounter.__eq__c C s | � |� S )zXinequality operator >>> c = Counter() >>> c != 10 True )r r r r r �__ne__= s zCounter.__ne__c C s | � d� dS )a: increment my value by 1 >>> from twisted.trial.test.mockdoctest import Counter >>> c = Counter(10, 11) >>> c.incr() >>> c.value() == 11 True >>> c.incr() Traceback (most recent call last): File "<stdin>", line 1, in ? File "twisted/trial/test/mockdoctest.py", line 51, in incr self.__iadd__(1) File "twisted/trial/test/mockdoctest.py", line 39, in __iadd__ raise ValueError, "sorry, counter got too big" ValueError: sorry, counter got too big � N)r �r r r r �incrF s z Counter.incrc C s | j S )zlreturn this counter's value >>> c = Counter(555) >>> c.value() == 555 True r r r r r �valueY s z Counter.valuec C s dS )zui will raise an unexpected exception... ... *CAUSE THAT'S THE KINDA GUY I AM* >>> 1/0 Nr r r r r �unexpectedExceptionb s zCounter.unexpectedException)r N)�__name__� __module__� __qualname__�__doc__r r r �object�boolr r r r r r r r r r s r N)r r r r r �<module> s PK b�Z�2d�\� \� + test/__pycache__/test_tests.cpython-310.pycnu �[��� o �b\� � @ s� d Z ddlZddlZddlZddlZddlmZ ddlm Z m Z ddl m Z ddl mZ ddlmZmZmZmZ ddlmZmZmZ dd lmZ dd lmZ G d d � d �ZG d d� d�Z G dd� de ej �Z G dd� de ej �Z G dd� de�Z!G dd� de!ej �Z"G dd� de!ej �Z#G dd� de�Z$G dd � d e$ej �Z%G d d � d e$ej �Z&G d d � d e�Z'G d!d"� d"e'ej �Z(G d#d$� d$e'ej �Z)G d%d&� d&e�Z*G d'd(� d(e*ej �Z+G d)d*� d*e*ej �Z,G d+d,� d,e�Z-G d-d.� d.e-ej �Z.G d/d0� d0e-ej �Z/G d1d2� d2ej �Z0G d3d4� d4�Z1G d5d6� d6e1ej �Z2G d7d8� d8e1ej �Z3G d9d:� d:eej �Z4G d;d<� d<�Z5G d=d>� d>e5ej �Z6G d?d@� d@e5ej �Z7G dAdB� dBej �Z8G dCdD� dD�Z9G dEdF� dFe9ej �Z:G dGdH� dHe9ej �Z;G dIdJ� dJ�Z<G dKdL� dLe<ej �Z=G dMdN� dNe<ej �Z>G dOdP� dP�Z?G dQdR� dRe?ej �Z@G dSdT� dTe?ej �ZAG dUdV� dV�ZBG dWdX� dXeBej �ZCG dYdZ� dZeBej �ZDG d[d\� d\�ZEG d]d^� d^eEej �ZFG d_d`� d`eEej �ZGG dadb� dbej �ZHdS )ca� Tests for the behaviour of unit tests. Many tests in this module follow a simple pattern. A mixin is defined which includes test methods for a certain feature. The mixin is inherited from twice, once by a class also inheriting from SynchronousTestCase and once from a class inheriting from TestCase. These two subclasses are named like I{SynchronousFooTests} and I{AsynchronousFooTests}, where I{Foo} is related to the name of the mixin. Sometimes the mixin is defined in another module, along with the synchronous subclass. The mixin is imported into this module to define the asynchronous subclass. This pattern allows the same tests to be applied to the two base test case classes trial provides, ensuring their behavior is the same. Most new tests should be added in this pattern. Tests for functionality which is intentionally only provided by TestCase, not SynchronousTestCase, is excepted of course. � N)�StringIO)�defer�reactor)�_PYPY)�namedAny)�reporter�runner�unittest�util)� _clearSuite� _ForceGarbageCollectionDecorator� _iterateTests)� erroneous)�SuppressionMixinc @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) �ResultsTestMixinzG Provide useful APIs for test cases that are about test cases. c C s& t �� | _| j�|�| _t�� | _dS )zt Load tests from the given test case class and create a new reporter to use for running it. N)�pyunit� TestLoader�loader�loadTestsFromTestCase�suiter � TestResult��selfr � r �?/usr/lib/python3/dist-packages/twisted/trial/test/test_tests.py� loadSuite1 s zResultsTestMixin.loadSuitec C sD | � | j�� � | �| jjg � | �| jjg � | �| jjg � dS )z test the setup N)� assertTruer � wasSuccessful� assertEqual�errors�failures�skips�r r r r � test_setUp: s zResultsTestMixin.test_setUpc C s2 | � | j�� |� | �| j� | � | jj|� dS )z: Asserts that the test count is plausible N)r r �countTestCasesr �testsRun)r �numTestsr r r � assertCountC s z ResultsTestMixin.assertCountN)�__name__� __module__� __qualname__�__doc__r r$ r( r r r r r , s r c @ �@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )� SuccessMixinz\ Tests for the reporting of successful tests in L{twisted.trial.unittest.TestCase}. c C s t �� | _dS ��% Setup our test case N)r r �resultr# r r r �setUpQ � zSuccessMixin.setUpc C s dS )z9 A successful test, used by other tests. Nr r# r r r �test_successfulW s z SuccessMixin.test_successfulc C sX | � |jd� | � |jg � | � |jg � | � |jg � | � |jg � | � |jg � dS )zd Utility function -- assert there is one success and the state is plausible � N)r � successesr! r �expectedFailures�unexpectedSuccessesr" �r �testr1 r r r �assertSuccessful\ s z SuccessMixin.assertSuccessfulc C s( | � d�}|�| j� | �|| j� dS )z� Test that when a successful test is run, it is reported as a success, and not as any other kind of result. r4 N�� __class__�runr1 r; �r r: r r r �test_successfulIsReportedh s z&SuccessMixin.test_successfulIsReportedc C s& | � � }|�| j� | �|| j� dS )zz The test case type can be instantiated with no arguments, run, and reported as being successful. Nr< r? r r r �test_defaultIsSuccessfulq s z%SuccessMixin.test_defaultIsSuccessfulc C sJ | � d�}t�|�}|�| j� | �|| j� ~t�� | �|� d� dS )zF Test that no reference is kept on a successful test. r4 N) r= �weakref�refr> r1 r; �gc�collect�assertIdentical)r r: rC r r r �test_noReferencez s z SuccessMixin.test_noReferenceN) r) r* r+ r, r2 r4 r; r@ rA rG r r r r r. L s r. c @ � e Zd ZdZdS )�SynchronousSuccessTests�N Tests for the reporting of successful tests in the synchronous case. N�r) r* r+ r, r r r r rI � � rI c @ rH )�AsynchronousSuccessTestsrJ NrK r r r r rM � rL rM c @ r- )�SkipMethodsMixinzZ Tests for the reporting of skipping tests in L{twisted.trial.unittest.TestCase}. c C � | � | j� dS r/ )r �Skippingr# r r r r2 � � zSkipMethodsMixin.setUpc C � | � d� dS )z4 Assert that there are three tests. � N�r( r# r r r � test_counting� r3 z SkipMethodsMixin.test_countingc C �d | � | j� | �| j�� � | �| jjg � | �| jjg � | �t| jj�d� | �| jj d� dS )z� Running a suite in which all methods are individually set to skip produces a successful result with no recorded errors or failures, all the skipped methods recorded as skips, and no methods recorded as successes. rS r N� r r r r r r r! �lenr" r6 r# r r r � test_results� � z SkipMethodsMixin.test_resultsc C sp | � | j� | �| j� | �| j�� � | �| jjg � | �| jjg � | �t | jj �d� | �| jj d� dS )a Running a suite in which all methods are skipped by C{setUp} raising L{SkipTest} produces a successful result with no recorded errors or failures, all skipped methods recorded as skips, and no methods recorded as successes. � r N) r � SkippingSetUpr r r r r r r! rX r" r6 r# r r r r$ � s zSkipMethodsMixin.test_setUpc C sF | � | j� d}| jjD ]\}}| �|�� t|�d� t|�� q dS )z( Test that reasons work �test_N)r r r" r �shortDescriptionrX �str)r �prefixr: �reasonr r r � test_reasons� s "�z SkipMethodsMixin.test_reasonsc C sd | � | j� | �| j� | �| jjg�}| �dt|�� | �t|d d � | �d|d d � dS )zo If a test method raises L{SkipTest} with no reason, a deprecation warning is emitted. r5 r �categoryzSDo not raise unittest.SkipTest with no arguments! Give a reason for skipping tests!�messageN) r �DeprecatedReasonlessSkipr r � flushWarnings�test_1r rX �DeprecationWarning)r �warningsr r r � test_deprecatedSkipWithoutReason� s �z1SkipMethodsMixin.test_deprecatedSkipWithoutReasonN) r) r* r+ r, r2 rU rY r$ rb rj r r r r rN � s rN c @ �( e Zd ZdZed�Zed�Zed�ZdS )�SynchronousSkipMethodTestsz� Tests for the reporting of skipping tests in the synchronous case. See: L{twisted.trial.test.test_tests.SkipMethodsMixin} z/twisted.trial.test.skipping.SynchronousSkippingz4twisted.trial.test.skipping.SynchronousSkippingSetUpz?twisted.trial.test.skipping.SynchronousDeprecatedReasonlessSkipN�r) r* r+ r, r rP r\ re r r r r rl � � �rl c @ rk )�AsynchronousSkipMethodTestsz� Tests for the reporting of skipping tests in the asynchronous case. See: L{twisted.trial.test.test_tests.SkipMethodsMixin} z0twisted.trial.test.skipping.AsynchronousSkippingz5twisted.trial.test.skipping.AsynchronousSkippingSetUpz@twisted.trial.test.skipping.AsynchronousDeprecatedReasonlessSkipNrm r r r r ro � rn ro c @ �8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �SkipClassesMixinzQ Test the class skipping features of L{twisted.trial.unittest.TestCase}. c C s | � | j� d| j_dS )r0 FN)r � SkippedClass� _setUpRanr# r r r r2 � s zSkipClassesMixin.setUpc C rR )zP Skipped test methods still contribute to the total test count. � NrT r# r r r rU r3 z SkipClassesMixin.test_countingc C s | � | j� | �| jj� dS )zP The C{setUp} method is not called if the class is set to skip. N)r r � assertFalserr rs r# r r r � test_setUpRan s z SkipClassesMixin.test_setUpRanc C rV )a Skipped test methods don't cause C{wasSuccessful} to return C{False}, nor do they contribute to the C{errors} or C{failures} of the reporter, or to the count of successes. They do, however, add elements to the reporter's C{skips} list. rt r NrW r# r r r rY rZ z SkipClassesMixin.test_resultsc C �6 | � | j� g d�}dd� | jjD �}| �||� dS )z� Test methods which raise L{unittest.SkipTest} or have their C{skip} attribute set to something are skipped. )�class�skip2rx rx c S s g | ]\}}|�qS r r )�.0r: ra r r r � <listcomp>' s z1SkipClassesMixin.test_reasons.<locals>.<listcomp>N)r r r" r �r �expectedReasons� reasonsGivenr r r rb s z SkipClassesMixin.test_reasonsN) r) r* r+ r, r2 rU rv rY rb r r r r rq � s rq c @ � e Zd ZdZed�ZdS )�SynchronousSkipClassTestsz Test the class skipping features in the synchronous case. See: L{twisted.trial.test.test_tests.SkipClassesMixin} z3twisted.trial.test.skipping.SynchronousSkippedClassN�r) r* r+ r, r rr r r r r r� + � r� c @ r )�AsynchronousSkipClassTestsz� Test the class skipping features in the asynchronous case. See: L{twisted.trial.test.test_tests.SkipClassesMixin} z4twisted.trial.test.skipping.AsynchronousSkippedClassNr� r r r r r� 5 r� r� c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )� TodoMixinzv Tests for the individual test method I{expected failure} features of L{twisted.trial.unittest.TestCase}. c C rO r/ )r �Todor# r r r r2 E rQ zTodoMixin.setUpc C rR )z9 Ensure that we've got three test cases. rS NrT r# r r r rU K r3 zTodoMixin.test_countingc C s� | � | j� | �| j�� � | �| jjg � | �| jjg � | �| jjg � | �t| jj �d� | �t| jj �d� | �| jj d� dS )a� Running a suite in which all methods are individually marked as expected to fail produces a successful result with no recorded errors, failures, or skips, all methods which fail and were expected to fail recorded as C{expectedFailures}, and all methods which pass but which were expected to fail recorded as C{unexpectedSuccesses}. Additionally, no tests are recorded as successes. r[ r5 r N� r r r r r r r! r" rX r7 r8 r6 r# r r r rY Q � zTodoMixin.test_resultsc C �6 | � | j� ddg}dd� | jjD �}| �||� dS )�E Ensure that expected failures are handled properly. �todo1�todo2c S � g | ]\}}}|j �qS r �ra �rz �t�e�rr r r r{ i � z3TodoMixin.test_expectedFailures.<locals>.<listcomp>N�r r r7 r r| r r r �test_expectedFailuresc � z TodoMixin.test_expectedFailuresc C s4 | � | j� dg}dd� | jjD �}| �||� dS )�> Ensure that unexpected successes are caught. �todo3c S � g | ]\}}|j �qS r r� �rz r� r� r r r r{ r � z6TodoMixin.test_unexpectedSuccesses.<locals>.<listcomp>N�r r r8 r r| r r r �test_unexpectedSuccessesl s z"TodoMixin.test_unexpectedSuccessesc C s� | � | j� | �| j� | �| j�� � | �t| jj�d� | �| jj g � | �| jj g � | �t| jj �d� | �t| jj �d� | �| jj d� dS )z| C{setUp} is excluded from the failure expectation defined by a C{todo} attribute on a test method. r5 r N)r � SetUpTodor r ru r r rX r r! r" r7 r8 r6 r# r r r �test_expectedSetUpFailureu s z#TodoMixin.test_expectedSetUpFailurec C s� | � | j� | �| j� | �| j�� � | �t| jj�d� | �| jj g � | �| jj g � | �t| jj �d� | �t| jj �d� | �| jj d� dS )z C{tearDown} is excluded from the failure expectation defined by a C{todo} attribute on a test method. r5 r N)r � TearDownTodor r ru r r rX r r! r" r7 r8 r6 r# r r r � test_expectedTearDownFailure� s z&TodoMixin.test_expectedTearDownFailureN) r) r* r+ r, r2 rU rY r� r� r� r� r r r r r� ? s r� c @ rk )�SynchronousTodoTestszx Test the class skipping features in the synchronous case. See: L{twisted.trial.test.test_tests.TodoMixin} z+twisted.trial.test.skipping.SynchronousTodoz0twisted.trial.test.skipping.SynchronousSetUpTodoz3twisted.trial.test.skipping.SynchronousTearDownTodoN�r) r* r+ r, r r� r� r� r r r r r� � � r� c @ rk )�AsynchronousTodoTestszy Test the class skipping features in the asynchronous case. See: L{twisted.trial.test.test_tests.TodoMixin} z,twisted.trial.test.skipping.AsynchronousTodoz1twisted.trial.test.skipping.AsynchronousSetUpTodoz4twisted.trial.test.skipping.AsynchronousTearDownTodoNr� r r r r r� � r� r� c @ rp ) �ClassTodoMixinzj Tests for the class-wide I{expected failure} features of L{twisted.trial.unittest.TestCase}. c C rO r/ )r � TodoClassr# r r r r2 � rQ zClassTodoMixin.setUpc C rR )z8 Ensure that we've got four test cases. rt NrT r# r r r rU � r3 z ClassTodoMixin.test_countingc C s� | � | j� | �| j�� � | �| jjg � | �| jjg � | �| jjg � | �t| jj �d� | �t| jj �d� | �| jj d� dS )a� Running a suite in which an entire class is marked as expected to fail produces a successful result with no recorded errors, failures, or skips, all methods which fail and were expected to fail recorded as C{expectedFailures}, and all methods which pass but which were expected to fail recorded as C{unexpectedSuccesses}. Additionally, no tests are recorded as successes. r[ r Nr� r# r r r rY � r� zClassTodoMixin.test_resultsc C r� )r� �methodrx c S r� r r� r� r r r r{ � r� z8ClassTodoMixin.test_expectedFailures.<locals>.<listcomp>Nr� r| r r r r� � r� z$ClassTodoMixin.test_expectedFailuresc C r� )r� r� rx c S r� r r� r� r r r r{ � r� z;ClassTodoMixin.test_unexpectedSuccesses.<locals>.<listcomp>Nr� r| r r r r� � r� z'ClassTodoMixin.test_unexpectedSuccessesN� r) r* r+ r, r2 rU rY r� r� r r r r r� � s r� c @ r )�SynchronousClassTodoTestsz� Tests for the class-wide I{expected failure} features in the synchronous case. See: L{twisted.trial.test.test_tests.ClassTodoMixin} z0twisted.trial.test.skipping.SynchronousTodoClassN�r) r* r+ r, r r� r r r r r� � r� r� c @ r )�AsynchronousClassTodoTestsz� Tests for the class-wide I{expected failure} features in the asynchronous case. See: L{twisted.trial.test.test_tests.ClassTodoMixin} z1twisted.trial.test.skipping.AsynchronousTodoClassNr� r r r r r� � r� r� c @ rp ) �StrictTodoMixinz� Tests for the I{expected failure} features of L{twisted.trial.unittest.TestCase} in which the exact failure which is expected is indicated. c C rO r/ )r � StrictTodor# r r r r2 rQ zStrictTodoMixin.setUpc C rR )z3 Assert there are seven test cases � NrT r# r r r rU r3 z StrictTodoMixin.test_countingc C s� | � | j� | �| j�� � | �t| jj�d� | �t| jj�d� | �t| jj�d� | �t| jj �d� | �| jj d� | �| jj g � dS )z� A test method which is marked as expected to fail with a particular exception is only counted as an expected failure if it does fail with that exception, not if it fails with some other exception. r[ r5 rS r N) r r ru r r rX r r! r7 r8 r6 r" r# r r r rY s z StrictTodoMixin.test_resultsc C rw )r� )r� r� �todo5c S r� r r� r� r r r r{ " r� z9StrictTodoMixin.test_expectedFailures.<locals>.<listcomp>Nr� �r r} � reasonsGottenr r r r� r� z%StrictTodoMixin.test_expectedFailuresc C s: | � | j� tgdfg}dd� | jjD �}| �||� dS )r� �todo7c S s g | ] \}}|j |jf�qS r )r ra r� r r r r{ + s �z<StrictTodoMixin.test_unexpectedSuccesses.<locals>.<listcomp>N)r r � RuntimeErrorr8 r r� r r r r� % s �z(StrictTodoMixin.test_unexpectedSuccessesNr� r r r r r� � s r� c @ r )�SynchronousStrictTodoTestsz� Tests for the expected failure case when the exact failure that is expected is indicated in the synchronous case See: L{twisted.trial.test.test_tests.StrictTodoMixin} z1twisted.trial.test.skipping.SynchronousStrictTodoN�r) r* r+ r, r r� r r r r r� 1 � r� c @ r )�AsynchronousStrictTodoTestsz� Tests for the expected failure case when the exact failure that is expected is indicated in the asynchronous case See: L{twisted.trial.test.test_tests.StrictTodoMixin} z2twisted.trial.test.skipping.AsynchronousStrictTodoNr� r r r r r� < r� r� c @ r ) �ReactorCleanupTestszc Tests for cleanup and reporting of reactor event sources left behind by test methods. c C s t �t� �| _t�� | _dS r/ )r �Reporterr r1 r r r r# r r r r2 M s zReactorCleanupTests.setUpc C s^ | j �d�}|�| j� | �| j�� � | �| jjd� | jjd d }| � |� t j �� dS )zm Trial reports a L{util.DirtyReactorAggregateError} if a test leaves sockets behind. z@twisted.trial.test.erroneous.SocketOpenTest.test_socketsLeftOpenr5 r N) r � loadByNamer> r1 ru r r r6 r r �checkr �DirtyReactorAggregateError�r r �failurer r r �test_leftoverSocketsT s � z(ReactorCleanupTests.test_leftoverSocketsc C s\ t �d�}|�| j� | �| j�� � | jjd d }| �| jjd� | � |� t j �� dS )z� Trial reports a L{util.DirtyReactorAggregateError} and fails the test if a test leaves a L{DelayedCall} hanging. �test_leftoverPendingCallsr r5 N) r r� r> r1 ru r r r r6 r r� r r� r� r r r r� e s z-ReactorCleanupTests.test_leftoverPendingCallsN)r) r* r+ r, r2 r� r� r r r r r� G s r� c @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � FixtureMixinzB Tests for fixture helper methods (e.g. setUp, tearDown). c C s t �� | _ t�� | _dS r/ )r r� r r r r# r r r r2 w s zFixtureMixin.setUpc C s` | j �| j�}|�| j� | �t| jj�dk� | �| jjd d j t j � | � d| jj � dS )zO When setUp fails, the error is recorded in the result object. r r5 N)r r �TestFailureInSetUpr> r r rX r �assertIsInstance�valuer � FoolishErrorr r6 r r r r �test_brokenSetUp~ s z FixtureMixin.test_brokenSetUpc C s` | j �| j�}|�| j� | jj}| �t|�dk� | �|d d j t j � | � d| jj � dS )zR When tearDown fails, the error is recorded in the result object. r r5 N)r r �TestFailureInTearDownr> r r r rX r� r� r r� r r6 )r r r r r r �test_brokenTearDown� s z FixtureMixin.test_brokenTearDownc C s� | j �| j�}t|�d }| �|j� |�| j� | jj}| � t |�dk� | � |d d j t j� | �d| jj� | � |j� dS )zP L{SynchronousTestCase.tearDown} runs when a test method fails. r r5 N)r r �TestFailureButTearDownRuns�listru �tornDownr> r r r rX r� r� r r� r r6 )r r �caser r r r � test_tearDownRunsOnTestFailure� s z+FixtureMixin.test_tearDownRunsOnTestFailureN)r) r* r+ r, r2 r� r� r� r r r r r� r s r� c @ rk )�SynchronousFixtureTestsz� Tests for broken fixture helper methods in the synchronous case See: L{twisted.trial.test.test_tests.FixtureMixin} z:twisted.trial.test.erroneous.SynchronousTestFailureInSetUpz=twisted.trial.test.erroneous.SynchronousTestFailureInTearDownzBtwisted.trial.test.erroneous.SynchronousTestFailureButTearDownRunsN�r) r* r+ r, r r� r� r� r r r r r� � � ���r� c @ rk )�AsynchronousFixtureTestsz� Tests for broken fixture helper methods in the asynchronous case See: L{twisted.trial.test.test_tests.FixtureMixin} z;twisted.trial.test.erroneous.AsynchronousTestFailureInSetUpz>twisted.trial.test.erroneous.AsynchronousTestFailureInTearDownzCtwisted.trial.test.erroneous.AsynchronousTestFailureButTearDownRunsNr� r r r r r� � r� r� c @ s0 e Zd ZdZed�Zed�Zed�Zed�ZdS )� AsynchronousSuppressionTestsz� Tests for the warning suppression features of L{twisted.trial.unittest.TestCase} See L{twisted.trial.test.test_suppression.SuppressionMixin} z?twisted.trial.test.suppression.AsynchronousTestSetUpSuppressionzBtwisted.trial.test.suppression.AsynchronousTestTearDownSuppressionz:twisted.trial.test.suppression.AsynchronousTestSuppressionz;twisted.trial.test.suppression.AsynchronousTestSuppression2N) r) r* r+ r, r �TestSetUpSuppression�TestTearDownSuppression�TestSuppression�TestSuppression2r r r r r� � s ����r� c @ sB e Zd ZdZG dd� dej�Zdd� Zdd� Zdd � Z d d � Z d S ) �GCMixinz� I provide a few mock tests that log setUp, tearDown, test execution and garbage collection. I'm used to test whether gc.collect gets called. c @ r ) zGCMixin.BasicTestz# Mock test to run. c C rR )z$ Mock setUp r2 N��_logr# r r r r2 � r3 zGCMixin.BasicTest.setUpc C rR )z( Mock test case r: Nr� r# r r r �test_foo� r3 zGCMixin.BasicTest.test_fooc C rR )z, Mock tear tearDown �tearDownNr� r# r r r r� � r3 zGCMixin.BasicTest.tearDownN)r) r* r+ r, r2 r� r� r r r r � BasicTest� s r� c C s | j �|� dS )z Log function N)�_collectCalled�append)r �msgr r r r� � rQ z GCMixin._logc C rR )zFake gc.collectrE Nr� r# r r r rE s zGCMixin.collectc C s$ g | _ | j| j_tj| _| jt_dS r/ )r� r� r� rD rE � _oldCollectr# r r r r2 s z GCMixin.setUpc C s | j t_dS �z$ Tear down the test N)r� rD rE r# r r r r� s zGCMixin.tearDownN) r) r* r+ r, r �SynchronousTestCaser� r� rE r2 r� r r r r r� � s r� c @ � e Zd ZdZdd� ZdS )� GarbageCollectionDefaultTestsz@ By default, tests should not force garbage collection. c C s2 | � d�}t�� }|�|� | �| jg d�� dS )zH By default, tests should not force garbage collection. r� )r2 r: r� N)r� r r r> r r� r9 r r r �test_collectNotDefault s z4GarbageCollectionDefaultTests.test_collectNotDefaultN)r) r* r+ r, r� r r r r r� � r� c @ r� )�GarbageCollectionTestsz- Test that, when force GC, it works. c C s: t �d�}t|�}t�� }|�|� | �| jg d�� dS )zG test gc.collect is called before and after each test. r� )rE r2 r: r� rE N)r� r� r r r r> r r� r9 r r r �test_collectCalled* s �z)GarbageCollectionTests.test_collectCalledN)r) r* r+ r, r� r r r r r� % r� r� c @ s< e Zd ZdZdd� Zdd� Ze�ed�dd� �Z d d � Z d S ) �UnhandledDeferredTestsz\ Test what happens when we have an unhandled deferred left around after a test. c C s( ddl m} t�� t|�d��| _dS )r0 r )�weird�test_unhandledDeferredN)�twisted.trial.testr� rD �disabler � TestBleeding�test1)r r� r r r r2 = s �z UnhandledDeferredTests.setUpc C s* t �� }| �|� | �t|j�dd� dS )zo Forcing garbage collection should cause unhandled Deferreds to be reported as errors. r5 z(Unhandled deferred passed without noticeN)r r r� r rX r )r r1 r r r �test_isReportedI s �z&UnhandledDeferredTests.test_isReportedz GC works differently on PyPy.c C sP t �� }| �|� | �� ttj�}| �|dd� | �� }| �t|�dd� dS )z� Forcing garbage collection in the test should mean that there are no unreachable cycles immediately after the test completes. r z unreachable cycle still existedz Errors logged after gc.collectN)r r r� �flushLoggedErrorsrX rD �garbager )r r1 �n�xr r r �test_doesntBleedT s z'UnhandledDeferredTests.test_doesntBleedc C s t �� t �� | �� dS r� )rD rE �enabler� r# r r r r� e s z UnhandledDeferredTests.tearDownN) r) r* r+ r, r2 r� r �skipIfr r� r� r r r r r� 7 s r� c sP e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z � Z S )�AddCleanupMixinz1 Test the addCleanup method of TestCase. c s" t � �� t�� | _| �� | _dS r/ )�superr2 r r r1 � AddCleanupr: r# �r= r r r2 s s zAddCleanupMixin.setUpc C �D | j j| j _| j �| j jd� | j �| j� | �ddg| j j� dS )zQ Callables added with C{addCleanup} are run even if setUp fails. �foor2 N) r: � brokenSetUpr2 � addCleanupr� r> r1 r �logr# r r r �!test_addCleanupCalledIfSetUpFails{ s z1AddCleanupMixin.test_addCleanupCalledIfSetUpFailsc C r� )z� Callables added with C{addCleanup} are run even if setUp raises L{SkipTest}. This allows test authors to reliably provide clean up code using C{addCleanup}. r� r2 N) r: � skippingSetUpr2 r r� r> r1 r r r# r r r �!test_addCleanupCalledIfSetUpSkips� s z1AddCleanupMixin.test_addCleanupCalledIfSetUpSkipsc C sJ | j �| j jd� | j �| j jd� | j �| j� | �g d�| j j� dS )z~ Callables added with C{addCleanup} should be called before C{tearDown} in reverse order of addition. r� �bar�r2 �runTestr r� r� N�r: r r� r> r1 r r r# r r r �#test_addCleanupCalledInReverseOrder� s z3AddCleanupMixin.test_addCleanupCalledInReverseOrderc C st | j �| j jd� | j �| j� | �| j�� � | �dt| jj �� | jj \\}}| �|| j � | �|� � d� dS )z� Errors raised in cleanup functions should be treated like errors in C{tearDown}. They should be added as errors and fail the test. Skips, todos and failures are all treated as errors. r� r5 N) r: r �failr> r1 ru r r rX r �getErrorMessage�r r: �errorr r r � test_errorInCleanupIsCaptured� s z-AddCleanupMixin.test_errorInCleanupIsCapturedc C s� | j �| j jd� | j �| j jd� | j �| j� | �g d�| j j� | �dt| jj �� | jj \\}}| �|| j � | �|� � d� dS )zq If a cleanup raises an error then that does not stop the other cleanups from being run. r� r )r2 r r� r� r5 N) r: r r� r r> r1 r r rX r r r r r r �&test_cleanupsContinueRunningAfterError� s z6AddCleanupMixin.test_cleanupsContinueRunningAfterErrorc C s� | j �| j jd� | j �| j jd� | j �| j� | �g d�| j j� | �dt| jj�� | jj\\}}\}}| �|| j � | �|| j � | �|� � d� | �|� � d� dS )zm If more than one cleanup fails, then the test should fail with more than one error. r� r )r2 r r� r[ N) r: r r r> r1 r r rX r r )r r� �error1�test2�error2r r r �test_multipleErrorsReported� s z+AddCleanupMixin.test_multipleErrorsReported) r) r* r+ r, r2 r r r r r r � __classcell__r r r� r r� n s r� c @ r )�SynchronousAddCleanupTestsz� Test the addCleanup method of TestCase in the synchronous case See: L{twisted.trial.test.test_tests.AddCleanupMixin} z1twisted.trial.test.skipping.SynchronousAddCleanupN)r) r* r+ r, r r� r r r r r � r� r c @ s e Zd ZdZed�Zdd� ZdS )�AsynchronousAddCleanupTestsz� Test the addCleanup method of TestCase in the asynchronous case See: L{twisted.trial.test.test_tests.AddCleanupMixin} z2twisted.trial.test.skipping.AsynchronousAddCleanupc sR � fdd�}� j �� j jd� � j �|d� � j �� j� � �g d�� j j� dS )z� If an added callable returns a L{Deferred}, then the test should wait until that L{Deferred} has fired before running the next cleanup method. c s& t �� }t�d|j| � |�� jj�S )Nr )r �Deferredr � callLater�callback� addCallbackr: r� )rd �dr# r r �cleanup� s zMAsynchronousAddCleanupTests.test_addCleanupWaitsForDeferreds.<locals>.cleanupr� r r Nr )r r r r# r � test_addCleanupWaitsForDeferreds� s z<AsynchronousAddCleanupTests.test_addCleanupWaitsForDeferredsN)r) r* r+ r, r r� r r r r r r � s r c @ � e Zd ZdZdd� Zdd� ZdS )�SuiteClearingMixinzM Tests for our extension that allows us to clear out a L{TestSuite}. c C �B t �� }|�| �� � | �d|�� � t|� | �d|�� � dS )z_ Calling L{_clearSuite} on a populated L{TestSuite} removes all tests. r5 r N)r � TestSuite�addTest�TestCaser r% r r r r r �test_clearSuite� s z"SuiteClearingMixin.test_clearSuitec C r )z� Calling L{_clearSuite} on a populated standard library L{TestSuite} removes all tests. This test is important since C{_clearSuite} operates by mutating internal variables. r5 r N)r r! r" r# r r% r r r r r �test_clearPyunitSuite� s z(SuiteClearingMixin.test_clearPyunitSuiteN)r) r* r+ r, r$ r% r r r r r � s r c @ � e Zd ZdZejZdS )� SynchronousSuiteClearingTestsz� Tests for our extension that allows us to clear out a L{TestSuite} in the synchronous case. See L{twisted.trial.test.test_tests.SuiteClearingMixin} N�r) r* r+ r, r r� r# r r r r r' � r' c @ � e Zd ZdZejZdS )� AsynchronousSuiteClearingTestsz� Tests for our extension that allows us to clear out a L{TestSuite} in the asynchronous case. See L{twisted.trial.test.test_tests.SuiteClearingMixin} N�r) r* r+ r, r r# r r r r r+ r) r+ c @ sh e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )�TestDecoratorMixinz1 Tests for our test decoration features. c C sd | � |j|jd� t|dd�}t|dd�}| �||� || u r%du r0n dS | �||� dS dS )zB Assert that the given decorated tests are equal. �Different class� _originalTestN)r r= �getattrrF )r �observed�expected�observedOriginal�expectedOriginalr r r �assertTestsEqual' s �z#TestDecoratorMixin.assertTestsEqualc C sr | � |j|jd� | � t|j�t|j�d� t|j|j�D ]\}}t|dd�dur0| �||� q | �||� q dS )zS Assert that the given test suites with decorated tests are equal. r. zDifferent number of tests.�_testsN)r r= rX r6 �zipr0 �assertSuitesEqualr5 )r r1 r2 � observedTest� expectedTestr r r r8 2 s ��z$TestDecoratorMixin.assertSuitesEqualc C s@ | � � }t�|�}ddlm} |� }|�|� | �|j|� dS )z� For decorated tests, C{run} uses a result adapter that preserves the test decoration for calls to C{addError}, C{startTest} and the like. See L{reporter._AdaptedReporter}. r ��LoggingReporterN)r# r � TestDecorator� twisted.trial.test.test_reporterr< r> r5 r: �r r: � decoratedTestr< r1 r r r � test_usesAdaptedReporterWithRun@ s z2TestDecoratorMixin.test_usesAdaptedReporterWithRunc C s> | � � }t�|�}ddlm} |� }||� | �|j|� dS )z� For decorated tests, C{__call__} uses a result adapter that preserves the test decoration for calls to C{addError}, C{startTest} and the like. See L{reporter._AdaptedReporter}. r r; N)r# r r= r> r< r5 r: r? r r r � test_usesAdaptedReporterWithCallP s z3TestDecoratorMixin.test_usesAdaptedReporterWithCallc C s, | � � }t�|tj�}| �t�|�|� dS )z� Calling L{decorate} on a single test case returns the test case decorated with the provided decorator. N�r# r �decorater= r5 )r r: r@ r r r �test_decorateSingleTesta s z*TestDecoratorMixin.test_decorateSingleTestc C s@ | � � }t�|g�}t�|tj�}| �|t�t�|�g�� dS )z� Calling L{decorate} on a test suite will return a test suite with each test decorated with the provided decorator. N�r# r r! rD r= r8 �r r: r r@ r r r �test_decorateTestSuitej � �z)TestDecoratorMixin.test_decorateTestSuitec C sZ | � � }t�|g�}t�|tj�}| �|t�t�|�g�� | �|t�t�|�g�� dS )zU Calling L{decorate} on a test suite will mutate the original suite. NrF rG r r r �#test_decorateInPlaceMutatesOriginalv s ��z6TestDecoratorMixin.test_decorateInPlaceMutatesOriginalc C s` t tdd�}|du rt�d��| �� }t�|g�}||�}t�|tj� ||�}| �||� dS )ac When decorating a test suite in-place, the number of references to the test objects in that test suite should stay the same. Previously, L{unittest.decorate} recreated a test suite, so the original suite kept references to the test objects. This test is here to ensure the problem doesn't reappear again. � getrefcountNz*getrefcount not supported on this platform) r0 �sysr �SkipTestr# r! rD r= r )r rK r: r �count1�count2r r r � test_decorateTestSuiteReferences� s z3TestDecoratorMixin.test_decorateTestSuiteReferencesc C sT | � � }t�t�|g�g�}t�|tj�}t�t�t�|�g�g�}| �||� dS )z� Calling L{decorate} on a test suite with nested suites will return a test suite that maintains the same structure, but with all tests decorated. NrF )r r: r r@ r2 r r r � test_decorateNestedTestSuite� s �z/TestDecoratorMixin.test_decorateNestedTestSuitec C s: | � � }t�|tj�}t�|tj�}| �|t�|�� dS )z� Calling L{decorate} on a test suite with already-decorated tests decorates all of the tests in the suite again. NrC )r r: r@ �redecoratedTestr r r �test_decorateDecoratedSuite� s z.TestDecoratorMixin.test_decorateDecoratedSuitec C s@ | � � }t�|g�}t�|tj�}| �|t�t�|�g�� dS )z� Tests can be in non-standard suites. L{decorate} preserves the non-standard suites when it decorates the tests. N)r# r �DestructiveTestSuiter rD r= r8 )r r: r � decoratedr r r �test_decoratePreservesSuite� rI z.TestDecoratorMixin.test_decoratePreservesSuiteN)r) r* r+ r, r5 r8 rA rB rE rH rJ rP rQ rS rV r r r r r- " s r- c @ r& )� SynchronousTestDecoratorTestsz� Tests for our test decoration features in the synchronous case. See L{twisted.trial.test.test_tests.TestDecoratorMixin} Nr( r r r r rW � � rW c @ r* )� AsynchronousTestDecoratorTestsz� Tests for our test decoration features in the asynchronous case. See L{twisted.trial.test.test_tests.TestDecoratorMixin} Nr, r r r r rY � rX rY c @ r- )�MonkeyPatchMixinzF Tests for the patch() helper method in L{unittest.TestCase}. c C s" d| _ d| _| j | _| �� | _dS )r0 �original�patchedN)� originalValue� patchedValue� objectToPatchr# r: r# r r r r2 � s zMonkeyPatchMixin.setUpc C s& | j �| d| j� | �| j| j� dS )zi Calling C{patch()} on a test monkey patches the specified object and attribute. r_ N)r: �patchr^ r r_ r# r r r � test_patch� s zMonkeyPatchMixin.test_patchc C s6 | j �| d| j� | j �t�� � | �| j| j� dS )zw Any monkey patches introduced by a test using C{patch()} are reverted after the test has run. r_ N) r: r` r^ r> r r� r r_ r] r# r r r �test_patchRestoredAfterRun� s z+MonkeyPatchMixin.test_patchRestoredAfterRunc C s. | j �| d| j�}|�� | �| j| j� dS )z� C{patch()} return a L{monkey.MonkeyPatcher} object that can be used to restore the original values before the end of the test. r_ N)r: r` r^ �restorer r_ r] �r r` r r r �test_revertDuringTest� s z&MonkeyPatchMixin.test_revertDuringTestc C s6 | j �| d| j�}|�� |�� | �| j| j� dS )zq The returned L{monkey.MonkeyPatcher} object can re-apply the patch during the test run. r_ N)r: r` r^ rc r r_ rd r r r �test_revertAndRepatch� s z&MonkeyPatchMixin.test_revertAndRepatchc C sd | j �| d| j� | �| j| j� | j �| dd� | �| jd� | j �t�� � | �| j| j� dS )zW Successive patches are applied and reverted just like a single patch. r_ z second valueN) r: r` r^ r r_ r> r r� r] r# r r r �test_successivePatches s z'MonkeyPatchMixin.test_successivePatchesN) r) r* r+ r, r2 ra rb re rf rg r r r r rZ � s rZ c @ r& )�SynchronousMonkeyPatchTestsz� Tests for the patch() helper method in the synchronous case. See L{twisted.trial.test.test_tests.MonkeyPatchMixin} Nr( r r r r rh rX rh c @ r* )� AsynchronousMonkeyPatchTestsz� Tests for the patch() helper method in the asynchronous case. See L{twisted.trial.test.test_tests.MonkeyPatchMixin} Nr, r r r r ri rX ri c @ r� ) �IterateTestsMixinz] L{_iterateTests} returns a list of all test cases in a test suite or test case. c C s" | � � }| �|gtt|��� dS )zj L{_iterateTests} on a single test case returns a list containing that test case. N)r# r r� r r? r r r �test_iterateTestCase) s z&IterateTestsMixin.test_iterateTestCasec C s. | � � }t�|g�}| �|gtt|��� dS )z� L{_iterateTests} on a test suite that contains a single test case returns a list containing that test case. N�r# r r! r r� r �r r: r r r r � test_iterateSingletonTestSuite1 s z0IterateTestsMixin.test_iterateSingletonTestSuitec C s6 | � � }t�t�|g�g�}| �|gtt|��� dS )zP L{_iterateTests} returns tests that are in nested test suites. Nrl rm r r r �test_iterateNestedTestSuite: s z-IterateTestsMixin.test_iterateNestedTestSuitec C s: | � � }t�t�|g�| g�}| �|| gtt|��� dS )zU L{_iterateTests} returns tests in left-to-right, depth-first order. Nrl rm r r r �#test_iterateIsLeftToRightDepthFirstB s z5IterateTestsMixin.test_iterateIsLeftToRightDepthFirstN)r) r* r+ r, rk rn ro rp r r r r rj # s rj c @ r& )� SynchronousIterateTestsTestsz� Check that L{_iterateTests} returns a list of all test cases in a test suite or test case for synchronous tests. See L{twisted.trial.test.test_tests.IterateTestsMixin} Nr( r r r r rq K r) rq c @ r* )� AsynchronousIterateTestsTestsz� Check that L{_iterateTests} returns a list of all test cases in a test suite or test case for asynchronous tests. See L{twisted.trial.test.test_tests.IterateTestsMixin} Nr, r r r r rr V r) rr c @ r )�TrialGeneratorFunctionTestsz= Tests for generator function methods in test cases. c C � G dd� dt j�}|d�}t�� }|�|� | �t|j�d� | �t|j�d� | � d|jd d j j d � | � d|jd d j j d � | � d|jd d j j d � d S ) z� In a TestCase, a test method which is a generator function is reported as an error, as such a method will never run assertions. c @ r� )zTTrialGeneratorFunctionTests.test_errorOnGeneratorFunction.<locals>.GeneratorTestCasez? A fake TestCase for testing purposes. c s � � | � d� dV dS �zt A method which is also a generator function, for testing purposes. z this should never be reachedN�r r# r r r �test_generatorq � � zcTrialGeneratorFunctionTests.test_errorOnGeneratorFunction.<locals>.GeneratorTestCase.test_generatorN�r) r* r+ r, rx r r r r �GeneratorTestCasel r� r{ rx r r5 z GeneratorTestCase.test_generatorz+GeneratorTestCase testMethod=test_generator�4is a generator function and therefore will never runN) r r# r r r> r rX r! r �assertInr� �args)r r{ �testCaser1 r r r � test_errorOnGeneratorFunctionf s" ���z9TrialGeneratorFunctionTests.test_errorOnGeneratorFunctionc C rt ) z� In a SynchronousTestCase, a test method which is a generator function is reported as an error, as such a method will never run assertions. c @ r� )zrTrialGeneratorFunctionTests.test_synchronousTestCaseErrorOnGeneratorFunction.<locals>.GeneratorSynchronousTestCasezJ A fake SynchronousTestCase for testing purposes. c s ru rv rw r# r r r rx � ry z�TrialGeneratorFunctionTests.test_synchronousTestCaseErrorOnGeneratorFunction.<locals>.GeneratorSynchronousTestCase.test_generatorNrz r r r r � GeneratorSynchronousTestCase� r� r� rx r r5 z+GeneratorSynchronousTestCase.test_generatorz6GeneratorSynchronousTestCase testMethod=test_generatorr| N) r r� r r r> r rX r! r r} r� r~ )r r� r r1 r r r �0test_synchronousTestCaseErrorOnGeneratorFunction� s$ ���zLTrialGeneratorFunctionTests.test_synchronousTestCaseErrorOnGeneratorFunctionN)r) r* r+ r, r� r� r r r r rs a s $rs )Ir, rD rL r r rB �ior �twisted.internetr r �twisted.python.compatr �twisted.python.reflectr � twisted.trialr r r �twisted.trial._asyncrunnerr r r r� r �#twisted.trial.test.test_suppressionr r r. r� rI r# rM rN rl ro rq r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r' r+ r- rW rY rZ rh ri rj rq rr rs r r r r �<module> st ;I3 X 7 7 +377X ! > ( PK b�ZPn�,Y ,Y , test/__pycache__/test_loader.cpython-310.pycnu �[��� o �bXW � @ s� d Z ddlZddlZddlZddlmZ ddlmZm Z ddl m Z ddl m Z ddlmZmZmZ ddlmZ dd lmZ dd lmZ d d � ZG d d� dej�ZG dd� dej�ZG dd� dej�ZG dd� de�Z G dd� dej�Z dS )z" Tests for loading tests by name. � N)�md5)�filepath�util)� getModule)�ModuleNotFound)�reporter�runner�unittest)� _iterateTests)� ITestCase)�packagesc C s$ g }t | �D ] }|�|�� � q|S )zI Return the id of each test within the given test suite or case. )r �append�id)�tests�names�test� r �@/usr/lib/python3/dist-packages/twisted/trial/test/test_loader.py� testNames s r c s< e Zd Z� fdd�Zdd� Zdd� Zdd� Zd d � Z� ZS ) �FinderPy3Testsc s t � �� t�� | _d S �N)�super�setUpr � TestLoader�loader��self�� __class__r r r " s zFinderPy3Tests.setUpc C � | � t| jjd� dS )z� findByName, if given something findable up until the last entry, will raise AttributeError (as it cannot tell if 'nonexistent' here is supposed to be a module or a class). z twisted.trial.test.nonexistentN)� assertRaises�AttributeErrorr � findByNamer r r r �test_findNonModule& s �z!FinderPy3Tests.test_findNonModulec C � | � t| jjd� d S )N� nonextant)r r r r" r r r r �test_findNonPackage0 s z"FinderPy3Tests.test_findNonPackagec C s" t �td�}| �t| jj|� dS )z� findByName, given a file path that doesn't exist, will raise a ValueError saying that it is not a Python file. znonexistent.pyN)r �sibpath�__file__r � ValueErrorr r" )r �pathr r r �test_findNonFile3 s z FinderPy3Tests.test_findNonFilec C r )zn findByName will re-raise ImportErrors inside modules that it has found and imported. z unimportablepackage.test_moduleN)r � ImportErrorr r" r r r r � test_findFileWithImportError; s �z+FinderPy3Tests.test_findFileWithImportError) �__name__� __module__� __qualname__r r# r& r+ r- � __classcell__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 dS )� FileTestsz/ Tests for L{runner.filenameToModule}. c C s$ | � ttjd�}| �t|�d� dS )zo L{runner.filenameToModule} raises a C{ValueError} when a non-existing file is passed. �itz'it' doesn't existN)r r) r �filenameToModule� assertEqual�str)r �errr r r � test_notFileJ s zFileTests.test_notFilec C s. t �t�td��}ddlm} | �||� dS )z� If the file in question is a module on the Python path, then it should properly import and return that module. z sample.pyr ��sampleN)r r4 r r' r( �twisted.trial.testr: r5 �r �sample1�sample2r r r �test_moduleInPathR s zFileTests.test_moduleInPathc C sr | � | j� t�tj�| jdd��}| �|j d� | � � | � | j � ddl m } | �||� | �|j|j� dS )a If passed the path to a file containing the implementation of a module within a package which is not on the import path, L{runner.filenameToModule} returns a module object loosely resembling the module defined by that file anyway. � goodpackageztest_sample.pyzgoodpackage.test_sampler )� test_sampleN)� mangleSysPath�oldPathr r4 �osr* �join�parentr5 r. �cleanUpModules�newPathr@ rA � assertIsNot�__spec__r< r r r �test_moduleNotInPath\ s � z FileTests.test_moduleNotInPathc C s, t �tj�| jd��}| �|tjd � dS )z� If the file in question is a package on the Python path, then it should properly import and return that package. r@ N) r r4 rD r* rE rF �assertIs�sys�modules)r �package1r r r �test_packageInPathq s z FileTests.test_packageInPathc C sl | � | j� t�tj�| jd��}| �|j d� | � � | � | j � ddl }| � ||� | �|j|j� dS )z� If passed the path to a directory which represents a package which is not on the import path, L{runner.filenameToModule} returns a module object loosely resembling the package defined by that directory anyway. r@ r N)rB rC r r4 rD r* rE rF r5 r. rG rH r@ rI rJ )r rO r@ r r r �test_packageNotInPathz s z FileTests.test_packageNotInPathc C sH t �| j��d�}|�� | �ttj|j �}| � t |�|j �d�� dS )z� L{runner.filenameToModule} raises a C{ValueError} when the name of an empty directory is passed that isn't considered a valid Python package because it doesn't contain a C{__init__.py} file. �emptyDirectoryz is not a package directoryN) r �FilePathrF �child�createDirectoryr r) r r4 r* r5 r6 )r �emptyDirr7 r r r �test_directoryNotPackage� s z"FileTests.test_directoryNotPackagec C s2 t �| j��d�}|�d� | �ttj|j � dS )zn L{runner.filenameToModule} raises a C{SyntaxError} when a non-Python file is passed. � notpythons This isn't pythonN) r rS rF rT � setContentr � SyntaxErrorr r4 r* )r �filenamer r r �test_filenameNotPython� s z FileTests.test_filenameNotPythonc C sZ t �| j��d�}|�tj�d�� zt� |j �}| � |j |j � W |� � dS |� � w )zX The C{__file__} attribute of the module should match the package name. zgoodpackage.py�utf8N)r rS rF rT rY r � testModule�encoder r4 r* r5 r( �remove)r r[ �moduler r r �test_filenameMatchesPackage� s z%FileTests.test_filenameMatchesPackagec C s� t �| j��d�}|�� |�d��d� z)t�|j�}| � |j � d�� t�|jt jj �}| � |j � d�� W |�� dS |�� w )z� Test loader against a filesystem directory containing an empty C{__init__.py} file. It should handle 'path' and 'path/' the same way. � goodDirectory� __init__.py� N)r rS rF rT rU rY r r4 r* � assertTruer. �endswithrD �sepr` )r �goodDirra r r r �test_directory� s zFileTests.test_directoryN) r. r/ r0 �__doc__r8 r? rK rP rQ rW r\ rb rj r r r r r2 E s r2 c @ 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$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z!d>d?� Z"d@S )A� LoaderTestsz( Tests for L{trial.TestLoader}. c C s t �� | _tj�| � d S r )r r r r �SysPathManglingTestr r r r r r � s zLoaderTests.setUpc s� ddl m} | j�|j�}| �g d�dd� |jD �� g d�}tt|t d���� � fdd �| j_ | j�|j�}| �|d d� |jD �� d S ) Nr r9 )�test_a�test_b�test_cc S � g | ]}|j �qS r ��_testMethodName��.0r r r r � <listcomp>� � z.LoaderTests.test_sortCases.<locals>.<listcomp>)ro rp rn � c s � � | �� d�S )N���)�get�shortDescription)�x��sortDictr r �<lambda>� s z,LoaderTests.test_sortCases.<locals>.<lambda>c S rq r rr rt r r r rv � rw ) r; r: r � loadClass� AlphabetTestr5 �_tests�dict�zip�range�sorter)r r: �suite�newOrderr r} r �test_sortCases� s � zLoaderTests.test_sortCasesc C sB | j �d�}t�� }|�|� | �|jd� | �t|j�d� dS )z{ Loading a test that fails and getting the result of it ends up with one test ran and one failure. z6twisted.trial.test.erroneous.TestRegularFail.test_fail� N) r � loadByNamer � TestResult�runr5 �testsRun�len�failures)r r� �resultr r r �test_loadFailure� s � z LoaderTests.test_loadFailurec C �J ddl m} | jj|jj|jg d�d�}| �d|�� � | �d|j� dS )z� A decorated test method for which the decorator has failed to set the method's __name__ correctly is loaded and its name in the class scope discovered. r r9 )r: �DecorationTest�test_badDecorator�rF �qualNamer� r� N) r; r: r � loadAnythingr� r� r5 �countTestCasesrs �r r: r� r r r �test_loadBadDecorator� � �z!LoaderTests.test_loadBadDecoratorc C r� )z� A decorated test method for which the decorator has set the method's __name__ correctly is loaded and the only name by which it goes is used. r r9 )r: r� �test_goodDecoratorr� r� r� N) r; r: r r� r� r� r5 r� rs r� r r r �test_loadGoodDecorator� s �z"LoaderTests.test_loadGoodDecoratorc C r� )z� Load a decorated method which has been copied to a new name inside the class. Thus its __name__ and its key in the class's __dict__ no longer match. r r9 )r: r� �test_renamedDecoratorr� r� r� N) r; r: r r� r� r� r5 r� rs r� r r r �test_loadRenamedDecorator r� z%LoaderTests.test_loadRenamedDecoratorc C sJ ddl m} | j�|j�}| �d|�� � | �ddgdd� |jD �� d S )Nr r9 � �test_bar�test_fooc S rq r rr rt r r r rv rw z.LoaderTests.test_loadClass.<locals>.<listcomp>)r; r: r r� �FooTestr5 r� r� r� r r r �test_loadClass s �zLoaderTests.test_loadClassc C s\ ddl m} | �t| jj|� | �t| jj|jj� | �t| jjd� | �t| jjd� d S �Nr r9 �string)�foo�bar)r; r: r � TypeErrorr r� r� r� �r r: r r r �test_loadNonClass s z LoaderTests.test_loadNonClassc C s$ ddl m} | �t| jj|j� d S �Nr r9 )r; r: r r) r r� �NotATestr� r r r �test_loadNonTestCase$ s z LoaderTests.test_loadNonTestCasec C s, ddl m} | j�|�}| �d|�� � d S )Nr r9 � )r; r: r � loadModuler5 r� r� r r r �test_loadModule) s zLoaderTests.test_loadModulec C �^ ddl m} | �t| jj|j� | �t| jj|jj� | �t| jjd� | �t| jjd� d S r� )r; r: r r� r r� r� r� r� r r r �test_loadNonModule/ � z LoaderTests.test_loadNonModulec C s( dd l }| j�|�}| �d|�� � d S �Nr � �r@ r � loadPackager5 r� �r r@ r� r r r �test_loadPackage7 s z LoaderTests.test_loadPackagec C r� r� )r; r: r r� r r� r� r� r� r r r �test_loadNonPackage= r� z LoaderTests.test_loadNonPackagec C s" ddl m} | �t| jj|� d S r� )r; r: r r� r r� r� r r r �test_loadModuleAsPackageE s z$LoaderTests.test_loadModuleAsPackagec C s, dd l }| jj|dd�}| �d|�� � d S �Nr T��recurse� r� r� r r r �test_loadPackageRecursiveK s z%LoaderTests.test_loadPackageRecursivec C s: ddl m} | j�|�}| �|j|jd jd jj� d S r� ) r; r: r r� r5 r. r� r r/ r� r r r �test_loadAnythingOnModuleQ s �z%LoaderTests.test_loadAnythingOnModulec C s. ddl m} | j�|j�}| �d|�� � d S )Nr r9 r� )r; r: r r� r� r5 r� r� r r r �test_loadAnythingOnClassY s z$LoaderTests.test_loadAnythingOnClassc C s< dd l }| j�|�}| �t|| jj�� | �d|�� � d S r� �r@ r r� rf � isinstance� suiteFactoryr5 r� r� r r r �test_loadAnythingOnPackage_ s z&LoaderTests.test_loadAnythingOnPackagec C s@ dd l }| jj|dd�}| �t|| jj�� | �d|�� � d S r� r� r� r r r �#test_loadAnythingOnPackageRecursivef s z/LoaderTests.test_loadAnythingOnPackageRecursivec C r$ )Nr@ )r r� r r� r r r r �test_loadAnythingOnStringm s z%LoaderTests.test_loadAnythingOnStringc C sx dd l }| jj|dd�}t�� }|�|� | �d|�� � | �dt|j �� dd� |j D �}|� � | �|dd g� d S ) Nr Tr� Fr� c S s g | ]\}}|� � �qS r )r )ru r �errorr r r rv z s z1LoaderTests.test_importErrors.<locals>.<listcomp>zpackage.test_bad_modulezpackage.test_import_module) �packager r� r �Reporterr� r5 � wasSuccessfulr� �errors�sort)r r� r� r� r� r r r �test_importErrorsr s �z LoaderTests.test_importErrorsc C sB G dd� dt j�}| j�|�}t�� }|�|� | �|�� � dS )z� L{TestLoader.loadClass} returns a suite with each test method represented by a different instances of the L{TestCase} they are defined on. c @ s e Zd Zdd� Zdd� ZdS )z>LoaderTests.test_differentInstances.<locals>.DistinctInstancesc S s d| _ d S )N�test1Run)�firstr r r r �test_1� s zELoaderTests.test_differentInstances.<locals>.DistinctInstances.test_1c S s | � t| d�� d S )Nr� )� assertFalse�hasattrr r r r �test_2� s zELoaderTests.test_differentInstances.<locals>.DistinctInstances.test_2N)r. r/ r0 r� r� r r r r �DistinctInstances� s r� N) �pyunit�TestCaser r� r r� r� rf r� )r r� r� r� r r r �test_differentInstances� s z#LoaderTests.test_differentInstancesc C �@ ddl m} | j�|�}| �d|�� � | �dt|dd�� dS )zp Check that C{test_suite} is used when present and other L{TestCase}s are not included. r )�mockcustomsuite� MyCustomSuite�nameN)r; r� r r� r5 r� �getattr)r r� r� r r r � test_loadModuleWith_test_suite� � z*LoaderTests.test_loadModuleWith_test_suitec C r� )zo Check that C{testSuite} is used when present and other L{TestCase}s are not included. r ��mockcustomsuite2r� r� N)r; r� r r� r5 r� r� )r r� r� r r r � test_loadModuleWith_testSuite� r� z)LoaderTests.test_loadModuleWith_testSuitec C s0 ddl m} | j�|�}| �dt|dd�� dS )z� Check that if C{testSuite} and C{test_suite} are both present in a module then C{testSuite} gets priority. r )�mockcustomsuite3� testSuiter� N)r; r� r r� r5 r� )r r� r� r r r � test_loadModuleWithBothCustom� s z)LoaderTests.test_loadModuleWithBothCustomc C sJ dd� }ddl m} ||j|_}z| �t| jj|� W ||_dS ||_w )zz Make sure that any C{AttributeError}s raised by C{testSuite} are not swallowed by L{TestLoader}. c S s t d��)Nzshould be reraised)r! r r r r r� � s zBLoaderTests.test_customLoadRaisesAttributeError.<locals>.testSuiter r� N)r; r� r� r r! r r� )r r� r� �originalr r r �#test_customLoadRaisesAttributeError� s z/LoaderTests.test_customLoadRaisesAttributeErrorc C s0 t |�}t |�}|�� |�� | �||� d S r )r r� r5 )r �test1�test2�names1�names2r r r �assertSuitesEqual� s z LoaderTests.assertSuitesEqualc C s4 d}| j �||gd�}| j �|d�}| �||� dS )z@ Check that loadByNames ignores duplicate names �twisted.trial.test.test_logTN)r � loadByNamesr� r� )r ra �suite1�suite2r r r �test_loadByNamesDuplicate� s z%LoaderTests.test_loadByNamesDuplicatec C s@ g d�}| j �|�}t�t| j j|��}| �t|�t|�� dS )zX L{TestLoader.loadByNames} preserves the order of tests provided to it. )�$inheritancepackage.test_x.A.test_fooztwisted.trial.test.sampler@ r� z!twisted.trial.test.sample.FooTest�package.test_moduleN)r r� r � TestSuite�mapr� r5 r �r rN r� r� r r r � test_loadByNamesPreservesOrder� s z*LoaderTests.test_loadByNamesPreservesOrderc C �8 ddg}| j �|�}t�t| j j|��}| �||� dS )zM Check that loadByNames loads all the names that it is given r@ r� N�r r� r r� r� r� r� r� r r r �test_loadDifferentNames� s z#LoaderTests.test_loadDifferentNamesc C r� )zu Check that test methods names which are inherited from are all loaded rather than just one. r� z$inheritancepackage.test_x.B.test_fooNr� )r �methodsr� r� r r r �test_loadInheritedMethods� s � z%LoaderTests.test_loadInheritedMethodsN)#r. r/ r0 rk r r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r rl � sB rl c @ s e Zd Zdd� ZdS )�ZipLoadingTestsc C sN ddl m} t�| � || j| jd � | jd7 _| �| j| jg � d S )Nr )�zipitz.zip)� twisted.python.test.test_zippathr rl r rF rB rC )r r r r r r � s zZipLoadingTests.setUpN)r. r/ r0 r r r r r r � s r c @ s: e Zd Zdd� Zdd� Zejfdd�Zdd� Zd d � Z d S ) �PackageOrderingTestsc C sl t �� | _| �� | _tj�| jd�}t�|� t tj�|d�d�� � t j � | |� | �| j| jg � d S )N� uberpackagerd �wb)r r r �mktemp�topDirrD r* rE �makedirs�open�closer rm r rB rC )r rF r r r r s zPackageOrderingTests.setUpc c s� � t d�}g }|�� D ]}|j�d�d �d�r |�|� q t||d�}|D ]S}|�d�}|du r5|V q&g }|�� D ]} t � | �� �rI|�| � q;t||d�} | D ]&} g } | �� D ]} | j�d�d �d�rl| �| � qZt| |d�}|E dH qRq&dS )a� Right now, halfway by accident, trial sorts like this: 1. all modules are grouped together in one list and sorted. 2. within each module, the classes are grouped together in one list and sorted. 3. finally within each class, each test method is grouped together in a list and sorted. This attempts to return a sorted list of testable thingies following those rules, so that we can compare the behavior of loadPackage. The things that show as 'cases' are errors from modules which failed to import, and test methods. Let's gather all those together. r �.ry �test_)�keyNr ) r � walkModulesr� �split� startswithr �sorted�load�iterAttributesr � isTestCase)r r� �pkg� testModulesr^ � sortedModules�modinfora � testClasses�attrib� sortedClasses�clsinfo� testMethods�attr� sortedMethodsr r r �_trialSortAlgorithm s8 � � � � ��z(PackageOrderingTests._trialSortAlgorithmc C s� ddl }|| j_| jj|dd�}t�|t�}tt|��}t| � |��}t t ||��D ]\}\}}| � |j |�� d||j |�� f � q*| � t|�t|�� dS )zG Verify that packages are loaded in the correct order. r NTr� z #%d: %s != %s)r r r� r� r �decorater �listr r � enumerater� r5 r� r r� ) r r� r r� �resultingTests�manifest�number� manifestTest� actualTestr r r �loadSortedPackages; s ��z'PackageOrderingTests.loadSortedPackagesc C s | � � d S r �r) r r r r � test_sortPackagesDefaultOrderR s z2PackageOrderingTests.test_sortPackagesDefaultOrderc C s dd� }| � |� d S )Nc S s t �| �}t|�d���� }|S )Nr] )r r� r r_ � hexdigest)�s�n�dr r r � sillySorterV s zEPackageOrderingTests.test_sortPackagesSillyOrder.<locals>.sillySorterr* )r r0 r r r �test_sortPackagesSillyOrderU s z0PackageOrderingTests.test_sortPackagesSillyOrderN) r. r/ r0 r r r r� r) r+ r1 r r r r r s + r ) rk rD rM r r� �hashlibr �twisted.pythonr r �twisted.python.modulesr �twisted.python.reflectr � twisted.trialr r �twisted.trial._asyncrunnerr �twisted.trial.itrialr r; r r rm r r2 rl r r r r r r �<module> s( ${ > PK b�Z��J6�# �# ) test/__pycache__/test_log.cpython-310.pycnu �[��� o �bh � @ s� d Z ddlZddlmZmZ ddlmZmZ ddlm Z m Z m Z dd� Z G dd � d �Z G d d � d e j�ZG d d � d �ZG dd� dee j�ZG dd� dee j�ZdS )zG Test the interaction between trial and errors logged during test run. � N)�reactor�task)�failure�log)� _synctest�reporter�unittestc C s, zdd W | S t y t�� } Y | S w )z* Return a new, realistic failure. � r )�ZeroDivisionErrorr �Failure)�f� r �=/usr/lib/python3/dist-packages/twisted/trial/test/test_log.py� makeFailure s � �r c @ sF e Zd ZdZG dd� d�ZG dd� deej�ZG dd� deej�Z dS ) �Maskz? Hide C{MockTest}s from Trial's automatic test finder. c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) zMask.FailureLoggingMixinc C s dS )z/ Don't log any errors. Nr ��selfr r r � test_silent s z$Mask.FailureLoggingMixin.test_silentc C s t �t� � dS )z- Log a single error. N�r �errr r r r r � test_single% s z$Mask.FailureLoggingMixin.test_singlec C s t �t� � t �t� � dS )z) Log two errors. Nr r r r r � test_double+ s z$Mask.FailureLoggingMixin.test_doublec C s t �t� � dd dS )z8 Log a single error, then fail. r Nr r r r r �test_singleThenFail2 s z,Mask.FailureLoggingMixin.test_singleThenFailN)�__name__� __module__� __qualname__r r r r r r r r �FailureLoggingMixin s r c @ s e Zd ZdS )z Mask.SynchronousFailureLoggingN)r r r r r r r �SynchronousFailureLogging9 s r c @ s e Zd Zdd� ZdS )z Mask.AsynchronousFailureLoggingc C s t �tddd� �S )zC Log an error in an asynchronous callback. r c S s t �t� �S �Nr r r r r �<lambda>A s zAMask.AsynchronousFailureLogging.test_inCallback.<locals>.<lambda>)r � deferLaterr r r r r �test_inCallback= s z/Mask.AsynchronousFailureLogging.test_inCallbackN)r r r r! r r r r �AsynchronousFailureLogging< s r" N) r r r �__doc__r r �SynchronousTestCaser �TestCaser" r r r r r s r c @ sP e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dS )� ObserverTestsz Tests for L{_synctest._LogObserver}, a helper for the implementation of L{SynchronousTestCase.flushLoggedErrors}. c C s t �� | _t�� | _d S r )r � TestResult�resultr � _LogObserver�observerr r r r �setUpJ s zObserverTests.setUpc C s0 | j �dt�� ddd�� | �| j �� g � dS )zW Test that a standard log message doesn't go anywhere near the result. )z some messager �-)�message�time�isError�systemN)r* �gotEventr. � assertEqual� getErrorsr r r r �test_msgN s ��zObserverTests.test_msgc C s< t � }| j�dt�� dd|dd�� | �| j�� |g� dS )zF Test that an observed error gets added to the result r r r, N�r- r. r/ r0 r �why)r r* r1 r. r2 r3 �r r r r r � test_error\ s �� zObserverTests.test_errorc C sL | � � | j�� }| �| j�� g � | �t|�d� | �|d �t�� dS )zS Check that flushing the observer with no args removes all errors. r r N) r8 r* � flushErrorsr2 r3 �len� assertTrue�checkr )r �flushedr r r � test_flushm s zObserverTests.test_flushc C s t �td��S )Nz test error)r r � RuntimeErrorr r r r �_makeRuntimeFailurew � z!ObserverTests._makeRuntimeFailurec C sx | � � | �� }| j�tdt�� dd|dd�� | j�t�}| �| j� � |g� | �t |�d� | � |d � t�� dS )zY Check that flushing the observer remove all failures of the given type. r r r, Nr5 r ) r8 r@ r* r1 �dictr. r9 r r2 r3 r: r; r< )r r r= r r r �test_flushByTypez s �� z ObserverTests.test_flushByTypec C sF | j �t� t� }| j �dt�� dd|dd�� | �| j �� g � dS )zS Check that C{_ignoreErrors} actually causes errors to be ignored. r r r, Nr5 )r* � _ignoreErrorsr r r1 r. r2 r3 r7 r r r �test_ignoreErrors� s �� z ObserverTests.test_ignoreErrorsc C sR | j �t� | j �� t� }| j �dt�� dd|dd�� | �| j �� |g� dS )zj Check that C{_clearIgnores} ensures that previously ignored errors get captured. r r r, Nr5 ) r* rD r � _clearIgnoresr r1 r. r2 r3 r7 r r r �test_clearIgnores� s �� z ObserverTests.test_clearIgnoresN) r r r r# r+ r4 r8 r> r@ rC rE rG r r r r r& D s r& c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�LogErrorsMixinzb High-level tests demonstrating the expected behaviour of logged errors during tests. c C s t �� | _d S r )r r' r( r r r r r+ � rA zLogErrorsMixin.setUpc C s | � t� d S r )�flushLoggedErrorsr r r r r �tearDown� rA zLogErrorsMixin.tearDownc C sf | � d�}|| j� | �t| jj�d� | �| jjd d �t�| jjd d � | �d| jj� dS )zI Test that a logged error gets reported as a test error. r r r N) �MockTestr( r2 r: �errorsr; r< r � successes�r �testr r r �test_singleError� s "�z LogErrorsMixin.test_singleErrorc C s< | � d�}|| j� | �t| jj�d� | �d| jj� dS )zf Test that when two errors get logged, they both get reported as test errors. r � r N�rK r( r2 r: rL rM rN r r r �test_twoErrors� s z LogErrorsMixin.test_twoErrorsc C sh | � d�}| � d�}|| j� || j� | �t| jj�d� | �| jjd d |� | �d| jj� dS )zT Check that an error logged in one test doesn't fail the next test. r r r r NrR �r �t1�t2r r r �test_errorsIsolated� s z"LogErrorsMixin.test_errorsIsolatedc C s� | � d�}| � d�}|| j� || j� | �t| jj�d� | �| jjd d |� | jjd d �t� | �| jjd d |� | jjd d �t� | �d| jj� dS )zN An error logged in a failed test doesn't fail the next test. r r rQ r r N) rK r( r2 r: rL �trap� TypeErrorr rM rT r r r � test_errorsIsolatedWhenTestFails� s z/LogErrorsMixin.test_errorsIsolatedWhenTestFailsc C sL t �� }| �t d|� tjjdd� }| �� }|| j� | �|tjj� dS )zE There are no extra log observers after a test runs. � _logObserverN) r r) �patchr �theLogPublisher� observersrK r( r2 )r r* r^ rO r r r �test_boundedObservers� s z$LogErrorsMixin.test_boundedObserversN) r r r r# r+ rJ rP rS rW rZ r_ r r r r rH � s rH c @ s e Zd ZejZdS )�SynchronousLogErrorsTestsN)r r r r r rK r r r r r` � s r` c @ s e Zd ZejZdd� ZdS )�AsynchronousLogErrorsTestsc C sV | � d�}|| j� | �t| jj�d� | �| jjd d �t�| jjd d � dS )zS Test that errors logged in callbacks get reported as test errors. r! r r N)rK r( r2 r: rL r; r< r rN r r r r! s "�z*AsynchronousLogErrorsTests.test_inCallbackN)r r r r r" rK r! r r r r ra s ra )r# r. �twisted.internetr r �twisted.pythonr r � twisted.trialr r r r r r$ r& rH r` r% ra r r r r �<module> s *mMPK b�Z|��ع � , test/__pycache__/suppression.cpython-310.pycnu �[��� o �b� � @ sL d Z ddlZddlmZmZ dZdZdZG dd� de�Z G d d � d e�Z G d d � d e�Z G d d� d�Z G dd� de �Z G dd� d�ZG dd� d�ZG dd� de �Zejed�gZG dd� de ej�ZG dd� dee�ZG d d � d ee�ZG d d � d eej�ZG d d!� d!e ej�ZG d"d#� d#ee�ZG d$d%� d%ee�ZG d&d'� d'eej�ZdS )(z� Test cases used to make sure that warning suppression works at the module, method, and class levels. See the L{twisted.trial.test.test_tests} module docstring for details about how this code is arranged. � N)�unittest�utilzmethod warning messagezclass warning messagezmodule warning messagec @ � e Zd ZdS )� MethodWarningN��__name__� __module__� __qualname__� r r �@/usr/lib/python3/dist-packages/twisted/trial/test/suppression.pyr � r c @ r )� ClassWarningNr r r r r r r r c @ r )� ModuleWarningNr r r r r r r r c @ s e Zd ZdZdd� ZdS )� EmitMixinz2 Mixin for emiting a variety of warnings. c C s( t �tt� t �tt� t �tt� d S �N)�warnings�warn�METHOD_WARNING_MSGr �CLASS_WARNING_MSGr �MODULE_WARNING_MSGr ��selfr r r �_emit( s zEmitMixin._emitN)r r r �__doc__r r r r r r # s r c @ sH e Zd Zejed�gZdd� Zejed�ge_dd� Zdd� Z g e _dS ) �SuppressionMixin��messagec C � | � � d S r �r r r r r �testSuppressMethod1 � z#SuppressionMixin.testSuppressMethodc C r r r r r r r �testSuppressClass6 r z"SuppressionMixin.testSuppressClassc C r r r r r r r �testOverrideSuppressClass9 r z*SuppressionMixin.testOverrideSuppressClassN) r r r r �suppressr r r r! r" r r r r r . s r c @ � e Zd Zdd� ZdS )�SetUpSuppressionMixinc C r r r r r r r �setUp@ r zSetUpSuppressionMixin.setUpN)r r r r& r r r r r% ? � r% c @ r$ )�TearDownSuppressionMixinc C r r r r r r r �tearDownE r z!TearDownSuppressionMixin.tearDownN)r r r r) r r r r r( D r' r( c @ r$ )�TestSuppression2Mixinc C r r r r r r r �testSuppressModuleJ r z(TestSuppression2Mixin.testSuppressModuleN)r r r r+ r r r r r* I r' r* r c @ r )�SynchronousTestSuppressionNr r r r r r, Q r r, c @ r )� SynchronousTestSetUpSuppressionNr r r r r r- U � r- c @ r )�"SynchronousTestTearDownSuppressionNr r r r r r/ [ r. r/ c @ r )�SynchronousTestSuppression2Nr r r r r r0 a r r0 c @ r )�AsynchronousTestSuppressionNr r r r r r1 e r r1 c @ r )� AsynchronousTestSetUpSuppressionNr r r r r r2 i r. r2 c @ r )�#AsynchronousTestTearDownSuppressionNr r r r r r3 o r. r3 c @ r )� AsynchronousTestSuppression2Nr r r r r r4 u r r4 ) r r � twisted.trialr r r r r �Warningr r r r r r% r( r* r# �SynchronousTestCaser, r- r/ r0 �TestCaser1 r2 r3 r4 r r r r �<module> s> � � � �PK b�Z�a1�Z �Z * test/__pycache__/test_util.cpython-310.pycnu �[��� o �b�L � @ s d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m Z ddl m Z ddl mZ dd lmZ dd lmZ dd lmZmZmZmZ G d d � d e�ZG dd� de�ZG dd� d�ZG dd� d�ZG dd� de�Z G dd� de�Z G dd� de�Z G dd� de�Z G d d � d e�Z dS ) z! Tests for L{twisted.trial.util} � N)�StringIO)� implementer)� DelayedCall)�IProcessTransport)�filepath)�Failure)�util)�SynchronousTestCase)�DirtyReactorAggregateError�_Janitor�acquireAttribute�excInfoOrFailureToExcInfoc @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) � MktempTestszm Tests for L{TestCase.mktemp}, a helper function for creating temporary file or directory names. c C s8 | � � }tj�|��tj�dd� }| �|g d�� dS )z� The path name returned by C{mktemp} is directly beneath a directory which identifies the test method which created the name. N���)z twisted.trial.test.test_utilr � test_name)�mktemp�os�path�dirname�split�sep� assertEqual)�self�name�dirs� r �>/usr/lib/python3/dist-packages/twisted/trial/test/test_util.pyr $ s �zMktempTests.test_namec C s | � � }| �|| � � � dS )zF Repeated calls to C{mktemp} return different values. N)r �assertNotEqual)r r r r r � test_unique/ s zMktempTests.test_uniquec C s< | � � }tj�|�}| �tj�|�� | �tj�|�� dS )zS The directory part of the path name returned by C{mktemp} exists. N)r r r r � assertTrue�exists� assertFalse)r r r r r r � test_created6 s zMktempTests.test_createdc C s( t j�| �� �}| �|�t �� �� dS )zZ The path returned by C{mktemp} is beneath the current working directory. N)r r �abspathr r � startswith�getcwd)r r r r r � test_location? s zMktempTests.test_locationN)�__name__� __module__� __qualname__�__doc__r r r# r' r r r r r s r c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) � DirtyReactorAggregateErrorTestsz6 Tests for the L{DirtyReactorAggregateError}. c C s t ddg�}| �t|�d� dS )z5 Delayed calls are formatted nicely. �Foo�barzhReactor was unclean. DelayedCalls: (set twisted.internet.base.DelayedCall.debug = True to debug) Foo barN�r r �str�r �errorr r r �test_formatDelayedCallL s �z6DirtyReactorAggregateErrorTests.test_formatDelayedCallc C s" t g ddg�}| �t|�d� dS )z3 Selectables are formatted nicely. z selectable 1z selectable 2z;Reactor was unclean. Selectables: selectable 1 selectable 2Nr0 r2 r r r �test_formatSelectablesZ s �z6DirtyReactorAggregateErrorTests.test_formatSelectablesc C s& t ddgddg�}| �t|�d� dS )zR Both delayed calls and selectables can appear in the same error. �bleck�Boozo�Sel1�Sel2z�Reactor was unclean. DelayedCalls: (set twisted.internet.base.DelayedCall.debug = True to debug) bleck Boozo Selectables: Sel1 Sel2Nr0 r2 r r r �%test_formatDelayedCallsAndSelectablesh s �zEDirtyReactorAggregateErrorTests.test_formatDelayedCallsAndSelectablesN)r( r) r* r+ r4 r5 r: r r r r r- G s r- c @ s4 e Zd ZdZd dd�Zd dd�Zdd� Zd d � ZdS ) � StubReactora~ A reactor stub which contains enough functionality to be used with the L{_Janitor}. @ivar iterations: A list of the arguments passed to L{iterate}. @ivar removeAllCalled: Number of times that L{removeAll} was called. @ivar selectables: The value that will be returned from L{removeAll}. @ivar delayedCalls: The value to return from L{getDelayedCalls}. Nc C s$ || _ g | _d| _|s g }|| _dS )z� @param delayedCalls: See L{StubReactor.delayedCalls}. @param selectables: See L{StubReactor.selectables}. r N)� delayedCalls� iterations�removeAllCalled� selectables)r r< r? r r r �__init__� s zStubReactor.__init__c C � | j �|� dS )z/ Increment C{self.iterations}. N)r= �append)r �timeoutr r r �iterate� � zStubReactor.iteratec C s | j S )z. Return C{self.delayedCalls}. )r< �r r r r �getDelayedCalls� s zStubReactor.getDelayedCallsc C s | j d7 _ | jS )zS Increment C{self.removeAllCalled} and return C{self.selectables}. � )r> r? rF r r r � removeAll� s zStubReactor.removeAll�N)r( r) r* r+ r@ rD rG rI r r r r r; z s r; c @ � e Zd ZdZdd� Zdd� ZdS )�StubErrorReporterz� A subset of L{twisted.trial.itrial.IReporter} which records L{addError} calls. @ivar errors: List of two-tuples of (test, error) which were passed to L{addError}. c C � g | _ d S rJ )�errorsrF r r r r@ � � zStubErrorReporter.__init__c C s | j �||f� dS )z6 Record parameters in C{self.errors}. N)rN rB )r �testr3 r r r �addError� s zStubErrorReporter.addErrorN)r( r) r* r+ r@ rQ r r r r rL � s rL c @ sh e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )� JanitorTestsz Tests for L{_Janitor}! c C s4 t g �}tdd|d�}|�� | �|jddg� dS )a During pending-call cleanup, the reactor will be spun twice with an instant timeout. This is not a requirement, it is only a test for current behavior. Hopefully Trial will eventually not do this kind of reactor stuff. N��reactorr )r; r � _cleanPendingr r= �r rT �janr r r � test_cleanPendingSpinsReactor� s z*JanitorTests.test_cleanPendingSpinsReactorc C sV dd� }g }t d|di |jdd� �}t|g�}tdd|d�}|�� | �||g� dS ) zW During pending-call cleanup, the janitor cancels pending timed calls. c S � dS )N�Lulzr r r r r �func� � z8JanitorTests.test_cleanPendingCancelsCalls.<locals>.func�, r c S � d S rJ r ��xr r r �<lambda>� � z<JanitorTests.test_cleanPendingCancelsCalls.<locals>.<lambda>NrS )r rB r; r rU r )r r[ � cancelled� delayedCallrT rW r r r � test_cleanPendingCancelsCalls� s z*JanitorTests.test_cleanPendingCancelsCallsc C s` t ddd� di dd� dd� dd� d�}t|�}t|g�}tdd|d �}|�� }| �||g� dS ) aK The Janitor produces string representations of delayed calls from the delayed call cleanup method. It gets the string representations *before* cancelling the calls; this is important because cancelling the call removes critical debugging information from the string representation. r] c S r^ rJ r r r r r ra � rb zIJanitorTests.test_cleanPendingReturnsDelayedCallStrings.<locals>.<lambda>r c S r^ rJ r r_ r r r ra � rb c S rY �Nr r r r r r ra � rb ��secondsNrS )r r1 r; r rU r )r rd �delayedCallStringrT rW �stringsr r r �*test_cleanPendingReturnsDelayedCallStrings� s � z7JanitorTests.test_cleanPendingReturnsDelayedCallStringsc C s0 t g �}tdd|d�}|�� | �|jd� dS )zM The Janitor will remove selectables during reactor cleanup. NrS rH )r; r � _cleanReactorr r> rV r r r �#test_cleanReactorRemovesSelectables� s z0JanitorTests.test_cleanReactorRemovesSelectablesc C sR t t�G dd� d��}|� }tg |g�}tdd|d�}|�� | �|jdg� dS )zI The Janitor will kill processes during reactor cleanup. c @ rK )zJJanitorTests.test_cleanReactorKillsProcesses.<locals>.StubProcessTransportz� A stub L{IProcessTransport} provider which records signals. @ivar signals: The signals passed to L{signalProcess}. c S rM rJ )�signalsrF r r r r@ � rO zSJanitorTests.test_cleanReactorKillsProcesses.<locals>.StubProcessTransport.__init__c S rA )zF Append C{signal} to C{self.signals}. N)rn rB )r �signalr r r � signalProcess rE zXJanitorTests.test_cleanReactorKillsProcesses.<locals>.StubProcessTransport.signalProcessN)r( r) r* r+ r@ rp r r r r �StubProcessTransport� s rq NrS �KILL)r r r; r rl r rn )r rq �ptrT rW r r r � test_cleanReactorKillsProcesses� s z,JanitorTests.test_cleanReactorKillsProcessesc C s@ G dd� d�}t g |� g�}tdd|d�}| �|�� dg� dS )z� The Janitor returns string representations of the selectables that it cleaned up from the reactor cleanup method. c @ s e Zd ZdZdefdd�ZdS )zJJanitorTests.test_cleanReactorReturnsSelectableStrings.<locals>.Selectablezl A stub Selectable which only has an interesting string representation. �returnc S rY )N� (SELECTABLE!)r rF r r r �__repr__ r\ zSJanitorTests.test_cleanReactorReturnsSelectableStrings.<locals>.Selectable.__repr__N)r( r) r* r+ r1 rw r r r r � Selectable s rx NrS rv )r; r r rl )r rx rT rW r r r �)test_cleanReactorReturnsSelectableStrings s z6JanitorTests.test_cleanReactorReturnsSelectableStringsc C sB t g �}t� }t� }t|||d�}| �|�� � | �|jg � dS )z� The post-case cleanup method will return True and not call C{addError} on the result if there are no pending calls. rS N)r; �objectrL r r �postCaseCleanupr rN �r rT rP �reporterrW r r r � test_postCaseCleanupNoErrors s z)JanitorTests.test_postCaseCleanupNoErrorsc C s� t ddd� di dd� dd� dd� d�}t|�}t|gg �}t� }t� }t|||d�}| �|�� � | �t |j �d � | �|j d d j j |g� d S ) z� The post-case cleanup method will return False and call C{addError} on the result with a L{DirtyReactorAggregateError} Failure if there are pending calls. r] c S r^ rJ r r r r r ra 3 rb z=JanitorTests.test_postCaseCleanupWithErrors.<locals>.<lambda>r c S r^ rJ r r_ r r r ra 3 rb c S rY rf r r r r r ra 3 rb rg rS rH r N) r r1 r; rz rL r r" r{ r �lenrN �valuer< �r rd ri rT rP r} rW r r r � test_postCaseCleanupWithErrors, s � z+JanitorTests.test_postCaseCleanupWithErrorsc C s< t g �}t� }t� }t|||d�}|�� | �|jg � dS )z� The post-class cleanup method will not call C{addError} on the result if there are no pending calls or selectables. rS N)r; rz rL r �postClassCleanupr rN r| r r r � test_postClassCleanupNoErrors> s z*JanitorTests.test_postClassCleanupNoErrorsc C s� t ddd� di dd� dd� dd� d�}t|�}t|gg �}t� }t� }t|||d�}|�� | �t|j �d � | �|j d d j j |g� d S ) z� The post-class cleanup method call C{addError} on the result with a L{DirtyReactorAggregateError} Failure if there are pending calls. r] c S r^ rJ r r r r r ra P rb zIJanitorTests.test_postClassCleanupWithPendingCallErrors.<locals>.<lambda>r c S r^ rJ r r_ r r r ra P rb c S rY rf r r r r r ra P rb rg rS rH r N) r r1 r; rz rL r r� r r rN r� r< r� r r r �*test_postClassCleanupWithPendingCallErrorsJ s � z7JanitorTests.test_postClassCleanupWithPendingCallErrorsc C sh d}t g |g�}t� }t� }t|||d�}|�� | �t|j�d� | �|jd d jj t |�g� dS )z� The post-class cleanup method call C{addError} on the result with a L{DirtyReactorAggregateError} Failure if there are selectables. zSELECTABLE HERErS rH r N) r; rz rL r r� r r rN r� r? �repr)r � selectablerT rP r} rW r r r �)test_postClassCleanupWithSelectableErrors[ s $z6JanitorTests.test_postClassCleanupWithSelectableErrorsN)r( r) r* r+ rX re rk rm rt ry r~ r� r� r� r� r r r r rR � s rR c @ r, ) �RemoveSafelyTestsz* Tests for L{util._removeSafely}. c C s8 | � � �d�}t�|� t�|�}| �tjtj |� dS )z� If a path doesn't contain a node named C{"_trial_marker"}, that path is not removed by L{util._removeSafely} and a L{util._NoTrialMarker} exception is raised instead. �utf-8N) r �encoder �mkdirr �FilePath� assertRaisesr �_NoTrialMarker� _removeSafely)r � directory�dirPathr r r � test_removeSafelyNoTrialMarkero s z0RemoveSafelyTests.test_removeSafelyNoTrialMarkerc C sp dd� }t � }| �td|� | �� �d�}t�|� t�|�}|� d�� � ||_ t � |� | �d|�� � dS )z� If an L{OSError} is raised while removing a path in L{util._removeSafely}, an attempt is made to move the path to a new name. c S s t � �)�� Raise an C{OSError} to emulate the branch of L{util._removeSafely} in which path removal fails. ��OSErrorr r r r � dummyRemove� s zORemoveSafelyTests.test_removeSafelyRemoveFailsMoveSucceeds.<locals>.dummyRemove�stdoutr� � _trial_marker�could not remove FilePathN)r �patch�sysr r� r r� r r� �child�touch�remover r� �assertIn�getvalue)r r� �outr� r� r r r �(test_removeSafelyRemoveFailsMoveSucceedsz s z:RemoveSafelyTests.test_removeSafelyRemoveFailsMoveSucceedsc C s� dd� }dd� }t � }| �td|� | �� �d�}t�|� t�|�}|� d�� � ||_ ||_ | � ttj|�}| �t|�d� | �d |�� � d S ) z� If an L{OSError} is raised while removing a path in L{util._removeSafely}, an attempt is made to move the path to a new name. If that attempt fails, the L{OSError} is re-raised. c S � t d��)r� zpath removal failedr� r r r r r� � � zLRemoveSafelyTests.test_removeSafelyRemoveFailsMoveFails.<locals>.dummyRemovec S r� )z� Raise an C{OSError} to emulate the branch of L{util._removeSafely} in which path movement fails. �path movement failedr� )r r r r � dummyMoveTo� r� zLRemoveSafelyTests.test_removeSafelyRemoveFailsMoveFails.<locals>.dummyMoveTor� r� r� r� r� N)r r� r� r r� r r� r r� r� r� r� �moveTor� r� r r� r r1 r� r� )r r� r� r� r� r� r3 r r r �%test_removeSafelyRemoveFailsMoveFails� s z7RemoveSafelyTests.test_removeSafelyRemoveFailsMoveFailsN)r( r) r* r+ r� r� r� r r r r r� j s r� c @ rK )� ExcInfoTestsz1 Tests for L{excInfoOrFailureToExcInfo}. c C s$ t t d�df}| �|t|�u � dS )z� L{excInfoOrFailureToExcInfo} returns exactly what it is passed, if it is passed a tuple like the one returned by L{sys.exc_info}. �fooN)� ValueErrorr r )r �infor r r � test_excInfo� s zExcInfoTests.test_excInfoc C sF zdd W n t y t� }Y nw | �|j|j|jft|�� dS )z� When called with a L{Failure} instance, L{excInfoOrFailureToExcInfo} returns a tuple like the one returned by L{sys.exc_info}, with the elements taken from the type, value, and traceback of the failure. rH r N)� BaseExceptionr r �typer� �tbr )r �fr r r � test_failure� s � zExcInfoTests.test_failureN)r( r) r* r+ r� r� r r r r r� � s r� c @ r ) �AcquireAttributeTestsz( Tests for L{acquireAttribute}. c C s* t � | _}| �|t| t � gd�u � dS )z� The value returned by L{acquireAttribute} is the value of the requested attribute on the first object in the list passed in which has that attribute. r� N�rz r� r r �r r� r r r �test_foundOnEarlierObject� s z/AcquireAttributeTests.test_foundOnEarlierObjectc C s* t � | _}| �|tt � | gd�u � dS )z� The same as L{test_foundOnEarlierObject}, but for the case where the 2nd element in the object list has the attribute and the first does not. r� Nr� r� r r r �test_foundOnLaterObject� s z-AcquireAttributeTests.test_foundOnLaterObjectc C s | � ttt� gd� dS )z� If none of the objects passed in the list to L{acquireAttribute} have the requested attribute, L{AttributeError} is raised. r� N)r� �AttributeErrorr rz rF r r r �test_notFoundException� s z,AcquireAttributeTests.test_notFoundExceptionc C s$ t � }| �|tt � gd|�u � dS )z� If none of the objects passed in the list to L{acquireAttribute} have the requested attribute and a default value is given, the default value is returned. r� N)rz r r )r �defaultr r r �test_notFoundDefault� s z*AcquireAttributeTests.test_notFoundDefaultN)r( r) r* r+ r� r� r� r� 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 dS )�ListToPhraseTestsz� Input is transformed into a string representation of the list, with each item separated by delimiter (defaulting to a comma) and the final two being separated by a final delimiter. c C s$ g }d}t �|d�}| �||� dS )zB If things is empty, an empty string is returned. � �andN�r � _listToPhraser �r �sample�expected�resultr r r � test_empty s z ListToPhraseTests.test_emptyc C s& dg}d}t �|d�}| �||� dS )z; With a single item, the item is returned. �Oner� Nr� r� r r r � test_oneWord s z ListToPhraseTests.test_oneWordc C s( ddg}d}t �|d�}| �||� dS )zA Two words are separated by the final delimiter. r� �Twoz One and Twor� Nr� r� r r r � test_twoWords � z ListToPhraseTests.test_twoWordsc C �( g d�}d}t �|d�}| �||� dS )zY With more than two words, the first two are separated by the delimiter. )r� r� �ThreezOne, Two, and Threer� Nr� r� r r r �test_threeWords" r� z!ListToPhraseTests.test_threeWordsc C s, g d�}d}t j|ddd�}| �||� dS )zW If a delimiter is specified, it is used instead of the default comma. )r� r� r� �FourzOne; Two; Three; or Four�orz; )� delimiterNr� r� r r r �test_fourWords+ s z ListToPhraseTests.test_fourWordsc C r� )zS If something in things is not a string, it is converted into one. )rH � �threez1, 2, and threer� Nr� r� r r r �test_notString4 r� z ListToPhraseTests.test_notStringc C s* d}| � ttj|d�}| �t|�d� dS )z? If things is a string, a TypeError is raised. zOne, two, threer� � Things must be a list or a tupleN�r� � TypeErrorr r� r r1 �r r� r3 r r r �test_stringTypeError= s z&ListToPhraseTests.test_stringTypeErrorc C s2 t g d��}| �ttj|d�}| �t|�d� dS )zB If things is an iterator, a TypeError is raised. )rH r� � r� r� N)�iterr� r� r r� r r1 r� r r r �test_iteratorTypeErrorE s z(ListToPhraseTests.test_iteratorTypeErrorc C s. dd� }| � ttj|d�}| �t|�d� dS )zB If things is a generator, a TypeError is raised. c s s � t d�E d H d S )Nr� )�ranger r r r r� R s �z9ListToPhraseTests.test_generatorTypeError.<locals>.sampler� r� Nr� r� r r r �test_generatorTypeErrorM s z)ListToPhraseTests.test_generatorTypeErrorN) r( r) r* r+ r� r� r� r� r� r� r� r� r� r r r r r� s r� )!r+ r r� �ior �zope.interfacer �twisted.internet.baser �twisted.internet.interfacesr �twisted.pythonr �twisted.python.failurer � twisted.trialr �twisted.trial.unittestr �twisted.trial.utilr r r r r r- r; rL rR r� r� r� r� r r r r �<module> s, )3+ 3U'PK b�Z�w��� � 0 test/__pycache__/mockcustomsuite.cpython-310.pycnu �[��� o �b � @ s2 d Z ddlmZmZ G dd� dej�Zdd� ZdS )z� Mock test module that contains a C{test_suite} method. L{runner.TestLoader} should load the tests from the C{test_suite}, not from the C{Foo} C{TestCase}. See {twisted.trial.test.test_loader.LoaderTest.test_loadModuleWith_test_suite}. � )�runner�unittestc @ s e Zd Zdd� ZdS )�Fooc C s d S )N� )�selfr r �D/usr/lib/python3/dist-packages/twisted/trial/test/mockcustomsuite.py�test_foo s z Foo.test_fooN)�__name__� __module__� __qualname__r r r r r r s r c C s t �� } d| _| S )N� MyCustomSuite)r � TestSuite�name)�tsr r r � test_suite s r N)�__doc__� twisted.trialr r �SynchronousTestCaser r r r r r �<module> s PK b�Z� �e e * test/__pycache__/test_skip.cpython-310.pycnu �[��� o �b[ � @ s� d Z ddlmZ ddlmZ edd�G dd� de��Zedd�G d d � d e��ZG d d � d e�ZG d d� de�ZG dd� de�Z dS )z! Tests for L{twisted.trial.util} � )�skipIf)�TestCaseTz.Skip all tests when @skipIf is used on a classc @ � e Zd ZdZdd� Zdd� ZdS )�SkipDecoratorUsedOnClasszZ All tests should be skipped because @skipIf decorator is used on this class. c C � t d���Nz%Test should skip and never reach here�� Exception��self� r �>/usr/lib/python3/dist-packages/twisted/trial/test/test_skip.py�test_shouldNeverRun_1 � z.SkipDecoratorUsedOnClass.test_shouldNeverRun_1c C r r r r r r r �test_shouldNeverRun_2 r z.SkipDecoratorUsedOnClass.test_shouldNeverRun_2N��__name__� __module__� __qualname__�__doc__r r r r r r r � r � c @ r )�'SkipDecoratorUsedOnClassWithEmptyReasonz� All tests should be skipped because @skipIf decorator is used on this class, even if the reason is an empty string c C r r r r r r r r # r z=SkipDecoratorUsedOnClassWithEmptyReason.test_shouldNeverRun_1c C r r r r r r r r & r z=SkipDecoratorUsedOnClassWithEmptyReason.test_shouldNeverRun_2Nr r r r r r r r c @ s` e Zd ZdZedd�dd� �Zedd�dd� �Zd d � Zed d �d d� �Zed d�dd� �Z dS )�SkipDecoratorUsedOnMethods�I Only methods where @skipIf decorator is used should be skipped. Tz"skipIf decorator used so skip testc C r r r r r r r �test_shouldNeverRun/ � z.SkipDecoratorUsedOnMethods.test_shouldNeverRunr c C r r r r r r r �"test_shouldNeverRunWithEmptyReason3 r z=SkipDecoratorUsedOnMethods.test_shouldNeverRunWithEmptyReasonc C � | � dd� d S �NTz"Test should run and not be skipped�� assertTruer r r r �test_shouldShouldRun7 � z/SkipDecoratorUsedOnMethods.test_shouldShouldRunFzshould not skipc C r r r r r r r �#test_shouldShouldRunWithSkipIfFalse: � z>SkipDecoratorUsedOnMethods.test_shouldShouldRunWithSkipIfFalsec C r r r r r r r �.test_shouldShouldRunWithSkipIfFalseEmptyReason> r% zISkipDecoratorUsedOnMethods.test_shouldShouldRunWithSkipIfFalseEmptyReasonN) r r r r r r r r" r$ r& r r r r r * s r c @ s$ e Zd ZdZdZdd� Zdd� ZdS )�SkipAttributeOnClasszV All tests should be skipped because skip attribute is set on this class. z5'skip' attribute set on this class, so skip all testsc C r r r r r r r �test_oneK r z SkipAttributeOnClass.test_onec C r r r r r r r �test_twoN r z SkipAttributeOnClass.test_twoN)r r r r �skipr( r) r r r r r' C s r' c @ s& e Zd ZdZdd� Zde_dd� ZdS )�SkipAttributeOnMethodsr c C r )NzShould never reach herer r r r r r( W r z SkipAttributeOnMethods.test_onez'skip test, skip attribute set on methodc C r r r r r r r �test_shouldNotSkip\ r# z)SkipAttributeOnMethods.test_shouldNotSkipN)r r r r r( r* r, r r r r r+ R s r+ N) r �unittestr �twisted.trial.unittestr r r r r' r+ r r r r �<module> s PK b�Zj���d! d! ( test/__pycache__/detests.cpython-310.pycnu �[��� o �b# � @ s� d Z ddlmZmZmZ ddlmZ ddlmZ ddl m Z G dd� dej �Z G dd � d ej �ZG d d � d ej �ZG d d � d ej �ZG dd� dej �ZG dd� dej �ZG dd� dej �ZG dd� dej �ZG dd� dej �ZdS )zD Tests for Deferred handling by L{twisted.trial.unittest.TestCase}. � )�defer�reactor�threads)�runWithWarningsSuppressed)�unittest)�suppressc @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�DeferredSetUpOKc C � t �d�}|�| j� |S �N�value�r �succeed� addCallback�_cb_setUpCalled��self�d� r �</usr/lib/python3/dist-packages/twisted/trial/test/detests.py�setUp � zDeferredSetUpOK.setUpc C s d| _ d S �NT)� _setUpCalled�r �ignoredr r r r � z DeferredSetUpOK._cb_setUpCalledc C s | � | j� d S �N)� assertTruer �r r r r �test_ok � zDeferredSetUpOK.test_okN)�__name__� __module__� __qualname__r r r r r r r r s r c @ � e Zd ZdZdd� Zdd� ZdS )�DeferredSetUpFailFc C s t �t�d��S )Nzi fail)r �failr �FailTestr r r r r r zDeferredSetUpFail.setUpc C s dt _| �d� d S )NTzI should not get called)r% � testCalledr& r r r r r " s zDeferredSetUpFail.test_okN�r! r" r# r( r r r r r r r% � r% c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) �DeferredSetUpCallbackFailFc C r r r r r r r r * r z DeferredSetUpCallbackFail.setUpc C s | � d� d S )Nzdeliberate failure�r& r r r r r / � z)DeferredSetUpCallbackFail._cb_setUpCalledc C � dt _d S r )r, r( r r r r r 2 r z!DeferredSetUpCallbackFail.test_okN)r! r" r# r( r r r r r r r r, ' � r, c @ r$ )�DeferredSetUpErrorFc C s t �td��S )Nzdeliberate error)r r& � RuntimeErrorr r r r r 9 r. zDeferredSetUpError.setUpc C r/ r )r1 r( r r r r r < r zDeferredSetUpError.test_okNr) r r r r r1 6 r* r1 c @ r$ )�DeferredSetUpNeverFireFc C � t �� S r �r �Deferredr r r r r C � z DeferredSetUpNeverFire.setUpc C r/ r )r3 r( r r r r r F r z DeferredSetUpNeverFire.test_okNr) r r r r r3 @ r* r3 c @ r+ ) �DeferredSetUpSkipFc C r r )r r r �_cb1r r r r r M r zDeferredSetUpSkip.setUpc C s t �d��)Nzskip me�r �SkipTestr r r r r9 R r zDeferredSetUpSkip._cb1c C r/ r )r8 r( r r r r r U r zDeferredSetUpSkip.test_okN)r! r" r# r( r r9 r r r r r r8 J r0 r8 c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z e e dd�ge je �Z e jdd� �Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd e_d!S )"� DeferredTestsFc C s | � |� d S r r- �r �reasonr r r �_cb_fail\ r. zDeferredTests._cb_failc C s t |��r )r2 r= r r r � _cb_error_ r7 zDeferredTests._cb_errorc C s t �|��r r: r= r r r �_cb_skipb r zDeferredTests._cb_skipc C � d| j _d S r �� __class__�touchedr r r r � _touchClasse � zDeferredTests._touchClassc C rB )NFrC r r r r r h rG zDeferredTests.setUpc C s t �d�S )N�success)r r r r r r � test_passk r zDeferredTests.test_passc c s � | � d � d V d S r �rF r r r r �test_passGeneratedn s � z DeferredTests.test_passGeneratedz7twisted.internet.defer.deferredGenerator was deprecated)�messagec c s � | � d� dV dS )zL Test case that is decorated with L{defer.inlineCallbacks}. NrJ r r r r �test_passInlineCallbacks| s � z&DeferredTests.test_passInlineCallbacksc C s t �| �d��S )NzI fail)r r& �failureExceptionr r r r � test_fail� r zDeferredTests.test_failc C r )Nr& )r r r r? r r r r �test_failureInCallback� r z$DeferredTests.test_failureInCallbackc C r )N�error�r r r r@ r r r r �test_errorInCallback� r z"DeferredTests.test_errorInCallbackc C s& t �d�}|�| j� |�| j� |S )N�skip)r r r rA rF r r r r � test_skip� s zDeferredTests.test_skipc C s t �dd� �S )Nc S s d S r r r r r r �<lambda>� s z+DeferredTests.test_thread.<locals>.<lambda>)r � deferToThreadr r r r � test_thread� r. zDeferredTests.test_threadc C r )N�todorR r r r r �test_expectedFailure� r z"DeferredTests.test_expectedFailurezExpected failureN)r! r" r# rE r? r@ rA rF r rI rK r �SUPPRESSr �deferredGenerator�inlineCallbacksrM rO rP rS rU rX rZ rY r r r r r< Y s4 ��� r< c @ s� e Zd ZdZdd� Zde_dd� Zdd� Zd e_d d � Zd e_d d� Z d e _de _ dd� Z d e _de _ dd� Z d e _dd� Zd e_dS )� TimeoutTestsNc C � t �� }t�d|jd� |S �Nr zhoorj!�r r6 r � callLater�callbackr r r r rI � s zTimeoutTests.test_pass� c C r_ r` ra r r r r �test_passDefault� s z TimeoutTests.test_passDefaultc C r4 r r5 r r r r � test_timeout� r7 zTimeoutTests.test_timeoutg�������?c C r4 r r5 r r r r �test_timeoutZero� r7 z TimeoutTests.test_timeoutZeror c C r4 r r5 r r r r rZ � r7 z!TimeoutTests.test_expectedFailurez i will get it right, eventuallyc C r4 r r5 r r r r rU � r7 zTimeoutTests.test_skipc s" � fdd�}t �� }|�|� |S )Nc s | � j _| S r )rD �timedOut)�errr r r rh � s z4TimeoutTests.test_errorPropagation.<locals>.timedOut)r r6 � addErrback)r rh r r r r �test_errorPropagation� s z"TimeoutTests.test_errorPropagationc C s( t �� }dd� }|�|� |�d� |S )Nc S r4 r r5 )�rr r r � neverFire� r7 z;TimeoutTests.test_calledButNeverCallback.<locals>.neverFire� )r r6 r rc )r r rm r r r �test_calledButNeverCallback� s z(TimeoutTests.test_calledButNeverCallback)r! r" r# rh rI �timeoutre rf rg rZ rY rU rT rk ro r r r r r^ � s& r^ c @ r$ )�TestClassTimeoutAttributeg�������?c C s t �� | _d S r )r r6 r r r r r r � r. z TestClassTimeoutAttribute.setUpc C s d| _ | jS r )� methodCalledr r r r r � testMethod� s z$TestClassTimeoutAttribute.testMethodN)r! r" r# rp r rs r r r r rq � r* rq N)�__doc__�twisted.internetr r r �twisted.python.utilr � twisted.trialr �twisted.trial.utilr r[ �TestCaser r% r, r1 r3 r8 r< r^ rq r r r r �<module> s I>PK b�Z���� � , test/__pycache__/test_output.cpython-310.pycnu �[��� o �b� � @ s^ d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z dZ dd � Z G d d � d e j �Z dS ) z* Tests for the output generated by trial. � N)�StringIO)�trial)�runner)�packageszNo module named 'frotz'c G sV ddl m} t�� }|�| � t� }tj|j||d d�}t� |�}|� |� |� � S )Nr )�reporterztemp-directory)�stream�workingDirectory) � twisted.trialr r �Options� parseOptionsr r � TrialRunner�VerboseTextReporter� _getSuite�run�getvalue)�argsr �config�output�myRunner�suite� r �@/usr/lib/python3/dist-packages/twisted/trial/test/test_output.py�runTrial s � r c s� e Zd ZdZdd� ZdZdd� Zdd� Z� fd d �Z� fd d �Z d d� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Z� ZS ))�ImportErrorsTestszbActually run trial as if on the command line and check that the output is what we expect. c C s d S �Nr ��selfr r r �debug( s zImportErrorsTests.debug�_testImportErrorsc G s t d| �� g|�R � S )Nz--temp-directory)r �mktemp)r r r r r r - s zImportErrorsTests.runTrialc C s t |� |S r )�print)r �stuffr r r �_print0 s zImportErrorsTests._printc � t � j||g|�R i |�� |S r )�super�assertIn�r � container� containeer �kwargs�� __class__r r r% 4 � zImportErrorsTests.assertInc r# r )r$ � assertNotInr& r* r r r- 9 r, z ImportErrorsTests.assertNotInc C s | � � d S r )r r r r r � test_trialRun> s z ImportErrorsTests.test_trialRunc C s& | � d�}| �|d� | �|d� |S )Nztwisted.doesntexist�[ERROR]�r r% �r �dr r r �test_nonexistentModuleA s z(ImportErrorsTests.test_nonexistentModulec C �2 | � d�}| �|d� | �|d� | �|d� |S )N� doesntexist�ModuleNotFoundr/ r0 r1 r r r �test_nonexistentPackageG � z)ImportErrorsTests.test_nonexistentPackagec C r4 )Nzdoesntexist.barney�ObjectNotFoundr/ r0 r1 r r r �!test_nonexistentPackageWithModuleN r8 z3ImportErrorsTests.test_nonexistentPackageWithModulec C �2 | � d�}| �|d� | �|d� | �|d� |S )N� badpackager/ �IOError�r r% r- r1 r r r �test_badpackageU r8 z!ImportErrorsTests.test_badpackagec C r; )Nzbadpackage.test_moduler/ r= r> r1 r r r �test_moduleInBadpackage\ r8 z)ImportErrorsTests.test_moduleInBadpackagec C �> | � d�}| �|d� | �|d� | �|d� | �|d� |S )Nzpackage.test_bad_moduler/ r= �<module r> r1 r r r �test_badmodulec � z ImportErrorsTests.test_badmodulec C rA )Nzpackage.test_import_moduler/ r= rB r> r1 r r r �test_badimportk rD z ImportErrorsTests.test_badimportc C sJ | � d�}| �|d� | �|d� | �|d� | �|d� | �|d� |S )N�packager/ �test_bad_module�test_import_modulerB r= r> r1 r r r �test_recurseImports s z$ImportErrorsTests.test_recurseImportc C sV | � d�}| �|d� | �|d� | �|d� | �|t� | �|d� | �|d� |S )N�package2r/ � test_modulerB r= �r r% �_noModuleErrorr- r1 r r r �test_recurseImportErrors| s z*ImportErrorsTests.test_recurseImportErrorsc C s4 | � dd�}| �|d� | �|t� | �|d� |S )Nz-NrJ r/ rB rL r1 r r r �test_nonRecurseImportErrors� s z-ImportErrorsTests.test_nonRecurseImportErrorsc C s> | � d�}| �|d� | �|d� | �|d� | �|d� |S )Nzpackage.test_moduler/ r= �OK�PASSED (successes=1))r r- r% r1 r r r �test_regularRun� rD z!ImportErrorsTests.test_regularRunc C �X | � | j� | �tj�| jdd��}| �|d� | �|d� | �|d� | �|d� |S )NrF ztest_module.pyr/ r= rP rQ � � mangleSysPath�oldPathr �os�path�join�parentr- r% r1 r r r � test_filename� s z ImportErrorsTests.test_filenamec C rS )NrF ztest_dos_module.pyr/ r= rP rQ rT r1 r r r � test_dosFile� s z ImportErrorsTests.test_dosFile)�__name__� __module__� __qualname__�__doc__r rZ r r" r% r- r. r3 r7 r: r? r@ rC rE rI rN rO rR r[ r\ � __classcell__r r r* r r # s, r )r` rW �ior �twisted.scriptsr r r �twisted.trial.testr rM r �SysPathManglingTestr r r r r �<module> s PK b�Z�Ḧ́� � 1 test/__pycache__/mockcustomsuite2.cpython-310.pycnu �[��� o �b � @ s2 d Z ddlmZmZ G dd� dej�Zdd� ZdS )z� Mock test module that contains a C{testSuite} method. L{runner.TestLoader} should load the tests from the C{testSuite}, not from the C{Foo} C{TestCase}. See L{twisted.trial.test.test_loader.LoaderTest.test_loadModuleWith_testSuite}. � )�runner�unittestc @ s e Zd Zdd� ZdS )�Fooc C s d S )N� )�selfr r �E/usr/lib/python3/dist-packages/twisted/trial/test/mockcustomsuite2.py�test_foo s z Foo.test_fooN)�__name__� __module__� __qualname__r r r r r r s r c C s t �� } d| _| S )N� MyCustomSuite)r � TestSuite�name)�tsr r r � testSuite s r N)�__doc__� twisted.trialr r �SynchronousTestCaser r r r r r �<module> s PK b�Zz��X}E }E - test/__pycache__/test_warning.cpython-310.pycnu �[��� o �b�D � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m Z m Z ddl m Z G dd � d �ZG d d � d e �ZG d d � d e�ZG dd� de �ZdS )z? Tests for Trial's interaction with the Python warning system. � N)�StringIO)� TestResult)�FilePath)�_collectWarnings�_setWarningRegistryToNone)�SynchronousTestCasec @ s e Zd ZdZG dd� de�ZdS )�MaskzQ Hide a test case definition from trial's automatic discovery mechanism. c @ s( e Zd ZdZdZeZdd� Zdd� ZdS )zMask.MockTestsz� A test case which is used by L{FlushWarningsTests} to verify behavior which cannot be verified by code inside a single test method. �some warning textc C s t �| j| j� dS )z@ Generate a warning and don't flush it. N)�warnings�warn�message�category��self� r �A/usr/lib/python3/dist-packages/twisted/trial/test/test_warning.py�test_unflushed! s z Mask.MockTests.test_unflushedc C s( t �| j| j� | �t| �� �d� dS )z: Generate a warning and flush it. � N)r r r r � assertEqual�len� flushWarningsr r r r � test_flushed' s zMask.MockTests.test_flushedN) �__name__� __module__� __qualname__�__doc__r � UserWarningr r r r r r r � MockTests s r N)r r r r r r r r r r r s r c @ 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 )%�FlushWarningsTestsze Tests for C{flushWarnings}, an API for examining the warnings emitted so far in a test. c C s& |� � D ] \}}| �|| |� qdS )z� Assert that all the keys present in C{subset} are also present in C{set} and that the corresponding values are equal. N)�itemsr )r �set�subset�k�vr r r �assertDictSubset5 s �z#FlushWarningsTests.assertDictSubsetc C s8 | � t|�t|�� t||�D ] \}}| �||� qdS )z� For each pair of corresponding elements in C{sets} and C{subsets}, assert that the element from C{subsets} is a subset of the element from C{sets}. N)r r �zipr$ )r �sets�subsets�a�br r r �assertDictSubsets= s �z$FlushWarningsTests.assertDictSubsetsc C s | � | �� g � dS )zg If no warnings are emitted by a test, C{flushWarnings} returns an empty list. N)r r r r r r � test_noneG s z FlushWarningsTests.test_nonec C sP d}t }tj||d� d}t}tj||d� | �| �� ||d�||d�g� dS )z| If several warnings are emitted by a test, C{flushWarnings} returns a list containing all of them. zfirst warning message�r r zsecond warning message�r r N)r r r �RuntimeWarningr* r )r � firstMessage� firstCategory� secondMessage�secondCategoryr r r � test_severalN s ��z FlushWarningsTests.test_severalc C sD d}t }td�D ] }tj||d� q| �| �� ||d�gd � dS )z� The same warning triggered twice from the same place is included twice in the list returned by C{flushWarnings}. � the message� r, r- N)r. �ranger r r* r )r r r �ir r r � test_repeatedc s �z FlushWarningsTests.test_repeatedc C sB d}t }tj||d� | �| �� ||d�g� | �| �� g � dS )z� After a particular warning event has been returned by C{flushWarnings}, it is not returned by subsequent calls. r4 r, r- N)r. r r r* r r )r r r r r r � test_clearedq s �z FlushWarningsTests.test_clearedc C s� t � }t�d�}|�|� | �tjjg�}| �|d d d� | �|d d t� t |�jj }|j }|j d }| �|d d |� | �|d d |� | �t |�d � d S ) zx Any warnings emitted by a test which are not flushed are emitted to the Python warning system. r r r r r � �filename�linenor N)r r r �runr r r �assertIdenticalr �type�__code__� co_filename�co_firstlinenor )r �result�case� warningsShown�wherer; r< r r r r ~ s z!FlushWarningsTests.test_unflushedc C sJ t � }t�d�}t� }| �td|�}|�|� |�� | �|� � d� dS )zx Any warnings emitted by a test which are flushed are not emitted to the Python warning system. r �stdout� N) r r r r �patch�sysr= �restorer �getvalue)r rC rD �output�monkeyr r r r � s z FlushWarningsTests.test_flushedc C s� G dd� dt �}t� }t�d�}||_tjdd� }z9t�d� |�|� | � t |j �d� | � |j d d |� | � |j d d �� d �d �� W |tjdd�< dS |tjdd�< w ) z� If a warnings filter has been installed which turns warnings into exceptions, tests have an error added to the reporter for them for each unflushed warning. c @ � e Zd ZdS )zIFlushWarningsTests.test_warningsConfiguredAsErrors.<locals>.CustomWarningN�r r r r r r r � CustomWarning� � rQ r N�errorr r ���z CustomWarning: some warning text)�Warningr r r r r �filters� simplefilterr= r r �errorsr> � assertTrue� splitlines�endswith�r rQ rC rD �originalWarningsr r r � test_warningsConfiguredAsErrors� s" ��"z2FlushWarningsTests.test_warningsConfiguredAsErrorsc C s| G dd� dt �}t� }t�d�}||_tjdd� }zt�d� |�|� | � |j g � W |tjdd�< dS |tjdd�< w )z� If a warnings filter has been installed which turns warnings into exceptions, tests which emit those warnings but flush them do not have an error added to the reporter. c @ rO )zPFlushWarningsTests.test_flushedWarningsConfiguredAsErrors.<locals>.CustomWarningNrP r r r r rQ � rR rQ r NrS ) rU r r r r r rV rW r= r rX r\ r r r �&test_flushedWarningsConfiguredAsErrors� s "z9FlushWarningsTests.test_flushedWarningsConfiguredAsErrorsc C s@ t �d� | �t| �� �d� t �d� | �t| �� �d� dS )z� Any warnings emitted after a call to C{flushWarnings} can be flushed by another call to C{flushWarnings}. z first messager zsecond messageN)r r r r r r r r r �test_multipleFlushes� s z'FlushWarningsTests.test_multipleFlushesc sx d�t � � �fdd�}d�t���fdd�}|� |� | �| j|gd�� �d�g� | �| j|gd���d�g� d S ) z� The list returned by C{flushWarnings} includes only those warnings which refer to the source of the function passed as the value for C{offendingFunction}, if a value is passed for that parameter. zfirst warning textc � t j�� dd� d S �Nr )� stacklevel�r r r )r0 r/ r r �one� � z>FlushWarningsTests.test_filterOnOffendingFunction.<locals>.onez some textc ra rb rd r )r2 r1 r r �two� rf z>FlushWarningsTests.test_filterOnOffendingFunction.<locals>.two��offendingFunctionsr- N)r r. r* r )r re rg r )r0 r/ r2 r1 r � test_filterOnOffendingFunction� s � �z1FlushWarningsTests.test_filterOnOffendingFunctionc C s, dd� }|� | � t| j|gd��d� dS )z� Verify that warnings emitted at the very edges of a function are still determined to be emitted from that function. c S s" t �d� t �d� t �d� d S )Nzfirst line warningzinternal line warningzlast line warningrd r r r r �warner s z:FlushWarningsTests.test_functionBoundaries.<locals>.warnerrh � N�r r r )r rk r r r �test_functionBoundaries� s z*FlushWarningsTests.test_functionBoundariesc C s4 t �d� | �t| jdg� | �t| �� �d� dS )z� If an object which is neither a function nor a method is included in the C{offendingFunctions} list, C{flushWarnings} raises L{ValueError}. Such a call flushes no warnings. �oh noNr )r r � assertRaises� ValueErrorr r r r r r r �test_invalidFilter s z%FlushWarningsTests.test_invalidFilterc C s� t | �� �d���d�}|�� |�d��d� |�d��d� |�� j�d�}t j� d|� | � t jj |� ddl m} | � t jjd � | � t jj|j� |�d�� � |�� | �t| �|jg��d � d S ) zx Warnings emitted by a function the source code of which is not available can still be flushed. �utf-8� twisted_private_helper� __init__.py� s missingsourcefile.py�7 import warnings def foo(): warnings.warn("oh no") r )�missingsourcefile�twisted_private_helperr N)r �mktemp�encode�child�makedirs� setContent�parent�path�decoderJ �insert� addCleanup�removery rx �modules�popr �foor r r )r �package� pathEntryrx r r r �test_missingSource s" � � z%FlushWarningsTests.test_missingSourcec C s t | �� �d���d�}|�� |�d��d� |�d��d� |�� j�d�}t j� d|� | � t jj |� ddl m} t jd = t j|j= zdd lm} W n tyW Y nw |� |�|�d �� ddlm} | � t jjd � | � t jj|j� |�� | �t| �|jg��d � dS )a Warnings emitted by a function defined in a file which has been renamed since it was initially compiled can still be flushed. This is testing the code which specifically supports working around the unfortunate behavior of CPython to write a .py source file name into the .pyc files it generates and then trust that it is correct in various places. If source files are renamed, .pyc files may not be regenerated, but they will contain incorrect filenames. rs rt ru rv s module.pyrw r )�modulery )�invalidate_cachess twisted_renamed_helper�twisted_renamed_helperr N) r rz r{ r| r} r~ r r� r� rJ r� r� r� ry r� r� r � importlibr� � ImportError�moveTo�siblingr� r� r� r r r )r r� r� r� r� r r r �test_renamedSource3 s4 � � � z%FlushWarningsTests.test_renamedSourcec C s, ddd�}|� | � t| �|g��d� dS )a� In Python 3.6 the dis.findlinestarts documented behaviour was changed such that the reported lines might not be sorted ascending. In Python 3.10 PEP 626 introduced byte-code change such that the last line of a function wasn't always associated with the last byte-code. In the past flushWarning was not detecting that such a function was associated with any warnings. r c S s | r|r t �d� d S d S d S )Nro rd )r( r) r r r r� y s �zCFlushWarningsTests.test_offendingFunctions_deep_branch.<locals>.fooN)r r rm )r r� r r r �#test_offendingFunctions_deep_brancho s z6FlushWarningsTests.test_offendingFunctions_deep_branchN)r r r r r$ r* r+ r3 r8 r9 r r r^ r_ r` rj rn rr r� r� r� r r r r r / s& <r c @ rO )� FakeWarningNrP r r r r r� � rR r� c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�CollectWarningsTestsz( Tests for L{_collectWarnings}. c s� d��ddd� �t ddd��g � � ���fdd�}t� j|� | �� d d � | �� d j�� | �� d j�� | �� d jt��� | �� d d � | �t� �d � dS )zS L{_collectWarnings} calls the observer with each emitted warning. z dummy calls observer warningNrT r r5 rl c s6 � � d� t��� t��� t��� � � d� d S )N�call� returning)�appendr r r ��eventsr/ r1 � thirdMessager r �f� s z2CollectWarningsTests.test_callsObserver.<locals>.fr r� r: r� � )rU r r� r r �strr )r r� r r� r �test_callsObserver� s z'CollectWarningsTests.test_callsObserverc C s: t � }| �td|� tdd� tjd� | �|�� d� dS )z� Any warnings emitted by a call to a function passed to L{_collectWarnings} are not actually emitted to the warning system. rG c S � d S �Nr ��xr r r �<lambda>� � z6CollectWarningsTests.test_suppresses.<locals>.<lambda>�textrH N)r rI rJ r r r r rL )r rM r r r �test_suppresses� s z$CollectWarningsTests.test_suppressesc sX g � t � �� �fdd�}tdd� |ddddd �}| �� d ddd �fg� | �|�� d S ) z� L{_collectWarnings} returns the result of calling the callable passed to it with the parameters given. c s � � | |f� �S r� )r� )�args�kwargs�� arguments�valuer r r� � s z2CollectWarningsTests.test_callsFunction.<locals>.fc S r� r� r r� r r r r� � r� z9CollectWarningsTests.test_callsFunction.<locals>.<lambda>r r( r5 �d)r) �c)r r( N)�objectr r r> )r r� rC r r� r �test_callsFunction� s z'CollectWarningsTests.test_callsFunctionc C sd b dd� }t�d� |� g }t|j|� | �t|�d� | �|d jd� | �t| �� �d� dS )z� Subsequent emissions of a warning from a particular source site can be collected by L{_collectWarnings}. In particular, the per-module emitted-warning cache should be bypassed (I{__warningregistry__}). c S s t �d� d S )Nr� rd r r r r r� � � z>CollectWarningsTests.test_duplicateWarningCollected.<locals>.f�defaultr r r� N) �__warningregistry__r rW r r� r r r r )r r� r� r r r � test_duplicateWarningCollected� s z3CollectWarningsTests.test_duplicateWarningCollectedc C s, t � }|tj|< | �tjj|� | �� dS )z� L{_collectWarnings}'s behavior is not altered by the presence of an object which cannot have attributes set on it as a value in C{sys.modules}. N)r� rJ r� r� r� r� �r �keyr r r �test_immutableObject� s z)CollectWarningsTests.test_immutableObjectc sn i � G � fdd�d�}t � }t � }||�� |< t � }t � }||�� |< t� � | �||||ht� �� �� dS )a� If the dictionary passed to L{_setWarningRegistryToNone} changes size partway through the process, C{_setWarningRegistryToNone} continues to set C{__warningregistry__} to L{None} on the rest of the values anyway. This might be caused by C{sys.modules} containing something that's not really a module and imports things on setattr. py.test does this, as does L{twisted.python.deprecate.deprecatedModuleAttribute}. c s e Zd Zdd� Z� fdd�ZdS )zKCollectWarningsTests.test_setWarningRegistryChangeWhileIterating.<locals>.Ac S s || j d< d S )N�_key)�__dict__r� r r r �__init__� r� zTCollectWarningsTests.test_setWarningRegistryChangeWhileIterating.<locals>.A.__init__c s d � | j < d S r� )r� )r r� �item�r� r r � __setattr__� r� zWCollectWarningsTests.test_setWarningRegistryChangeWhileIterating.<locals>.A.__setattr__N)r r r r� r� r r� r r �A� s r� N)r� r r r �keys)r r� �key1�key2�key3�key4r r� r �+test_setWarningRegistryChangeWhileIterating� s z@CollectWarningsTests.test_setWarningRegistryChangeWhileIteratingN) r r r r r� r� r� r� r� r� r r r r r� � s r� )r rJ r �ior �unittestr �twisted.python.filepathr �twisted.trial._synctestr r �twisted.trial.unittestr r r rU r� r� r r r r �<module> s ZPK b�Z(��/ / + test/__pycache__/scripttest.cpython-310.pycnu �[��� o 5�@g� � @ s G d d� d�Z dS )c @ s e Zd ZdS )�FooN)�__name__� __module__� __qualname__� r r �?/usr/lib/python3/dist-packages/twisted/trial/test/scripttest.pyr s r N)r r r r r �<module> s PK b�Z�$�� � . test/__pycache__/test_testcase.cpython-310.pycnu �[��� o �b� � @ sJ d Z ddlmZmZ G dd� d�ZG dd� dee�ZG dd� dee�Zd S ) zm Direct unit tests for L{twisted.trial.unittest.SynchronousTestCase} and L{twisted.trial.unittest.TestCase}. � )�SynchronousTestCase�TestCasec @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) � TestCaseMixinz L{TestCase} tests. c C s | � d�| _| � d�| _dS )z� Create a couple instances of C{MyTestCase}, each for the same test method, to be used in the test methods of this class. �test_1N)� MyTestCase�first�second��self� r �B/usr/lib/python3/dist-packages/twisted/trial/test/test_testcase.py�setUp s zTestCaseMixin.setUpc C s: | � | j| jk� | � | j| jk� | �| j| jk� dS )z� In order for one test method to be runnable twice, two TestCase instances with the same test method name must not compare as equal. N)� assertTruer r � assertFalser r r r � test_equality s zTestCaseMixin.test_equalityc C s, i }d|| j < d|| j< | �t|�d� dS )z� In order for one test method to be runnable twice, two TestCase instances with the same test method name should not have the same hash value. N� )r r � assertEqual�len)r � containerr r r �test_hashability# s z TestCaseMixin.test_hashabilityN)�__name__� __module__� __qualname__�__doc__r r r r r r r r s r c @ � e Zd ZG dd� de�ZdS )�SynchronousTestCaseTestsc @ � e Zd ZdZdd� ZdS )z#SynchronousTestCaseTests.MyTestCasezj Some test methods which can be used to test behaviors of L{SynchronousTestCase}. c C � d S �Nr r r r r r 6 � z*SynchronousTestCaseTests.MyTestCase.test_1N�r r r r r r r r r r 0 � r N)r r r r r r r r r r / � r c @ r )�AsynchronousTestCaseTestsc @ r )z$AsynchronousTestCaseTests.MyTestCasez_ Some test methods which can be used to test behaviors of L{TestCase}. c C r r r r r r r r C r z+AsynchronousTestCaseTests.MyTestCase.test_1Nr r r r r r = r! r N)r r r r r r r r r r# < r" r# N)r �twisted.trial.unittestr r r r r# r r r r �<module> s " PK b�Z],�� � 5 test/__pycache__/test_asyncassertions.cpython-310.pycnu �[��� o �b� � @ sF d Z ddlZddlmZ ddlmZ ddlmZ G dd� dej�Z dS )zL Tests for async assertions provided by C{twisted.trial.unittest.TestCase}. � N)�defer)�failure)�unittestc @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�AsynchronousAssertionsTestszp Tests for L{TestCase}'s asynchronous extensions to L{SynchronousTestCase}. That is, assertFailure. c C s t �dd� �}| �|t�S )Nc S � dd S �N� r � r r r �I/usr/lib/python3/dist-packages/twisted/trial/test/test_asyncassertions.py�<lambda> � z@AsynchronousAssertionsTests.test_assertFailure.<locals>.<lambda>)r � maybeDeferred� assertFailure�ZeroDivisionError��self�dr r r �test_assertFailure s z.AsynchronousAssertionsTests.test_assertFailurec s: t �dd� �}� �|t� |�� fdd�� fdd�� |S )Nc S r r r r r r r r r zOAsynchronousAssertionsTests.test_assertFailure_wrongException.<locals>.<lambda>c � � � d�S �NzShould have failed��fail��x�r r r r � c � | � � j�S �N��trap�failureExceptionr r r r r � )r r r � OverflowError� addCallbacksr r r r �!test_assertFailure_wrongException s �z=AsynchronousAssertionsTests.test_assertFailure_wrongExceptionc s6 t �d �}� �|t� |�� fdd�� fdd�� |S )Nc r r r r r r r r ' r zLAsynchronousAssertionsTests.test_assertFailure_noException.<locals>.<lambda>c r r r r r r r r ( r! )r �succeedr r r# r r r r � test_assertFailure_noException# s �z:AsynchronousAssertionsTests.test_assertFailure_noExceptionc C sP zdd W n t y t�� }t�|�}Y nw | �|t�}|�| j|� |S )z� In the case of assertFailure failing, check that we get lots of information about the exception that was raised. r r ) r r �Failurer r r � RuntimeError� addErrback� _checkInfo)r �fr r r r �test_assertFailure_moreInfo, s � z7AsynchronousAssertionsTests.test_assertFailure_moreInfoc C s< |� | j�sJ �|�� }| �|�� |� | �|�� |� d S r )�checkr �getErrorMessage�assertIn�getBriefTraceback)r �assertionFailurer+ �outputr r r r* : s z&AsynchronousAssertionsTests._checkInfoc sV G dd� dt �� G � fdd�dtj�}|d�}t�� }|�|� | �dt|j�� dS )zJ A single wrong assertFailure should fail the whole test. c @ s e Zd ZdS )zMAsynchronousAssertionsTests.test_assertFailure_masked.<locals>.ExampleFailureN)�__name__� __module__� __qualname__r r r r �ExampleFailureE s r6 c s e Zd Z� Zdd� ZdS )zAAsynchronousAssertionsTests.test_assertFailure_masked.<locals>.TCc S s* t �dd� �}| �|t� | �|t� |S )Nc S r r r r r r r r L r zfAsynchronousAssertionsTests.test_assertFailure_masked.<locals>.TC.test_assertFailure.<locals>.<lambda>)r r r r" r r r r r r K s zTAsynchronousAssertionsTests.test_assertFailure_masked.<locals>.TC.test_assertFailureN)r3 r4 r5 r r r �r6 r r �TCH s r8 r r N) � Exceptionr �TestCase�pyunit� TestResult�run� assertEqual�len�failures)r r8 �test�resultr r7 r �test_assertFailure_masked@ s z5AsynchronousAssertionsTests.test_assertFailure_maskedN) r3 r4 r5 �__doc__r r$ r& r, r* rC r r r r r s r ) rD r r; �twisted.internetr �twisted.pythonr � twisted.trialr: r r r r r �<module> s PK b�Z�+{� � ) test/__pycache__/packages.cpython-310.pycnu �[��� o �b+ � @ sj d Z ddlZddlZddlmZ ddlmZ dZe� dd�Z dZ d Z G d d � d ej �ZG d d � d e�ZdS )zf Classes and functions used by L{twisted.trial.test.test_util} and L{twisted.trial.test.test_loader}. � N)�invalidate_caches)�unittestzv from twisted.trial import unittest class FooTest(unittest.SynchronousTestCase): def testFoo(self): pass � z a� '''This module is used by test_loader to test the Trial test loading functionality. Do NOT change the number of tests in this module. Do NOT change the names the tests in this module. ''' import unittest as pyunit from twisted.trial import unittest class FooTest(unittest.SynchronousTestCase): def test_foo(self): pass def test_bar(self): pass class PyunitTest(pyunit.TestCase): def test_foo(self): pass def test_bar(self): pass class NotATest: def test_foo(self): pass class AlphabetTest(unittest.SynchronousTestCase): def test_a(self): pass def test_b(self): pass def test_c(self): pass az '''This module is used by test_loader to test the Trial test loading functionality. Do NOT change the number of tests in this module. Do NOT change the names the tests in this module. ''' from twisted.trial import unittest class X: def test_foo(self): pass class A(unittest.SynchronousTestCase, X): pass class B(unittest.SynchronousTestCase, X): pass c @ s� e Zd Zddddddddd d efd d efd defddefddefgZdd� Zdd� Z dd� Z d#dd�Z d d � Z d$d d �Z d!d"� Zd S )%� PackageTest)zbadpackage/__init__.py�frotz )zbadpackage/test_module.py� )z unimportablepackage/__init__.pyr )z"unimportablepackage/test_module.pyzimport notarealmoduleok )zpackage2/__init__.pyr )zpackage2/test_module.pyz import frotz )zpackage/__init__.pyr )zpackage/frotz.pyr )zpackage/test_bad_module.pyz%raise ZeroDivisionError("fake error")zpackage/test_dos_module.py)z package/test_import_module.pyz import frotzzpackage/test_module.py)zgoodpackage/__init__.pyr zgoodpackage/test_sample.py)zgoodpackage/sub/__init__.pyr z goodpackage/sub/test_sample.py)z inheritancepackage/__init__.pyr z inheritancepackage/test_x.pyc C s< t j�|�d }|�d�}|d dkr|d d� }d�|�S )Nr �/����__init__�.)�os�path�splitext�split�join)�self�filename�name�segs� r �=/usr/lib/python3/dist-packages/twisted/trial/test/packages.py� _toModuleNamet s zPackageTest._toModuleNamec s � fdd�� j D �S )zQ Return matching module names for files listed in C{self.files}. c s g | ] \}}� � |��qS r )r )�.0r �code�r r r � <listcomp> s z*PackageTest.getModules.<locals>.<listcomp>)�filesr r r r � getModules{ s zPackageTest.getModulesc C sD | � � }|�� |�� |D ]}ztj|= W q ty Y qw d S �N)r �sort�reverse�sys�modules�KeyError)r r" �moduler r r �cleanUpModules� s ��zPackageTest.cleanUpModulesr c C s` | j D ]*\}}tj�||�}| �|� t|d�� }|�|� W d � n1 s(w Y qd S )N�w)r r r r �_createDirectory�open�write)r r � parentDirr �contents�fdr r r � createFiles� s ���zPackageTest.createFilesc C s* t j�|�}t j�|�st �|� d S d S r )r r �dirname�exists�makedirs)r r � directoryr r r r' � s �z PackageTest._createDirectoryNc C s. t � |d u r | �� }|| _| �| j|� d S r )�invalidateImportCaches�mktemp�parentr- r )r r* r r r �setUp� s zPackageTest.setUpc C s | � � d S r )r% r r r r �tearDown� s zPackageTest.tearDown)r r )�__name__� __module__� __qualname__� dosModule� testModule� testSample�testInheritanceSampler r r r% r- r' r5 r6 r r r r r ^ s6 � r c @ s& e Zd Zddd�Zdd� Zdd� ZdS ) �SysPathManglingTestNc C s` t � tjd d � | _tjd d � | _|d u r| �� }t�| |� | j�| j � | � | j� d S r ) r2 r! r �oldPath�newPathr3 r r5 �appendr4 � mangleSysPath)r r4 r r r r5 � s zSysPathManglingTest.setUpc C s t �| � | �| j� d S r )r r6 rB r? r r r r r6 � s z SysPathManglingTest.tearDownc C s |t jd d �< d S r )r! r )r �pathVarr r r rB � s z!SysPathManglingTest.mangleSysPathr )r7 r8 r9 r5 r6 rB r r r r r> � s r> )�__doc__r r! � importlibr r2 � twisted.trialr r; �replacer: r< r= �SynchronousTestCaser r> r r r r �<module> s )DPK b�Z�Ӟ�r �r , test/__pycache__/test_script.cpython-310.pycnu �[��� o �b�r � @ sz d dl Z d dlZd dlZd dlZd dlZd dlmZ d dlmZ d dl m Z d dl m Z d dl mZ d dlmZ d dlmZ d d lmZmZmZmZ d d lmZ ed �Zd d � Z G dd� dej �Z G dd� dej �Z G dd� dej �Z G dd� dej �Z!G dd� dej �Z"G dd� dej#�Z$G dd� dej#�Z%G d d � d ej#�Z&G d d � d ej#�Z'G d d!� d!ej#�Z(G d"d#� d#ej#�Z)dS )$� N)�StringIO)�util)�FilePath)� UsageError)�trial)�unittest)�DistTrialRunner)�DestructiveTestSuite� TestLoader� TestSuite� TrialRunner)� testNamesr c C s t �t| �S )z1 For finding files in twisted/trial/test )r �sibpath�__file__)�filename� r �@/usr/lib/python3/dist-packages/twisted/trial/test/test_script.pyr s r c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�ForceGarbageCollectionTestsz* Tests for the --force-gc option. c C s> t �� | _g | _| �td| j� t�| j �}t ||g�| _ d S )N�collect) r �Options�config�log�patch�gcr �pyunit�FunctionTestCase� simpleTestr �test)�selfr r r r �setUp) s z!ForceGarbageCollectionTests.setUpc C � | j �d� dS )zD A simple test method that records that it was run. r N�r �append�r r r r r 0 � z&ForceGarbageCollectionTests.simpleTestc C r )zI A replacement for gc.collect that logs calls to itself. r Nr! r# r r r r 6 r$ z#ForceGarbageCollectionTests.collectc C s t �| j�}t� |_|S )zN Return a L{TrialRunner} object that is safe to use in tests. )r � _makeRunnerr r �stream�r �runnerr r r � makeRunner< s z&ForceGarbageCollectionTests.makeRunnerc C s> d| j d< | j �� | �� }|�| j� | �| jg d�� dS )z� Passing the --force-gc option to the trial script forces the garbage collector to run before and after each test. Tzforce-gc)r r r r r r N�r � postOptionsr) �runr � assertEqualr r' r r r � test_forceGcD s �z(ForceGarbageCollectionTests.test_forceGcc C s4 | j �� | �� }|�| j� | �| jddg� dS )z> By default, no garbage collection is forced. r Nr* r' r r r �test_unforceGcQ s z*ForceGarbageCollectionTests.test_unforceGcN) �__name__� __module__� __qualname__�__doc__r r r r) r. r/ r r r r r $ s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �SuiteUsedTestsz? Check the category of tests suite used by the loader. c C � t �� | _dS )z6 Create a trial configuration object. N�r r r r# r r r r ` � zSuiteUsedTests.setUpc C s t �| j�}| �|jt� dS )zK By default, the loader should use L{DestructiveTestSuite} N)r � _getLoaderr r- � suiteFactoryr �r �loaderr r r �test_defaultSuitef s z SuiteUsedTests.test_defaultSuitec C s( d| j d< t�| j �}| �|jt� dS )zw The C{until-failure} configuration uses the L{TestSuite} to keep instances alive across runs. Tz until-failureN)r r r8 r- r9 r r: r r r �test_untilFailureSuitem s z%SuiteUsedTests.test_untilFailureSuiteN)r0 r1 r2 r3 r r< r= r r r r r4 [ s r4 c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � 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%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Zd3d4� Z d5S )6�TestModuleTestsc C � t �� | _d S �Nr6 r# r r r r x � zTestModuleTests.setUpc C s d | _ d S r@ )r r# r r r �tearDown{ � zTestModuleTests.tearDownc C s | � t| �| �� g� dS )zq Check that the testNames helper method accurately collects the names of tests in suite. N)r- r �idr# r r r �test_testNames~ s z TestModuleTests.test_testNamesc C sB t � }t|�}ttt|j|���}|�� |�� | �||� d S r@ )r r r �map� loadByName�sortr- )r �test1�namesr; �names1�names2r r r �assertSuitesEqual� s z!TestModuleTests.assertSuitesEqualc C s | � dt| jd �� d S )Nr �tests)r- �lenr r# r r r �test_baseState� s z TestModuleTests.test_baseStatec C �* | j �td�� | �t�| j �dg� dS )z� Check that --testmodule loads a suite which contains the tests referred to in test-case-name inside its parameter. � moduletest.py�twisted.trial.test.test_logN�r �opt_testmoduler rM r � _getSuiter# r r r �test_testmoduleOnModule� � �z'TestModuleTests.test_testmoduleOnModulec C s: | j �td�� | j �td�� | �t�| j �dg� dS )z� When the same module is specified with two --testmodule flags, it should only appear once in the suite. rR rS NrT r# r r r �test_testmoduleTwice� s �z$TestModuleTests.test_testmoduleTwicec C s: | j �td�� | j �td�� | �t�| j �dg� dS )z� If --testmodule is specified twice, once for module A and once for a module which refers to module A, then make sure module A is only added once. rR z test_log.pyrS NrT r# r r r � test_testmoduleOnSourceAndTarget� s �z0TestModuleTests.test_testmoduleOnSourceAndTargetc C rQ )z� When given a module that refers to *itself* in the test-case-name variable, check that --testmodule only adds the tests once. z moduleself.pyz twisted.trial.test.moduleselfNrT r# r r r �test_testmoduleOnSelfModule� rX z+TestModuleTests.test_testmoduleOnSelfModulec C s, | j �td�� | �t�| j �ddg� dS )zm Check that --testmodule loads tests referred to in test-case-name buffer variables. � scripttest.pyrS � twisted.trial.test.test_runnerNrT r# r r r �test_testmoduleOnScript� s �z'TestModuleTests.test_testmoduleOnScriptc C �h t � }tj|}t_d}z#| j�|� | �dt| jd �� | �d|�d�|�� � W |t_dS |t_w )zz Check that --testmodule displays a meaningful error message when passed a non-existent filename. z test_thisbetternoteverexist.pyr rN �File � doesn't exist N�r �sys�stderrr rU r- rO �getvalue)r �buffyrd r r r r � test_testmoduleOnNonexistentFile� � z0TestModuleTests.test_testmoduleOnNonexistentFilec C s* | j �td�� | �dt| j d �� dS )z� Check that --testmodule adds no tests to the suite for modules which lack test-case-name buffer variables. � novars.pyr rN N)r rU r r- rO r# r r r �test_testmoduleOnEmptyVars� s z*TestModuleTests.test_testmoduleOnEmptyVarsc C r_ )z� Check that --testmodule does *not* support module names as arguments and that it displays a meaningful error message. z twisted.trial.test.test_scriptr rN r` ra Nrb )r rf rd � moduleNamer r r �test_testmoduleOnModuleName� rh z+TestModuleTests.test_testmoduleOnModuleNamec C �" d}t �|�}| �ddi|� d S )Nz5-*- test-case-name: twisted.trial.test.test_tests -*-�test-case-name� twisted.trial.test.test_tests�r �_parseLocalVariablesr- �r � declaration� localVarsr r r �test_parseLocalVariable� � z'TestModuleTests.test_parseLocalVariablec C rm )Nz6-*- test-case-name: twisted.trial.test.test_tests; -*-rn ro rp rr r r r �test_trailingSemicolon� rv z&TestModuleTests.test_trailingSemicolonc C s$ d}t �|�}| �ddd�|� d S )Nz?-*- test-case-name: twisted.trial.test.test_tests; foo: bar -*-ro �bar)rn �foorp rr r r r �test_parseLocalVariables� s � �z(TestModuleTests.test_parseLocalVariablesc C rm )Nz:## -*- test-case-name: twisted.trial.test.test_tests -*- #rn ro rp rr r r r �test_surroundingGuff� rv z$TestModuleTests.test_surroundingGuffc C s | � ttjd� d S �Nry �� assertRaises� ValueErrorr rq r# r r r �test_invalidLine s z TestModuleTests.test_invalidLinec C s4 | � ttjd� | � ttjd� | � ttjd� d S )Nz -*- foo -*-z-*- foo: bar; qux -*-z -*- foo: bar: baz; qux: qax -*-r} r# r r r �test_invalidDeclaration s ��z'TestModuleTests.test_invalidDeclarationc C �" t �td��}| �ddi|� d S )NrR rn rS �r �loadLocalVariablesr r- �r rt r r r �test_variablesFromFile � z&TestModuleTests.test_variablesFromFilec C s t �td��}| �i |� d S )Nri r� r� r r r �test_noVariablesInFile s z&TestModuleTests.test_noVariablesInFilec C r� )Nr\ rn z:twisted.trial.test.test_log,twisted.trial.test.test_runnerr� r� r r r �test_variablesFromScript s ��z(TestModuleTests.test_variablesFromScriptc C s t �td��}| �|dg� d S )NrR rS )r �getTestModulesr r- �r �modulesr r r �test_getTestModules# s z#TestModuleTests.test_getTestModulesc C s" t �td��}| �t|�d� d S )Nri r )r r� r r- rO r� r r r �test_getTestModules_noVars' r� z*TestModuleTests.test_getTestModules_noVarsc C s& t �td��}| �t|�ddh� d S )Nr\ rS r] )r r� r r- �setr� r r r � test_getTestModules_multiple+ s �z,TestModuleTests.test_getTestModules_multiplec C sV dD ]}| � t�|�|�d�� qdtd�td�fD ]}| �t�|�|�d�� qd S )N)ztest_script.pyz!twisted/trial/test/test_script.pyz should be a test filez twisted/trial/test/moduletest.pyr\ z test_foo.batz should *not* be a test file)� assertTruer � isTestFiler � assertFalse)r r r r r �test_looksLikeTestModule2 s ����z(TestModuleTests.test_looksLikeTestModuleN) r0 r1 r2 r rB rE rM rP rW rY rZ r[ r^ rg rj rl ru rw rz r{ r� r� r� r� r� r� r� r� r� r r r r r> w s6 r> c @ �H e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )�WithoutModuleTestsz* Test the C{without-module} flag. c C s t �� | _ttj�| _dS )zl Create a L{trial.Options} object to be used in the tests, and save C{sys.modules}. N)r r r �dictrc r� � savedModulesr# r r r r H s zWithoutModuleTests.setUpc C s8 dD ]}|| j v r| j | tj|< qtj�|d� qdS )z) Restore C{sys.modules}. )�imaplib�smtplibN)r� rc r� �pop)r �moduler r r rB P s �zWithoutModuleTests.tearDownc C � ddl }|S )zE Try to import the C{smtplib} module, and return it. r N)r� )r r� r r r � _checkSMTPZ � z WithoutModuleTests._checkSMTPc C r� )zE Try to import the C{imaplib} module, and return it. r N)r� )r r� r r r � _checkIMAPb r� z WithoutModuleTests._checkIMAPc C s< | j �ddg� | �t| j� tjd= | �| �� tj � dS )zT Check that after disabling a module, it can't be imported anymore. �--without-moduler� N) r � parseOptionsr~ � ImportErrorr� rc r� �assertIsInstance�types� ModuleTyper# r r r �test_disableOneModulej s z(WithoutModuleTests.test_disableOneModulec C sd | j �ddg� | �t| j� | �t| j� tjd= tjd= | �| �� t j � | �| �� t j � dS )zE Check that several modules can be disabled at once. r� zsmtplib,imaplibr� r� N) r r� r~ r� r� r� rc r� r� r� r� r# r r r �test_disableMultipleModulesu s z.WithoutModuleTests.test_disableMultipleModulesc C s@ | � | �� tj� | �tdtj| jj ddg� | � t | j� dS )zP Disabling an already imported module should produce a warning. z4Module 'smtplib' already imported, disabling anyway.r� r� N) r� r� r� r� � assertWarns�RuntimeWarningr r r r� r~ r� r# r r r �!test_disableAlreadyImportedModule� s �z4WithoutModuleTests.test_disableAlreadyImportedModuleN) r0 r1 r2 r3 r rB r� r� r� r� r� r r r r r� C s r� c @ sD e Zd ZdZeedd�du rdZdd� Zdd� Zd d � Z d d � Z dS ) � CoverageTestsz+ Tests for the I{coverage} option. �gettraceNz;Cannot test trace hook installation without inspection API.c C s | � tjt�� � dS )zf Arrange for the current trace hook to be restored when the test is complete. N)� addCleanuprc �settracer� r# r r r r � s zCoverageTests.setUpc C s, t �� }|�dg� | �t�� |jj� dS )z} L{trial.Options} handles C{"--coverage"} by installing a trace hook to record coverage information. z --coverageN)r r r� r- rc r� �tracer� globaltrace�r �optionsr r r �test_tracerInstalled� s z"CoverageTests.test_tracerInstalledc C s. t �� }| �|�� td��|d dg�� dS )z� L{trial.Options.coverdir} returns a L{FilePath} based on the default for the I{temp-directory} option if that option is not specified. �.ztemp-directory�coverageN)r r r- �coverdirr � descendantr� r r r �test_coverdirDefault� s �z"CoverageTests.test_coverdirDefaultc C s< | � � }t�� }|�d|g� | �|�� t|��d�� dS )z� If a value is specified for the I{temp-directory} option, L{trial.Options.coverdir} returns a child of that path. z--temp-directoryr� N)�mktempr r r� r- r� r �child)r �pathr� r r r �test_coverdirOverridden� s z%CoverageTests.test_coverdirOverridden) r0 r1 r2 r3 �getattrrc �skipr r� r� r� r r r r r� � s r� c @ r� )� OptionsTestsz% Tests for L{trial.Options}. c C r5 )zE Build an L{Options} object to be used in the tests. N�r r r� r# r r r r � r7 zOptionsTests.setUpc C sj | � tjt�� � t�� r| � tj� | j�g d�� | j� � }| � d|� |� d� | � ddg|� dS )z� C{_getWorkerArguments} discards options like C{random} as they only matter in the manager, and forwards options like C{recursionlimit} or C{disablegc}. )�--recursionlimit�2000�--random�4� --disablegcr� r� r� N) r� rc �setrecursionlimit�getrecursionlimitr � isenabled�enabler� r� �_getWorkerArguments�assertIn�remover- )r �argsr r r �test_getWorkerArguments� s � z$OptionsTests.test_getWorkerArgumentsc C �* | � t| jjg d��}| �dt|�� dS )z� C{parseOptions} raises a C{UsageError} when C{--debug} is passed along C{--jobs} as it's not supported yet. @see: U{http://twistedmatrix.com/trac/ticket/5825} )�--jobsr� �--debugz+You can't specify --debug when using --jobsN�r~ r r� r� r- �str�r �errorr r r �test_jobsConflictWithDebug� � �z'OptionsTests.test_jobsConflictWithDebugc C r� )z� C{parseOptions} raises a C{UsageError} when C{--profile} is passed along C{--jobs} as it's not supported yet. @see: U{http://twistedmatrix.com/trac/ticket/5827} )r� r� z --profilez-You can't specify --profile when using --jobsNr� r� r r r � test_jobsConflictWithProfile� r� z)OptionsTests.test_jobsConflictWithProfilec C r� )z� C{parseOptions} raises a C{UsageError} when C{--debug-stacktraces} is passed along C{--jobs} as it's not supported yet. @see: U{http://twistedmatrix.com/trac/ticket/5826} )r� r� z--debug-stacktracesz7You can't specify --debug-stacktraces when using --jobsNr� r� r r r �%test_jobsConflictWithDebugStackTraces� s ��z2OptionsTests.test_jobsConflictWithDebugStackTracesc C r� )z� C{parseOptions} raises a C{UsageError} when C{--exitfirst} is passed along C{--jobs} as it's not supported yet. @see: U{http://twistedmatrix.com/trac/ticket/6436} )r� r� � --exitfirstz/You can't specify --exitfirst when using --jobsNr� r� r r r � test_jobsConflictWithExitFirst r� z+OptionsTests.test_jobsConflictWithExitFirstc C r� )zr C{parseOptions} raises a C{UsageError} when C{--order} is passed along with C{--random}. )�--order� alphabeticalr� �1234z-You can't specify --random when using --orderNr� r� r r r � test_orderConflictWithRandom s �z)OptionsTests.test_orderConflictWithRandomN) r0 r1 r2 r3 r r� r� r� r� r� r� r r r r r� � s r� c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �MakeRunnerTestsz. Tests for the L{_makeRunner} helper. c C r? r@ r� r# r r r r # rA zMakeRunnerTests.setUpc C sJ | j �g d�� t�| j �}| �|t� | �d|j� | �dg|j� dS )z� L{_makeRunner} returns a L{DistTrialRunner} instance when the C{--jobs} option is passed, and passes the C{workerNumber} and C{workerArguments} parameters to it. )r� r� � --force-gc� r� N) r� r� r r% r� r r- � _workerNumber�_workerArgumentsr' r r r � test_jobs& s zMakeRunnerTests.test_jobsc C s< | j �g d�� t�| j �}| �|t� | �tj|j� dS )z� L{_makeRunner} returns a L{TrialRunner} instance in C{DRY_RUN} mode when the C{--dry-run} option is passed, even if C{--jobs} is set. )r� r� z --dry-runN) r� r� r r% r� r r- �DRY_RUN�moder' r r r �test_dryRunWithJobs2 s z#MakeRunnerTests.test_dryRunWithJobsc sP t jj� � fdd�}| �t jd|� t �� }|�g d�� | �t jt j|� d S )Nc s | dkr t j�| ��� | �S )N� doNotFind)r �reflect�ModuleNotFound)�fqn��namedAnyr r �namedAnyExceptdoNotFind? s zFMakeRunnerTests.test_DebuggerNotFound.<locals>.namedAnyExceptdoNotFindr� )r� z --debuggerr� ) r r� r� r r r� r~ �_DebuggerNotFoundr% )r r� r� r r� r �test_DebuggerNotFound< s z%MakeRunnerTests.test_DebuggerNotFoundc C s* | j �dg� t�| j �}| �|j� dS )z� Passing C{--exitfirst} wraps the reporter with a L{reporter._ExitWrapper} that stops on any non-success. r� N)r� r� r r% r� � _exitFirstr' r r r �test_exitfirstK s z MakeRunnerTests.test_exitfirstN) r0 r1 r2 r3 r r� r� r� r� r r r r r� s r� c @ � e Zd ZdZdd� Zdd� ZdS )�RunTestsz( Tests for the L{run} function. c C s | � tjddd� � d S )Nr� c S s d S r@ r r# r r r �<lambda>] s z RunTests.setUp.<locals>.<lambda>)r r r r# r r r r Z s zRunTests.setUpc C sh dd� }| � td|� zt�� W n ty, } z| �dt|�� W Y d}~dS d}~ww | �d� dS )zY When a debugger is not found, an error message is printed to the user. c _ s t �d��r| )r r� )r� �kwargsr r r r% e rC z3RunTests.test_debuggerNotFound.<locals>._makeRunnerr% ry Nz0Should have exited due to non-existent debugger!)r r r, � SystemExitr� r� �fail)r r% �er r r �test_debuggerNotFound_ s ��z RunTests.test_debuggerNotFoundN)r0 r1 r2 r3 r r� r r r r r� U s r� c @ r� )�TestArgumentOrderTestszQ Tests for the order-preserving behavior on provided command-line tests. c C s t �� | _t� | _d S r@ )r r r r r; r# r r r r w s z TestArgumentOrderTests.setUpc C sR g d�}| j �|� t�| j �}t|�}tt| jj|��}t|�}| � ||� dS )zN Multiple tests passed on the command line are not reordered. )ro z"twisted.trial.test.test_assertionsz twisted.trial.test.test_deferredN) r r� r rV r r rF r; rG r- )r rN �suiterJ � expectedSuite� expectedNamesr r r �test_preserveArgumentOrder{ s z1TestArgumentOrderTests.test_preserveArgumentOrderN)r0 r1 r2 r3 r r r 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 dS )� OrderTestsz' Tests for the --order option. c C r? r@ r6 r# r r r r � rA zOrderTests.setUpc C �D | j �g d�� t�| j �}|�| j d �}| �t|�g d�� dS )zn --order=alphabetical causes trial to run tests alphabetically within each test case. )r� r� �%twisted.trial.test.ordertests.FooTestrN )�0twisted.trial.test.ordertests.FooTest.test_first�1twisted.trial.test.ordertests.FooTest.test_fourth�1twisted.trial.test.ordertests.FooTest.test_second�0twisted.trial.test.ordertests.FooTest.test_thirdN�r r� r r8 � loadByNamesr- r �r r; r� r r r �test_alphabetical� s � �z OrderTests.test_alphabeticalc C r )zu --order=alphabetical causes trial to run test classes within a given module alphabetically. )r� r� � twisted.trial.test.ordertestsrN )�.twisted.trial.test.ordertests.BarTest.test_bar�.twisted.trial.test.ordertests.BazTest.test_bazr r r r Nr r r r r �test_alphabeticalModule� � � �z"OrderTests.test_alphabeticalModulec C sV | j �g d�� t�| j �}|�| j d �}t|�}| j|dd� | �|t|�� dS )z� --order=alphabetical causes trial to run test modules within a given package alphabetically, with tests within each module alphabetized. )r� r� �twisted.trial.testrN zFailed to load any tests!��msgN) r r� r r8 r r r� r- �sorted�r r; r� rJ r r r �test_alphabeticalPackage� s z#OrderTests.test_alphabeticalPackagec C r )z� --order=toptobottom causes trial to run test methods within a given test case from top to bottom as they are defined in the body of the class. )r� � toptobottomr rN )r r r r Nr r r r r �test_toptobottom� s � �zOrderTests.test_toptobottomc C r )z� --order=toptobottom causes trial to run test classes within a given module from top to bottom as they are defined in the module's source. �r� r r rN )r r r r r r Nr r r r r �test_toptobottomModule� r z!OrderTests.test_toptobottomModulec C sP | j �g d�� t�| j �}|�| j d �}t|�}| �|t|dd� d�� dS )z� --order=toptobottom causes trial to run test modules within a given package alphabetically, with tests within each module run top to bottom. )r� r r rN c S s | � d�d d� S )Nr� r� )�split)�namer r r r� s z4OrderTests.test_toptobottomPackage.<locals>.<lambda>)�keyN)r r� r r8 r r r- r r r r r �test_toptobottomPackage� s �z"OrderTests.test_toptobottomPackagec C s� | � � }t|��d�}|�� |�d��d� |�d��t�d��d�� |�� j }t j � d|� | � t j j |� ddlm} | � t jjd� | � t jj|j� |�d�� � | j�g d �� t�| j�}|�|�}| �t|�g d �� d S ) z{ --order=toptobottom detects the source line of methods from modules whose source file is missing. �twisted_toptobottom_tempz __init__.py� ztest_missing.pya from twisted.trial.unittest import TestCase class TestMissing(TestCase): def test_second(self): pass def test_third(self): pass def test_fourth(self): pass def test_first(self): pass �utf8r )� test_missingr )z=twisted_toptobottom_temp.test_missing.TestMissing.test_secondz<twisted_toptobottom_temp.test_missing.TestMissing.test_thirdz=twisted_toptobottom_temp.test_missing.TestMissing.test_fourthz<twisted_toptobottom_temp.test_missing.TestMissing.test_firstN)r� r r� �makedirs� setContent�textwrap�dedent�encode�parentr� rc �insertr� r� r r# r� r� r0 r r� r r8 � loadModuler- r )r �tempdir�package� pathEntryr# r; r� r r r � test_toptobottomMissingSource s4 � � � �z(OrderTests.test_toptobottomMissingSourcec C s | � t| jjddg� dS )zL An unknown order passed to --order raises a L{UsageError}. r� z I don't existN)r~ r r r� r# r r r �test_unknownOrder? s �z OrderTests.test_unknownOrderN) r0 r1 r2 r3 r r r r r r r r/ r0 r r r r r � s .r c @ s e Zd ZdZdd� ZdS )�HelpOrderTestsz+ Tests for the --help-orders flag. c C s� | � tdt� � | �tt�� jdg�}| �|j d� tj � � }d}tj � � D ]"\}\}}t�t�|�� dt�|�� �|�}| j||||f d� q&dS )zS --help-orders prints each of the available orders and then exits. �stdoutz --help-ordersr z4%r with its description not properly described in %rz.*r N)r rc r r~ r� r r r� r- �coder2 re � _runOrders�items�re�search�escaper� )r �exc�outputr � orderName� orderDesc�_�matchr r r �&test_help_ordersPrintsSynopsisAndQuitsN s � ��z5HelpOrderTests.test_help_ordersPrintsSynopsisAndQuitsN)r0 r1 r2 r3 r? r r r r r1 I s r1 )*r r6 rc r& r� �ior �twisted.pythonr �twisted.python.filepathr �twisted.python.usager �twisted.scriptsr � twisted.trialr � twisted.trial._dist.disttrialr �twisted.trial.runnerr r r r � twisted.trial.test.test_loaderr � __import__r r �SynchronousTestCaser r4 r> r� r� �TestCaser� r� r� r� r r1 r r r r �<module> s: 7 MO.^7 ;PK b�Z Z� �' �' 2 test/__pycache__/test_pyunitcompat.cpython-310.pycnu �[��� o �b� � @ s� d dl Z d dlZd dlZd dlmZ d dlmZ d dlmZ d dl m Z m Z d dl m Z mZ G dd� de�ZG d d � d e�ZdS ) � N)�skipIf)� implementer)�Failure)� IReporter� ITestCase)�PyUnitResultAdapter�SynchronousTestCasec @ s. e Zd ZG dd� dej�Zdd� Zdd� ZdS )�PyUnitTestTestsc @ s e Zd Zdd� ZdS )zPyUnitTestTests.PyUnitTestc C s d S �N� ��selfr r �F/usr/lib/python3/dist-packages/twisted/trial/test/test_pyunitcompat.py� test_pass s z$PyUnitTestTests.PyUnitTest.test_passN)�__name__� __module__� __qualname__r r r r r � PyUnitTest s r c C s | � d�| _t| j�| _d S )Nr )r �originalr �testr r r r �setUp s zPyUnitTestTests.setUpc C s | � t| j�| j�d�� dS )zW Tests must be callable in order to be used with Python's unittest.py. z is not callable.N)� assertTrue�callabler r r r r � test_callable s z PyUnitTestTests.test_callableN)r r r �pyunit�TestCaser r r r r r r r s r c @ sp e Zd ZdZG dd� de�Zdd� Zdd� Zdd � Zd d � Z d d � Z dd� Z dd� Z dd� Z dd� Zdd� ZdS )�PyUnitResultTestsz� Tests to show that PyUnitResultAdapter wraps TestResult objects from the standard library 'unittest' module in such a way as to make them usable and useful from Trial. c @ s e Zd ZdZdZdd� ZdS )zPyUnitResultTests.ErrorTestz� A test case which has a L{test_foo} which will raise an error. @ivar ran: boolean indicating whether L{test_foo} has been run. Fc C s d| _ dd dS )zR Set C{self.ran} to True and raise a C{ZeroDivisionError} T� r N��ranr r r r �test_foo3 s z$PyUnitResultTests.ErrorTest.test_fooN)r r r �__doc__r r r r r r � ErrorTest* s r" c C sF t t�G dd� d��}| �d�}|� }|�|� | �|jd t� dS )z� The L{PyUnitResultAdapter} is only used when the result passed to C{run} does *not* provide L{IReporter}. c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) zXPyUnitResultTests.test_dontUseAdapterWhenReporterProvidesIReporter.<locals>.StubReporterz� A reporter which records data about calls made to it. @ivar errors: Errors passed to L{addError}. @ivar failures: Failures passed to L{addFailure}. c S s g | _ g | _d S r )�errors�failuresr r r r �__init__I s zaPyUnitResultTests.test_dontUseAdapterWhenReporterProvidesIReporter.<locals>.StubReporter.__init__c S � dS �z- Do nothing. Nr �r r r r r � startTestM � zbPyUnitResultTests.test_dontUseAdapterWhenReporterProvidesIReporter.<locals>.StubReporter.startTestc S r& r' r r( r r r �stopTestR r* zaPyUnitResultTests.test_dontUseAdapterWhenReporterProvidesIReporter.<locals>.StubReporter.stopTestc S s | j �|� dS )z3 Record the error. N)r# �append)r r �errorr r r �addErrorW s zaPyUnitResultTests.test_dontUseAdapterWhenReporterProvidesIReporter.<locals>.StubReporter.addErrorN)r r r r! r% r) r+ r. r r r r � StubReporter@ s r/ r r N)r r r" �run�assertIsInstancer# r )r r/ r �resultr r r �0test_dontUseAdapterWhenReporterProvidesIReporter: s zBPyUnitResultTests.test_dontUseAdapterWhenReporterProvidesIReporterc C sV G dd� dt �}|d�}t�� }|�|� | �|j� | �d|j� | �|�� � d S )Nc @ � e Zd ZdZdd� ZdS )z3PyUnitResultTests.test_success.<locals>.SuccessTestFc S � d| _ d S �NTr ��sr r r r f � z<PyUnitResultTests.test_success.<locals>.SuccessTest.test_fooN�r r r r r r r r r � SuccessTestc � r; r r ) r r � TestResultr0 r r � assertEqual�testsRun� wasSuccessful)r r; r r2 r r r � test_successb s z PyUnitResultTests.test_successc C sh G dd� dt �}|d�}t�� }|�|� | �|j� | �d|j� | �dt|j �� | � |� � � d S )Nc @ r4 )z3PyUnitResultTests.test_failure.<locals>.FailureTestFc S s d| _ | �d� d S )NTzboom!)r �failr7 r r r r u s z<PyUnitResultTests.test_failure.<locals>.FailureTest.test_fooNr: r r r r � FailureTestr r< rC r r ) r r r= r0 r r r> r? �lenr$ � assertFalser@ )r rC r r2 r r r � test_failureq s z PyUnitResultTests.test_failurec C sZ | � d�}t�� }|�|� | �|j� | �d|j� | �dt|j �� | � |� � � d S )Nr r ) r" r r= r0 r r r> r? rD r# rE r@ )r r r2 r r r � test_error� s z PyUnitResultTests.test_errorc C sh G dd� dt �}|d�}t�� }|�|� | �|j� | �d|j� | �dt|j �� | �|� � � d S )Nc @ s e Zd ZdZdd� Zdd� ZdS )z4PyUnitResultTests.test_setUpError.<locals>.ErrorTestFc S � dd d S �Nr r r r r r r r � s z:PyUnitResultTests.test_setUpError.<locals>.ErrorTest.setUpc S r5 r6 r r7 r r r r � r9 z=PyUnitResultTests.test_setUpError.<locals>.ErrorTest.test_fooN)r r r r r r r r r r r" � s r" r r ) r r r= r0 rE r r> r? rD r# r@ )r r" r r2 r r r �test_setUpError� s z!PyUnitResultTests.test_setUpErrorc C sp zdd W n t y t�� }t� }Y nw t�� }t|�}|�| |� | �|j d d d� t j |� �� dS )z� Errors added through the L{PyUnitResultAdapter} have the same traceback information as if there were no adapter at all. r r � N) �ZeroDivisionError�sys�exc_infor r r= r r. r> r# �join� traceback�format_exception�r rN �f�pyresultr2 r r r �test_tracebackFromFailure� s � �z+PyUnitResultTests.test_tracebackFromFailurec C s� G dd� dt �}|d�}t�� }|�|� d�t�|jd ��}d�|jd d � � d d � �}| � |� � |t |� d � � � � d S ) zG As test_tracebackFromFailure, but covering more code. c @ s e Zd ZdZdd� ZdS )z3PyUnitResultTests.test_traceback.<locals>.ErrorTestNc S s* zdd W d S t y t�� | _� w rI )rL rM rN r r r r r � s �z<PyUnitResultTests.test_traceback.<locals>.ErrorTest.test_foo)r r r rN r r r r r r" � r< r" r rK � � r r N���) r r r= r0 rO rP � format_tbrN r# � splitlinesr> �striprD )r r" r r2 �expected_stack�observed_stackr r r �test_traceback� s �z PyUnitResultTests.test_tracebackc C sx zdd W n t y t�� }t� }Y nw |�� t�� }t|�}|�| |� | � |j d d d� t j |� �� dS )z� Errors added through the L{PyUnitResultAdapter} have the same traceback information as if there were no adapter at all, even if the Failure that held the information has been cleaned. r r rK N)rL rM rN r � cleanFailurer r= r r. r> r# rO rP rQ rR r r r � test_tracebackFromCleanFailure� s � �z0PyUnitResultTests.test_tracebackFromCleanFailurec C �B G dd� dt �}|d�}t�� }|�|� | �|j|dfg� dS )zw Skips using trial's skipping functionality are reported as skips in the L{pyunit.TestResult}. c @ s e Zd Zedd�dd� �ZdS )z2PyUnitResultTests.test_trialSkip.<locals>.SkipTestT� Let's skip!c S rH rI r r r r r � test_skip� � z<PyUnitResultTests.test_trialSkip.<locals>.SkipTest.test_skipN)r r r r rc r r r r �SkipTest� � re rc rb N�r r r= r0 r> �skipped�r re r r2 r r r �test_trialSkip� � z PyUnitResultTests.test_trialSkipc C ra )zx Skips using pyunit's skipping functionality are reported as skips in the L{pyunit.TestResult}. c @ s e Zd Ze�d�dd� �ZdS )z3PyUnitResultTests.test_pyunitSkip.<locals>.SkipTest�skippyc S rH rI r r r r r rc � rd z=PyUnitResultTests.test_pyunitSkip.<locals>.SkipTest.test_skipN)r r r r �skiprc r r r r re � rf re rc rl Nrg ri r r r �test_pyunitSkip� rk z!PyUnitResultTests.test_pyunitSkipN)r r r r! r r" r3 rA rF rG rJ rU r^ r` rj rn r r r r r ! s ( ! r )rM rP �unittestr r �zope.interfacer �twisted.python.failurer �twisted.trial.itrialr r �twisted.trial.unittestr r r r r r r r �<module> s PK b�ZK�a� � � , test/__pycache__/test_runner.cpython-310.pycnu �[��� o �b� � @ s� d dl Z d dlZd dlZd dlZd dlmZ d dlmZ d dl m Z d dl m Z d dl mZ d dlmZ d dlmZ d d lmZmZmZ d d lmZ d d lmZ d d lm Z d d l m Z m Z mZm Z d dl!m"Z" d dl#m$Z$m%Z% G dd� d�Z&e e$�G dd� d��Z'G dd� d�Z(G dd� de(ej)�Z*G dd� de(ej)�Z+G dd� d�Z,G d d � d e,ej)�Z-G d d � d e,ej)�Z.G d d!� d!e,ej)�Z/G d"d#� d#ej)�Z0G d$d%� d%ej)�Z1G d&d'� d'ej)�Z2G d(d)� d)e2�Z3G d*d+� d+e j4�Z5G d,d-� d-ej)�Z6G d.d/� d/ej)�Z7G d0d1� d1�Z8G d2d3� d3e8e7�Z9G d4d5� d5e8e7�Z:G d6d7� d7ej)�Z;G d8d9� d9ej)�Z<G d:d;� d;ej)�Z=G d<d=� d=ej)�Z>G d>d?� d?ej)�Z?dS )@� N)�StringIO)�List)� implementer)� verifyObject)�plugin)�defer)� twisted_trial)�failure�log�reflect)�FilePath��namedAny)�trial)�reporter�runner�unittest�util)� _ForceGarbageCollectionDecorator)� IReporter� ITestCasec @ s e Zd Zdd� Zdd� ZdS )�CapturingDebuggerc C � g | _ d S �N)�_calls��self� r �@/usr/lib/python3/dist-packages/twisted/trial/test/test_runner.py�__init__ � zCapturingDebugger.__init__c O s* | j �d� |d |dd � i |�� d S )N�runcallr � �r �append)r �args�kwargsr r r r! " s zCapturingDebugger.runcallN)�__name__� __module__� __qualname__r r! r r r r r s r c @ s� e Zd ZdZdZdZdZdZdZddd�Z dd� Z dd� Z d d � Z d d � Z d d� Zdd� Zdd� Zd dd�Zd dd�Zdd� Zdd� ZdS ) �CapturingReporterzC Reporter that keeps a log of all actions performed on it. Nc C s( g | _ d| _|| _|| _|| _|| _dS )z. Create a capturing reporter. FN)r � shouldStop�_stream� _tbformat� _rterrors� _publisher)r �stream�tbformat�rterrors� publisherr r r r 3 s zCapturingReporter.__init__c C � | j �d� dS )z� Report the beginning of a run of a single test method @param method: an object that is adaptable to ITestMethod � startTestNr# �r �methodr r r r5 > � zCapturingReporter.startTestc C r4 )z} Report the status of a single test method @param method: an object that is adaptable to ITestMethod �stopTestNr# r6 r r r r9 E r8 zCapturingReporter.stopTestc C r4 )z�called when the reactor has been left in a 'dirty' state @param errs: a list of L{twisted.python.failure.Failure}s � cleanupErrorNr# )r �errsr r r � cleanupErrorsL � z CapturingReporter.cleanupErrorsc C s | j �d� d S )N� addSuccessr# �r �testr r r r> R � z CapturingReporter.addSuccessc C � dS )z@ Do nothing. These tests don't care about done. Nr r r r r �doneU � zCapturingReporter.donec C rB )zD Do nothing. These tests don't care about addError. Nr �r r@ �errorr r r �addErrorZ rD zCapturingReporter.addErrorc C rB )zF Do nothing. These tests don't care about addFailure. Nr )r r@ r r r r � addFailure_ rD z CapturingReporter.addFailurec C rB )zN Do nothing. These tests don't care about addExpectedFailure. Nr )r r@ r �todor r r �addExpectedFailured rD z$CapturingReporter.addExpectedFailurec C rB )zP Do nothing. These tests don't care about addUnexpectedSuccess. Nr )r r@ rI r r r �addUnexpectedSuccessi rD z&CapturingReporter.addUnexpectedSuccessc C rB )zC Do nothing. These tests don't care about addSkip. Nr )r r@ �reasonr r r �addSkipn rD zCapturingReporter.addSkipc C rB )zI Do nothing. These tests don't care about wasSuccessful. Nr r r r r � wasSuccessfuls rD z CapturingReporter.wasSuccessful)NNNNr )r' r( r) �__doc__r0 r1 r% � separator�testsRunr r5 r9 r< r> rC rG rH rJ rK rM rN r r r r r* ' s& r* c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�TrialRunnerTestsMixinz9 Mixin defining tests for L{runner.TrialRunner}. c C s | j �� d S r )r �_tearDownLogFiler r r r �tearDown~ � z TrialRunnerTestsMixin.tearDownc C rB )z= Empty test method, used by the other tests. Nr r r r r � test_empty� rD z TrialRunnerTestsMixin.test_emptyc C s t jjS r )r �theLogPublisher� observersr r r r � _getObservers� s z#TrialRunnerTestsMixin._getObserversc C s6 t | �� �}| j�| j� t | �� �}| �||� dS )zn Any log system observers L{TrialRunner.run} adds are removed by the time it returns. N)�lenrY r �runr@ � assertEqual)r � originalCount�newCountr r r �test_addObservers� s z'TrialRunnerTestsMixin.test_addObserversc sl �j j�g � � ��fdd�}|�j _�j ��j� �j ��j� ��t� �d� ��� d � d u d� dS )z= Test that a new file is opened on each run. c � �� � � �jj� d S r )r$ r �_logFileObserverr ��l�oldSetUpLogFiler r r � setUpLogFile� � zDTrialRunnerTestsMixin.test_logFileAlwaysActive.<locals>.setUpLogFile� r r" z'Should have created a new file observerN)r � _setUpLogFiler[ r@ r\ rZ � assertFalse�r re r rb r �test_logFileAlwaysActive� s z.TrialRunnerTestsMixin.test_logFileAlwaysActivec sV �j j�g � � ��fdd�}|�j _�j ��j� ��t� �d� ��� d j� dS )zB Test that file created is closed during the run. c r` r )r$ r �_logFileObjectr rb r r re � rf zBTrialRunnerTestsMixin.test_logFileGetsClosed.<locals>.setUpLogFiler" r N)r rh r[ r@ r\ rZ � assertTrue�closedrj r rb r �test_logFileGetsClosed� s z,TrialRunnerTestsMixin.test_logFileGetsClosedN) r' r( r) rO rT rV rY r_ rk ro r r r r rR y s rR c @ � e Zd ZdZdd� Zdd� ZdS )�TrialRunnerTestszm Tests for L{runner.TrialRunner} with the feature to turn unclean errors into warnings disabled. c C s( t � | _tjt| jd�| _td�| _d S )N�r0 rV �r r0 r � TrialRunnerr* rq r@ r r r r �setUp� s zTrialRunnerTests.setUpc C s | j �� }| �|jt� dS )z� The reporter constructed by L{runner.TrialRunner} is passed L{twisted.python.log} as the value for the C{publisher} parameter. N)r � _makeResult�assertIdenticalr/ r �r �resultr r r �test_publisher� s z TrialRunnerTests.test_publisherN)r' r( r) rO ru rz r r r r rq � s rq c @ � e Zd ZdZdd� ZdS )�+TrialRunnerWithUncleanWarningsReporterTestsza Tests for the TrialRunner's interaction with an unclean-error suppressing reporter. c C s* t � | _tjt| jdd�| _td�| _d S )NT�r0 �uncleanWarningsrV rs r r r r ru � s �z1TrialRunnerWithUncleanWarningsReporterTests.setUpN�r' r( r) rO ru r r r r r| � s r| c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) � DryRunMixinze Mixin for testing that 'dry run' mode works with various L{pyunit.TestCase} subclasses. c C s2 g | _ t� | _tjttjj| jd�| _| �� d S )Nrr )r r r0 r rt r* �DRY_RUN�makeTestFixturesr r r r ru � s � zDryRunMixin.setUpc C rB )zh Set C{self.test} and C{self.suite}, where C{self.suite} is an empty TestSuite. Nr r r r r r� � rD z DryRunMixin.makeTestFixturesc C s" | j �t �� �}| �|jg � dS )zf If there are no tests, the reporter should not receive any events to report. N)r r[ � TestSuiter\ r rx r r r rV � s zDryRunMixin.test_emptyc C s$ | j �| j�}| �|jg d�� dS )z� If we are running a single test, check the reporter starts, passes and then stops the test during a dry run. )r5 r> r9 N)r r[ r@ r\ r rx r r r �test_singleCaseReporting� s z$DryRunMixin.test_singleCaseReportingc C s | j �| j� | �| jg � dS )zT When we are doing a dry run, the tests should not actually be run. N)r r[ r@ r\ r r r r r �test_testsNotRun� s z DryRunMixin.test_testsNotRunN) r' r( r) rO ru r� rV r� r� r r r r r� � s r� c @ r{ )�SynchronousDryRunTestszS Check that 'dry run' mode works well with trial's L{SynchronousTestCase}. c C s* G dd� dt j�}|d�| _t�� | _d S )Nc @ � e Zd Zdd� ZdS )z;SynchronousDryRunTests.makeTestFixtures.<locals>.PyunitCasec S � d S r r r r r r �test_foo � zDSynchronousDryRunTests.makeTestFixtures.<locals>.PyunitCase.test_fooN�r' r( r) r� r r r r � PyunitCase � r� r� )r �SynchronousTestCaser@ �pyunitr� �suite�r r� r r r r� � z'SynchronousDryRunTests.makeTestFixturesN�r' r( r) rO r� r r r r r� � r� c @ r{ )� DryRunTestsz@ Check that 'dry run' mode works well with Trial tests. c s. G � fdd�dt j�}|d�� _t�� � _d S )Nc � e Zd Z� fdd�ZdS )z.DryRunTests.makeTestFixtures.<locals>.MockTestc s � j �d� d S )Nr� )r r$ �r@ r r r r� rA z7DryRunTests.makeTestFixtures.<locals>.MockTest.test_fooNr� r r r r �MockTest � r� r� )r �TestCaser@ r r� r� )r r� r r r r� s z DryRunTests.makeTestFixturesNr� r r r r r� r� r� c @ r{ )�PyUnitDryRunTestszJ Check that 'dry run' mode works well with stdlib unittest tests. c C s* G dd� dt j�}|d�| _t �� | _d S )Nc @ r� )z6PyUnitDryRunTests.makeTestFixtures.<locals>.PyunitCasec S r� r r r r r r r� ( r� z?PyUnitDryRunTests.makeTestFixtures.<locals>.PyunitCase.test_fooNr� r r r r r� ' r� r� r� )r� r� r@ r� r� r� r r r r� & r� z"PyUnitDryRunTests.makeTestFixturesNr� r r r r r� ! r� r� c @ s� e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� Zdd � Zd d � Zd d � Ze� Zd!d"� Zd#d$� Zd%S )&� RunnerTestsc sv t �� �_t�t��d�}d�|d d� �}|d }tj d|ddd |d�g� � �fdd�}t j �_ |t _ g d ��_ d S ) N�.���zTest Helper ReporterzUtility for unit testing.� capturing)� description�longOpt�shortOpt�klassc s, �� | t� � t�j| g|�R i |��� S r )r\ r �list�original)�iface�a�kw��pluginsr r r � getPluginsE s z%RunnerTests.setUp.<locals>.getPlugins) r5 r> r9 r5 r> r9 r5 r> r9 r5 r> r9 r5 r> r9 r5 r> r9 r5 r> r9 r5 r> r9 r5 r> r9 r5 r> r9 )r �Options�configr �qualr* �split�joinr � _Reporterr r� r� �standardReport)r �parts�packager� r� r r� r ru 0 s" �� zRunnerTests.setUpc C s | j t_d S r )r� r r� r r r r rT m s zRunnerTests.tearDownc C s | j �|� d S r )r� � parseOptions�r r% r r r r� p rA zRunnerTests.parseOptionsc C s. t �| j�}t� |_| �|j� t�� |_ |S r ) r � _makeRunnerr� r r0 � addCleanuprS r � LogPublisher�_log)r �rr r r � getRunners s zRunnerTests.getRunnerc C s2 | � g � | jd }| �� }| �||�� j� d S �Nr )r� r� r� r\ rv � __class__)r ry r r r r � test_runner_can_get_reporter� s z(RunnerTests.test_runner_can_get_reporterc C s2 | � g � | �� }|�� }| �|j| jd � d S r� )r� r� rv r\ r� r� �r r ry r r r �test_runner_get_result� s z"RunnerTests.test_runner_get_resultc C s( | � g � | �� }| �|�� tj� dS )z� By default Trial sets the 'uncleanWarnings' option on the runner to False. This means that dirty reactor errors will be reported as errors. See L{test_reporter.DirtyReactorTests}. N)r� r� �assertNotIsInstancerv r � UncleanWarningsReporterWrapper�r r r r r � test_uncleanWarningsOffByDefault� s �z,RunnerTests.test_uncleanWarningsOffByDefaultc C s* | � dg� | �� }| �|�� tj� dS )z� Specifying '--unclean-warnings' on the trial command line will cause reporters to be wrapped in a device which converts unclean errors to warnings. See L{test_reporter.DirtyReactorTests} for implications. z--unclean-warningsN)r� r� �assertIsInstancerv r r� r� r r r �test_getsUncleanWarnings� s �z$RunnerTests.test_getsUncleanWarningsc C s( | � ddg� | �� }| �|jd� d S )N�--temp-directory� some_path)r� r� r\ �workingDirectoryr� r r r � test_runner_working_directory� s z)RunnerTests.test_runner_working_directoryc s� | � g � | �tjt�� � t| �� ����� t��j� | � � }| � � �i �G � ���fdd�dt j �� |� � d��}|j |j }|rN| �|d d � | ����d�j��d�jd�� d S ) z� If no working directory is explicitly specified and the default working directory is in use by another runner, L{TrialRunner.run} selects a different default working directory to use. c s* e Zd Z� ���fdd�Z�fdd�ZdS )zKRunnerTests.test_concurrentImplicitWorkingDirectory.<locals>.ConcurrentCasec s< t �� �d< }t ��j� | �t j|� ��� d�� dS )z� Start a second test run which will have a default working directory which is the same as the working directory of the test run already in progress. � concurrent� test_secondN)�os�getcwd�chdir�pathr� r[ )r �subsequentDirectory��ConcurrentCase� runDirectory� secondRunner�wherer r � test_first� s zVRunnerTests.test_concurrentImplicitWorkingDirectory.<locals>.ConcurrentCase.test_firstc s t �� � d< dS )zR Record the working directory for later analysis. �recordN)r� r� r )r� r r r� � r= zWRunnerTests.test_concurrentImplicitWorkingDirectory.<locals>.ConcurrentCase.test_secondN)r' r( r) r� r� r r� r r r� � s r� r� r r" � _trial_tempz _trial_temp-1)r� r� N)r� r� r� r� r� r �mktemp�makedirsr� r� r r� r[ �errors�failures�failr\ �child)r � firstRunnerry �badr r� r �'test_concurrentImplicitWorkingDirectory� s& ��z3RunnerTests.test_concurrentImplicitWorkingDirectoryc s� | � dtj�| �� �g� t�� }| �tj|� | �� }| �� �G � �fdd�dt j �� |� � d��}|j |j }|rF| �|d d � dS dS )z� If a working directory which is already in use is explicitly specified, L{TrialRunner.run} raises L{_WorkingDirectoryBusy}. r� c s" e Zd Z� �fdd�Zdd� ZdS )zKRunnerTests.test_concurrentExplicitWorkingDirectory.<locals>.ConcurrentCasec s | � tj�j� d�� dS )z� Try to start another runner in the same working directory and assert that it raises L{_WorkingDirectoryBusy}. � test_failureN)� assertRaisesr �_WorkingDirectoryBusyr[ r �r� r� r r �test_concurrent� s �z[RunnerTests.test_concurrentExplicitWorkingDirectory.<locals>.ConcurrentCase.test_concurrentc S � | � d� dS )zE Should not be called, always fails. z$test_failure should never be called.N)r� r r r r r� � � zXRunnerTests.test_concurrentExplicitWorkingDirectory.<locals>.ConcurrentCase.test_failureN)r' r( r) r� r� r r� r r r� � s r� r� r r" N)r� r� r� �abspathr� r� r� r� r� r r� r[ r� r� r� )r �initialDirectoryr� ry r� r r� r �'test_concurrentExplicitWorkingDirectory� s �z3RunnerTests.test_concurrentExplicitWorkingDirectoryc C sR | � d| �� dddg� | �� }t�� }|�dd�}|�|�}| �| j|j � d S )Nr� � --reporterr� �twisted.trial.test.sampleT) r� r� r� r � TestLoader� loadByNamer[ r\ r� r )r � my_runner�loaderr� ry r r r �test_runner_normal s �� z RunnerTests.test_runner_normalc C s t �� }|�dd�}|�|�S )Nr� T)r r� r� r[ )r r� r� r� r r r �runSampleSuite s zRunnerTests.runSampleSuitec C sP | � g d�� | �� }t� }|_| �|�}| �| j|j� | �dg|j� dS )zL Trial uses its debugger if the `--debug` option is passed. )r� r� �--debugr� r! N)r� r� r �debuggerr� r\ r� r )r r� r� ry r r r �test_runnerDebug s � z RunnerTests.test_runnerDebugc s^ � � ddg� td�}|�� d� _� fdd�}� �tjd|� � �� �� � � � � j� dS ) zL Trial uses pdb if no debugger is specified by `--debugger` r� r� �pdbrcFc � d� _ d S �NT��runcall_called��pdbr� ry r r r r! 5 r z=RunnerTests.test_runnerDebuggerDefaultsToPdb.<locals>.runcallr! N) r� r �touchr� �patchr� �Pdbr� r� rm )r � pdbrcFiler! r r r � test_runnerDebuggerDefaultsToPdb+ s z,RunnerTests.test_runnerDebuggerDefaultsToPdbc sN � � g d�� d� _� fdd�}� �tjd|� � �� �� � � �� j� dS )zU Trial uses pdb if pdb is passed explicitly to the `--debugger` arg. )r� r� � --debuggerr� r� r� Fc r� r� r� r� r r r r! O r zGRunnerTests.test_runnerDebuggerWithExplicitlyPassedPdb.<locals>.runcallr! N)r� r� r r� r r� r� rm )r r! r r r �*test_runnerDebuggerWithExplicitlyPassedPdb> s � z6RunnerTests.test_runnerDebuggerWithExplicitlyPassedPdbc C sF | � g d�� | �� }| �|�}| �| j|j� | �dg|jj� dS )zM Trial uses specified debugger if the debugger is available. )r� r� r z4twisted.trial.test.test_runner.RunnerTests.cdebuggerr� r� r! N)r� r� r� r\ r� r r� )r r� ry r r r �test_runnerDebuggerZ s � z RunnerTests.test_runnerDebuggerc C s. | � dg� | �� }|�� }| �|tj� dS )z� If trial was passed the C{--exitfirst} option, the constructed test result object is wrapped with L{reporter._ExitWrapper}. z --exitfirstN)r� r� rv r� r � _ExitWrapperr� r r r �test_exitfirstm s zRunnerTests.test_exitfirstN)r' r( r) ru rT r� r� r� r� r� r� r� r� r� r� r� r� r r r � cdebuggerr r r r r r r� / s( = 9$ r� c @ r� )�TrialSuiteTestsc C s t d� d S )Nz twisted.trial.runner.TrialSuiter r r r r � test_importsy s z TrialSuiteTests.test_importsN)r' r( r) r r r r r r x r� r c @ sF e Zd ZG dd� dej�Zdd� Zdd� Zdd� Zd d � Z d d � Z d S )�UntilFailureTestsc @ s* e Zd ZU dZg Zed ed< dd� ZdS )zUntilFailureTests.FailAfterzC A test case that fails when run 3 times in a row. N�countc C s, | j �d � t| j �dkr| �d� d S d S )N� zCount reached 3)r r$ rZ r� r r r r r� � s �z$UntilFailureTests.FailAfter.test_foo)r' r( r) rO r r �__annotations__r� r r r r � FailAfter s r c C s4 g t j_t �d�| _t� | _tjtj | jd�| _d S )Nr� rr ) r r r r@ r r0 r rt r �Reporterr r r r ru � s zUntilFailureTests.setUpc C s@ | j �| j�}| �|jd� | �|�� � | �| �|�d� dS )zl Test that the runUntilFailure method of the runner actually fail after a few runs. r" N)r �runUntilFailurer@ r\ rQ ri rN � _getFailuresrx r r r �test_runUntilFailure� s z&UntilFailureTests.test_runUntilFailurec C s t |j�S )zL Get the number of failures that were reported to a result. )rZ r� rx r r r r � s z UntilFailureTests._getFailuresc sb g � � fdd�}| � td|� | j�| j�}| �|jd� | �t� �d� | �� | jtfg� dS )z� C{runUntilFailure} doesn't decorate the tests uselessly: it does it one time when run starts, but not at each turn. c � � � | |f� | S r �r$ �r@ � interface�� decoratedr r �decorate� � z@UntilFailureTests.test_runUntilFailureDecorate.<locals>.decorater r" N) r r r r r@ r\ rQ rZ r �r r ry r r r � test_runUntilFailureDecorate� s z.UntilFailureTests.test_runUntilFailureDecoratec sr g � � fdd�}| � td|� d| j_| j�| j�}| �|jd� | �t� �d� | �� | jt f| jt fg� dS )z� C{runUntilFailure} applies the force-gc decoration after the standard L{ITestCase} decoration, but only one time. c r r r r r r r r � r zGUntilFailureTests.test_runUntilFailureForceGCDecorate.<locals>.decorater Tr" rg N) r r r �_forceGarbageCollectionr r@ r\ rQ rZ r r r r r r �#test_runUntilFailureForceGCDecorate� s �z5UntilFailureTests.test_runUntilFailureForceGCDecorateN) r' r( r) r� r� r ru r r r r! r r r r r ~ s r c @ rp )�UncleanUntilFailureTestszh Test that the run-until-failure feature works correctly with the unclean error suppressor. c C s$ t �| � tjtj| jdd�| _d S )NTr} )r ru r rt r r r0 r r r r ru � s �z UncleanUntilFailureTests.setUpc C s t |jj�S )z� Get the number of failures that were reported to a result that is wrapped in an UncleanFailureWrapper. )rZ �_originalReporterr� rx r r r r � � z%UncleanUntilFailureTests._getFailuresN)r' r( r) rO ru r r r r r r" � s r" c @ r{ )� BreakingSuitez; A L{TestSuite} that logs an error when it is run. c C s, zt d�� t y t�t�� � Y d S w )Nz#error that occurs outside of a test)� RuntimeErrorr �errr �Failurerx r r r r[ � s �zBreakingSuite.runN)r' r( r) rO r[ r r r r r% � r� r% c @ �( e Zd ZdZdd� Zdd� Zdd� ZdS ) �LoggedErrorsTestsa It is possible for an error generated by a test to be logged I{outside} of any test. The log observers constructed by L{TestCase} won't catch these errors. Here we try to generate such errors and ensure they are reported to a L{TestResult} object. c C s | � t� d S r )�flushLoggedErrorsr& r r r r rT � rU zLoggedErrorsTests.tearDownc C s t �� }| �|�� d� dS )zg Check that we can construct a L{runner.LoggedSuite} and that it starts empty. r N)r � LoggedSuiter\ �countTestCases)r r� r r r �test_construct� s z LoggedErrorsTests.test_constructc C sl t �� }t�t� g�}|�|� | �t|j�d� | �|jd d � � tj � | � |jd d � t �� dS )zU Chek that a L{LoggedSuite} reports any logged errors to its result. r" r N)r � TestResultr r, r% r[ r\ rZ r� �id� NOT_IN_TESTrm �checkr& )r ry r� r r r �test_capturesError� s z$LoggedErrorsTests.test_capturesErrorN)r' r( r) rO rT r. r3 r r r r r* � s r* c @ s, e Zd Zdd� Zdd� Zdd� Zdd� Zd S ) �TestHolderTestsc C s d| _ t�| j �| _d S �Nr� )r� r � TestHolder�holderr r r r ru rf zTestHolderTests.setUpc C s, | � | j�� | j� | � | j�� | j� dS )z� Check that L{runner.TestHolder} takes a description as a parameter and that this description is returned by the C{id} and C{shortDescription} methods. N)r\ r7 r0 r� �shortDescriptionr r r r � test_holder s zTestHolderTests.test_holderc C s6 | � | jt| j�� | �tt| j�d| jtf � dS )z? L{runner.TestHolder} implements L{ITestCase}. z5%r claims to provide %r but does not do so correctly.N)rw r7 r rm r r r r r � test_holderImplementsITestCase s ��z.TestHolderTests.test_holderImplementsITestCasec C �4 t �� }| j�|� | �|�� � | �d|j� dS )zc A L{runner.TestHolder} can run against the standard Python C{TestResult}. r" N)r� r/ r7 r[ rm rN r\ rQ rx r r r �test_runsWithStandardResult" � z+TestHolderTests.test_runsWithStandardResultN)r' r( r) ru r9 r: r< r r r r r4 s r4 c @ sN e Zd ZdZed�ZG dd� d�Zdd� Zdd� Zd d � Z d d � Z d d� Z dS )�ErrorHolderTestsMixinaa This mixin defines test methods which can be applied to a L{runner.ErrorHolder} constructed with either a L{Failure} or a C{exc_info}-style tuple. Subclass this and implement C{setUp} to create C{self.holder} referring to a L{runner.ErrorHolder} instance and C{self.error} referring to a L{Failure} which the holder holds. z"integer division or modulo by zeroc @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) z$ErrorHolderTestsMixin.TestResultStubz) Stub for L{TestResult}. c C r r )r� r r r r r ? r z-ErrorHolderTestsMixin.TestResultStub.__init__c C r� r r r? r r r r5 B r� z.ErrorHolderTestsMixin.TestResultStub.startTestc C r� r r r? r r r r9 E r� z-ErrorHolderTestsMixin.TestResultStub.stopTestc C s | j �||f� d S r )r� r$ rE r r r rG H s z-ErrorHolderTestsMixin.TestResultStub.addErrorN)r' r( r) rO r r5 r9 rG r r r r �TestResultStub: s r? c C r; )zd A L{runner.ErrorHolder} can run against the standard Python C{TestResult}. r" N)r� r/ r7 r[ ri rN r\ rQ rx r r r r< K r= z1ErrorHolderTestsMixin.test_runsWithStandardResultc C s< | j �| j� | �| jj| j | jj| jj| jjffg� dS )zM L{runner.ErrorHolder} adds an error to the result when run. N) r7 r[ ry r\ r� rF �type�value�tbr r r r �test_runU s �z ErrorHolderTestsMixin.test_runc C s: | � | j� | �| jj| j | jj| jj| jjffg� dS )zP L{runner.ErrorHolder} adds an error to the result when called. N)r7 ry r\ r� rF r@ rA rB r r r r � test_call_ s �z ErrorHolderTestsMixin.test_callc C s | � | j�� d� dS )zH L{runner.ErrorHolder.countTestCases} always returns 0. r N)r\ r7 r- r r r r �test_countTestCasesi s z)ErrorHolderTestsMixin.test_countTestCasesc C s, d� t| jjd ��}| �t| j�|� dS )zh L{runner.ErrorHolder.__repr__} returns a string describing the error it holds. z0<ErrorHolder description='description' error={}>r" N)�format�reprr7 rF r\ )r �expectedr r r � test_repro s �z ErrorHolderTestsMixin.test_reprN) r' r( r) rO �ZeroDivisionError�exceptionForTestsr? r< rC rD rE rI r r r r r> - s r> c @ r{ )� FailureHoldingErrorHolderTestsz� Tests for L{runner.ErrorHolder} behaving similarly to L{runner.TestHolder} when constructed with a L{Failure} representing its error. c C sJ d| _ z| j� ty t�� | _Y nw t�| j | j�| _| � � | _ d S r5 ) r� rK rJ r r( rF r � ErrorHolderr7 r? ry r r r r ru � s �z$FailureHoldingErrorHolderTests.setUpNr r r r r rL { � rL c @ r{ )� ExcInfoHoldingErrorHolderTestsz� Tests for L{runner.ErrorHolder} behaving similarly to L{runner.TestHolder} when constructed with a C{exc_info}-style tuple representing its error. c C sP d| _ z| j� ty t�� }t�� | _Y nw t� | j |�| _ | � � | _ d S r5 ) r� rK rJ �sys�exc_infor r( rF r rM r7 r? ry )r � exceptionInfor r r ru � s �z$ExcInfoHoldingErrorHolderTests.setUpNr r r r r rO � rN rO c @ sB e Zd ZdZG dd� dej�Zdd� Zdd� Zdd � Z d d � Z d S ) �MalformedMethodTestszR Test that trial manages when test methods don't have correct signatures. c @ s* e Zd ZdZdd� Zdd� Ze�e�ZdS )z%MalformedMethodTests.ContainMalformedzV This TestCase holds malformed test methods that trial should handle. c C r� r r )r �blahr r r r� � r� z.MalformedMethodTests.ContainMalformed.test_fooc C r� r r r r r r �test_bar� r� z.MalformedMethodTests.ContainMalformed.test_barN) r' r( r) rO r� rU r �inlineCallbacks� test_spamr r r r �ContainMalformed� s rX c C s\ t � }tjtj|d�}t�|�}|�|�}| �|j d� | � |� � � | �t |j �d� dS )zL Wrapper for one of the test method of L{ContainMalformed}. rr r" N)r r rt r r rS rX r[ r\ rQ ri rN rZ r� )r r7 r0 � trialRunnerr@ ry r r r �_test� s zMalformedMethodTests._testc C r� )zE Test when the method has extra (useless) arguments. r� N�rZ r r r r � test_extraArg� r� z"MalformedMethodTests.test_extraArgc C r� )zJ Test when the method doesn't have even self as argument. rU Nr[ r r r r � test_noArg� r� z MalformedMethodTests.test_noArgc C r� )z5 Test a decorated method also fails. rW Nr[ r r r r �test_decorated� r� z#MalformedMethodTests.test_decoratedN) r' r( r) rO r� r� rX rZ r\ r] r^ r r r r rS � s rS c @ r) ) �DestructiveTestSuiteTestsz2 Test for L{runner.DestructiveTestSuite}. c sn g � G � fdd�dt j�}|d�}t�� }t�|g�}| �� g � |�|� | �� dg� | �|�� d� dS )zL Thes destructive test suite should run the tests normally. c r� )z6DestructiveTestSuiteTests.test_basic.<locals>.MockTestc � � � d� d S r� r r� ��calledr r r� � rU z?DestructiveTestSuiteTests.test_basic.<locals>.MockTest.test_fooNr� r ra r r r� � r� r� r� Tr N) r� r� r r/ r �DestructiveTestSuiter\ r[ r- �r r� r@ ry r� r ra r � test_basic� s z$DestructiveTestSuiteTests.test_basicc st g � G � fdd�dt j�}t�� }t�� }tj|_|�|�}| � � g � |� |� | � � dg� | � |� � d� dS )zu Test the C{shouldStop} management: raising a C{KeyboardInterrupt} must interrupt the suite. c s, e Zd Z� fdd�Zdd� Z� fdd�ZdS )z;DestructiveTestSuiteTests.test_shouldStop.<locals>.MockTestc r` )Nr" r r� ra r r � test_foo1� rU zEDestructiveTestSuiteTests.test_shouldStop.<locals>.MockTest.test_foo1c S s t � �r )�KeyboardInterruptr� r r r � test_foo2� s zEDestructiveTestSuiteTests.test_shouldStop.<locals>.MockTest.test_foo2c r` )Nrg r r� ra r r � test_foo3� rU zEDestructiveTestSuiteTests.test_shouldStop.<locals>.MockTest.test_foo3N)r' r( r) rf rh ri r ra r r r� � s r� r" N) r r� r r/ r r� rc � suiteFactory� loadClassr\ r[ r- )r r� ry r� r� r ra r �test_shouldStop� s z)DestructiveTestSuiteTests.test_shouldStopc C s\ G dd� dt j�}|d�}t�� }t�|g�}| �|�� d� |�|� | �|�� d� dS )zn Checks that the test suite cleanups its tests during the run, so that it ends empty. c @ r� )z8DestructiveTestSuiteTests.test_cleanup.<locals>.MockTestc S r� r r r� r r r r� r� zADestructiveTestSuiteTests.test_cleanup.<locals>.MockTest.test_fooNr� r r r r r� r� r� r� r" r N) r� r� r r/ r rc r\ r- r[ rd r r r � test_cleanup s z&DestructiveTestSuiteTests.test_cleanupN)r' r( r) rO re rl rm r r r r r_ � s r_ c @ s& e Zd ZG dd� dej�Zdd� ZdS )�RunnerDeprecationTestsc @ s< e Zd ZdZdZdZdZdd� Zdd� Zdd� Z d d � Z dS ) z#RunnerDeprecationTests.FakeReporterz� Fake reporter that does *not* implement done() but *does* implement printErrors, separator, printSummary, stream, write and writeln without deprecations. Nc G r� r r r� r r r � printErrors r� z/RunnerDeprecationTests.FakeReporter.printErrorsc G r� r r r� r r r � printSummary" r� z0RunnerDeprecationTests.FakeReporter.printSummaryc G r� r r r� r r r �write% r� z)RunnerDeprecationTests.FakeReporter.writec G r� r r r� r r r �writeln( r� z+RunnerDeprecationTests.FakeReporter.writeln) r' r( r) rO rC rP r0 ro rp rq rr r r r r � FakeReporter s rs c s� t �d��| �� � � fdd��_�fdd�}|� | �| jg�}| �|d d t� | �|d d d t� � j � � | � t � |d d �� | �t|�d � dS ) zk The runner emits a warning if it is using a result that doesn't implement 'done'. Nc s � S r r r )ry r r �<lambda>2 rD zBRunnerDeprecationTests.test_reporterDeprecations.<locals>.<lambda>c s � � t�d�� d S )Nr0 )r[ r� r� r )rY r r �f4 s z;RunnerDeprecationTests.test_reporterDeprecations.<locals>.fr �category�messagezR%s should implement done() but doesn't. Falling back to printErrors() and friends.�filenamer" )r rt rs rv � flushWarnings�test_reporterDeprecationsr\ �DeprecationWarningr r� r� rm �__file__� startswithrZ )r ru �warningsr )ry rY r rz + s ��z0RunnerDeprecationTests.test_reporterDeprecationsN)r' r( r) r r rs rz r r r r rn s rn c @ r{ )�QualifiedNameWalkerTestsz< Tests for L{twisted.trial.runner._qualNameWalker}. c C s6 t t�d��}| �|dg fddgfdddgfg� dS )z� C{_qualNameWalker} is a generator that, when given a Python qualified name, yields that name, and then the parent of that name, and so forth, along with a list of the tried components, in a 2-tuple. zwalker.texas.rangerz walker.texas�ranger�walker�texasN)r� r �_qualNameWalkerr\ )r � walkerResultsr r r �test_walksDownPathK s ��z+QualifiedNameWalkerTests.test_walksDownPathN)r' r( r) rO r� r r r r r F r� r c @ r{ )�TrialMainDoesNothingTestszl Importing L{twisted.trial.__main__} will not run the script unless it is actually C{__main__}. c C s t d� dS )zO If we import L{twisted.trial.__main__}, it should do nothing. ztwisted.trial.__main__N)� __import__r r r r �test_importDoesNothingc r$ z0TrialMainDoesNothingTests.test_importDoesNothingN)r' r( r) rO r� r r r r r� ] rN r� )@r� r� rP r r� �ior �typingr �zope.interfacer �zope.interface.verifyr �twistedr �twisted.internetr �twisted.pluginsr �twisted.pythonr r r �twisted.python.filepathr �twisted.python.reflectr �twisted.scriptsr � twisted.trialr r r �twisted.trial._asyncrunnerr �twisted.trial.itrialr r r r* rR r� rq r| r� r� r� r� r� r r r" r� r% r* r4 r> rL rO rS r_ rn r r� r r r r �<module> s^ Q< �, KL $N1D3PK b�Zz�� / / + test/__pycache__/moduletest.cpython-310.pycnu �[��� o �b. � @ s G d d� d�Z dS )c @ s e Zd ZdS )�FooN)�__name__� __module__� __qualname__� r r �?/usr/lib/python3/dist-packages/twisted/trial/test/moduletest.pyr s r N)r r r r r �<module> s PK b�Z�:Ѩ5 5 + test/__pycache__/ordertests.cpython-310.pycnu �[��� o �b` � @ sJ d Z ddlmZ G dd� dej�ZG dd� dej�ZG dd� dej�Zd S ) z/ Tests for handling of trial's --order option. � )�unittestc @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �FooTestzK Used to make assertions about the order its tests will be run in. c C � d S �N� ��selfr r �?/usr/lib/python3/dist-packages/twisted/trial/test/ordertests.py� test_first � zFooTest.test_firstc C r r r r r r r � test_second r zFooTest.test_secondc C r r r r r r r � test_third r zFooTest.test_thirdc C r r r r r r r � test_fourth r zFooTest.test_fourthN)�__name__� __module__� __qualname__�__doc__r r r r r r r r r s r c @ � e Zd ZdZdd� ZdS )�BazTest�_ Used to make assertions about the order the test cases in this module are run in. c C r r r r r r r �test_baz$ r zBazTest.test_bazN)r r r r r r r r r r � r c @ r )�BarTestr c C r r r r r r r �test_bar. r zBarTest.test_barN)r r r r r r r r r r ( r r N)r � twisted.trialr �TestCaser r r r r r r �<module> s PK b�Z��-}�% �% ) test/__pycache__/skipping.cpython-310.pycnu �[��� o �bM � @ s d Z ddlmZmZmZmZ G dd� d�ZG dd� dee�ZG dd� dee�ZG d d � d �Z G d d � d e e�Z G d d� de e�Z G dd� d�Z G dd� de e�Z G dd� de e�ZG dd� d�ZG dd� dee�ZG dd� dee�ZG dd � d �ZG d d � d ee�ZG d d � d ee�ZG d!d"� d"�ZG d#d$� d$ee�ZG d%d&� d&ee�ZG d'd(� d(�ZG d)d*� d*ee�ZG d+d,� d,ee�ZG d-d.� d.�ZG d/d0� d0ee�Z G d1d2� d2ee�Z G d3d4� d4�Z G d5d6� d6e e�Z G d7d8� d8e e�Z G d9d:� d:�Z!G d;d<� d<e!e�Z"G d=d>� d>e!e�Z#d?S )@a$ Definitions of test cases with various interesting behaviors, to be used by L{twisted.trial.test.test_tests} and other test modules to exercise different features of trial's test runner. See the L{twisted.trial.test.test_tests} module docstring for details about how this code is arranged. � )�FailTest�SkipTest�SynchronousTestCase�TestCasec @ s0 e Zd Zdd� Zdd� Zde_dd� Zde_d S ) � SkippingMixinc C � t d���N�skip1�r ��self� r �=/usr/lib/python3/dist-packages/twisted/trial/test/skipping.py� test_skip1 � zSkippingMixin.test_skip1c C r )NzI should not get raised�� RuntimeErrorr r r r � test_skip2 r zSkippingMixin.test_skip2�skip2c C � | � d� d S )NzI should not fail��failr r r r � test_skip3 � zSkippingMixin.test_skip3�skip3N)�__name__� __module__� __qualname__r r �skipr r r r r r s r c @ � e Zd ZdS )�SynchronousSkippingN�r r r r r r r r ! � r c @ r )�AsynchronousSkippingNr! r r r r r# % r" r# c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�SkippingSetUpMixinc C r )N� skipSetUpr r r r r �setUp* r zSkippingSetUpMixin.setUpc C � d S �Nr r r r r �test_1- � zSkippingSetUpMixin.test_1c C r' r( r r r r r �test_20 r* zSkippingSetUpMixin.test_2N)r r r r& r) r+ r r r r r$ ) s r$ c @ r )�SynchronousSkippingSetUpNr! r r r r r, 4 r" r, c @ r )�AsynchronousSkippingSetUpNr! r r r r r- 8 r" r- c @ s e Zd Zdd� ZdS )� DeprecatedReasonlessSkipMixinc C s t � �r( r r r r r r) = s z$DeprecatedReasonlessSkipMixin.test_1N)r r r r) r r r r r. < s r. c @ r )�#SynchronousDeprecatedReasonlessSkipNr! r r r r r/ A s r/ c @ r )�$AsynchronousDeprecatedReasonlessSkipNr! r r r r r0 G r" r0 c @ s> e Zd ZdZdd� Zdd� Zdd� Zde_d d � Zd d � Zd S )�SkippedClassMixin�classc C s d| j _d S )NT)� __class__� _setUpRanr r r r r& N � zSkippedClassMixin.setUpc C r r r r r r r r Q r z SkippedClassMixin.test_skip1c C r )NzOught to skip mer r r r r r T r z SkippedClassMixin.test_skip2r c C r' r( r r r r r r Y r* z SkippedClassMixin.test_skip3c C r )Nz Skip me toor r r r r � test_skip4\ r z SkippedClassMixin.test_skip4N) r r r r r& r r r r6 r r r r r1 K s r1 c @ r )�SynchronousSkippedClassNr! r r r r r7 ` r" r7 c @ r )�AsynchronousSkippedClassNr! r r r r r8 d r" r8 c @ s6 e Zd Zdd� Zde_dd� Zde_dd� Zd e_d S ) � TodoMixinc C r �Nzdeliberate failurer r r r r � test_todo1i r zTodoMixin.test_todo1�todo1c C r �Nzdeliberate errorr r r r r � test_todo2n r zTodoMixin.test_todo2�todo2c C s dS )zunexpected successNr r r r r � test_todo3s s zTodoMixin.test_todo3�todo3N)r r r r; �todor> r@ r r r r r9 h s r9 c @ r )�SynchronousTodoNr! r r r r rC y r" rC c @ r )�AsynchronousTodoNr! r r r r rD } r" rD c @ �" e Zd Zdd� Zdd� Zde_dS )�SetUpTodoMixinc C r r= r r r r r r& � r zSetUpTodoMixin.setUpc C r' r( r r r r r r; � r* zSetUpTodoMixin.test_todo1z setUp todo1N)r r r r& r; rB r r r r rF � � rF c @ r )�SynchronousSetUpTodoNr! r r r r rH � r" rH c @ r )�AsynchronousSetUpTodoNr! r r r r rI � r" rI c @ rE )�TearDownTodoMixinc C r r= r r r r r �tearDown� r zTearDownTodoMixin.tearDownc C r' r( r r r r r r; � r* z TearDownTodoMixin.test_todo1ztearDown todo1N)r r r rK r; rB r r r r rJ � rG rJ c @ r )�SynchronousTearDownTodoNr! r r r r rL � r" rL c @ r )�AsynchronousTearDownTodoNr! r r r r rM � r" rM c @ s< e Zd ZdZdd� Zde_dd� Zdd� Zde_d d � Zd S ) �TodoClassMixinr2 c C r' r( r r r r r r; � r* zTodoClassMixin.test_todo1�methodc C r' r( r r r r r r> � r* zTodoClassMixin.test_todo2c C r �NzDeliberate Failurer r r r r r@ � r zTodoClassMixin.test_todo3c C r rP r r r r r � test_todo4� r zTodoClassMixin.test_todo4N)r r r rB r; r> r@ rQ r r r r rN � s rN c @ r )�SynchronousTodoClassNr! r r r r rR � r" rR c @ r )�AsynchronousTodoClassNr! r r r r rS � r" rS c @ s� e Zd Zdd� Zedfe_dd� Zeefdfe_dd� Zed fe_d d � Z ee fd fe _d d� Z e dfe _dd� Z edfe _dd� Zedfe_dS )�StrictTodoMixinc C r �Nzexpected failurer r r r r r; � r zStrictTodoMixin.test_todo1r< c C r rU r r r r r r> � r zStrictTodoMixin.test_todo2r? c C r �Nzwe had no idea!r r r r r r@ � r zStrictTodoMixin.test_todo3rA c C r rV r r r r r rQ � r zStrictTodoMixin.test_todo4�todo4c C r r: r r r r r � test_todo5� r zStrictTodoMixin.test_todo5�todo5c C r r: r r r r r � test_todo6� r zStrictTodoMixin.test_todo6�todo6c C r' r( r r r r r � test_todo7� r* zStrictTodoMixin.test_todo7�todo7N)r r r r; r rB r> �OSErrorr@ rQ � SyntaxErrorrX r rZ r\ r r r r rT � s rT c @ r )�SynchronousStrictTodoNr! r r r r r` � r" r` c @ r )�AsynchronousStrictTodoNr! r r r r ra � r" ra c @ s< e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd S )�AddCleanupMixinc C s dg| _ d S )Nr& )�logr r r r r& � r5 zAddCleanupMixin.setUpc C � dg| _ td��)Nr& zDeliberate failure)rc r r r r r � brokenSetUp� � zAddCleanupMixin.brokenSetUpc C rd )Nr& z Don't do this)rc r r r r r � skippingSetUp� rf z AddCleanupMixin.skippingSetUpc C s | j �|� d S r( �rc �append)r �thingr r r ri � � zAddCleanupMixin.appendc C � | j �d� d S )NrK rh r r r r rK � rk zAddCleanupMixin.tearDownc C rl )N�runTestrh r r r r rm rk zAddCleanupMixin.runTestN) r r r r& re rg ri rK rm r r r r rb � s rb c @ r )�SynchronousAddCleanupNr! r r r r rn r" rn c @ r )�AsynchronousAddCleanupNr! r r r r ro r" ro N)$�__doc__�twisted.trial.unittestr r r r r r r# r$ r, r- r. r/ r0 r1 r7 r8 r9 rC rD rF rH rI rJ rL rM rN rR rS rT r` ra rb rn ro r r r r �<module> sD � %PK b�Z�5�� � + test/__pycache__/moduleself.cpython-310.pycnu �[��� o �b� � @ s" d dl mZ G dd� dej�ZdS )� )�unittestc @ s e Zd Zdd� ZdS )�Fooc C s d S )N� )�selfr r �?/usr/lib/python3/dist-packages/twisted/trial/test/moduleself.py�testFoo s z Foo.testFooN)�__name__� __module__� __qualname__r r r r r r s r N)� twisted.trialr �SynchronousTestCaser r r r r �<module> s PK b�Z&!4"� "� 0 test/__pycache__/test_assertions.cpython-310.pycnu �[��� o �b�� � @ s� d Z ddlZddlZddlmZmZ ddlmZm Z m Z ddl m Z m Z ddlmZ ddlmZmZmZ ddlmZ dd lmZ G d d � d e�ZG d d � d �ZG dd� dej�ZG dd� dej�Z G dd� dej�Z G dd� dej�Z G dd� dej�Z G dd� dej�Z G dd� dej�Z!G d d � d ej�Z"G d d � d ej�Z#e e#j$�d d!� �Z%e e#j$d"d#�d$d%� �Z&G d&d'� d'ej�Z'd(d)� Z(e(Z)e e'j$d*e*d)� d+d,� Z+dS )-a� Tests for assertions provided by C{SynchronousTestCase} and C{TestCase}, provided by L{twisted.trial.unittest}. L{TestFailureTests} demonstrates that L{SynchronousTestCase.fail} works, so that is the only method on C{twisted.trial.unittest.SynchronousTestCase} that is initially assumed to work. The test classes are arranged so that the methods demonstrated to work earlier in the file are used by those later in the file (even though the runner will probably not run the tests in this order). � N)�Version�getVersionString)�Deferred�fail�succeed)� deprecated�deprecatedModuleAttribute)�Failure)�accumulateMethods�fullyQualifiedName�prefixedMethods)� FancyEqMixin)�unittestc @ s& e Zd ZdZdd� Zdefdd�ZdS )� MockEquality��namec C s || _ d S �Nr )�selfr � r �D/usr/lib/python3/dist-packages/twisted/trial/test/test_assertions.py�__init__$ s zMockEquality.__init__�returnc C s d| j � d�S )Nz MockEquality(�)r �r r r r �__repr__' � zMockEquality.__repr__N)�__name__� __module__� __qualname__�compareAttributesr �strr r r r r r ! s r c @ s e Zd ZdZdd� ZeZeZdS )�ComparisonErrorzH An object which raises exceptions from its comparison methods. c C s t d��)NzComparison is broken)� ValueError)r �otherr r r �_error0 � zComparisonError._errorN)r r r �__doc__r$ �__eq__�__ne__r r r r r! + s r! c @ s: e Zd ZdZG dd� dej�Zdd� Zdd� Zdd � Z d S ) �TestFailureTestsa� Tests for the most basic functionality of L{SynchronousTestCase}, for failing tests. This class contains tests to demonstrate that L{SynchronousTestCase.fail} can be used to fail a test, and that that failure is reflected in the test result object. This should be sufficient functionality so that further tests can be built on L{SynchronousTestCase} instead of L{unittest.TestCase}. This depends on L{unittest.TestCase} working. c @ � e Zd Zdd� ZdS )z TestFailureTests.FailingTestc C s | � d� d S )NzThis test fails.�r r r r r � test_failsD r z'TestFailureTests.FailingTest.test_failsN)r r r r, r r r r � FailingTestC � r- c C sD t | jj | jj g}t�� | _| j�d�|��| _t | j�d | _ dS )zo Load a suite of one test which can be used to exercise the failure handling behavior. �.r N) r � __class__r- �pyunit� TestLoader�loader�loadTestsFromName�join�suite�list�test)r � componentsr r r �setUpG s zTestFailureTests.setUpc C sZ z| j �d� W n | j jy% } z| �dt|�� W Y d}~dS d}~ww | �d� dS )z} L{SynchronousTestCase.fail} raises L{SynchronousTestCase.failureException} with the given argument. �failedNzRSynchronousTestCase.fail method did not raise SynchronousTestCase.failureException)r8 r �failureException� assertEqualr �r �resultr r r � test_failQ s ���zTestFailureTests.test_failc C s^ t �� }| j�|� | �|�� � | �|jg � | �t|j �d� | �|j d d | j � dS )z� When a test method raises L{SynchronousTestCase.failureException}, the test is marked as having failed on the L{TestResult}. � r N) r1 � TestResultr6 �run� assertFalse� wasSuccessfulr= �errors�len�failuresr8 r> r r r �test_failingExceptionFails` s z+TestFailureTests.test_failingExceptionFailsN) r r r r& r �SynchronousTestCaser- r: r@ rI r r r r r) 7 s r) c @ �@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�AssertFalseTestsa Tests for L{SynchronousTestCase}'s C{assertFalse} and C{failIf} assertion methods. This is pretty paranoid. Still, a certain paranoia is healthy if you are testing a unit testing framework. @note: As of 11.2, C{assertFalse} is preferred over C{failIf}. c C sB dddddg fD ]}||d|���}||kr | � d|��� qdS )z� Perform the positive case test for C{failIf} or C{assertFalse}. @param method: The test method to test. r � FNr � failed on �Did not return argument r+ )r �method�notTruer? r r r �_assertFalseFalsex s ��z"AssertFalseTests._assertFalseFalsec C s� dddddgdfD ]<}z ||d|��� W n% | j y: } z| �d|��t|�d|�d|��� W Y d }~q d }~ww | �d |j|f � q d S ) z� Perform the negative case test for C{failIf} or C{assertFalse}. @param method: The test method to test. rA T�cat� �� � rN � Raised incorrect exception on �: N�Call to %s(%r) didn't fail�r< �assertInr r r )r rP �true�er r r �_assertFalseTrue� s& �������z!AssertFalseTests._assertFalseTruec C � | � | j� dS )zt L{SynchronousTestCase.failIf} returns its argument if its argument is not considered true. N)rR �failIfr r r r �test_failIfFalse� � z!AssertFalseTests.test_failIfFalsec C r` )zy L{SynchronousTestCase.assertFalse} returns its argument if its argument is not considered true. N)rR rD r r r r �test_assertFalseFalse� rc z&AssertFalseTests.test_assertFalseFalsec C r` )z� L{SynchronousTestCase.failIf} raises L{SynchronousTestCase.failureException} if its argument is considered true. N)r_ ra r r r r �test_failIfTrue� � z AssertFalseTests.test_failIfTruec C r` )z� L{SynchronousTestCase.assertFalse} raises L{SynchronousTestCase.failureException} if its argument is considered true. N)r_ rD r r r r �test_assertFalseTrue� rf z%AssertFalseTests.test_assertFalseTrueN) r r r r& rR r_ rb rd re rg r r r r rL m s rL c @ rK )�AssertTrueTestsa Tests for L{SynchronousTestCase}'s C{assertTrue} and C{failUnless} assertion methods. This is pretty paranoid. Still, a certain paranoia is healthy if you are testing a unit testing framework. @note: As of 11.2, C{assertTrue} is preferred over C{failUnless}. c C s� dddddg fD ]<}z ||d|��� W n% | j y9 } z| �d|��t|�d|�d|��� W Y d}~qd}~ww | �d |j|f � qdS ) z� Perform the negative case test for C{assertTrue} and C{failUnless}. @param method: The test method to test. r rM FNr rN rX rY rZ r[ )r rP rQ r^ r r r �_assertTrueFalse� s& �������z AssertTrueTests._assertTrueFalsec C sD dddddgdfD ]}||d|���}||kr | � d|��� q dS ) z� Perform the positive case test for C{assertTrue} and C{failUnless}. @param method: The test method to test. rA TrS rT rU rN rO Nr+ )r rP r] r? r r r �_assertTrueTrue� s ��z AssertTrueTests._assertTrueTruec C r` )z� L{SynchronousTestCase.assertTrue} raises L{SynchronousTestCase.failureException} if its argument is not considered true. N)ri � assertTruer r r r �test_assertTrueFalse� rf z$AssertTrueTests.test_assertTrueFalsec C r` )z� L{SynchronousTestCase.failUnless} raises L{SynchronousTestCase.failureException} if its argument is not considered true. N)ri � failUnlessr r r r �test_failUnlessFalse� rf z$AssertTrueTests.test_failUnlessFalsec C r` )zt L{SynchronousTestCase.assertTrue} returns its argument if its argument is considered true. N)rj rk r r r r �test_assertTrueTrue� rc z#AssertTrueTests.test_assertTrueTruec C r` )zt L{SynchronousTestCase.failUnless} returns its argument if its argument is considered true. N)rj rm r r r r �test_failUnlessTrue� rc z#AssertTrueTests.test_failUnlessTrueN) r r r r& ri rj rl rn ro rp r r r r rh � s rh c @ sl 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$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z!d>d?� Z"d@dA� Z#dBdC� Z$dDdE� Z%dFdG� Z&dHdI� Z'dJdK� Z(dLdM� Z)dNdO� Z*dPdQ� Z+e,e-j.dRdS�dSu r�dTe+_/dSS dSS )U�SynchronousAssertionsTestsa� Tests for L{SynchronousTestCase}'s assertion methods. That is, failUnless*, failIf*, assert* (not covered by other more specific test classes). Note: As of 11.2, assertEqual is preferred over the failUnlessEqual(s) variants. Tests have been modified to reflect this preference. This is pretty paranoid. Still, a certain paranoia is healthy if you are testing a unit testing framework. c C s& | � ||�}||kr| �d� d S d S )Nz)assertEqual should return first parameter)r= r )r �first�second�xr r r �_testEqualPair s �z)SynchronousAssertionsTests._testEqualPairc C s� d}z| � ||� W nM | jyW } z@t�d�}z|� ||� W n, |jyL } z d}t|�}t|�}||krB| �d|�d|��� W Y d}~nd}~ww W Y d}~nd}~ww |sh| �d|�d|�d �� dS dS ) z� Assert that when called with unequal arguments, C{assertEqual} raises a failure exception with the same message as the standard library C{assertEqual} would have raised. Fr: Tz Expected: z; Got: NzCall to assertEqual(z, z ) didn't fail)r= r< r1 �TestCaser r ) r rr rs �raised� ourFailure�case� theirFailure�got�expectedr r r �_testUnequalPair s( ���� �z+SynchronousAssertionsTests._testUnequalPairc C s: | � dd� | �dd� | � dgdg� | �dgd� d S )NrS �dogrA �orange)ru r} r r r r �test_assertEqual_basic/ s z1SynchronousAssertionsTests.test_assertEqual_basicc C sL t d�}t d�}t d�}| �||� | �||� | �||� | �||� d S )Nrr rs )r ru r} )r rt �y�zr r r �test_assertEqual_custom5 s z2SynchronousAssertionsTests.test_assertEqual_customc C s. d}| � | j| jdd|�}| �|t|�� dS )zi When a message is passed to L{assertEqual} it is included in the error message. �message�foo�barN)� assertRaisesr< r= r\ r )r r� � exceptionr r r �test_assertEqualMessage> s �z2SynchronousAssertionsTests.test_assertEqualMessagec C sB | � | j| jddd�}| � | j| jdd�}| �t|�t|�� dS )zz If a message is specified as L{None}, it is not included in the error message of L{assertEqual}. r� r� N)r� r< r= r )r �exceptionForNone�exceptionWithoutr r r �test_assertEqualNoneMessageI s � �z6SynchronousAssertionsTests.test_assertEqualNoneMessagec C sf t � }dg}z| �||� W n | jy | �d� Y d S ty' Y d S w | �d�||�� d S )Nr z6Fail raised when ValueError ought to have been raised.z7Comparing {!r} and {!r} should have raised an exception)r! r= r< r r" �format)r �appler r r r � test_assertEqual_incomparableV s ���z8SynchronousAssertionsTests.test_assertEqual_incomparablec C s |�r r )r �errorr r r � _raiseErrorg � z&SynchronousAssertionsTests._raiseErrorc C s& | � t| jt�}| �t|t�d� d S )Nz?Expect failUnlessRaises to return instance of raised exception.)�failUnlessRaisesr" r� rk � isinstance�r rt r r r � test_failUnlessRaises_expectedj s �z9SynchronousAssertionsTests.test_failUnlessRaises_expectedc C sV z | � t| jt� W n ty | �d� Y d S | jy# Y d S w | �d� d S )Nz9failUnlessRaises shouldn't re-raise unexpected exceptionsz4Expected exception wasn't raised. Should have failed)r� r" r� � TypeErrorr r< r r r r � test_failUnlessRaises_unexpectedq s �z;SynchronousAssertionsTests.test_failUnlessRaises_unexpectedc sd d� z | � t� fdd�� W n | jy* } z| �t|�d� W Y d }~d S d }~ww | �d� d S )NrV c s � S r r r �� returnValuer r �<lambda> � zNSynchronousAssertionsTests.test_failUnlessRaises_noException.<locals>.<lambda>z"ValueError not raised (3 returned)z(Exception not raised. Should have failed)r� r" r< r= r r �r r^ r r� r �!test_failUnlessRaises_noException| s ��z<SynchronousAssertionsTests.test_failUnlessRaises_noExceptionc C sn | � | j| j| j�}| �t|| j�d| j�d�� z | � | j| jt�}W n | jy/ Y d S w | �d� d S )Nz Expected z instance to be returnedz Should have raised exception)r� r< r� rk r� r" r r� r r r �&test_failUnlessRaises_failureException� s � � ��zASynchronousAssertionsTests.test_failUnlessRaises_failureExceptionc C s: t d�}| �t ��}|�1 sw Y | �||j� dS )z� If C{assertRaises} is used to create a context manager and an exception is raised from the body of the C{with} statement then the context manager's C{exception} attribute is set to the exception that was raised. �markerN)r" r� �assertIsr� )r r� �contextr r r � test_assertRaisesContextExpected� s �z;SynchronousAssertionsTests.test_assertRaisesContextExpectedc C s� z| � t�� td��1 sw Y W n, | jy@ } z t|�}djtt�d�}| �|�|�d�|�� W Y d}~dS d}~ww | � d� dS )z� If C{assertRaises} is used to create a context manager and the wrong exception type is raised from the body of the C{with} statement then the C{with} statement raises C{failureException} describing the mismatch. r� Nz/{type} raised instead of ValueError: Traceback)�typez=Exception message did not begin with expected information: {}�:Mismatched exception type should have caused test failure.) r� r" r� r< r r� r rk � startswithr )r r� r� r| r r r �"test_assertRaisesContextUnexpected� s" ����� z=SynchronousAssertionsTests.test_assertRaisesContextUnexpectedc C sz z| � t�� W d � n1 sw Y W n | jy5 } zt|�}| �|d� W Y d}~dS d}~ww | �d� dS )z� If C{assertRaises} is used to create a context manager and no exception is raised from the body of the C{with} statement then the C{with} statement raises C{failureException} describing the lack of exception. Nz%ValueError not raised (None returned)z5Non-exception result should have caused test failure.)r� r" r< r r= r )r r� r� r r r �#test_assertRaisesContextNoException� s ����z>SynchronousAssertionsTests.test_assertRaisesContextNoExceptionc C s� z| � ttf�� t� �1 sw Y W nE | jyZ } z8t|�}d|v}d|v}g }|r3|�d� |r:|�d� |rO| �d�|�d|� �� W Y d}~dS W Y d}~dS d}~ww | �d� dS ) z� If the exception type passed to C{assertRaises} does not have a C{__name__} then the context manager still manages to construct a descriptive string for it. Nr" r� z(expected ValueError in exception messagez'expected TypeError in exception messagez; z message = r� ) r� r" r� �AttributeErrorr< r �appendr r5 )r r� r� � valueError� typeErrorrF r r r �test_brokenName� s& � &��� z*SynchronousAssertionsTests.test_brokenNamec C s\ dgdgdg}}}| � ||�}| �||d� | �| j| j ||� | �| j| j ||� d S )NrA rT �)failIfEqual should return first parameter)� failIfEqualr= r� r< �r rt r� r� �retr r r �test_failIfEqual_basic� � z1SynchronousAssertionsTests.test_failIfEqual_basicc C sX t d�}t d�}t d�}| �||�}| �||d� | �| j| j||� | �||d� d S )Nrr rs �fecundr� z"__ne__ should make these not equal)r r� r= r� r< r� r r r �test_failIfEqual_customEq� s z4SynchronousAssertionsTests.test_failIfEqual_customEqc C s( t � }t � }| �||�}| �||� dS )z� C{failIfIdentical} returns its first argument if its first and second arguments are not the same object. N)�object�failIfIdenticalr= )r rt r� r? r r r � test_failIfIdenticalPositive� s z7SynchronousAssertionsTests.test_failIfIdenticalPositivec C s t � }| �| j| j||� dS )z~ C{failIfIdentical} raises C{failureException} if its first and second arguments are the same object. N)r� r� r< r� r� r r r � test_failIfIdenticalNegative s z7SynchronousAssertionsTests.test_failIfIdenticalNegativec C s\ dgdgdg}}}| � ||�}| �||d� | �| j| j ||� | �| j| j ||� d S )NrA rT z1failUnlessIdentical should return first parameter)�failUnlessIdenticalr= r� r< r� r r r �test_failUnlessIdentical r� z3SynchronousAssertionsTests.test_failUnlessIdenticalc C sd d\}}}| � ||d� | � ||d�}| �||d� | �| j| j ||d� | �| j| j ||d� d S )N)g �?g�������?g333333�?g�������?z4failUnlessApproximates should return first parameterg�������?)�failUnlessApproximatesr= r� r< r� r r r �test_failUnlessApproximates s ���z6SynchronousAssertionsTests.test_failUnlessApproximatesc C s\ d}d}d}d}| � |||� | � |||�}| �||d||f � | �| j| j |||� d S )N� �A�! @�X�O @��C @z<failUnlessAlmostEqual should return first parameter (%r, %r))�failUnlessAlmostEqualr= r� r< �r � precisionrt r� r� r� r r r �test_failUnlessAlmostEqual s ���z5SynchronousAssertionsTests.test_failUnlessAlmostEqualc C sd d}d}d}d}| � |||�}| �||d||f � | �| j| j |||� | �| j| j |||� d S )Nr� r� r� r� z8failIfAlmostEqual should return first parameter (%r, %r))�failIfAlmostEqualr= r� r< r� r r r �test_failIfAlmostEqual. s ���z1SynchronousAssertionsTests.test_failIfAlmostEqualc C s^ d}d}d}| � ||� | � ||�}| �||d� | �| j| j ||� | �| j| j ||� d S �NrS z the dog satz the cat satz should return first parameter)�failUnlessSubstringr= r� r< r� r r r �test_failUnlessSubstring@ � z3SynchronousAssertionsTests.test_failUnlessSubstringc C s^ d}d}d}| � ||� | � ||�}| �||d� | �| j| j ||� | �| j| j ||� d S r� )�failIfSubstringr= r� r< r� r r r �test_failIfSubstringJ r� z/SynchronousAssertionsTests.test_failIfSubstringc C s t d�}| �||� dS )zB L{assertIs} passes if two objects are identical. rr N)r r� �r �ar r r � test_assertIsT s z(SynchronousAssertionsTests.test_assertIsc C s6 t d�t d�}}| �||� | �| j| j||� dS )zE L{assertIs} fails if two objects are not identical. rr N)r r= r� r< r� �r r� �br r r �test_assertIsError[ s z-SynchronousAssertionsTests.test_assertIsErrorc C s. t d�t d�}}| �||� | �||� dS )zI L{assertIsNot} passes if two objects are not identical. rr N)r r= � assertIsNotr� r r r �test_assertIsNotc s z+SynchronousAssertionsTests.test_assertIsNotc C s t d�}| �| j| j||� dS )zD L{assertIsNot} fails if two objects are identical. rr N)r r� r< r� r� r r r �test_assertIsNotErrork s z0SynchronousAssertionsTests.test_assertIsNotErrorc C s$ t dtfi �}|� }| �||� dS )z< Test a true condition of assertIsInstance. �AN�r� r� �assertIsInstance)r r� r� r r r �test_assertIsInstancer s z0SynchronousAssertionsTests.test_assertIsInstancec C s6 t dtfi �}t dtfi �}|� }| �|||f� dS )zR Test a true condition of assertIsInstance with multiple classes. r� �BNr� �r r� r� r� r r r �$test_assertIsInstanceMultipleClassesz s z?SynchronousAssertionsTests.test_assertIsInstanceMultipleClassesc C s: t dtfi �}t dtfi �}|� }| �| j| j||� dS )z6 Test an error with assertIsInstance. r� r� N�r� r� r� r< r� r� r r r �test_assertIsInstanceError� s z5SynchronousAssertionsTests.test_assertIsInstanceErrorc C sL t dtfi �}t dtfi �}t dtfi �}|� }| �| j| j|||f� dS )zK Test an error with assertIsInstance and multiple classes. r� r� �CNr� �r r� r� r� r� r r r �)test_assertIsInstanceErrorMultipleClasses� s zDSynchronousAssertionsTests.test_assertIsInstanceErrorMultipleClassesc C s* | � | j| jdtd�}| �dt|�� dS )z� If L{TestCase.assertIsInstance} is passed a custom message as its 3rd argument, the message is included in the failure exception raised when the assertion fails. rV zSilly assertionN)r� r< r� r r\ )r �excr r r �"test_assertIsInstanceCustomMessage� s �z=SynchronousAssertionsTests.test_assertIsInstanceCustomMessagec C s2 t dtfi �}t dtfi �}|� }| �||� dS )z? Test a true condition of assertNotIsInstance. r� r� N�r� r� �assertNotIsInstancer� r r r �test_assertNotIsInstance� s z3SynchronousAssertionsTests.test_assertNotIsInstancec C sD t dtfi �}t dtfi �}t dtfi �}|� }| �|||f� dS )zT Test a true condition of assertNotIsInstance and multiple classes. r� r� r� Nr� r� r r r �'test_assertNotIsInstanceMultipleClasses� s zBSynchronousAssertionsTests.test_assertNotIsInstanceMultipleClassesc C sF t dtfi �}|� }| �| j| j||�}| �t|�|�d|� �� dS )z9 Test an error with assertNotIsInstance. r� z is an instance of N)r� r� r� r< r� r= r )r r� r� r� r r r � test_assertNotIsInstanceError� s z8SynchronousAssertionsTests.test_assertNotIsInstanceErrorc C s> t dtfi �}t dtfi �}|� }| �| j| j|||f� dS )zN Test an error with assertNotIsInstance and multiple classes. r� r� N)r� r� r� r< r� r� r r r �,test_assertNotIsInstanceErrorMultipleClasses� s zGSynchronousAssertionsTests.test_assertNotIsInstanceErrorMultipleClassesc C s | � ddiddi� dS )z� L{twisted.trial.unittest.TestCase} supports the C{assertDictEqual} method inherited from the standard library in Python 2.7. r� rA N)�assertDictEqualr r r r �test_assertDictEqual� � z/SynchronousAssertionsTests.test_assertDictEqualr� Nz:assertDictEqual is not available on this version of Python)0r r r r& ru r} r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� �getattrr rJ �skipr r r r rq s\ ��rq c @ st e Zd Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d� Z dd� Z dd� Z dd� Z dd� Z dd� Zdd� ZdS ) �WarningAssertionTestsc C �* dd� }| � tdt|d�}| �|d� dS )z0 Test basic assertWarns report. c S � t jdtd� | S �N�Woo deprecated��category��warnings�warn�DeprecationWarning�r� r r r r � � z:WarningAssertionTests.test_assertWarns.<locals>.deprecatedr� �{ N�� assertWarnsr� �__file__r= �r r �rr r r �test_assertWarns� � �z&WarningAssertionTests.test_assertWarnsc C sH dd� }| � tdt|d�}| �|d� | � tdt|d�}| �|d� dS )z} Test that assertWarns cleans the warning registry, so the warning is not swallowed the second time. c S r� r� r� r� r r r r � r� zGWarningAssertionTests.test_assertWarnsRegistryClean.<locals>.deprecatedr� r� �A Nr� )r r �r1�r2r r r � test_assertWarnsRegistryClean� s � �z3WarningAssertionTests.test_assertWarnsRegistryCleanc C �& dd� }| � | j| jtdt|d� dS )zH Test assertWarns failure when no warning is generated. c S � | S r r r� r r r �normal� r� z;WarningAssertionTests.test_assertWarnsError.<locals>.normalr� r� N�r� r< r� r� r )r r r r r �test_assertWarnsError� s �z+WarningAssertionTests.test_assertWarnsErrorc C r )zF Test assertWarns failure when the category is wrong. c S r� �N�Foo deprecatedr� r� r� r r r r r� zGWarningAssertionTests.test_assertWarnsWrongCategory.<locals>.deprecatedr r� N)r� r< r� � UserWarningr �r r r r r � test_assertWarnsWrongCategory � �z3WarningAssertionTests.test_assertWarnsWrongCategoryc C r )zE Test assertWarns failure when the message is wrong. c S r� r r� r� r r r r r� zFWarningAssertionTests.test_assertWarnsWrongMessage.<locals>.deprecated�Bar deprecatedr� Nr r r r r � test_assertWarnsWrongMessage r z2WarningAssertionTests.test_assertWarnsWrongMessagec C r )z� If the warning emitted by a function refers to a different file than is passed to C{assertWarns}, C{failureException} is raised. c S s t jdtdd� d S )Nr rT )r� � stacklevelr� r� r r r r 4 s zCWarningAssertionTests.test_assertWarnsWrongFile.<locals>.deprecatedr r� Nr r r r r �test_assertWarnsWrongFile. s �z/WarningAssertionTests.test_assertWarnsWrongFilec C sR G dd� d�}| � tdt|�}| �t||�� | � tdt|�}| �t||�� dS )zH Test assertWarns works when creating a class instance. c @ r* )z;WarningAssertionTests.test_assertWarnsOnClass.<locals>.Warnc S � t jdtd� d S )N�Do not call mer� )r� r� �RuntimeWarningr r r r r S � zDWarningAssertionTests.test_assertWarnsOnClass.<locals>.Warn.__init__N)r r r r r r r r �WarnR r. r r N)r� r r rk r� )r r r r r r �test_assertWarnsOnClassM s z-WarningAssertionTests.test_assertWarnsOnClassc C sX G dd� d�}|� }| � tdt|jd�}| �|d� | � tdt|jd�}| �|d� dS )zI Test assertWarns works when used on an instance method. c @ r* )z<WarningAssertionTests.test_assertWarnsOnMethod.<locals>.Warnc S � t jdtd� |S )Nr r� r� r� r r r r a r� zGWarningAssertionTests.test_assertWarnsOnMethod.<locals>.Warn.deprecatedN)r r r r r r r r r ` r. r r r N)r� r� r r r= �r r �wr r r r �test_assertWarnsOnMethod[ s � �z.WarningAssertionTests.test_assertWarnsOnMethodc C sT G dd� d�}|� }| � tdt|d�}| �|d� | � tdt|d�}| �|d� dS )zM Test assertWarns works on instance with C{__call__} method. c @ r* )z:WarningAssertionTests.test_assertWarnsOnCall.<locals>.Warnc S r )N�Egg deprecatedr� r� r� r r r �__call__u r� zCWarningAssertionTests.test_assertWarnsOnCall.<locals>.Warn.__call__N)r r r r# r r r r r t r. r r" r Nr� r r r r �test_assertWarnsOnCallo s z,WarningAssertionTests.test_assertWarnsOnCallc C r� )zD Test assertWarns on a warning filtered by default. c S r� r� �r� r� �PendingDeprecationWarningr� r r r r � r� z@WarningAssertionTests.test_assertWarnsFilter.<locals>.deprecatedr� r� N)r� r& r r= r r r r �test_assertWarnsFilter r z,WarningAssertionTests.test_assertWarnsFilterc s( dd� � � fdd�}| � tdt|� dS )z� C{assertWarns} does not raise an exception if the function it is passed triggers the same warning more than once. c S r r� r% r r r r r � r zJWarningAssertionTests.test_assertWarnsMultipleWarnings.<locals>.deprecatedc s � � � � d S r r r �r r r �f� s zAWarningAssertionTests.test_assertWarnsMultipleWarnings.<locals>.fr� N)r� r& r )r r) r r( r � test_assertWarnsMultipleWarnings� s z6WarningAssertionTests.test_assertWarnsMultipleWarningsc C s6 dd� }| � | j| jtdt|d�}| �t|�d� dS )z� For now, assertWarns is unable to handle multiple different warnings, so it should raise an exception if it's the case. c S s t jdtd� t jdtd� d S )Nr� r� z Another one)r� r� r� r& r� r r r r � s zKWarningAssertionTests.test_assertWarnsDifferentWarnings.<locals>.deprecatedr� r� z Can't handle different warningsN)r� r< r� r� r r= r )r r r^ r r r �!test_assertWarnsDifferentWarnings� s � z7WarningAssertionTests.test_assertWarnsDifferentWarningsc sX G dd� dt �� � fdd�}|d� | �� dt|d� | �|g�\}| �|d d� dS ) z� Warnings emitted before L{TestCase.assertWarns} is called do not get flushed and do not alter the behavior of L{TestCase.assertWarns}. c @ s e Zd ZdS )zPWarningAssertionTests.test_assertWarnsAfterUnassertedWarning.<locals>.TheWarningN)r r r r r r r � TheWarning� s r, c s t j| � d� d S )Nr� )r� r� �r� �r, r r r) � r zGWarningAssertionTests.test_assertWarnsAfterUnassertedWarning.<locals>.fr� r� r� N)�Warningr� r � flushWarningsr= )r r) �warningr r. r �&test_assertWarnsAfterUnassertedWarning� s z<WarningAssertionTests.test_assertWarnsAfterUnassertedWarningN)r r r r r r r r r r r! r$ r' r* r+ r2 r r r r r� � s r� c @ s� e Zd ZdZe� Zeed��Zdd� Z dd� Z dd� Z d d � Z d d � Z d d� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd'd(� Zd)S )*�ResultOfAssertionsTestsz� Tests for L{SynchronousTestCase.successResultOf}, L{SynchronousTestCase.failureResultOf}, and L{SynchronousTestCase.assertNoResult}. � Bad timesc C � | � | j| jt� � dS )z� L{SynchronousTestCase.successResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with no current result. N)r� r< �successResultOfr r r r r �test_withoutResult� � z*ResultOfAssertionsTests.test_withoutResultc C � | � | j| jt| j�� dS )z� L{SynchronousTestCase.successResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with a failure result. N)r� r< r6 r �failurer r r r � test_successResultOfWithFailure� � �z7ResultOfAssertionsTests.test_successResultOfWithFailurec C sV z | � t| j�� W dS | jy* } z| �| j�� t|�� W Y d}~dS d}~ww )z� L{SynchronousTestCase.successResultOf} raises a L{SynchronousTestCase.failureException} that has the original failure traceback when called with a L{Deferred} with a failure result. N)r6 r r: r< r\ � getTracebackr r� r r r �+test_successResultOfWithFailureHasTraceback� s $��zCResultOfAssertionsTests.test_successResultOfWithFailureHasTracebackc C r5 )z� L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with no current result. N)r� r< �failureResultOfr r r r r �!test_failureResultOfWithoutResult� r8 z9ResultOfAssertionsTests.test_failureResultOfWithoutResultc C r9 )z� L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with a success result. N)r� r< r? r r? r r r r � test_failureResultOfWithSuccess� r< z7ResultOfAssertionsTests.test_failureResultOfWithSuccessc C s | � | j| jt| j�t� dS )z� L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} that fails with an exception type that was not expected. N)r� r< r? r r: �KeyErrorr r r r �$test_failureResultOfWithWrongFailure� s �z<ResultOfAssertionsTests.test_failureResultOfWithWrongFailurec C s^ z | � t| j�t� W dS | jy. } z| �d�tjtj�t |�� W Y d}~dS d}~ww )a= L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} that fails with an exception type that was not expected, and the L{SynchronousTestCase.failureException} message contains the expected exception type. �#Failure of type ({}.{}) expected onN) r? r r: rB r< r\ r� r r r r� r r r �6test_failureResultOfWithWrongFailureOneExpectedFailure s ����zNResultOfAssertionsTests.test_failureResultOfWithWrongFailureOneExpectedFailurec C sX z | � t| j�t� W dS | jy+ } z| �| j�� t|�� W Y d}~dS d}~ww )a@ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} that fails with an exception type that was not expected, and the L{SynchronousTestCase.failureException} message contains the original failure traceback. N)r? r r: rB r< r\ r= r r� r r r �;test_failureResultOfWithWrongFailureOneExpectedFailureHasTB s $��zSResultOfAssertionsTests.test_failureResultOfWithWrongFailureOneExpectedFailureHasTBc C sh z | � t| j�tt� W dS | jy3 } z| �d�tjtj tjtj �t |�� W Y d}~dS d}~ww )aH L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with an exception type that was not expected, and the L{SynchronousTestCase.failureException} message contains the expected exception types in the error message. �,Failure of type ({}.{} or {}.{}) expected onN) r? r r: rB �IOErrorr< r\ r� r r r r� r r r �9test_failureResultOfWithWrongFailureMultiExpectedFailures% s ����zQResultOfAssertionsTests.test_failureResultOfWithWrongFailureMultiExpectedFailuresc C sZ z | � t| j�tt� W dS | jy, } z| �| j�� t|�� W Y d}~dS d}~ww )aJ L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a L{Deferred} with an exception type that was not expected, and the L{SynchronousTestCase.failureException} message contains the original failure traceback in the error message. N) r? r r: rB rH r< r\ r= r r� r r r �>test_failureResultOfWithWrongFailureMultiExpectedFailuresHasTB: s $��zVResultOfAssertionsTests.test_failureResultOfWithWrongFailureMultiExpectedFailuresHasTBc C � | � | j| �t| j��� dS )a When passed a L{Deferred} which currently has a result (ie, L{Deferred.addCallback} would cause the added callback to be called before C{addCallback} returns), L{SynchronousTestCase.successResultOf} returns that result. N)�assertIdenticalr? r6 r r r r r �%test_successResultOfWithSuccessResultG � z=ResultOfAssertionsTests.test_successResultOfWithSuccessResultc C s& | � | j| �t| j�| jjt�� dS )a= When passed a L{Deferred} which currently has a L{Failure} result (ie, L{Deferred.addErrback} would cause the added errback to be called before C{addErrback} returns), L{SynchronousTestCase.failureResultOf} returns that L{Failure} if its contained exception type is expected. N)rL r: r? r r� rB r r r r �-test_failureResultOfWithExpectedFailureResultP s �zEResultOfAssertionsTests.test_failureResultOfWithExpectedFailureResultc C rK )a When passed a L{Deferred} which currently has a L{Failure} result (ie, L{Deferred.addErrback} would cause the added errback to be called before C{addErrback} returns), L{SynchronousTestCase.failureResultOf} returns that L{Failure}. N)rL r: r? r r r r r �%test_failureResultOfWithFailureResult\ rN z=ResultOfAssertionsTests.test_failureResultOfWithFailureResultc C r9 )z� When passed a L{Deferred} which currently has a success result (see L{test_withSuccessResult}), L{SynchronousTestCase.assertNoResult} raises L{SynchronousTestCase.failureException}. N)r� r< �assertNoResultr r? r r r r �test_assertNoResultSuccesse r< z2ResultOfAssertionsTests.test_assertNoResultSuccessc C r9 )z� When passed a L{Deferred} which currently has a failure result (see L{test_withFailureResult}), L{SynchronousTestCase.assertNoResult} raises L{SynchronousTestCase.failureException}. N)r� r< rQ r r: r r r r �test_assertNoResultFailureo r< z2ResultOfAssertionsTests.test_assertNoResultFailurec C s | � t� � dS )z� When passed a L{Deferred} with no current result, L{SynchronousTestCase.assertNoResult} does not raise an exception. N)rQ r r r r r �test_assertNoResulty rc z+ResultOfAssertionsTests.test_assertNoResultc C �4 t � }| �|� |�| j� | �| j| �|�� dS )z� When passed a L{Deferred} with no current result, which is then fired with a success result, L{SynchronousTestCase.assertNoResult} doesn't modify the result of the L{Deferred}. N�r rQ �callbackr? r= r6 �r �dr r r �$test_assertNoResultPropagatesSuccess� � z<ResultOfAssertionsTests.test_assertNoResultPropagatesSuccessc C rU )z� When passed a L{Deferred} with no current result, which is then fired with a L{Failure} result, L{SynchronousTestCase.assertNoResult} doesn't modify the result of the L{Deferred}. N)r rQ �errbackr: r= r? rX r r r �)test_assertNoResultPropagatesLaterFailure� r[ zAResultOfAssertionsTests.test_assertNoResultPropagatesLaterFailurec C sD t | j�}z| �|� W n | jy Y nw | �d| �|�� dS )�� When passed a L{Deferred} which currently has a L{Failure} result, L{SynchronousTestCase.assertNoResult} changes the result of the L{Deferred} to a success. N�r r: rQ r< r= r6 rX r r r �+test_assertNoResultSwallowsImmediateFailure� s �zCResultOfAssertionsTests.test_assertNoResultSwallowsImmediateFailureN) r r r r& r� r? r � Exceptionr: r7 r; r> r@ rA rC rE rF rI rJ rM rO rP rR rS rT rZ r] r` r r r r r3 � s. r3 c @ s� e Zd ZdZe� Zed�Zee�Z dd� Z dd� Z d0dd �Z d d � Z d d � Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Z d*d+� Z d,d-� Z d.d/� Z dS )1� ResultOfCoroutineAssertionsTestsz� Tests for L{SynchronousTestCase.successResultOf}, L{SynchronousTestCase.failureResultOf}, and L{SynchronousTestCase.assertNoResult} when given a coroutine. r4 c � s �| j S r )r? r r r r � successResult� s �z.ResultOfCoroutineAssertionsTests.successResultc � s �t � I d H d S r )r r r r r �noCurrentResult� s �z0ResultOfCoroutineAssertionsTests.noCurrentResultNc � s �|d u r| j }|�r )r� �r r� r r r �raisesException� s �z0ResultOfCoroutineAssertionsTests.raisesExceptionc C � | � | j| j| �� � dS )z� L{SynchronousTestCase.successResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine with no current result. N)r� r< r6 rd r r r r r7 � � �z3ResultOfCoroutineAssertionsTests.test_withoutResultc C rg )z� L{SynchronousTestCase.successResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception. N)r� r< r6 rf r r r r �!test_successResultOfWithException� rh zBResultOfCoroutineAssertionsTests.test_successResultOfWithExceptionc C sh t d�}z | �| �|�� W dS | jy3 } z| �dt|�� | �dt|�� W Y d}~dS d}~ww )z� L{SynchronousTestCase.successResultOf} raises a L{SynchronousTestCase.failureException} that has the original failure traceback when called with a coroutine with a failure result. r4 zSuccess result expected on� builtins.Exception: Bad timesN)ra r6 rf r< r\ r �r r� r^ r r r r> � s ��zLResultOfCoroutineAssertionsTests.test_successResultOfWithFailureHasTracebackc C rg )z� L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine with no current result. N)r� r< r? rd r r r r r@ � rh zBResultOfCoroutineAssertionsTests.test_failureResultOfWithoutResultc C rg )z� L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine with a success result. N)r� r< r? rc r r r r rA � rh z@ResultOfCoroutineAssertionsTests.test_failureResultOfWithSuccessc C s | � | j| j| �� t� dS )z� L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception that was not expected. N)r� r< r? rf rB r r r r rC � s �zEResultOfCoroutineAssertionsTests.test_failureResultOfWithWrongFailurec C s\ z | � | �� t� W dS | jy- } z| �d�tjtj�t|�� W Y d}~dS d}~ww )aF L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception with a failure type that was not expected, and the L{SynchronousTestCase.failureException} message contains the expected exception type. rD N) r? rf rB r< r\ r� r r r r� r r r �:test_failureResultOfWithWrongExceptionOneExpectedException� s ����z[ResultOfCoroutineAssertionsTests.test_failureResultOfWithWrongExceptionOneExpectedExceptionc C sj t d�}z | �| �|�t� W dS | jy4 } z| �dt|�� | �dt|�� W Y d}~dS d}~ww )aK L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception with a failure type that was not expected, and the L{SynchronousTestCase.failureException} message contains the original exception traceback. r4 z/Failure of type (builtins.KeyError) expected onrj N)ra r? rf rB r< r\ r rk r r r �?test_failureResultOfWithWrongExceptionOneExpectedExceptionHasTB s ��z`ResultOfCoroutineAssertionsTests.test_failureResultOfWithWrongExceptionOneExpectedExceptionHasTBc C sf z | � | �� tt� W dS | jy2 } z| �d�tjtjtjtj�t |�� W Y d}~dS d}~ww )aN L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception of a type that was not expected, and the L{SynchronousTestCase.failureException} message contains expected exception types in the error message. rG N) r? rf rB rH r< r\ r� r r r r� r r r �=test_failureResultOfWithWrongExceptionMultiExpectedExceptions s ����z^ResultOfCoroutineAssertionsTests.test_failureResultOfWithWrongExceptionMultiExpectedExceptionsc C sl t d�}z | �| �|�tt� W dS | jy5 } z| �dt|�� | �dt|�� W Y d}~dS d}~ww )aV L{SynchronousTestCase.failureResultOf} raises L{SynchronousTestCase.failureException} when called with a coroutine that raises an exception of a type that was not expected, and the L{SynchronousTestCase.failureException} message contains the original exception traceback in the error message. r4 zCFailure of type (builtins.KeyError or builtins.OSError) expected onrj N)ra r? rf rB rH r< r\ r rk r r r �Btest_failureResultOfWithWrongExceptionMultiExpectedExceptionsHasTB2 s � ��zcResultOfCoroutineAssertionsTests.test_failureResultOfWithWrongExceptionMultiExpectedExceptionsHasTBc C s | � | j| �| �� �� dS )a$ When passed a coroutine which currently has a result (ie, if converted into a L{Deferred}, L{Deferred.addCallback} would cause the added callback to be called before C{addCallback} returns), L{SynchronousTestCase.successResultOf} returns that result. N)rL r? r6 rc r r r r rM E s zFResultOfCoroutineAssertionsTests.test_successResultOfWithSuccessResultc C s( | � | jj| �| �� | jjt�j� dS )ar When passed a coroutine which currently has an exception result (ie, if converted into a L{Deferred}, L{Deferred.addErrback} would cause the added errback to be called before C{addErrback} returns), L{SynchronousTestCase.failureResultOf} returns a L{Failure} containing that exception, if the exception type is expected. N)r= r: �valuer? rf r� rB r r r r �)test_failureResultOfWithExpectedExceptionN s ��zJResultOfCoroutineAssertionsTests.test_failureResultOfWithExpectedExceptionc C s | � | jj| �| �� �j� dS )aW When passed a coroutine which currently has an exception result (ie, if converted into a L{Deferred}, L{Deferred.addErrback} would cause the added errback to be called before C{addErrback} returns), L{SynchronousTestCase.failureResultOf} returns returns a L{Failure} containing that exception. N)r= r: rp r? rf r r r r �!test_failureResultOfWithException] s �zBResultOfCoroutineAssertionsTests.test_failureResultOfWithExceptionc C rg )z� When passed a coroutine which currently has a success result (see L{test_withSuccessResult}), L{SynchronousTestCase.assertNoResult} raises L{SynchronousTestCase.failureException}. N)r� r< rQ rc r r r r rR i rh z;ResultOfCoroutineAssertionsTests.test_assertNoResultSuccessc C rg )z� When passed a coroutine which currently has an exception result (see L{test_withFailureResult}), L{SynchronousTestCase.assertNoResult} raises L{SynchronousTestCase.failureException}. N)r� r< rQ rf r r r r rS s rh z;ResultOfCoroutineAssertionsTests.test_assertNoResultFailurec C s | � | �� � dS )z� When passed a coroutine with no current result, L{SynchronousTestCase.assertNoResult} does not raise an exception. N)rQ rd r r r r rT } s z4ResultOfCoroutineAssertionsTests.test_assertNoResultc sF t � � � fdd�}|� }| �� � � �| j� | �| j| �|�� dS )z� When passed a coroutine awaiting a L{Deferred} with no current result, which is then fired with a success result, L{SynchronousTestCase.assertNoResult} doesn't modify the result of the L{Deferred}. c � � �� I d H S r r r �rY r r rd � � � z^ResultOfCoroutineAssertionsTests.test_assertNoResultPropagatesSuccess.<locals>.noCurrentResultNrV )r rd �cr rt r rZ � s zEResultOfCoroutineAssertionsTests.test_assertNoResultPropagatesSuccessc sP t | j�}t� � � fdd�}|� }| �� � � �|� | �|j| �|�j� dS )z� When passed a coroutine awaiting a L{Deferred} with no current result, which is then fired with a L{Failure} result, L{SynchronousTestCase.assertNoResult} doesn't modify the result of the L{Deferred}. c � rs r r r rt r r rd � ru zcResultOfCoroutineAssertionsTests.test_assertNoResultPropagatesLaterFailure.<locals>.noCurrentResultN)r r� r rQ r\ r= rp r? )r r) rd rv r rt r r] � s zJResultOfCoroutineAssertionsTests.test_assertNoResultPropagatesLaterFailurec sV t | j�� � fdd�}|� }z| �� � W n | jy Y nw | �d| �|�� dS )r^ c � rs r r r rt r r rf � ru zeResultOfCoroutineAssertionsTests.test_assertNoResultSwallowsImmediateFailure.<locals>.raisesExceptionNr_ )r rf rv r rt r r` � s �zLResultOfCoroutineAssertionsTests.test_assertNoResultSwallowsImmediateFailurer ) r r r r& r� r? ra r� r r: rc rd rf r7 ri r> r@ rA rC rl rm rn ro rM rq rr rR rS rT rZ r] r` r r r r rb � s6 rb c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �AssertionNamesTestszK Tests for consistency of naming within TestCase assertion methods c s" i � t | � d� � fdd�� D �S )N�assertc s& g | ]}|� d �s|dkr� | �qS )�Not�_)r� )�.0�k��dctr r � <listcomp>� s & z3AssertionNamesTests._getAsserts.<locals>.<listcomp>)r r r r} r � _getAsserts� s z AssertionNamesTests._getAssertsc C s |j S r )r r� r r r �_name� s zAssertionNamesTests._namec C s0 t | �� �}t t| d��}| �||�|�� dS )a� The C{failUnless*} test methods are a subset of the C{assert*} test methods. This is intended to ensure that methods using the I{failUnless} naming scheme are not added without corresponding methods using the I{assert} naming scheme. The I{assert} naming scheme is preferred, and new I{assert}-prefixed methods may be added without corresponding I{failUnless}-prefixed methods. rm N)�setr� r r= � intersection)r �asserts� failUnlessesr r r � test_failUnlessMatchesAssert� s z0AssertionNamesTests.test_failUnlessMatchesAssertc C s< t tjd�}t tjd�}| �t|| jd�t|| jd�� d S )N� assertNotra )�key)r r rJ r= �sortedr� )r r� �failIfsr r r � test_failIf_matches_assertNot� s �z1AssertionNamesTests.test_failIf_matches_assertNotc C s� t | ��� D ]R\}}t|�sq|�d�r0| �t| |d �|� d|� d�� | �|t| |d �� |�d�rX| �t| |d d� �|� d|d d� � �� | �|t| |d d� �� qd S )N�Equal�sz but no �Equals���)�vars�items�callable�endswithrk �hasattrr= r� )r r rp r r r �test_equalSpelling� s " ,��z&AssertionNamesTests.test_equalSpellingN) r r r r& r� r� r� r� r� r r r r rw � s rw c @ sV e Zd ZdZedddd�Zdd� Zdd� Zd d � Zd d � Z d d� Z dd� Z dd� Z dS )�CallDeprecatedTestsz\ Test use of the L{SynchronousTestCase.callDeprecated} method with version objects. �Twisted� r c C s& | � | jtd� | �| �� g d� dS )zj callDeprecated calls a deprecated callable, suppressing the deprecation warning. r� zNo warnings should be shownN)�callDeprecated�version� oldMethodr= r0 r r r r �$test_callDeprecatedSuppressesWarning� s z8CallDeprecatedTests.test_callDeprecatedSuppressesWarningc C s | � | jtd�}| �d|� dS )zn L{callDeprecated} actually calls the callable passed to it, and forwards the result. r� N)r� r� r� r= r> r r r � test_callDeprecatedCallsFunction� s z4CallDeprecatedTests.test_callDeprecatedCallsFunctionc C s6 dd� }| � | j| j| j|�}| �d| t|�� dS )zd L{callDeprecated} raises a test failure if the callable is not deprecated. c S s d S r r r r r r � notDeprecated r� zGCallDeprecatedTests.test_failsWithoutDeprecation.<locals>.notDeprecatedz%r is not deprecated.N)r� r< r� r� r= r )r r� r� r r r � test_failsWithoutDeprecation� s �z0CallDeprecatedTests.test_failsWithoutDeprecationc C sR t dddd�}| �| j| j|td�}| �t| j�t|�� | �t|�t|�� dS )z� callDeprecated raises a test failure if the callable was deprecated at a different version to the one expected. �FoorA rT rV r� N) r r� r< r� r� r\ r r� r )r �differentVersionr� r r r �"test_failsWithIncorrectDeprecation s �z6CallDeprecatedTests.test_failsWithIncorrectDeprecationc C sT t dddd�}dd� }t|�|�}| �||d� | �� }| �t|�dd|� �� d S ) a: L{callDeprecated} ignores all deprecations apart from the first. Multiple warnings are generated when a deprecated function calls another deprecated function. The first warning is the one generated by the explicitly called function. That's the warning that we care about. r� rA rT rV c W s t | � S r )r� )�argsr r r �nestedDeprecation& r% zECallDeprecatedTests.test_nestedDeprecation.<locals>.nestedDeprecation� zUnexpected warnings: N)r r r� r0 r= rG )r r� r� � warningsShownr r r �test_nestedDeprecation s z*CallDeprecatedTests.test_nestedDeprecationc C s | � | jdftd� dS )zj L{callDeprecated} can take a message argument used to check the warning emitted. � newMethodrA N)r� r� �oldMethodReplacedr r r r � test_callDeprecationWithMessage3 r� z3CallDeprecatedTests.test_callDeprecationWithMessagec C sF | � | j| j| jdftd�}| �t| j�t|�� | �dt|�� dS )z| If the message passed to L{callDeprecated} doesn't match, L{callDeprecated} raises a test failure. zsomething.wrongrA z please use newMethod insteadN)r� r< r� r� r� r\ r r re r r r �$test_callDeprecationWithWrongMessage: s �z8CallDeprecatedTests.test_callDeprecationWithWrongMessageN) r r r r& r r� r� r� r� r� r� r� r� r r r r r� � s r� c C r )z( Deprecated method for testing. r �rt r r r r� J s r� r� )� replacementc C s d| S )zh Another deprecated method, which has been deprecated in favor of the mythical 'newMethod'. rT r r� r r r r� R s r� c @ s> e Zd ZdZedddd�Zdd� Zdd � Zd d � Zd d � Z dS )�!GetDeprecatedModuleAttributeTestsz� Test L{SynchronousTestCase.getDeprecatedModuleAttribute} @ivar version: The version at which L{test_assertions.somethingOld} is marked deprecated. @type version: L{incremental.Version} �BarrA rT rV c C s, | � t| �td| j�� | �g | �� � dS )z� L{getDeprecatedModuleAttribute} returns the specified attribute and consumes the deprecation warning that generates. � somethingOldN�r� � _somethingOld� getDeprecatedModuleAttributer r� r= r0 r r r r �test_deprecatedf s ��z1GetDeprecatedModuleAttributeTests.test_deprecatedc C s0 | � t| jtd| jdd�� | �g | �� � dS )z� The I{message} argument to L{getDeprecatedModuleAttribute} matches the prefix of the deprecation message. r� zIt's oldr- Nr� r r r r � test_messageu s �� z.GetDeprecatedModuleAttributeTests.test_messagec C s. | � | j| jtd| jd� | �g | �� � dS )z� L{getDeprecatedModuleAttribute} fails the test if the I{message} isn't part of the deprecation message prefix. r� zIt's shiny and newN)r� r< r� r r� r= r0 r r r r �test_messageMismatch� s �z6GetDeprecatedModuleAttributeTests.test_messageMismatchc C s | � | j| jtd| j� dS )z� L{getDeprecatedModuleAttribute} fails the test when used to get an attribute that isn't actually deprecated. � somethingNewN)r� r< r� r r� r r r r �test_notDeprecated� s �z4GetDeprecatedModuleAttributeTests.test_notDeprecatedN) r r r r& r r� r� r� r� r� r r r r r� [ s r� c C � dS )zj A deprecated module attribute. Used by L{GetDeprecatedModuleAttributeTests.test_deprecated}. Nr r r r r r� � r� r� zIt's old and clunkyc C r� )zy A module attribute that is not deprecated. Used by L{GetDeprecatedModuleAttributeTests.test_notDeprecated}. Nr r r r r r� � r� r� ),r& r r1 r� � incrementalr r �twisted.internet.deferr r r �twisted.python.deprecater r �twisted.python.failurer �twisted.python.reflectr r r �twisted.python.utilr � twisted.trialr r! rv r) rJ rL rh rq r� r3 rb rw r� r� r� r� r� r� r� r r� r r r r �<module> sT 6MM O q b -c G� PK b�Z���A� � - test/__pycache__/test_plugins.cpython-310.pycnu �[��� o �b� � @ s> d Z ddlmZ ddlmZ ddlmZ G dd� dej�ZdS )z- Tests for L{twisted.plugins.twisted_trial}. � )� getPlugins)�unittest)� IReporterc @ s e Zd ZdZdd� Zdd� ZdS )� PluginsTestsz- Tests for Trial's reporter plugins. c s: � fdd�t t�D �}t|�dkrtd� |f ��|d S )z� Return the Trial reporter plugin with the given long option. If more than one is found, raise ValueError. If none are found, raise IndexError. c s g | ] }|j � kr|�qS � )�longOpt)�.0�plugin�� longOptionr �A/usr/lib/python3/dist-packages/twisted/trial/test/test_plugins.py� <listcomp> s z7PluginsTests.getPluginsByLongOption.<locals>.<listcomp>� z2More than one plugin found with long option %r: %rr )r r �len� ValueError)�selfr �pluginsr r r �getPluginsByLongOption s � ��z#PluginsTests.getPluginsByLongOptionc C sT | � d�}| �d|j� | �d|j� | �d|j� | �d|j� | �d|j� dS )zM One of the reporter plugins is the subunit reporter plugin. �subunitzSubunit Reporterztwisted.trial.reporterN�SubunitReporter)r � assertEqual�name�moduler �assertIdentical�shortOpt�klass)r � subunitPluginr r r �test_subunitPlugin% s z PluginsTests.test_subunitPluginN)�__name__� __module__� __qualname__�__doc__r r r r r r r s r N) r! �twisted.pluginr � twisted.trialr �twisted.trial.itrialr �SynchronousTestCaser r r r r �<module> s PK b�Z_�]� � test/novars.pynu �[��� # fodder for test_script, which parses files for emacs local variable # declarations. This one is supposed to have none. # The class declaration is irrelevant class Bar: pass PK b�Z���S� � test/test_asyncassertions.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for async assertions provided by C{twisted.trial.unittest.TestCase}. """ import unittest as pyunit from twisted.internet import defer from twisted.python import failure from twisted.trial import unittest class AsynchronousAssertionsTests(unittest.TestCase): """ Tests for L{TestCase}'s asynchronous extensions to L{SynchronousTestCase}. That is, assertFailure. """ def test_assertFailure(self): d = defer.maybeDeferred(lambda: 1 / 0) return self.assertFailure(d, ZeroDivisionError) def test_assertFailure_wrongException(self): d = defer.maybeDeferred(lambda: 1 / 0) self.assertFailure(d, OverflowError) d.addCallbacks( lambda x: self.fail("Should have failed"), lambda x: x.trap(self.failureException), ) return d def test_assertFailure_noException(self): d = defer.succeed(None) self.assertFailure(d, ZeroDivisionError) d.addCallbacks( lambda x: self.fail("Should have failed"), lambda x: x.trap(self.failureException), ) return d def test_assertFailure_moreInfo(self): """ In the case of assertFailure failing, check that we get lots of information about the exception that was raised. """ try: 1 / 0 except ZeroDivisionError: f = failure.Failure() d = defer.fail(f) d = self.assertFailure(d, RuntimeError) d.addErrback(self._checkInfo, f) return d def _checkInfo(self, assertionFailure, f): assert assertionFailure.check(self.failureException) output = assertionFailure.getErrorMessage() self.assertIn(f.getErrorMessage(), output) self.assertIn(f.getBriefTraceback(), output) def test_assertFailure_masked(self): """ A single wrong assertFailure should fail the whole test. """ class ExampleFailure(Exception): pass class TC(unittest.TestCase): failureException = ExampleFailure def test_assertFailure(self): d = defer.maybeDeferred(lambda: 1 / 0) self.assertFailure(d, OverflowError) self.assertFailure(d, ZeroDivisionError) return d test = TC("test_assertFailure") result = pyunit.TestResult() test.run(result) self.assertEqual(1, len(result.failures)) PK b�Z� �q test/mockcustomsuite2.pynu �[��� # Copyright (c) 2006 Twisted Matrix Laboratories. See LICENSE for details """ Mock test module that contains a C{testSuite} method. L{runner.TestLoader} should load the tests from the C{testSuite}, not from the C{Foo} C{TestCase}. See L{twisted.trial.test.test_loader.LoaderTest.test_loadModuleWith_testSuite}. """ from twisted.trial import runner, unittest class Foo(unittest.SynchronousTestCase): def test_foo(self): pass def testSuite(): ts = runner.TestSuite() ts.name = "MyCustomSuite" return ts PK b�Z��2 M M test/skipping.pynu �[��� # -*- test-case-name: twisted.trial.test.test_tests -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Definitions of test cases with various interesting behaviors, to be used by L{twisted.trial.test.test_tests} and other test modules to exercise different features of trial's test runner. See the L{twisted.trial.test.test_tests} module docstring for details about how this code is arranged. """ from twisted.trial.unittest import FailTest, SkipTest, SynchronousTestCase, TestCase class SkippingMixin: def test_skip1(self): raise SkipTest("skip1") def test_skip2(self): raise RuntimeError("I should not get raised") test_skip2.skip = "skip2" # type: ignore[attr-defined] def test_skip3(self): self.fail("I should not fail") test_skip3.skip = "skip3" # type: ignore[attr-defined] class SynchronousSkipping(SkippingMixin, SynchronousTestCase): pass class AsynchronousSkipping(SkippingMixin, TestCase): pass class SkippingSetUpMixin: def setUp(self): raise SkipTest("skipSetUp") def test_1(self): pass def test_2(self): pass class SynchronousSkippingSetUp(SkippingSetUpMixin, SynchronousTestCase): pass class AsynchronousSkippingSetUp(SkippingSetUpMixin, TestCase): pass class DeprecatedReasonlessSkipMixin: def test_1(self): raise SkipTest() class SynchronousDeprecatedReasonlessSkip( DeprecatedReasonlessSkipMixin, SynchronousTestCase ): pass class AsynchronousDeprecatedReasonlessSkip(DeprecatedReasonlessSkipMixin, TestCase): pass class SkippedClassMixin: skip = "class" def setUp(self): self.__class__._setUpRan = True def test_skip1(self): raise SkipTest("skip1") def test_skip2(self): raise RuntimeError("Ought to skip me") test_skip2.skip = "skip2" # type: ignore def test_skip3(self): pass def test_skip4(self): raise RuntimeError("Skip me too") class SynchronousSkippedClass(SkippedClassMixin, SynchronousTestCase): pass class AsynchronousSkippedClass(SkippedClassMixin, TestCase): pass class TodoMixin: def test_todo1(self): self.fail("deliberate failure") test_todo1.todo = "todo1" # type: ignore[attr-defined] def test_todo2(self): raise RuntimeError("deliberate error") test_todo2.todo = "todo2" # type: ignore[attr-defined] def test_todo3(self): """unexpected success""" test_todo3.todo = "todo3" # type: ignore[attr-defined] class SynchronousTodo(TodoMixin, SynchronousTestCase): pass class AsynchronousTodo(TodoMixin, TestCase): pass class SetUpTodoMixin: def setUp(self): raise RuntimeError("deliberate error") def test_todo1(self): pass test_todo1.todo = "setUp todo1" # type: ignore[attr-defined] class SynchronousSetUpTodo(SetUpTodoMixin, SynchronousTestCase): pass class AsynchronousSetUpTodo(SetUpTodoMixin, TestCase): pass class TearDownTodoMixin: def tearDown(self): raise RuntimeError("deliberate error") def test_todo1(self): pass test_todo1.todo = "tearDown todo1" # type: ignore[attr-defined] class SynchronousTearDownTodo(TearDownTodoMixin, SynchronousTestCase): pass class AsynchronousTearDownTodo(TearDownTodoMixin, TestCase): pass class TodoClassMixin: todo = "class" def test_todo1(self): pass test_todo1.todo = "method" # type: ignore[attr-defined] def test_todo2(self): pass def test_todo3(self): self.fail("Deliberate Failure") test_todo3.todo = "method" # type: ignore[attr-defined] def test_todo4(self): self.fail("Deliberate Failure") class SynchronousTodoClass(TodoClassMixin, SynchronousTestCase): pass class AsynchronousTodoClass(TodoClassMixin, TestCase): pass class StrictTodoMixin: def test_todo1(self): raise RuntimeError("expected failure") test_todo1.todo = (RuntimeError, "todo1") # type: ignore[attr-defined] def test_todo2(self): raise RuntimeError("expected failure") test_todo2.todo = ((RuntimeError, OSError), "todo2") # type: ignore[attr-defined] def test_todo3(self): raise RuntimeError("we had no idea!") test_todo3.todo = (OSError, "todo3") # type: ignore[attr-defined] def test_todo4(self): raise RuntimeError("we had no idea!") test_todo4.todo = ((OSError, SyntaxError), "todo4") # type: ignore[attr-defined] def test_todo5(self): self.fail("deliberate failure") test_todo5.todo = (FailTest, "todo5") # type: ignore[attr-defined] def test_todo6(self): self.fail("deliberate failure") test_todo6.todo = (RuntimeError, "todo6") # type: ignore[attr-defined] def test_todo7(self): pass test_todo7.todo = (RuntimeError, "todo7") # type: ignore[attr-defined] class SynchronousStrictTodo(StrictTodoMixin, SynchronousTestCase): pass class AsynchronousStrictTodo(StrictTodoMixin, TestCase): pass class AddCleanupMixin: def setUp(self): self.log = ["setUp"] def brokenSetUp(self): self.log = ["setUp"] raise RuntimeError("Deliberate failure") def skippingSetUp(self): self.log = ["setUp"] raise SkipTest("Don't do this") def append(self, thing): self.log.append(thing) def tearDown(self): self.log.append("tearDown") def runTest(self): self.log.append("runTest") class SynchronousAddCleanup(AddCleanupMixin, SynchronousTestCase): pass class AsynchronousAddCleanup(AddCleanupMixin, TestCase): pass PK b�ZO�78� � test/test_output.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for the output generated by trial. """ import os from io import StringIO from twisted.scripts import trial from twisted.trial import runner from twisted.trial.test import packages _noModuleError = "No module named 'frotz'" def runTrial(*args): from twisted.trial import reporter config = trial.Options() config.parseOptions(args) output = StringIO() myRunner = runner.TrialRunner( reporter.VerboseTextReporter, stream=output, workingDirectory=config["temp-directory"], ) suite = trial._getSuite(config) myRunner.run(suite) return output.getvalue() class ImportErrorsTests(packages.SysPathManglingTest): """Actually run trial as if on the command line and check that the output is what we expect. """ def debug(self): pass parent = "_testImportErrors" def runTrial(self, *args): return runTrial("--temp-directory", self.mktemp(), *args) def _print(self, stuff): print(stuff) return stuff def assertIn(self, container, containee, *args, **kwargs): # redefined to be useful in callbacks super().assertIn(containee, container, *args, **kwargs) return container def assertNotIn(self, container, containee, *args, **kwargs): # redefined to be useful in callbacks super().assertNotIn(containee, container, *args, **kwargs) return container def test_trialRun(self): self.runTrial() def test_nonexistentModule(self): d = self.runTrial("twisted.doesntexist") self.assertIn(d, "[ERROR]") self.assertIn(d, "twisted.doesntexist") return d def test_nonexistentPackage(self): d = self.runTrial("doesntexist") self.assertIn(d, "doesntexist") self.assertIn(d, "ModuleNotFound") self.assertIn(d, "[ERROR]") return d def test_nonexistentPackageWithModule(self): d = self.runTrial("doesntexist.barney") self.assertIn(d, "doesntexist.barney") self.assertIn(d, "ObjectNotFound") self.assertIn(d, "[ERROR]") return d def test_badpackage(self): d = self.runTrial("badpackage") self.assertIn(d, "[ERROR]") self.assertIn(d, "badpackage") self.assertNotIn(d, "IOError") return d def test_moduleInBadpackage(self): d = self.runTrial("badpackage.test_module") self.assertIn(d, "[ERROR]") self.assertIn(d, "badpackage.test_module") self.assertNotIn(d, "IOError") return d def test_badmodule(self): d = self.runTrial("package.test_bad_module") self.assertIn(d, "[ERROR]") self.assertIn(d, "package.test_bad_module") self.assertNotIn(d, "IOError") self.assertNotIn(d, "<module ") return d def test_badimport(self): d = self.runTrial("package.test_import_module") self.assertIn(d, "[ERROR]") self.assertIn(d, "package.test_import_module") self.assertNotIn(d, "IOError") self.assertNotIn(d, "<module ") return d def test_recurseImport(self): d = self.runTrial("package") self.assertIn(d, "[ERROR]") self.assertIn(d, "test_bad_module") self.assertIn(d, "test_import_module") self.assertNotIn(d, "<module ") self.assertNotIn(d, "IOError") return d def test_recurseImportErrors(self): d = self.runTrial("package2") self.assertIn(d, "[ERROR]") self.assertIn(d, "package2") self.assertIn(d, "test_module") self.assertIn(d, _noModuleError) self.assertNotIn(d, "<module ") self.assertNotIn(d, "IOError") return d def test_nonRecurseImportErrors(self): d = self.runTrial("-N", "package2") self.assertIn(d, "[ERROR]") self.assertIn(d, _noModuleError) self.assertNotIn(d, "<module ") return d def test_regularRun(self): d = self.runTrial("package.test_module") self.assertNotIn(d, "[ERROR]") self.assertNotIn(d, "IOError") self.assertIn(d, "OK") self.assertIn(d, "PASSED (successes=1)") return d def test_filename(self): self.mangleSysPath(self.oldPath) d = self.runTrial(os.path.join(self.parent, "package", "test_module.py")) self.assertNotIn(d, "[ERROR]") self.assertNotIn(d, "IOError") self.assertIn(d, "OK") self.assertIn(d, "PASSED (successes=1)") return d def test_dosFile(self): ## XXX -- not really an output test, more of a script test self.mangleSysPath(self.oldPath) d = self.runTrial(os.path.join(self.parent, "package", "test_dos_module.py")) self.assertNotIn(d, "[ERROR]") self.assertNotIn(d, "IOError") self.assertIn(d, "OK") self.assertIn(d, "PASSED (successes=1)") return d PK b�Z't�` ` test/ordertests.pynu �[��� # -*- test-case-name: twisted.trial.test.test_script -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for handling of trial's --order option. """ from twisted.trial import unittest class FooTest(unittest.TestCase): """ Used to make assertions about the order its tests will be run in. """ def test_first(self): pass def test_second(self): pass def test_third(self): pass def test_fourth(self): pass class BazTest(unittest.TestCase): """ Used to make assertions about the order the test cases in this module are run in. """ def test_baz(self): pass class BarTest(unittest.TestCase): """ Used to make assertions about the order the test cases in this module are run in. """ def test_bar(self): pass PK b�Z��0 � � test/test_doctest.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test Twisted's doctest support. """ from twisted.trial import itrial, reporter, runner, unittest from twisted.trial.test import mockdoctest class RunnersTests(unittest.SynchronousTestCase): """ Tests for Twisted's doctest support. """ def test_id(self): """ Check that the id() of the doctests' case object contains the FQPN of the actual tests. """ loader = runner.TestLoader() suite = loader.loadDoctests(mockdoctest) idPrefix = "twisted.trial.test.mockdoctest.Counter" for test in suite._tests: self.assertIn(idPrefix, itrial.ITestCase(test).id()) def test_basicTrialIntegration(self): """ L{loadDoctests} loads all of the doctests in the given module. """ loader = runner.TestLoader() suite = loader.loadDoctests(mockdoctest) self.assertEqual(7, suite.countTestCases()) def _testRun(self, suite): """ Run C{suite} and check the result. """ result = reporter.TestResult() suite.run(result) self.assertEqual(5, result.successes) self.assertEqual(2, len(result.failures)) def test_expectedResults(self, count=1): """ Trial can correctly run doctests with its xUnit test APIs. """ suite = runner.TestLoader().loadDoctests(mockdoctest) self._testRun(suite) def test_repeatable(self): """ Doctests should be runnable repeatably. """ suite = runner.TestLoader().loadDoctests(mockdoctest) self._testRun(suite) self._testRun(suite) PK b�ZP��r �r test/test_script.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. import gc import re import sys import textwrap import types from io import StringIO from twisted.python import util from twisted.python.filepath import FilePath from twisted.python.usage import UsageError from twisted.scripts import trial from twisted.trial import unittest from twisted.trial._dist.disttrial import DistTrialRunner from twisted.trial.runner import ( DestructiveTestSuite, TestLoader, TestSuite, TrialRunner, ) from twisted.trial.test.test_loader import testNames pyunit = __import__("unittest") def sibpath(filename): """ For finding files in twisted/trial/test """ return util.sibpath(__file__, filename) class ForceGarbageCollectionTests(unittest.SynchronousTestCase): """ Tests for the --force-gc option. """ def setUp(self): self.config = trial.Options() self.log = [] self.patch(gc, "collect", self.collect) test = pyunit.FunctionTestCase(self.simpleTest) self.test = TestSuite([test, test]) def simpleTest(self): """ A simple test method that records that it was run. """ self.log.append("test") def collect(self): """ A replacement for gc.collect that logs calls to itself. """ self.log.append("collect") def makeRunner(self): """ Return a L{TrialRunner} object that is safe to use in tests. """ runner = trial._makeRunner(self.config) runner.stream = StringIO() return runner def test_forceGc(self): """ Passing the --force-gc option to the trial script forces the garbage collector to run before and after each test. """ self.config["force-gc"] = True self.config.postOptions() runner = self.makeRunner() runner.run(self.test) self.assertEqual( self.log, ["collect", "test", "collect", "collect", "test", "collect"] ) def test_unforceGc(self): """ By default, no garbage collection is forced. """ self.config.postOptions() runner = self.makeRunner() runner.run(self.test) self.assertEqual(self.log, ["test", "test"]) class SuiteUsedTests(unittest.SynchronousTestCase): """ Check the category of tests suite used by the loader. """ def setUp(self): """ Create a trial configuration object. """ self.config = trial.Options() def test_defaultSuite(self): """ By default, the loader should use L{DestructiveTestSuite} """ loader = trial._getLoader(self.config) self.assertEqual(loader.suiteFactory, DestructiveTestSuite) def test_untilFailureSuite(self): """ The C{until-failure} configuration uses the L{TestSuite} to keep instances alive across runs. """ self.config["until-failure"] = True loader = trial._getLoader(self.config) self.assertEqual(loader.suiteFactory, TestSuite) class TestModuleTests(unittest.SynchronousTestCase): def setUp(self): self.config = trial.Options() def tearDown(self): self.config = None def test_testNames(self): """ Check that the testNames helper method accurately collects the names of tests in suite. """ self.assertEqual(testNames(self), [self.id()]) def assertSuitesEqual(self, test1, names): loader = TestLoader() names1 = testNames(test1) names2 = testNames(TestSuite(map(loader.loadByName, names))) names1.sort() names2.sort() self.assertEqual(names1, names2) def test_baseState(self): self.assertEqual(0, len(self.config["tests"])) def test_testmoduleOnModule(self): """ Check that --testmodule loads a suite which contains the tests referred to in test-case-name inside its parameter. """ self.config.opt_testmodule(sibpath("moduletest.py")) self.assertSuitesEqual( trial._getSuite(self.config), ["twisted.trial.test.test_log"] ) def test_testmoduleTwice(self): """ When the same module is specified with two --testmodule flags, it should only appear once in the suite. """ self.config.opt_testmodule(sibpath("moduletest.py")) self.config.opt_testmodule(sibpath("moduletest.py")) self.assertSuitesEqual( trial._getSuite(self.config), ["twisted.trial.test.test_log"] ) def test_testmoduleOnSourceAndTarget(self): """ If --testmodule is specified twice, once for module A and once for a module which refers to module A, then make sure module A is only added once. """ self.config.opt_testmodule(sibpath("moduletest.py")) self.config.opt_testmodule(sibpath("test_log.py")) self.assertSuitesEqual( trial._getSuite(self.config), ["twisted.trial.test.test_log"] ) def test_testmoduleOnSelfModule(self): """ When given a module that refers to *itself* in the test-case-name variable, check that --testmodule only adds the tests once. """ self.config.opt_testmodule(sibpath("moduleself.py")) self.assertSuitesEqual( trial._getSuite(self.config), ["twisted.trial.test.moduleself"] ) def test_testmoduleOnScript(self): """ Check that --testmodule loads tests referred to in test-case-name buffer variables. """ self.config.opt_testmodule(sibpath("scripttest.py")) self.assertSuitesEqual( trial._getSuite(self.config), ["twisted.trial.test.test_log", "twisted.trial.test.test_runner"], ) def test_testmoduleOnNonexistentFile(self): """ Check that --testmodule displays a meaningful error message when passed a non-existent filename. """ buffy = StringIO() stderr, sys.stderr = sys.stderr, buffy filename = "test_thisbetternoteverexist.py" try: self.config.opt_testmodule(filename) self.assertEqual(0, len(self.config["tests"])) self.assertEqual(f"File {filename!r} doesn't exist\n", buffy.getvalue()) finally: sys.stderr = stderr def test_testmoduleOnEmptyVars(self): """ Check that --testmodule adds no tests to the suite for modules which lack test-case-name buffer variables. """ self.config.opt_testmodule(sibpath("novars.py")) self.assertEqual(0, len(self.config["tests"])) def test_testmoduleOnModuleName(self): """ Check that --testmodule does *not* support module names as arguments and that it displays a meaningful error message. """ buffy = StringIO() stderr, sys.stderr = sys.stderr, buffy moduleName = "twisted.trial.test.test_script" try: self.config.opt_testmodule(moduleName) self.assertEqual(0, len(self.config["tests"])) self.assertEqual(f"File {moduleName!r} doesn't exist\n", buffy.getvalue()) finally: sys.stderr = stderr def test_parseLocalVariable(self): declaration = "-*- test-case-name: twisted.trial.test.test_tests -*-" localVars = trial._parseLocalVariables(declaration) self.assertEqual({"test-case-name": "twisted.trial.test.test_tests"}, localVars) def test_trailingSemicolon(self): declaration = "-*- test-case-name: twisted.trial.test.test_tests; -*-" localVars = trial._parseLocalVariables(declaration) self.assertEqual({"test-case-name": "twisted.trial.test.test_tests"}, localVars) def test_parseLocalVariables(self): declaration = ( "-*- test-case-name: twisted.trial.test.test_tests; " "foo: bar -*-" ) localVars = trial._parseLocalVariables(declaration) self.assertEqual( {"test-case-name": "twisted.trial.test.test_tests", "foo": "bar"}, localVars ) def test_surroundingGuff(self): declaration = "## -*- test-case-name: " "twisted.trial.test.test_tests -*- #" localVars = trial._parseLocalVariables(declaration) self.assertEqual({"test-case-name": "twisted.trial.test.test_tests"}, localVars) def test_invalidLine(self): self.assertRaises(ValueError, trial._parseLocalVariables, "foo") def test_invalidDeclaration(self): self.assertRaises(ValueError, trial._parseLocalVariables, "-*- foo -*-") self.assertRaises( ValueError, trial._parseLocalVariables, "-*- foo: bar; qux -*-" ) self.assertRaises( ValueError, trial._parseLocalVariables, "-*- foo: bar: baz; qux: qax -*-" ) def test_variablesFromFile(self): localVars = trial.loadLocalVariables(sibpath("moduletest.py")) self.assertEqual({"test-case-name": "twisted.trial.test.test_log"}, localVars) def test_noVariablesInFile(self): localVars = trial.loadLocalVariables(sibpath("novars.py")) self.assertEqual({}, localVars) def test_variablesFromScript(self): localVars = trial.loadLocalVariables(sibpath("scripttest.py")) self.assertEqual( { "test-case-name": ( "twisted.trial.test.test_log," "twisted.trial.test.test_runner" ) }, localVars, ) def test_getTestModules(self): modules = trial.getTestModules(sibpath("moduletest.py")) self.assertEqual(modules, ["twisted.trial.test.test_log"]) def test_getTestModules_noVars(self): modules = trial.getTestModules(sibpath("novars.py")) self.assertEqual(len(modules), 0) def test_getTestModules_multiple(self): modules = trial.getTestModules(sibpath("scripttest.py")) self.assertEqual( set(modules), {"twisted.trial.test.test_log", "twisted.trial.test.test_runner"}, ) def test_looksLikeTestModule(self): for filename in ["test_script.py", "twisted/trial/test/test_script.py"]: self.assertTrue( trial.isTestFile(filename), f"{filename!r} should be a test file", ) for filename in [ "twisted/trial/test/moduletest.py", sibpath("scripttest.py"), sibpath("test_foo.bat"), ]: self.assertFalse( trial.isTestFile(filename), f"{filename!r} should *not* be a test file", ) class WithoutModuleTests(unittest.SynchronousTestCase): """ Test the C{without-module} flag. """ def setUp(self): """ Create a L{trial.Options} object to be used in the tests, and save C{sys.modules}. """ self.config = trial.Options() self.savedModules = dict(sys.modules) def tearDown(self): """ Restore C{sys.modules}. """ for module in ("imaplib", "smtplib"): if module in self.savedModules: sys.modules[module] = self.savedModules[module] else: sys.modules.pop(module, None) def _checkSMTP(self): """ Try to import the C{smtplib} module, and return it. """ import smtplib return smtplib def _checkIMAP(self): """ Try to import the C{imaplib} module, and return it. """ import imaplib return imaplib def test_disableOneModule(self): """ Check that after disabling a module, it can't be imported anymore. """ self.config.parseOptions(["--without-module", "smtplib"]) self.assertRaises(ImportError, self._checkSMTP) # Restore sys.modules del sys.modules["smtplib"] # Then the function should succeed self.assertIsInstance(self._checkSMTP(), types.ModuleType) def test_disableMultipleModules(self): """ Check that several modules can be disabled at once. """ self.config.parseOptions(["--without-module", "smtplib,imaplib"]) self.assertRaises(ImportError, self._checkSMTP) self.assertRaises(ImportError, self._checkIMAP) # Restore sys.modules del sys.modules["smtplib"] del sys.modules["imaplib"] # Then the functions should succeed self.assertIsInstance(self._checkSMTP(), types.ModuleType) self.assertIsInstance(self._checkIMAP(), types.ModuleType) def test_disableAlreadyImportedModule(self): """ Disabling an already imported module should produce a warning. """ self.assertIsInstance(self._checkSMTP(), types.ModuleType) self.assertWarns( RuntimeWarning, "Module 'smtplib' already imported, disabling anyway.", trial.__file__, self.config.parseOptions, ["--without-module", "smtplib"], ) self.assertRaises(ImportError, self._checkSMTP) class CoverageTests(unittest.SynchronousTestCase): """ Tests for the I{coverage} option. """ if getattr(sys, "gettrace", None) is None: skip = "Cannot test trace hook installation without inspection API." def setUp(self): """ Arrange for the current trace hook to be restored when the test is complete. """ self.addCleanup(sys.settrace, sys.gettrace()) def test_tracerInstalled(self): """ L{trial.Options} handles C{"--coverage"} by installing a trace hook to record coverage information. """ options = trial.Options() options.parseOptions(["--coverage"]) self.assertEqual(sys.gettrace(), options.tracer.globaltrace) def test_coverdirDefault(self): """ L{trial.Options.coverdir} returns a L{FilePath} based on the default for the I{temp-directory} option if that option is not specified. """ options = trial.Options() self.assertEqual( options.coverdir(), FilePath(".").descendant([options["temp-directory"], "coverage"]), ) def test_coverdirOverridden(self): """ If a value is specified for the I{temp-directory} option, L{trial.Options.coverdir} returns a child of that path. """ path = self.mktemp() options = trial.Options() options.parseOptions(["--temp-directory", path]) self.assertEqual(options.coverdir(), FilePath(path).child("coverage")) class OptionsTests(unittest.TestCase): """ Tests for L{trial.Options}. """ def setUp(self): """ Build an L{Options} object to be used in the tests. """ self.options = trial.Options() def test_getWorkerArguments(self): """ C{_getWorkerArguments} discards options like C{random} as they only matter in the manager, and forwards options like C{recursionlimit} or C{disablegc}. """ self.addCleanup(sys.setrecursionlimit, sys.getrecursionlimit()) if gc.isenabled(): self.addCleanup(gc.enable) self.options.parseOptions( ["--recursionlimit", "2000", "--random", "4", "--disablegc"] ) args = self.options._getWorkerArguments() self.assertIn("--disablegc", args) args.remove("--disablegc") self.assertEqual(["--recursionlimit", "2000"], args) def test_jobsConflictWithDebug(self): """ C{parseOptions} raises a C{UsageError} when C{--debug} is passed along C{--jobs} as it's not supported yet. @see: U{http://twistedmatrix.com/trac/ticket/5825} """ error = self.assertRaises( UsageError, self.options.parseOptions, ["--jobs", "4", "--debug"] ) self.assertEqual("You can't specify --debug when using --jobs", str(error)) def test_jobsConflictWithProfile(self): """ C{parseOptions} raises a C{UsageError} when C{--profile} is passed along C{--jobs} as it's not supported yet. @see: U{http://twistedmatrix.com/trac/ticket/5827} """ error = self.assertRaises( UsageError, self.options.parseOptions, ["--jobs", "4", "--profile"] ) self.assertEqual("You can't specify --profile when using --jobs", str(error)) def test_jobsConflictWithDebugStackTraces(self): """ C{parseOptions} raises a C{UsageError} when C{--debug-stacktraces} is passed along C{--jobs} as it's not supported yet. @see: U{http://twistedmatrix.com/trac/ticket/5826} """ error = self.assertRaises( UsageError, self.options.parseOptions, ["--jobs", "4", "--debug-stacktraces"], ) self.assertEqual( "You can't specify --debug-stacktraces when using --jobs", str(error) ) def test_jobsConflictWithExitFirst(self): """ C{parseOptions} raises a C{UsageError} when C{--exitfirst} is passed along C{--jobs} as it's not supported yet. @see: U{http://twistedmatrix.com/trac/ticket/6436} """ error = self.assertRaises( UsageError, self.options.parseOptions, ["--jobs", "4", "--exitfirst"] ) self.assertEqual("You can't specify --exitfirst when using --jobs", str(error)) def test_orderConflictWithRandom(self): """ C{parseOptions} raises a C{UsageError} when C{--order} is passed along with C{--random}. """ error = self.assertRaises( UsageError, self.options.parseOptions, ["--order", "alphabetical", "--random", "1234"], ) self.assertEqual("You can't specify --random when using --order", str(error)) class MakeRunnerTests(unittest.TestCase): """ Tests for the L{_makeRunner} helper. """ def setUp(self): self.options = trial.Options() def test_jobs(self): """ L{_makeRunner} returns a L{DistTrialRunner} instance when the C{--jobs} option is passed, and passes the C{workerNumber} and C{workerArguments} parameters to it. """ self.options.parseOptions(["--jobs", "4", "--force-gc"]) runner = trial._makeRunner(self.options) self.assertIsInstance(runner, DistTrialRunner) self.assertEqual(4, runner._workerNumber) self.assertEqual(["--force-gc"], runner._workerArguments) def test_dryRunWithJobs(self): """ L{_makeRunner} returns a L{TrialRunner} instance in C{DRY_RUN} mode when the C{--dry-run} option is passed, even if C{--jobs} is set. """ self.options.parseOptions(["--jobs", "4", "--dry-run"]) runner = trial._makeRunner(self.options) self.assertIsInstance(runner, TrialRunner) self.assertEqual(TrialRunner.DRY_RUN, runner.mode) def test_DebuggerNotFound(self): namedAny = trial.reflect.namedAny def namedAnyExceptdoNotFind(fqn): if fqn == "doNotFind": raise trial.reflect.ModuleNotFound(fqn) return namedAny(fqn) self.patch(trial.reflect, "namedAny", namedAnyExceptdoNotFind) options = trial.Options() options.parseOptions(["--debug", "--debugger", "doNotFind"]) self.assertRaises(trial._DebuggerNotFound, trial._makeRunner, options) def test_exitfirst(self): """ Passing C{--exitfirst} wraps the reporter with a L{reporter._ExitWrapper} that stops on any non-success. """ self.options.parseOptions(["--exitfirst"]) runner = trial._makeRunner(self.options) self.assertTrue(runner._exitFirst) class RunTests(unittest.TestCase): """ Tests for the L{run} function. """ def setUp(self): # don't re-parse cmdline options, because if --reactor was passed to # the test run trial will try to restart the (already running) reactor self.patch(trial.Options, "parseOptions", lambda self: None) def test_debuggerNotFound(self): """ When a debugger is not found, an error message is printed to the user. """ def _makeRunner(*args, **kwargs): raise trial._DebuggerNotFound("foo") self.patch(trial, "_makeRunner", _makeRunner) try: trial.run() except SystemExit as e: self.assertIn("foo", str(e)) else: self.fail("Should have exited due to non-existent debugger!") class TestArgumentOrderTests(unittest.TestCase): """ Tests for the order-preserving behavior on provided command-line tests. """ def setUp(self): self.config = trial.Options() self.loader = TestLoader() def test_preserveArgumentOrder(self): """ Multiple tests passed on the command line are not reordered. """ tests = [ "twisted.trial.test.test_tests", "twisted.trial.test.test_assertions", "twisted.trial.test.test_deferred", ] self.config.parseOptions(tests) suite = trial._getSuite(self.config) names = testNames(suite) expectedSuite = TestSuite(map(self.loader.loadByName, tests)) expectedNames = testNames(expectedSuite) self.assertEqual(names, expectedNames) class OrderTests(unittest.TestCase): """ Tests for the --order option. """ def setUp(self): self.config = trial.Options() def test_alphabetical(self): """ --order=alphabetical causes trial to run tests alphabetically within each test case. """ self.config.parseOptions( ["--order", "alphabetical", "twisted.trial.test.ordertests.FooTest"] ) loader = trial._getLoader(self.config) suite = loader.loadByNames(self.config["tests"]) self.assertEqual( testNames(suite), [ "twisted.trial.test.ordertests.FooTest.test_first", "twisted.trial.test.ordertests.FooTest.test_fourth", "twisted.trial.test.ordertests.FooTest.test_second", "twisted.trial.test.ordertests.FooTest.test_third", ], ) def test_alphabeticalModule(self): """ --order=alphabetical causes trial to run test classes within a given module alphabetically. """ self.config.parseOptions( ["--order", "alphabetical", "twisted.trial.test.ordertests"] ) loader = trial._getLoader(self.config) suite = loader.loadByNames(self.config["tests"]) self.assertEqual( testNames(suite), [ "twisted.trial.test.ordertests.BarTest.test_bar", "twisted.trial.test.ordertests.BazTest.test_baz", "twisted.trial.test.ordertests.FooTest.test_first", "twisted.trial.test.ordertests.FooTest.test_fourth", "twisted.trial.test.ordertests.FooTest.test_second", "twisted.trial.test.ordertests.FooTest.test_third", ], ) def test_alphabeticalPackage(self): """ --order=alphabetical causes trial to run test modules within a given package alphabetically, with tests within each module alphabetized. """ self.config.parseOptions(["--order", "alphabetical", "twisted.trial.test"]) loader = trial._getLoader(self.config) suite = loader.loadByNames(self.config["tests"]) names = testNames(suite) self.assertTrue(names, msg="Failed to load any tests!") self.assertEqual(names, sorted(names)) def test_toptobottom(self): """ --order=toptobottom causes trial to run test methods within a given test case from top to bottom as they are defined in the body of the class. """ self.config.parseOptions( ["--order", "toptobottom", "twisted.trial.test.ordertests.FooTest"] ) loader = trial._getLoader(self.config) suite = loader.loadByNames(self.config["tests"]) self.assertEqual( testNames(suite), [ "twisted.trial.test.ordertests.FooTest.test_first", "twisted.trial.test.ordertests.FooTest.test_second", "twisted.trial.test.ordertests.FooTest.test_third", "twisted.trial.test.ordertests.FooTest.test_fourth", ], ) def test_toptobottomModule(self): """ --order=toptobottom causes trial to run test classes within a given module from top to bottom as they are defined in the module's source. """ self.config.parseOptions( ["--order", "toptobottom", "twisted.trial.test.ordertests"] ) loader = trial._getLoader(self.config) suite = loader.loadByNames(self.config["tests"]) self.assertEqual( testNames(suite), [ "twisted.trial.test.ordertests.FooTest.test_first", "twisted.trial.test.ordertests.FooTest.test_second", "twisted.trial.test.ordertests.FooTest.test_third", "twisted.trial.test.ordertests.FooTest.test_fourth", "twisted.trial.test.ordertests.BazTest.test_baz", "twisted.trial.test.ordertests.BarTest.test_bar", ], ) def test_toptobottomPackage(self): """ --order=toptobottom causes trial to run test modules within a given package alphabetically, with tests within each module run top to bottom. """ self.config.parseOptions(["--order", "toptobottom", "twisted.trial.test"]) loader = trial._getLoader(self.config) suite = loader.loadByNames(self.config["tests"]) names = testNames(suite) # twisted.trial.test.test_module, so split and key on the first 4 to # get stable alphabetical sort on those self.assertEqual( names, sorted(names, key=lambda name: name.split(".")[:4]), ) def test_toptobottomMissingSource(self): """ --order=toptobottom detects the source line of methods from modules whose source file is missing. """ tempdir = self.mktemp() package = FilePath(tempdir).child("twisted_toptobottom_temp") package.makedirs() package.child("__init__.py").setContent(b"") package.child("test_missing.py").setContent( textwrap.dedent( """ from twisted.trial.unittest import TestCase class TestMissing(TestCase): def test_second(self): pass def test_third(self): pass def test_fourth(self): pass def test_first(self): pass """ ).encode("utf8") ) pathEntry = package.parent().path sys.path.insert(0, pathEntry) self.addCleanup(sys.path.remove, pathEntry) from twisted_toptobottom_temp import test_missing # type: ignore[import] self.addCleanup(sys.modules.pop, "twisted_toptobottom_temp") self.addCleanup(sys.modules.pop, test_missing.__name__) package.child("test_missing.py").remove() self.config.parseOptions( ["--order", "toptobottom", "twisted.trial.test.ordertests"] ) loader = trial._getLoader(self.config) suite = loader.loadModule(test_missing) self.assertEqual( testNames(suite), [ "twisted_toptobottom_temp.test_missing.TestMissing.test_second", "twisted_toptobottom_temp.test_missing.TestMissing.test_third", "twisted_toptobottom_temp.test_missing.TestMissing.test_fourth", "twisted_toptobottom_temp.test_missing.TestMissing.test_first", ], ) def test_unknownOrder(self): """ An unknown order passed to --order raises a L{UsageError}. """ self.assertRaises( UsageError, self.config.parseOptions, ["--order", "I don't exist"] ) class HelpOrderTests(unittest.TestCase): """ Tests for the --help-orders flag. """ def test_help_ordersPrintsSynopsisAndQuits(self): """ --help-orders prints each of the available orders and then exits. """ self.patch(sys, "stdout", StringIO()) exc = self.assertRaises( SystemExit, trial.Options().parseOptions, ["--help-orders"] ) self.assertEqual(exc.code, 0) output = sys.stdout.getvalue() msg = "%r with its description not properly described in %r" for orderName, (orderDesc, _) in trial._runOrders.items(): match = re.search( f"{re.escape(orderName)}.*{re.escape(orderDesc)}", output, ) self.assertTrue(match, msg=msg % (orderName, output)) PK b�Z {%[ [ test/test_skip.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # """ Tests for L{twisted.trial.util} """ from unittest import skipIf from twisted.trial.unittest import TestCase @skipIf(True, "Skip all tests when @skipIf is used on a class") class SkipDecoratorUsedOnClass(TestCase): """ All tests should be skipped because @skipIf decorator is used on this class. """ def test_shouldNeverRun_1(self): raise Exception("Test should skip and never reach here") def test_shouldNeverRun_2(self): raise Exception("Test should skip and never reach here") @skipIf(True, "") class SkipDecoratorUsedOnClassWithEmptyReason(TestCase): """ All tests should be skipped because @skipIf decorator is used on this class, even if the reason is an empty string """ def test_shouldNeverRun_1(self): raise Exception("Test should skip and never reach here") def test_shouldNeverRun_2(self): raise Exception("Test should skip and never reach here") class SkipDecoratorUsedOnMethods(TestCase): """ Only methods where @skipIf decorator is used should be skipped. """ @skipIf(True, "skipIf decorator used so skip test") def test_shouldNeverRun(self): raise Exception("Test should skip and never reach here") @skipIf(True, "") def test_shouldNeverRunWithEmptyReason(self): raise Exception("Test should skip and never reach here") def test_shouldShouldRun(self): self.assertTrue(True, "Test should run and not be skipped") @skipIf(False, "should not skip") def test_shouldShouldRunWithSkipIfFalse(self): self.assertTrue(True, "Test should run and not be skipped") @skipIf(False, "") def test_shouldShouldRunWithSkipIfFalseEmptyReason(self): self.assertTrue(True, "Test should run and not be skipped") class SkipAttributeOnClass(TestCase): """ All tests should be skipped because skip attribute is set on this class. """ skip = "'skip' attribute set on this class, so skip all tests" def test_one(self): raise Exception("Test should skip and never reach here") def test_two(self): raise Exception("Test should skip and never reach here") class SkipAttributeOnMethods(TestCase): """ Only methods where @skipIf decorator is used should be skipped. """ def test_one(self): raise Exception("Should never reach here") test_one.skip = "skip test, skip attribute set on method" # type: ignore[attr-defined] def test_shouldNotSkip(self): self.assertTrue(True, "Test should run and not be skipped") PK b�Z_-"� � test/test_pyunitcompat.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. import sys import traceback import unittest as pyunit from unittest import skipIf from zope.interface import implementer from twisted.python.failure import Failure from twisted.trial.itrial import IReporter, ITestCase from twisted.trial.unittest import PyUnitResultAdapter, SynchronousTestCase class PyUnitTestTests(SynchronousTestCase): class PyUnitTest(pyunit.TestCase): def test_pass(self): pass def setUp(self): self.original = self.PyUnitTest("test_pass") self.test = ITestCase(self.original) def test_callable(self): """ Tests must be callable in order to be used with Python's unittest.py. """ self.assertTrue(callable(self.test), f"{self.test!r} is not callable.") class PyUnitResultTests(SynchronousTestCase): """ Tests to show that PyUnitResultAdapter wraps TestResult objects from the standard library 'unittest' module in such a way as to make them usable and useful from Trial. """ # Once erroneous is ported to Python 3 this can be replaced with # erroneous.ErrorTest: class ErrorTest(SynchronousTestCase): """ A test case which has a L{test_foo} which will raise an error. @ivar ran: boolean indicating whether L{test_foo} has been run. """ ran = False def test_foo(self): """ Set C{self.ran} to True and raise a C{ZeroDivisionError} """ self.ran = True 1 / 0 def test_dontUseAdapterWhenReporterProvidesIReporter(self): """ The L{PyUnitResultAdapter} is only used when the result passed to C{run} does *not* provide L{IReporter}. """ @implementer(IReporter) class StubReporter: """ A reporter which records data about calls made to it. @ivar errors: Errors passed to L{addError}. @ivar failures: Failures passed to L{addFailure}. """ def __init__(self): self.errors = [] self.failures = [] def startTest(self, test): """ Do nothing. """ def stopTest(self, test): """ Do nothing. """ def addError(self, test, error): """ Record the error. """ self.errors.append(error) test = self.ErrorTest("test_foo") result = StubReporter() test.run(result) self.assertIsInstance(result.errors[0], Failure) def test_success(self): class SuccessTest(SynchronousTestCase): ran = False def test_foo(s): s.ran = True test = SuccessTest("test_foo") result = pyunit.TestResult() test.run(result) self.assertTrue(test.ran) self.assertEqual(1, result.testsRun) self.assertTrue(result.wasSuccessful()) def test_failure(self): class FailureTest(SynchronousTestCase): ran = False def test_foo(s): s.ran = True s.fail("boom!") test = FailureTest("test_foo") result = pyunit.TestResult() test.run(result) self.assertTrue(test.ran) self.assertEqual(1, result.testsRun) self.assertEqual(1, len(result.failures)) self.assertFalse(result.wasSuccessful()) def test_error(self): test = self.ErrorTest("test_foo") result = pyunit.TestResult() test.run(result) self.assertTrue(test.ran) self.assertEqual(1, result.testsRun) self.assertEqual(1, len(result.errors)) self.assertFalse(result.wasSuccessful()) def test_setUpError(self): class ErrorTest(SynchronousTestCase): ran = False def setUp(self): 1 / 0 def test_foo(s): s.ran = True test = ErrorTest("test_foo") result = pyunit.TestResult() test.run(result) self.assertFalse(test.ran) self.assertEqual(1, result.testsRun) self.assertEqual(1, len(result.errors)) self.assertFalse(result.wasSuccessful()) def test_tracebackFromFailure(self): """ Errors added through the L{PyUnitResultAdapter} have the same traceback information as if there were no adapter at all. """ try: 1 / 0 except ZeroDivisionError: exc_info = sys.exc_info() f = Failure() pyresult = pyunit.TestResult() result = PyUnitResultAdapter(pyresult) result.addError(self, f) self.assertEqual( pyresult.errors[0][1], "".join(traceback.format_exception(*exc_info)) ) def test_traceback(self): """ As test_tracebackFromFailure, but covering more code. """ class ErrorTest(SynchronousTestCase): exc_info = None def test_foo(self): try: 1 / 0 except ZeroDivisionError: self.exc_info = sys.exc_info() raise test = ErrorTest("test_foo") result = pyunit.TestResult() test.run(result) # We can't test that the tracebacks are equal, because Trial's # machinery inserts a few extra frames on the top and we don't really # want to trim them off without an extremely good reason. # # So, we just test that the result's stack ends with the # exception's stack. expected_stack = "".join(traceback.format_tb(test.exc_info[2])) observed_stack = "\n".join(result.errors[0][1].splitlines()[:-1]) self.assertEqual( expected_stack.strip(), observed_stack[-len(expected_stack) :].strip() ) def test_tracebackFromCleanFailure(self): """ Errors added through the L{PyUnitResultAdapter} have the same traceback information as if there were no adapter at all, even if the Failure that held the information has been cleaned. """ try: 1 / 0 except ZeroDivisionError: exc_info = sys.exc_info() f = Failure() f.cleanFailure() pyresult = pyunit.TestResult() result = PyUnitResultAdapter(pyresult) result.addError(self, f) self.assertEqual( pyresult.errors[0][1], "".join(traceback.format_exception(*exc_info)) ) def test_trialSkip(self): """ Skips using trial's skipping functionality are reported as skips in the L{pyunit.TestResult}. """ class SkipTest(SynchronousTestCase): @skipIf(True, "Let's skip!") def test_skip(self): 1 / 0 test = SkipTest("test_skip") result = pyunit.TestResult() test.run(result) self.assertEqual(result.skipped, [(test, "Let's skip!")]) def test_pyunitSkip(self): """ Skips using pyunit's skipping functionality are reported as skips in the L{pyunit.TestResult}. """ class SkipTest(SynchronousTestCase): @pyunit.skip("skippy") def test_skip(self): 1 / 0 test = SkipTest("test_skip") result = pyunit.TestResult() test.run(result) self.assertEqual(result.skipped, [(test, "skippy")]) PK b�Zȓ� � test/test_testcase.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Direct unit tests for L{twisted.trial.unittest.SynchronousTestCase} and L{twisted.trial.unittest.TestCase}. """ from twisted.trial.unittest import SynchronousTestCase, TestCase class TestCaseMixin: """ L{TestCase} tests. """ def setUp(self): """ Create a couple instances of C{MyTestCase}, each for the same test method, to be used in the test methods of this class. """ self.first = self.MyTestCase("test_1") self.second = self.MyTestCase("test_1") def test_equality(self): """ In order for one test method to be runnable twice, two TestCase instances with the same test method name must not compare as equal. """ self.assertTrue(self.first == self.first) self.assertTrue(self.first != self.second) self.assertFalse(self.first == self.second) def test_hashability(self): """ In order for one test method to be runnable twice, two TestCase instances with the same test method name should not have the same hash value. """ container = {} container[self.first] = None container[self.second] = None self.assertEqual(len(container), 2) class SynchronousTestCaseTests(TestCaseMixin, SynchronousTestCase): class MyTestCase(SynchronousTestCase): """ Some test methods which can be used to test behaviors of L{SynchronousTestCase}. """ def test_1(self): pass # Yes, subclass SynchronousTestCase again. There are no interesting behaviors # of self being tested below, only of self.MyTestCase. class AsynchronousTestCaseTests(TestCaseMixin, SynchronousTestCase): class MyTestCase(TestCase): """ Some test methods which can be used to test behaviors of L{TestCase}. """ def test_1(self): pass PK b�Z�vUu u test/mockdoctest.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # this module is a trivial class with doctests to test trial's doctest # support. class Counter: """a simple counter object for testing trial's doctest support >>> c = Counter() >>> c.value() 0 >>> c += 3 >>> c.value() 3 >>> c.incr() >>> c.value() == 4 True >>> c == 4 True >>> c != 9 True """ _count = 0 def __init__(self, initialValue=0, maxval=None): self._count = initialValue self.maxval = maxval def __iadd__(self, other): """add other to my value and return self >>> c = Counter(100) >>> c += 333 >>> c == 433 True """ if self.maxval is not None and ((self._count + other) > self.maxval): raise ValueError("sorry, counter got too big") else: self._count += other return self def __eq__(self, other: object) -> bool: """equality operator, compare other to my value() >>> c = Counter() >>> c == 0 True >>> c += 10 >>> c.incr() >>> c == 10 # fail this test on purpose True """ return self._count == other def __ne__(self, other: object) -> bool: """inequality operator >>> c = Counter() >>> c != 10 True """ return not self.__eq__(other) def incr(self): """increment my value by 1 >>> from twisted.trial.test.mockdoctest import Counter >>> c = Counter(10, 11) >>> c.incr() >>> c.value() == 11 True >>> c.incr() Traceback (most recent call last): File "<stdin>", line 1, in ? File "twisted/trial/test/mockdoctest.py", line 51, in incr self.__iadd__(1) File "twisted/trial/test/mockdoctest.py", line 39, in __iadd__ raise ValueError, "sorry, counter got too big" ValueError: sorry, counter got too big """ self.__iadd__(1) def value(self): """return this counter's value >>> c = Counter(555) >>> c.value() == 555 True """ return self._count def unexpectedException(self): """i will raise an unexpected exception... ... *CAUSE THAT'S THE KINDA GUY I AM* >>> 1/0 """ PK b�Z@���L �L test/test_util.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # """ Tests for L{twisted.trial.util} """ import os import sys from io import StringIO from zope.interface import implementer from twisted.internet.base import DelayedCall from twisted.internet.interfaces import IProcessTransport from twisted.python import filepath from twisted.python.failure import Failure from twisted.trial import util from twisted.trial.unittest import SynchronousTestCase from twisted.trial.util import ( DirtyReactorAggregateError, _Janitor, acquireAttribute, excInfoOrFailureToExcInfo, ) class MktempTests(SynchronousTestCase): """ Tests for L{TestCase.mktemp}, a helper function for creating temporary file or directory names. """ def test_name(self): """ The path name returned by C{mktemp} is directly beneath a directory which identifies the test method which created the name. """ name = self.mktemp() dirs = os.path.dirname(name).split(os.sep)[:-1] self.assertEqual( dirs, ["twisted.trial.test.test_util", "MktempTests", "test_name"] ) def test_unique(self): """ Repeated calls to C{mktemp} return different values. """ name = self.mktemp() self.assertNotEqual(name, self.mktemp()) def test_created(self): """ The directory part of the path name returned by C{mktemp} exists. """ name = self.mktemp() dirname = os.path.dirname(name) self.assertTrue(os.path.exists(dirname)) self.assertFalse(os.path.exists(name)) def test_location(self): """ The path returned by C{mktemp} is beneath the current working directory. """ path = os.path.abspath(self.mktemp()) self.assertTrue(path.startswith(os.getcwd())) class DirtyReactorAggregateErrorTests(SynchronousTestCase): """ Tests for the L{DirtyReactorAggregateError}. """ def test_formatDelayedCall(self): """ Delayed calls are formatted nicely. """ error = DirtyReactorAggregateError(["Foo", "bar"]) self.assertEqual( str(error), """\ Reactor was unclean. DelayedCalls: (set twisted.internet.base.DelayedCall.debug = True to debug) Foo bar""", ) def test_formatSelectables(self): """ Selectables are formatted nicely. """ error = DirtyReactorAggregateError([], ["selectable 1", "selectable 2"]) self.assertEqual( str(error), """\ Reactor was unclean. Selectables: selectable 1 selectable 2""", ) def test_formatDelayedCallsAndSelectables(self): """ Both delayed calls and selectables can appear in the same error. """ error = DirtyReactorAggregateError(["bleck", "Boozo"], ["Sel1", "Sel2"]) self.assertEqual( str(error), """\ Reactor was unclean. DelayedCalls: (set twisted.internet.base.DelayedCall.debug = True to debug) bleck Boozo Selectables: Sel1 Sel2""", ) class StubReactor: """ A reactor stub which contains enough functionality to be used with the L{_Janitor}. @ivar iterations: A list of the arguments passed to L{iterate}. @ivar removeAllCalled: Number of times that L{removeAll} was called. @ivar selectables: The value that will be returned from L{removeAll}. @ivar delayedCalls: The value to return from L{getDelayedCalls}. """ def __init__(self, delayedCalls, selectables=None): """ @param delayedCalls: See L{StubReactor.delayedCalls}. @param selectables: See L{StubReactor.selectables}. """ self.delayedCalls = delayedCalls self.iterations = [] self.removeAllCalled = 0 if not selectables: selectables = [] self.selectables = selectables def iterate(self, timeout=None): """ Increment C{self.iterations}. """ self.iterations.append(timeout) def getDelayedCalls(self): """ Return C{self.delayedCalls}. """ return self.delayedCalls def removeAll(self): """ Increment C{self.removeAllCalled} and return C{self.selectables}. """ self.removeAllCalled += 1 return self.selectables class StubErrorReporter: """ A subset of L{twisted.trial.itrial.IReporter} which records L{addError} calls. @ivar errors: List of two-tuples of (test, error) which were passed to L{addError}. """ def __init__(self): self.errors = [] def addError(self, test, error): """ Record parameters in C{self.errors}. """ self.errors.append((test, error)) class JanitorTests(SynchronousTestCase): """ Tests for L{_Janitor}! """ def test_cleanPendingSpinsReactor(self): """ During pending-call cleanup, the reactor will be spun twice with an instant timeout. This is not a requirement, it is only a test for current behavior. Hopefully Trial will eventually not do this kind of reactor stuff. """ reactor = StubReactor([]) jan = _Janitor(None, None, reactor=reactor) jan._cleanPending() self.assertEqual(reactor.iterations, [0, 0]) def test_cleanPendingCancelsCalls(self): """ During pending-call cleanup, the janitor cancels pending timed calls. """ def func(): return "Lulz" cancelled = [] delayedCall = DelayedCall(300, func, (), {}, cancelled.append, lambda x: None) reactor = StubReactor([delayedCall]) jan = _Janitor(None, None, reactor=reactor) jan._cleanPending() self.assertEqual(cancelled, [delayedCall]) def test_cleanPendingReturnsDelayedCallStrings(self): """ The Janitor produces string representations of delayed calls from the delayed call cleanup method. It gets the string representations *before* cancelling the calls; this is important because cancelling the call removes critical debugging information from the string representation. """ delayedCall = DelayedCall( 300, lambda: None, (), {}, lambda x: None, lambda x: None, seconds=lambda: 0 ) delayedCallString = str(delayedCall) reactor = StubReactor([delayedCall]) jan = _Janitor(None, None, reactor=reactor) strings = jan._cleanPending() self.assertEqual(strings, [delayedCallString]) def test_cleanReactorRemovesSelectables(self): """ The Janitor will remove selectables during reactor cleanup. """ reactor = StubReactor([]) jan = _Janitor(None, None, reactor=reactor) jan._cleanReactor() self.assertEqual(reactor.removeAllCalled, 1) def test_cleanReactorKillsProcesses(self): """ The Janitor will kill processes during reactor cleanup. """ @implementer(IProcessTransport) class StubProcessTransport: """ A stub L{IProcessTransport} provider which records signals. @ivar signals: The signals passed to L{signalProcess}. """ def __init__(self): self.signals = [] def signalProcess(self, signal): """ Append C{signal} to C{self.signals}. """ self.signals.append(signal) pt = StubProcessTransport() reactor = StubReactor([], [pt]) jan = _Janitor(None, None, reactor=reactor) jan._cleanReactor() self.assertEqual(pt.signals, ["KILL"]) def test_cleanReactorReturnsSelectableStrings(self): """ The Janitor returns string representations of the selectables that it cleaned up from the reactor cleanup method. """ class Selectable: """ A stub Selectable which only has an interesting string representation. """ def __repr__(self) -> str: return "(SELECTABLE!)" reactor = StubReactor([], [Selectable()]) jan = _Janitor(None, None, reactor=reactor) self.assertEqual(jan._cleanReactor(), ["(SELECTABLE!)"]) def test_postCaseCleanupNoErrors(self): """ The post-case cleanup method will return True and not call C{addError} on the result if there are no pending calls. """ reactor = StubReactor([]) test = object() reporter = StubErrorReporter() jan = _Janitor(test, reporter, reactor=reactor) self.assertTrue(jan.postCaseCleanup()) self.assertEqual(reporter.errors, []) def test_postCaseCleanupWithErrors(self): """ The post-case cleanup method will return False and call C{addError} on the result with a L{DirtyReactorAggregateError} Failure if there are pending calls. """ delayedCall = DelayedCall( 300, lambda: None, (), {}, lambda x: None, lambda x: None, seconds=lambda: 0 ) delayedCallString = str(delayedCall) reactor = StubReactor([delayedCall], []) test = object() reporter = StubErrorReporter() jan = _Janitor(test, reporter, reactor=reactor) self.assertFalse(jan.postCaseCleanup()) self.assertEqual(len(reporter.errors), 1) self.assertEqual(reporter.errors[0][1].value.delayedCalls, [delayedCallString]) def test_postClassCleanupNoErrors(self): """ The post-class cleanup method will not call C{addError} on the result if there are no pending calls or selectables. """ reactor = StubReactor([]) test = object() reporter = StubErrorReporter() jan = _Janitor(test, reporter, reactor=reactor) jan.postClassCleanup() self.assertEqual(reporter.errors, []) def test_postClassCleanupWithPendingCallErrors(self): """ The post-class cleanup method call C{addError} on the result with a L{DirtyReactorAggregateError} Failure if there are pending calls. """ delayedCall = DelayedCall( 300, lambda: None, (), {}, lambda x: None, lambda x: None, seconds=lambda: 0 ) delayedCallString = str(delayedCall) reactor = StubReactor([delayedCall], []) test = object() reporter = StubErrorReporter() jan = _Janitor(test, reporter, reactor=reactor) jan.postClassCleanup() self.assertEqual(len(reporter.errors), 1) self.assertEqual(reporter.errors[0][1].value.delayedCalls, [delayedCallString]) def test_postClassCleanupWithSelectableErrors(self): """ The post-class cleanup method call C{addError} on the result with a L{DirtyReactorAggregateError} Failure if there are selectables. """ selectable = "SELECTABLE HERE" reactor = StubReactor([], [selectable]) test = object() reporter = StubErrorReporter() jan = _Janitor(test, reporter, reactor=reactor) jan.postClassCleanup() self.assertEqual(len(reporter.errors), 1) self.assertEqual(reporter.errors[0][1].value.selectables, [repr(selectable)]) class RemoveSafelyTests(SynchronousTestCase): """ Tests for L{util._removeSafely}. """ def test_removeSafelyNoTrialMarker(self): """ If a path doesn't contain a node named C{"_trial_marker"}, that path is not removed by L{util._removeSafely} and a L{util._NoTrialMarker} exception is raised instead. """ directory = self.mktemp().encode("utf-8") os.mkdir(directory) dirPath = filepath.FilePath(directory) self.assertRaises(util._NoTrialMarker, util._removeSafely, dirPath) def test_removeSafelyRemoveFailsMoveSucceeds(self): """ If an L{OSError} is raised while removing a path in L{util._removeSafely}, an attempt is made to move the path to a new name. """ def dummyRemove(): """ Raise an C{OSError} to emulate the branch of L{util._removeSafely} in which path removal fails. """ raise OSError() # Patch stdout so we can check the print statements in _removeSafely out = StringIO() self.patch(sys, "stdout", out) # Set up a trial directory with a _trial_marker directory = self.mktemp().encode("utf-8") os.mkdir(directory) dirPath = filepath.FilePath(directory) dirPath.child(b"_trial_marker").touch() # Ensure that path.remove() raises an OSError dirPath.remove = dummyRemove util._removeSafely(dirPath) self.assertIn("could not remove FilePath", out.getvalue()) def test_removeSafelyRemoveFailsMoveFails(self): """ If an L{OSError} is raised while removing a path in L{util._removeSafely}, an attempt is made to move the path to a new name. If that attempt fails, the L{OSError} is re-raised. """ def dummyRemove(): """ Raise an C{OSError} to emulate the branch of L{util._removeSafely} in which path removal fails. """ raise OSError("path removal failed") def dummyMoveTo(path): """ Raise an C{OSError} to emulate the branch of L{util._removeSafely} in which path movement fails. """ raise OSError("path movement failed") # Patch stdout so we can check the print statements in _removeSafely out = StringIO() self.patch(sys, "stdout", out) # Set up a trial directory with a _trial_marker directory = self.mktemp().encode("utf-8") os.mkdir(directory) dirPath = filepath.FilePath(directory) dirPath.child(b"_trial_marker").touch() # Ensure that path.remove() and path.moveTo() both raise OSErrors dirPath.remove = dummyRemove dirPath.moveTo = dummyMoveTo error = self.assertRaises(OSError, util._removeSafely, dirPath) self.assertEqual(str(error), "path movement failed") self.assertIn("could not remove FilePath", out.getvalue()) class ExcInfoTests(SynchronousTestCase): """ Tests for L{excInfoOrFailureToExcInfo}. """ def test_excInfo(self): """ L{excInfoOrFailureToExcInfo} returns exactly what it is passed, if it is passed a tuple like the one returned by L{sys.exc_info}. """ info = (ValueError, ValueError("foo"), None) self.assertTrue(info is excInfoOrFailureToExcInfo(info)) def test_failure(self): """ When called with a L{Failure} instance, L{excInfoOrFailureToExcInfo} returns a tuple like the one returned by L{sys.exc_info}, with the elements taken from the type, value, and traceback of the failure. """ try: 1 / 0 except BaseException: f = Failure() self.assertEqual((f.type, f.value, f.tb), excInfoOrFailureToExcInfo(f)) class AcquireAttributeTests(SynchronousTestCase): """ Tests for L{acquireAttribute}. """ def test_foundOnEarlierObject(self): """ The value returned by L{acquireAttribute} is the value of the requested attribute on the first object in the list passed in which has that attribute. """ self.value = value = object() self.assertTrue(value is acquireAttribute([self, object()], "value")) def test_foundOnLaterObject(self): """ The same as L{test_foundOnEarlierObject}, but for the case where the 2nd element in the object list has the attribute and the first does not. """ self.value = value = object() self.assertTrue(value is acquireAttribute([object(), self], "value")) def test_notFoundException(self): """ If none of the objects passed in the list to L{acquireAttribute} have the requested attribute, L{AttributeError} is raised. """ self.assertRaises(AttributeError, acquireAttribute, [object()], "foo") def test_notFoundDefault(self): """ If none of the objects passed in the list to L{acquireAttribute} have the requested attribute and a default value is given, the default value is returned. """ default = object() self.assertTrue(default is acquireAttribute([object()], "foo", default)) class ListToPhraseTests(SynchronousTestCase): """ Input is transformed into a string representation of the list, with each item separated by delimiter (defaulting to a comma) and the final two being separated by a final delimiter. """ def test_empty(self): """ If things is empty, an empty string is returned. """ sample = [] expected = "" result = util._listToPhrase(sample, "and") self.assertEqual(expected, result) def test_oneWord(self): """ With a single item, the item is returned. """ sample = ["One"] expected = "One" result = util._listToPhrase(sample, "and") self.assertEqual(expected, result) def test_twoWords(self): """ Two words are separated by the final delimiter. """ sample = ["One", "Two"] expected = "One and Two" result = util._listToPhrase(sample, "and") self.assertEqual(expected, result) def test_threeWords(self): """ With more than two words, the first two are separated by the delimiter. """ sample = ["One", "Two", "Three"] expected = "One, Two, and Three" result = util._listToPhrase(sample, "and") self.assertEqual(expected, result) def test_fourWords(self): """ If a delimiter is specified, it is used instead of the default comma. """ sample = ["One", "Two", "Three", "Four"] expected = "One; Two; Three; or Four" result = util._listToPhrase(sample, "or", delimiter="; ") self.assertEqual(expected, result) def test_notString(self): """ If something in things is not a string, it is converted into one. """ sample = [1, 2, "three"] expected = "1, 2, and three" result = util._listToPhrase(sample, "and") self.assertEqual(expected, result) def test_stringTypeError(self): """ If things is a string, a TypeError is raised. """ sample = "One, two, three" error = self.assertRaises(TypeError, util._listToPhrase, sample, "and") self.assertEqual(str(error), "Things must be a list or a tuple") def test_iteratorTypeError(self): """ If things is an iterator, a TypeError is raised. """ sample = iter([1, 2, 3]) error = self.assertRaises(TypeError, util._listToPhrase, sample, "and") self.assertEqual(str(error), "Things must be a list or a tuple") def test_generatorTypeError(self): """ If things is a generator, a TypeError is raised. """ def sample(): yield from range(2) error = self.assertRaises(TypeError, util._listToPhrase, sample, "and") self.assertEqual(str(error), "Things must be a list or a tuple") PK b�Z�i��� � test/suppression.pynu �[��� # -*- test-case-name: twisted.trial.test.test_tests -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test cases used to make sure that warning suppression works at the module, method, and class levels. See the L{twisted.trial.test.test_tests} module docstring for details about how this code is arranged. """ import warnings from twisted.trial import unittest, util METHOD_WARNING_MSG = "method warning message" CLASS_WARNING_MSG = "class warning message" MODULE_WARNING_MSG = "module warning message" class MethodWarning(Warning): pass class ClassWarning(Warning): pass class ModuleWarning(Warning): pass class EmitMixin: """ Mixin for emiting a variety of warnings. """ def _emit(self): warnings.warn(METHOD_WARNING_MSG, MethodWarning) warnings.warn(CLASS_WARNING_MSG, ClassWarning) warnings.warn(MODULE_WARNING_MSG, ModuleWarning) class SuppressionMixin(EmitMixin): suppress = [util.suppress(message=CLASS_WARNING_MSG)] def testSuppressMethod(self): self._emit() testSuppressMethod.suppress = [util.suppress(message=METHOD_WARNING_MSG)] # type: ignore[attr-defined] def testSuppressClass(self): self._emit() def testOverrideSuppressClass(self): self._emit() testOverrideSuppressClass.suppress = [] # type: ignore[attr-defined] class SetUpSuppressionMixin: def setUp(self): self._emit() class TearDownSuppressionMixin: def tearDown(self): self._emit() class TestSuppression2Mixin(EmitMixin): def testSuppressModule(self): self._emit() suppress = [util.suppress(message=MODULE_WARNING_MSG)] class SynchronousTestSuppression(SuppressionMixin, unittest.SynchronousTestCase): pass class SynchronousTestSetUpSuppression( SetUpSuppressionMixin, SynchronousTestSuppression ): pass class SynchronousTestTearDownSuppression( TearDownSuppressionMixin, SynchronousTestSuppression ): pass class SynchronousTestSuppression2(TestSuppression2Mixin, unittest.SynchronousTestCase): pass class AsynchronousTestSuppression(SuppressionMixin, unittest.TestCase): pass class AsynchronousTestSetUpSuppression( SetUpSuppressionMixin, AsynchronousTestSuppression ): pass class AsynchronousTestTearDownSuppression( TearDownSuppressionMixin, AsynchronousTestSuppression ): pass class AsynchronousTestSuppression2(TestSuppression2Mixin, unittest.TestCase): pass PK b�Z�S��� �� test/test_reporter.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # # Maintainer: Jonathan Lange """ Tests for L{twisted.trial.reporter}. """ import errno import os import re import sys from inspect import getmro from io import BytesIO, StringIO from typing import Type from unittest import TestCase as StdlibTestCase, expectedFailure from twisted.python import log, reflect from twisted.python.failure import Failure from twisted.python.reflect import qual from twisted.trial import itrial, reporter, runner, unittest, util from twisted.trial.reporter import UncleanWarningsReporterWrapper, _ExitWrapper from twisted.trial.test import erroneous, sample from twisted.trial.unittest import SkipTest, Todo, makeTodo class BrokenStream: """ Stream-ish object that raises a signal interrupt error. We use this to make sure that Trial still manages to write what it needs to write. """ written = False flushed = False def __init__(self, fObj): self.fObj = fObj def write(self, s): if self.written: return self.fObj.write(s) self.written = True raise OSError(errno.EINTR, "Interrupted write") def flush(self): if self.flushed: return self.fObj.flush() self.flushed = True raise OSError(errno.EINTR, "Interrupted flush") class StringTest(unittest.SynchronousTestCase): def stringComparison(self, expect, output): output = list(filter(None, output)) self.assertTrue( len(expect) <= len(output), "Must have more observed than expected" "lines %d < %d" % (len(output), len(expect)), ) REGEX_PATTERN_TYPE = type(re.compile("")) for line_number, (exp, out) in enumerate(zip(expect, output)): if exp is None: continue elif isinstance(exp, str): self.assertSubstring( exp, out, "Line %d: %r not in %r" % (line_number, exp, out) ) elif isinstance(exp, REGEX_PATTERN_TYPE): self.assertTrue( exp.match(out), "Line %d: %r did not match string %r" % (line_number, exp.pattern, out), ) else: raise TypeError(f"don't know what to do with object {exp!r}") class TestResultTests(unittest.SynchronousTestCase): def setUp(self): self.result = reporter.TestResult() def test_pyunitAddError(self): # pyunit passes an exc_info tuple directly to addError try: raise RuntimeError("foo") except RuntimeError as e: excValue = e self.result.addError(self, sys.exc_info()) failure = self.result.errors[0][1] self.assertEqual(excValue, failure.value) self.assertEqual(RuntimeError, failure.type) def test_pyunitAddFailure(self): # pyunit passes an exc_info tuple directly to addFailure try: raise self.failureException("foo") except self.failureException as e: excValue = e self.result.addFailure(self, sys.exc_info()) failure = self.result.failures[0][1] self.assertEqual(excValue, failure.value) self.assertEqual(self.failureException, failure.type) class ReporterRealtimeTests(TestResultTests): def setUp(self): output = StringIO() self.result = reporter.Reporter(output, realtime=True) class ErrorReportingTests(StringTest): doubleSeparator = re.compile(r"^=+$") def setUp(self): self.loader = runner.TestLoader() self.output = StringIO() self.result = reporter.Reporter(self.output) def getOutput(self, suite): result = self.getResult(suite) result.done() return self.output.getvalue() def getResult(self, suite): suite.run(self.result) return self.result def test_formatErroredMethod(self): """ A test method which runs and has an error recorded against it is reported in the output stream with the I{ERROR} tag along with a summary of what error was reported and the ID of the test. """ cls = erroneous.SynchronousTestFailureInSetUp suite = self.loader.loadClass(cls) output = self.getOutput(suite).splitlines() match = [ self.doubleSeparator, "[ERROR]", "Traceback (most recent call last):", re.compile(r"^\s+File .*erroneous\.py., line \d+, in setUp$"), re.compile(r"^\s+raise FoolishError." r".I am a broken setUp method..$"), ( "twisted.trial.test.erroneous.FoolishError: " "I am a broken setUp method" ), f"{cls.__module__}.{cls.__name__}.test_noop", ] self.stringComparison(match, output) def test_formatFailedMethod(self): """ A test method which runs and has a failure recorded against it is reported in the output stream with the I{FAIL} tag along with a summary of what failure was reported and the ID of the test. """ suite = self.loader.loadByName( "twisted.trial.test.erroneous.TestRegularFail.test_fail" ) output = self.getOutput(suite).splitlines() match = [ self.doubleSeparator, "[FAIL]", "Traceback (most recent call last):", re.compile(r"^\s+File .*erroneous\.py., line \d+, in test_fail$"), re.compile(r'^\s+self\.fail\("I fail"\)$'), "twisted.trial.unittest.FailTest: I fail", "twisted.trial.test.erroneous.TestRegularFail.test_fail", ] self.stringComparison(match, output) def test_doctestError(self): """ A problem encountered while running a doctest is reported in the output stream with a I{FAIL} or I{ERROR} tag along with a summary of what problem was encountered and the ID of the test. """ from twisted.trial.test import erroneous suite = unittest.decorate(self.loader.loadDoctests(erroneous), itrial.ITestCase) output = self.getOutput(suite) path = "twisted.trial.test.erroneous.unexpectedException" for substring in ["1/0", "ZeroDivisionError", "Exception raised:", path]: self.assertSubstring(substring, output) self.assertTrue( re.search("Fail(ed|ure in) example:", output), "Couldn't match 'Failure in example: ' " "or 'Failed example: '", ) expect = [self.doubleSeparator, re.compile(r"\[(ERROR|FAIL)\]")] self.stringComparison(expect, output.splitlines()) def test_hiddenException(self): """ Check that errors in C{DelayedCall}s get reported, even if the test already has a failure. Only really necessary for testing the deprecated style of tests that use iterate() directly. See L{erroneous.DelayedCall.testHiddenException} for more details. """ from twisted.internet import reactor if reflect.qual(reactor).startswith("twisted.internet.asyncioreactor"): raise self.skipTest( "This test does not work on the asyncio reactor, as the " "traceback comes from inside asyncio, not Twisted." ) test = erroneous.DelayedCall("testHiddenException") output = self.getOutput(test).splitlines() errorQual = qual(RuntimeError) match = [ self.doubleSeparator, "[FAIL]", "Traceback (most recent call last):", re.compile( r"^\s+File .*erroneous\.py., line \d+, in " "testHiddenException$" ), re.compile( r'^\s+self\.fail\("Deliberate failure to mask the ' r'hidden exception"\)$' ), "twisted.trial.unittest.FailTest: " "Deliberate failure to mask the hidden exception", "twisted.trial.test.erroneous.DelayedCall.testHiddenException", self.doubleSeparator, "[ERROR]", "Traceback (most recent call last):", re.compile(r"^\s+File .* in runUntilCurrent"), re.compile(r"^\s+.*"), re.compile(r'^\s+File .*erroneous\.py", line \d+, in go'), re.compile(r"^\s+raise RuntimeError\(self.hiddenExceptionMsg\)"), errorQual + ": something blew up", "twisted.trial.test.erroneous.DelayedCall.testHiddenException", ] self.stringComparison(match, output) class UncleanWarningWrapperErrorReportingTests(ErrorReportingTests): """ Tests that the L{UncleanWarningsReporterWrapper} can sufficiently proxy IReporter failure and error reporting methods to a L{reporter.Reporter}. """ def setUp(self): self.loader = runner.TestLoader() self.output = StringIO() self.result = UncleanWarningsReporterWrapper(reporter.Reporter(self.output)) class TracebackHandlingTests(unittest.SynchronousTestCase): def getErrorFrames(self, test): """ Run the given C{test}, make sure it fails and return the trimmed frames. @param test: The test case to run. @return: The C{list} of frames trimmed. """ stream = StringIO() result = reporter.Reporter(stream) test.run(result) bads = result.failures + result.errors self.assertEqual(len(bads), 1) self.assertEqual(bads[0][0], test) return result._trimFrames(bads[0][1].frames) def checkFrames(self, observedFrames, expectedFrames): for observed, expected in zip(observedFrames, expectedFrames): self.assertEqual(observed[0], expected[0]) observedSegs = os.path.splitext(observed[1])[0].split(os.sep) expectedSegs = expected[1].split("/") self.assertEqual(observedSegs[-len(expectedSegs) :], expectedSegs) self.assertEqual(len(observedFrames), len(expectedFrames)) def test_basic(self): test = erroneous.TestRegularFail("test_fail") frames = self.getErrorFrames(test) self.checkFrames(frames, [("test_fail", "twisted/trial/test/erroneous")]) def test_subroutine(self): test = erroneous.TestRegularFail("test_subfail") frames = self.getErrorFrames(test) self.checkFrames( frames, [ ("test_subfail", "twisted/trial/test/erroneous"), ("subroutine", "twisted/trial/test/erroneous"), ], ) def test_deferred(self): """ C{_trimFrames} removes traces of C{_runCallbacks} when getting an error in a callback returned by a C{TestCase} based test. """ test = erroneous.TestAsynchronousFail("test_fail") frames = self.getErrorFrames(test) self.checkFrames(frames, [("_later", "twisted/trial/test/erroneous")]) def test_noFrames(self): result = reporter.Reporter(None) self.assertEqual([], result._trimFrames([])) def test_oneFrame(self): result = reporter.Reporter(None) self.assertEqual(["fake frame"], result._trimFrames(["fake frame"])) def test_exception(self): """ C{_trimFrames} removes traces of C{runWithWarningsSuppressed} from C{utils} when a synchronous exception happens in a C{TestCase} based test. """ test = erroneous.TestAsynchronousFail("test_exception") frames = self.getErrorFrames(test) self.checkFrames(frames, [("test_exception", "twisted/trial/test/erroneous")]) class FormatFailuresTests(StringTest): def setUp(self): try: raise RuntimeError("foo") except RuntimeError: self.f = Failure() self.f.frames = [ ["foo", "foo/bar.py", 5, [("x", 5)], [("y", "orange")]], ["qux", "foo/bar.py", 10, [("a", "two")], [("b", "MCMXCIX")]], ] self.stream = StringIO() self.result = reporter.Reporter(self.stream) def test_formatDefault(self): tb = self.result._formatFailureTraceback(self.f) self.stringComparison( [ "Traceback (most recent call last):", ' File "foo/bar.py", line 5, in foo', re.compile(r"^\s*$"), ' File "foo/bar.py", line 10, in qux', re.compile(r"^\s*$"), "RuntimeError: foo", ], tb.splitlines(), ) def test_formatString(self): tb = """ File "twisted/trial/unittest.py", line 256, in failUnlessSubstring return self.failUnlessIn(substring, astring, msg) exceptions.TypeError: iterable argument required """ expected = """ File "twisted/trial/unittest.py", line 256, in failUnlessSubstring return self.failUnlessIn(substring, astring, msg) exceptions.TypeError: iterable argument required """ formatted = self.result._formatFailureTraceback(tb) self.assertEqual(expected, formatted) def test_mutation(self): frames = self.f.frames[:] # The call shouldn't mutate the frames. self.result._formatFailureTraceback(self.f) self.assertEqual(self.f.frames, frames) class PyunitNamesTests(unittest.SynchronousTestCase): def setUp(self): self.stream = StringIO() self.test = sample.PyunitTest("test_foo") def test_verboseReporter(self): result = reporter.VerboseTextReporter(self.stream) result.startTest(self.test) output = self.stream.getvalue() self.assertEqual(output, "twisted.trial.test.sample.PyunitTest.test_foo ... ") def test_treeReporter(self): result = reporter.TreeReporter(self.stream) result.startTest(self.test) output = self.stream.getvalue() output = output.splitlines()[-1].strip() self.assertEqual(output, result.getDescription(self.test) + " ...") def test_getDescription(self): result = reporter.TreeReporter(self.stream) output = result.getDescription(self.test) self.assertEqual(output, "test_foo") def test_minimalReporter(self): """ The summary of L{reporter.MinimalReporter} is a simple list of numbers, indicating how many tests ran, how many failed etc. The numbers represents: * the run time of the tests * the number of tests run, printed 2 times for legacy reasons * the number of errors * the number of failures * the number of skips """ result = reporter.MinimalReporter(self.stream) self.test.run(result) result._printSummary() output = self.stream.getvalue().strip().split(" ") self.assertEqual(output[1:], ["1", "1", "0", "0", "0"]) def test_minimalReporterTime(self): """ L{reporter.MinimalReporter} reports the time to run the tests as first data in its output. """ times = [1.0, 1.2, 1.5, 1.9] result = reporter.MinimalReporter(self.stream) result._getTime = lambda: times.pop(0) self.test.run(result) result._printSummary() output = self.stream.getvalue().strip().split(" ") timer = output[0] self.assertEqual(timer, "0.7") def test_emptyMinimalReporter(self): """ The summary of L{reporter.MinimalReporter} is a list of zeroes when no test is actually run. """ result = reporter.MinimalReporter(self.stream) result._printSummary() output = self.stream.getvalue().strip().split(" ") self.assertEqual(output, ["0", "0", "0", "0", "0", "0"]) class DirtyReactorTests(unittest.SynchronousTestCase): """ The trial script has an option to treat L{DirtyReactorAggregateError}s as warnings, as a migration tool for test authors. It causes a wrapper to be placed around reporters that replaces L{DirtyReactorAggregatErrors} with warnings. """ def setUp(self): self.dirtyError = Failure(util.DirtyReactorAggregateError(["foo"], ["bar"])) self.output = StringIO() self.test = DirtyReactorTests("test_errorByDefault") def test_errorByDefault(self): """ L{DirtyReactorAggregateError}s are reported as errors with the default Reporter. """ result = reporter.Reporter(stream=self.output) result.addError(self.test, self.dirtyError) self.assertEqual(len(result.errors), 1) self.assertEqual(result.errors[0][1], self.dirtyError) def test_warningsEnabled(self): """ L{DirtyReactorAggregateError}s are reported as warnings when using the L{UncleanWarningsReporterWrapper}. """ result = UncleanWarningsReporterWrapper(reporter.Reporter(stream=self.output)) self.assertWarns( UserWarning, self.dirtyError.getErrorMessage(), reporter.__file__, result.addError, self.test, self.dirtyError, ) def test_warningsMaskErrors(self): """ L{DirtyReactorAggregateError}s are I{not} reported as errors if the L{UncleanWarningsReporterWrapper} is used. """ result = UncleanWarningsReporterWrapper(reporter.Reporter(stream=self.output)) self.assertWarns( UserWarning, self.dirtyError.getErrorMessage(), reporter.__file__, result.addError, self.test, self.dirtyError, ) self.assertEqual(result._originalReporter.errors, []) def test_dealsWithThreeTuples(self): """ Some annoying stuff can pass three-tuples to addError instead of Failures (like PyUnit). The wrapper, of course, handles this case, since it is a part of L{twisted.trial.itrial.IReporter}! But it does not convert L{DirtyReactorAggregateError} to warnings in this case, because nobody should be passing those in the form of three-tuples. """ result = UncleanWarningsReporterWrapper(reporter.Reporter(stream=self.output)) result.addError(self.test, (self.dirtyError.type, self.dirtyError.value, None)) self.assertEqual(len(result._originalReporter.errors), 1) self.assertEqual( result._originalReporter.errors[0][1].type, self.dirtyError.type ) self.assertEqual( result._originalReporter.errors[0][1].value, self.dirtyError.value ) class TrialNamesTests(unittest.SynchronousTestCase): def setUp(self): self.stream = StringIO() self.test = sample.FooTest("test_foo") def test_verboseReporter(self): result = reporter.VerboseTextReporter(self.stream) result.startTest(self.test) output = self.stream.getvalue() self.assertEqual(output, self.test.id() + " ... ") def test_treeReporter(self): result = reporter.TreeReporter(self.stream) result.startTest(self.test) output = self.stream.getvalue() output = output.splitlines()[-1].strip() self.assertEqual(output, result.getDescription(self.test) + " ...") def test_treeReporterWithDocstrings(self): """A docstring""" result = reporter.TreeReporter(self.stream) self.assertEqual(result.getDescription(self), "test_treeReporterWithDocstrings") def test_getDescription(self): result = reporter.TreeReporter(self.stream) output = result.getDescription(self.test) self.assertEqual(output, "test_foo") class SkipTests(unittest.SynchronousTestCase): """ Tests for L{reporter.Reporter}'s handling of skips. """ def setUp(self): self.stream = StringIO() self.result = reporter.Reporter(self.stream) self.test = sample.FooTest("test_foo") def _getSkips(self, result): """ Get the number of skips that happened to a reporter. """ return len(result.skips) def test_accumulation(self): self.result.addSkip(self.test, "some reason") self.assertEqual(self._getSkips(self.result), 1) def test_success(self): self.result.addSkip(self.test, "some reason") self.assertEqual(True, self.result.wasSuccessful()) def test_summary(self): """ The summary of a successful run with skips indicates that the test suite passed and includes the number of skips. """ self.result.addSkip(self.test, "some reason") self.result.done() output = self.stream.getvalue().splitlines()[-1] prefix = "PASSED " self.assertTrue(output.startswith(prefix)) self.assertEqual(output[len(prefix) :].strip(), "(skips=1)") def test_basicErrors(self): """ The output at the end of a test run with skips includes the reasons for skipping those tests. """ self.result.addSkip(self.test, "some reason") self.result.done() output = self.stream.getvalue().splitlines()[3] self.assertEqual(output.strip(), "some reason") def test_booleanSkip(self): """ Tests can be skipped without specifying a reason by setting the 'skip' attribute to True. When this happens, the test output includes 'True' as the reason. """ self.result.addSkip(self.test, True) self.result.done() output = self.stream.getvalue().splitlines()[3] self.assertEqual(output, "True") def test_exceptionSkip(self): """ Skips can be raised as errors. When this happens, the error is included in the summary at the end of the test suite. """ try: 1 / 0 except Exception as e: error = e self.result.addSkip(self.test, error) self.result.done() output = "\n".join(self.stream.getvalue().splitlines()[3:5]).strip() self.assertEqual(output, str(error)) class UncleanWarningSkipTests(SkipTests): """ Tests for skips on a L{reporter.Reporter} wrapped by an L{UncleanWarningsReporterWrapper}. """ def setUp(self): SkipTests.setUp(self) self.result = UncleanWarningsReporterWrapper(self.result) def _getSkips(self, result): """ Get the number of skips that happened to a reporter inside of an unclean warnings reporter wrapper. """ return len(result._originalReporter.skips) class TodoTests(unittest.SynchronousTestCase): """ Tests for L{reporter.Reporter}'s handling of todos. """ def setUp(self): self.stream = StringIO() self.result = reporter.Reporter(self.stream) self.test = sample.FooTest("test_foo") def _getTodos(self, result): """ Get the expected failures that happened to a reporter. """ return result.expectedFailures def _getUnexpectedSuccesses(self, result): """ Get the unexpected successes that happened to a reporter. """ return result.unexpectedSuccesses def test_accumulation(self): """ L{reporter.Reporter} accumulates the expected failures that it is notified of. """ self.result.addExpectedFailure( self.test, Failure(Exception()), makeTodo("todo!") ) self.assertEqual(len(self._getTodos(self.result)), 1) def test_noTodoProvided(self): """ If no C{Todo} is provided to C{addExpectedFailure}, then L{reporter.Reporter} makes up a sensible default. This allows standard Python unittests to use Twisted reporters. """ failure = Failure(Exception()) self.result.addExpectedFailure(self.test, failure) [(test, error, todo)] = self._getTodos(self.result) self.assertEqual(test, self.test) self.assertEqual(error, failure) self.assertEqual(repr(todo), repr(makeTodo("Test expected to fail"))) def test_success(self): """ A test run is still successful even if there are expected failures. """ self.result.addExpectedFailure( self.test, Failure(Exception()), makeTodo("todo!") ) self.assertEqual(True, self.result.wasSuccessful()) def test_unexpectedSuccess(self): """ A test which is marked as todo but succeeds will have an unexpected success reported to its result. A test run is still successful even when this happens. """ self.result.addUnexpectedSuccess(self.test, makeTodo("Heya!")) self.assertEqual(True, self.result.wasSuccessful()) self.assertEqual(len(self._getUnexpectedSuccesses(self.result)), 1) def test_unexpectedSuccessNoTodo(self): """ A test which is marked as todo but succeeds will have an unexpected success reported to its result. A test run is still successful even when this happens. If no C{Todo} is provided, then we make up a sensible default. This allows standard Python unittests to use Twisted reporters. """ self.result.addUnexpectedSuccess(self.test) [(test, todo)] = self._getUnexpectedSuccesses(self.result) self.assertEqual(test, self.test) self.assertEqual(repr(todo), repr(makeTodo("Test expected to fail"))) def test_summary(self): """ The reporter's C{printSummary} method should print the number of expected failures that occurred. """ self.result.addExpectedFailure( self.test, Failure(Exception()), makeTodo("some reason") ) self.result.done() output = self.stream.getvalue().splitlines()[-1] prefix = "PASSED " self.assertTrue(output.startswith(prefix)) self.assertEqual(output[len(prefix) :].strip(), "(expectedFailures=1)") def test_basicErrors(self): """ The reporter's L{printErrors} method should include the value of the Todo. """ self.result.addExpectedFailure( self.test, Failure(Exception()), makeTodo("some reason") ) self.result.done() output = self.stream.getvalue().splitlines()[3].strip() self.assertEqual(output, "Reason: 'some reason'") def test_booleanTodo(self): """ Booleans CAN'T be used as the value of a todo. Maybe this sucks. This is a test for current behavior, not a requirement. """ self.result.addExpectedFailure(self.test, Failure(Exception()), True) self.assertRaises(Exception, self.result.done) def test_exceptionTodo(self): """ The exception for expected failures should be shown in the C{printErrors} output. """ try: 1 / 0 except Exception as e: error = e self.result.addExpectedFailure(self.test, Failure(error), makeTodo("todo!")) self.result.done() output = "\n".join(self.stream.getvalue().splitlines()[3:]).strip() self.assertTrue(str(error) in output) def test_standardLibraryCompatibilityFailure(self): """ Tests that use the standard library C{expectedFailure} feature worth with Trial reporters. """ class Test(StdlibTestCase): @expectedFailure def test_fail(self): self.fail("failure") test = Test("test_fail") test.run(self.result) self.assertEqual(len(self._getTodos(self.result)), 1) def test_standardLibraryCompatibilitySuccess(self): """ Tests that use the standard library C{expectedFailure} feature worth with Trial reporters. """ class Test(StdlibTestCase): @expectedFailure def test_success(self): pass test = Test("test_success") test.run(self.result) self.assertEqual(len(self._getUnexpectedSuccesses(self.result)), 1) class UncleanWarningTodoTests(TodoTests): """ Tests for L{UncleanWarningsReporterWrapper}'s handling of todos. """ def setUp(self): TodoTests.setUp(self) self.result = UncleanWarningsReporterWrapper(self.result) def _getTodos(self, result): """ Get the todos that happened to a reporter inside of an unclean warnings reporter wrapper. """ return result._originalReporter.expectedFailures def _getUnexpectedSuccesses(self, result): """ Get the number of unexpected successes that happened to a reporter inside of an unclean warnings reporter wrapper. """ return result._originalReporter.unexpectedSuccesses class MockColorizer: """ Used by TreeReporterTests to make sure that output is colored correctly. """ def __init__(self, stream): self.log = [] def write(self, text, color): self.log.append((color, text)) class TreeReporterTests(unittest.SynchronousTestCase): def setUp(self): self.test = sample.FooTest("test_foo") self.stream = StringIO() self.result = reporter.TreeReporter(self.stream) self.result._colorizer = MockColorizer(self.stream) self.log = self.result._colorizer.log def makeError(self): try: 1 / 0 except ZeroDivisionError: f = Failure() return f def test_summaryColoredSuccess(self): """ The summary in case of success should have a good count of successes and be colored properly. """ self.result.addSuccess(self.test) self.result.done() self.assertEqual(self.log[1], (self.result.SUCCESS, "PASSED")) self.assertEqual( self.stream.getvalue().splitlines()[-1].strip(), "(successes=1)" ) def test_summaryColoredFailure(self): """ The summary in case of failure should have a good count of errors and be colored properly. """ try: raise RuntimeError("foo") except RuntimeError: self.result.addError(self, sys.exc_info()) self.result.done() self.assertEqual(self.log[1], (self.result.FAILURE, "FAILED")) self.assertEqual(self.stream.getvalue().splitlines()[-1].strip(), "(errors=1)") def test_getPrelude(self): """ The tree needs to get the segments of the test ID that correspond to the module and class that it belongs to. """ self.assertEqual( ["foo.bar", "baz"], self.result._getPreludeSegments("foo.bar.baz.qux") ) self.assertEqual(["foo", "bar"], self.result._getPreludeSegments("foo.bar.baz")) self.assertEqual(["foo"], self.result._getPreludeSegments("foo.bar")) self.assertEqual([], self.result._getPreludeSegments("foo")) def test_groupResults(self): """ If two different tests have the same error, L{Reporter._groupResults} includes them together in one of the tuples in the list it returns. """ try: raise RuntimeError("foo") except RuntimeError: self.result.addError(self, sys.exc_info()) self.result.addError(self.test, sys.exc_info()) try: raise RuntimeError("bar") except RuntimeError: extra = sample.FooTest("test_bar") self.result.addError(extra, sys.exc_info()) self.result.done() grouped = self.result._groupResults( self.result.errors, self.result._formatFailureTraceback ) self.assertEqual(grouped[0][1], [self, self.test]) self.assertEqual(grouped[1][1], [extra]) def test_printResults(self): """ L{Reporter._printResults} uses the results list and formatter callable passed to it to produce groups of results to write to its output stream. """ def formatter(n): return str(n) + "\n" first = sample.FooTest("test_foo") second = sample.FooTest("test_bar") third = sample.PyunitTest("test_foo") self.result._printResults( "FOO", [(first, 1), (second, 1), (third, 2)], formatter ) self.assertEqual( self.stream.getvalue(), "%(double separator)s\n" "FOO\n" "1\n" "\n" "%(first)s\n" "%(second)s\n" "%(double separator)s\n" "FOO\n" "2\n" "\n" "%(third)s\n" % { "double separator": self.result._doubleSeparator, "first": first.id(), "second": second.id(), "third": third.id(), }, ) class ReporterInterfaceTests(unittest.SynchronousTestCase): """ Tests for the bare interface of a trial reporter. Subclass this test case and provide a different 'resultFactory' to test that a particular reporter implementation will work with the rest of Trial. @cvar resultFactory: A callable that returns a reporter to be tested. The callable must take the same parameters as L{reporter.Reporter}. """ resultFactory: Type[itrial.IReporter] = reporter.Reporter def setUp(self): self.test = sample.FooTest("test_foo") self.stream = StringIO() self.publisher = log.LogPublisher() self.result = self.resultFactory(self.stream, publisher=self.publisher) def test_shouldStopInitiallyFalse(self): """ shouldStop is False to begin with. """ self.assertEqual(False, self.result.shouldStop) def test_shouldStopTrueAfterStop(self): """ shouldStop becomes True soon as someone calls stop(). """ self.result.stop() self.assertEqual(True, self.result.shouldStop) def test_wasSuccessfulInitiallyTrue(self): """ wasSuccessful() is True when there have been no results reported. """ self.assertEqual(True, self.result.wasSuccessful()) def test_wasSuccessfulTrueAfterSuccesses(self): """ wasSuccessful() is True when there have been only successes, False otherwise. """ self.result.addSuccess(self.test) self.assertEqual(True, self.result.wasSuccessful()) def test_wasSuccessfulFalseAfterErrors(self): """ wasSuccessful() becomes False after errors have been reported. """ try: 1 / 0 except ZeroDivisionError: self.result.addError(self.test, sys.exc_info()) self.assertEqual(False, self.result.wasSuccessful()) def test_wasSuccessfulFalseAfterFailures(self): """ wasSuccessful() becomes False after failures have been reported. """ try: self.fail("foo") except self.failureException: self.result.addFailure(self.test, sys.exc_info()) self.assertEqual(False, self.result.wasSuccessful()) class ReporterTests(ReporterInterfaceTests): """ Tests for the base L{reporter.Reporter} class. """ def setUp(self): ReporterInterfaceTests.setUp(self) self._timer = 0 self.result._getTime = self._getTime def _getTime(self): self._timer += 1 return self._timer def test_startStop(self): self.result.startTest(self.test) self.result.stopTest(self.test) self.assertTrue(self.result._lastTime > 0) self.assertEqual(self.result.testsRun, 1) self.assertEqual(self.result.wasSuccessful(), True) def test_brokenStream(self): """ Test that the reporter safely writes to its stream. """ result = self.resultFactory(stream=BrokenStream(self.stream)) result._writeln("Hello") self.assertEqual(self.stream.getvalue(), "Hello\n") self.stream.truncate(0) self.stream.seek(0) result._writeln("Hello %s!", "World") self.assertEqual(self.stream.getvalue(), "Hello World!\n") def test_warning(self): """ L{reporter.Reporter} observes warnings emitted by the Twisted log system and writes them to its output stream. """ message = RuntimeWarning("some warning text") category = "exceptions.RuntimeWarning" filename = "path/to/some/file.py" lineno = 71 self.publisher.msg( warning=message, category=category, filename=filename, lineno=lineno ) self.assertEqual( self.stream.getvalue(), "%s:%d: %s: %s\n" % (filename, lineno, category.split(".")[-1], message), ) def test_duplicateWarningSuppressed(self): """ A warning emitted twice within a single test is only written to the stream once. """ # Emit the warning and assert that it shows up self.test_warning() # Emit the warning again and assert that the stream still only has one # warning on it. self.test_warning() def test_warningEmittedForNewTest(self): """ A warning emitted again after a new test has started is written to the stream again. """ test = self.__class__("test_warningEmittedForNewTest") self.result.startTest(test) # Clear whatever startTest wrote to the stream self.stream.seek(0) self.stream.truncate() # Emit a warning (and incidentally, assert that it was emitted) self.test_warning() # Clean up from the first warning to simplify the rest of the # assertions. self.stream.seek(0) self.stream.truncate() # Stop the first test and start another one (it just happens to be the # same one, but that doesn't matter) self.result.stopTest(test) self.result.startTest(test) # Clean up the stopTest/startTest output self.stream.seek(0) self.stream.truncate() # Emit the warning again and make sure it shows up self.test_warning() def test_stopObserving(self): """ L{reporter.Reporter} stops observing log events when its C{done} method is called. """ self.result.done() self.stream.seek(0) self.stream.truncate() self.publisher.msg( warning=RuntimeWarning("some message"), category="exceptions.RuntimeWarning", filename="file/name.py", lineno=17, ) self.assertEqual(self.stream.getvalue(), "") class SafeStreamTests(unittest.SynchronousTestCase): def test_safe(self): """ Test that L{reporter.SafeStream} successfully write to its original stream even if an interrupt happens during the write. """ stream = StringIO() broken = BrokenStream(stream) safe = reporter.SafeStream(broken) safe.write("Hello") self.assertEqual(stream.getvalue(), "Hello") class SubunitReporterTests(ReporterInterfaceTests): """ Tests for the subunit reporter. This just tests that the subunit reporter implements the basic interface. """ resultFactory: Type[itrial.IReporter] = reporter.SubunitReporter def setUp(self): if reporter.TestProtocolClient is None: raise SkipTest("Subunit not installed, cannot test SubunitReporter") self.test = sample.FooTest("test_foo") self.stream = BytesIO() self.publisher = log.LogPublisher() self.result = self.resultFactory(self.stream, publisher=self.publisher) def assertForwardsToSubunit(self, methodName, *args, **kwargs): """ Assert that 'methodName' on L{SubunitReporter} forwards to the equivalent method on subunit. Checks that the return value from subunit is returned from the L{SubunitReporter} and that the reporter writes the same data to its stream as subunit does to its own. Assumes that the method on subunit has the same name as the method on L{SubunitReporter}. """ stream = BytesIO() subunitClient = reporter.TestProtocolClient(stream) subunitReturn = getattr(subunitClient, methodName)(*args, **kwargs) subunitOutput = stream.getvalue() reporterReturn = getattr(self.result, methodName)(*args, **kwargs) self.assertEqual(subunitReturn, reporterReturn) self.assertEqual(subunitOutput, self.stream.getvalue()) def removeMethod(self, klass, methodName): """ Remove 'methodName' from 'klass'. If 'klass' does not have a method named 'methodName', then 'removeMethod' succeeds silently. If 'klass' does have a method named 'methodName', then it is removed using delattr. Also, methods of the same name are removed from all base classes of 'klass', thus removing the method entirely. @param klass: The class to remove the method from. @param methodName: The name of the method to remove. """ method = getattr(klass, methodName, None) if method is None: return for base in getmro(klass): try: delattr(base, methodName) except (AttributeError, TypeError): break else: self.addCleanup(setattr, base, methodName, method) def test_subunitWithoutAddExpectedFailureInstalled(self): """ Some versions of subunit don't have "addExpectedFailure". For these versions, we report expected failures as successes. """ self.removeMethod(reporter.TestProtocolClient, "addExpectedFailure") try: 1 / 0 except ZeroDivisionError: self.result.addExpectedFailure(self.test, sys.exc_info(), "todo") expectedFailureOutput = self.stream.getvalue() self.stream.truncate(0) self.stream.seek(0) self.result.addSuccess(self.test) successOutput = self.stream.getvalue() self.assertEqual(successOutput, expectedFailureOutput) def test_subunitWithoutAddSkipInstalled(self): """ Some versions of subunit don't have "addSkip". For these versions, we report skips as successes. """ self.removeMethod(reporter.TestProtocolClient, "addSkip") self.result.addSkip(self.test, "reason") skipOutput = self.stream.getvalue() self.stream.truncate(0) self.stream.seek(0) self.result.addSuccess(self.test) successOutput = self.stream.getvalue() self.assertEqual(successOutput, skipOutput) def test_addExpectedFailurePassedThrough(self): """ Some versions of subunit have "addExpectedFailure". For these versions, when we call 'addExpectedFailure' on the test result, we pass the error and test through to the subunit client. """ addExpectedFailureCalls = [] def addExpectedFailure(test, error): addExpectedFailureCalls.append((test, error)) # Provide our own addExpectedFailure, whether or not the locally # installed subunit has addExpectedFailure. self.result._subunit.addExpectedFailure = addExpectedFailure try: 1 / 0 except ZeroDivisionError: exc_info = sys.exc_info() self.result.addExpectedFailure(self.test, exc_info, "todo") self.assertEqual(addExpectedFailureCalls, [(self.test, exc_info)]) def test_addSkipSendsSubunitAddSkip(self): """ Some versions of subunit have "addSkip". For these versions, when we call 'addSkip' on the test result, we pass the test and reason through to the subunit client. """ addSkipCalls = [] def addSkip(test, reason): addSkipCalls.append((test, reason)) # Provide our own addSkip, whether or not the locally-installed # subunit has addSkip. self.result._subunit.addSkip = addSkip self.result.addSkip(self.test, "reason") self.assertEqual(addSkipCalls, [(self.test, "reason")]) def test_doneDoesNothing(self): """ The subunit reporter doesn't need to print out a summary -- the stream of results is everything. Thus, done() does nothing. """ self.result.done() self.assertEqual(b"", self.stream.getvalue()) def test_startTestSendsSubunitStartTest(self): """ SubunitReporter.startTest() sends the subunit 'startTest' message. """ self.assertForwardsToSubunit("startTest", self.test) def test_stopTestSendsSubunitStopTest(self): """ SubunitReporter.stopTest() sends the subunit 'stopTest' message. """ self.assertForwardsToSubunit("stopTest", self.test) def test_addSuccessSendsSubunitAddSuccess(self): """ SubunitReporter.addSuccess() sends the subunit 'addSuccess' message. """ self.assertForwardsToSubunit("addSuccess", self.test) def test_addErrorSendsSubunitAddError(self): """ SubunitReporter.addError() sends the subunit 'addError' message. """ try: 1 / 0 except ZeroDivisionError: error = sys.exc_info() self.assertForwardsToSubunit("addError", self.test, error) def test_addFailureSendsSubunitAddFailure(self): """ SubunitReporter.addFailure() sends the subunit 'addFailure' message. """ try: self.fail("hello") except self.failureException: failure = sys.exc_info() self.assertForwardsToSubunit("addFailure", self.test, failure) def test_addUnexpectedSuccessSendsSubunitAddSuccess(self): """ SubunitReporter.addFailure() sends the subunit 'addSuccess' message, since subunit doesn't model unexpected success. """ stream = BytesIO() subunitClient = reporter.TestProtocolClient(stream) subunitClient.addSuccess(self.test) subunitOutput = stream.getvalue() self.result.addUnexpectedSuccess(self.test) self.assertEqual(subunitOutput, self.stream.getvalue()) def test_loadTimeErrors(self): """ Load-time errors are reported like normal errors. """ test = runner.TestLoader().loadByName("doesntexist") test.run(self.result) output = self.stream.getvalue() # Just check that 'doesntexist' is in the output, rather than # assembling the expected stack trace. self.assertIn(b"doesntexist", output) class SubunitReporterNotInstalledTests(unittest.SynchronousTestCase): """ Test behaviour when the subunit reporter is not installed. """ def test_subunitNotInstalled(self): """ If subunit is not installed, TestProtocolClient will be None, and SubunitReporter will raise an error when you try to construct it. """ stream = StringIO() self.patch(reporter, "TestProtocolClient", None) e = self.assertRaises(Exception, reporter.SubunitReporter, stream) self.assertEqual("Subunit not available", str(e)) class TimingReporterTests(ReporterTests): resultFactory: Type[itrial.IReporter] = reporter.TimingTextReporter class LoggingReporter(reporter.Reporter): """ Simple reporter that stores the last test that was passed to it. """ def __init__(self, *args, **kwargs): reporter.Reporter.__init__(self, *args, **kwargs) self.test = None def addError(self, test, error): self.test = test def addExpectedFailure(self, test, failure, todo=None): self.test = test def addFailure(self, test, failure): self.test = test def addSkip(self, test, skip): self.test = test def addUnexpectedSuccess(self, test, todo=None): self.test = test def startTest(self, test): self.test = test def stopTest(self, test): self.test = test class AdaptedReporterTests(unittest.SynchronousTestCase): """ L{reporter._AdaptedReporter} is a reporter wrapper that wraps all of the tests it receives before passing them on to the original reporter. """ def setUp(self): self.wrappedResult = self.getWrappedResult() def _testAdapter(self, test): return test.id() def assertWrapped(self, wrappedResult, test): self.assertEqual(wrappedResult._originalReporter.test, self._testAdapter(test)) def getFailure(self, exceptionInstance): """ Return a L{Failure} from raising the given exception. @param exceptionInstance: The exception to raise. @return: L{Failure} """ try: raise exceptionInstance except BaseException: return Failure() def getWrappedResult(self): result = LoggingReporter() return reporter._AdaptedReporter(result, self._testAdapter) def test_addError(self): """ C{addError} wraps its test with the provided adapter. """ self.wrappedResult.addError(self, self.getFailure(RuntimeError())) self.assertWrapped(self.wrappedResult, self) def test_addFailure(self): """ C{addFailure} wraps its test with the provided adapter. """ self.wrappedResult.addFailure(self, self.getFailure(AssertionError())) self.assertWrapped(self.wrappedResult, self) def test_addSkip(self): """ C{addSkip} wraps its test with the provided adapter. """ self.wrappedResult.addSkip(self, self.getFailure(SkipTest("no reason"))) self.assertWrapped(self.wrappedResult, self) def test_startTest(self): """ C{startTest} wraps its test with the provided adapter. """ self.wrappedResult.startTest(self) self.assertWrapped(self.wrappedResult, self) def test_stopTest(self): """ C{stopTest} wraps its test with the provided adapter. """ self.wrappedResult.stopTest(self) self.assertWrapped(self.wrappedResult, self) def test_addExpectedFailure(self): """ C{addExpectedFailure} wraps its test with the provided adapter. """ self.wrappedResult.addExpectedFailure( self, self.getFailure(RuntimeError()), Todo("no reason") ) self.assertWrapped(self.wrappedResult, self) def test_expectedFailureWithoutTodo(self): """ C{addExpectedFailure} works without a C{Todo}. """ self.wrappedResult.addExpectedFailure(self, self.getFailure(RuntimeError())) self.assertWrapped(self.wrappedResult, self) def test_addUnexpectedSuccess(self): """ C{addUnexpectedSuccess} wraps its test with the provided adapter. """ self.wrappedResult.addUnexpectedSuccess(self, Todo("no reason")) self.assertWrapped(self.wrappedResult, self) def test_unexpectedSuccessWithoutTodo(self): """ C{addUnexpectedSuccess} works without a C{Todo}. """ self.wrappedResult.addUnexpectedSuccess(self) self.assertWrapped(self.wrappedResult, self) class FakeStream: """ A fake stream which C{isatty} method returns some predictable. @ivar tty: returned value of C{isatty}. @type tty: C{bool} """ def __init__(self, tty=True): self.tty = tty def isatty(self): return self.tty class AnsiColorizerTests(unittest.SynchronousTestCase): """ Tests for L{reporter._AnsiColorizer}. """ def setUp(self): self.savedModules = sys.modules.copy() def tearDown(self): sys.modules.clear() sys.modules.update(self.savedModules) def test_supportedStdOutTTY(self): """ L{reporter._AnsiColorizer.supported} returns C{False} if the given stream is not a TTY. """ self.assertFalse(reporter._AnsiColorizer.supported(FakeStream(False))) def test_supportedNoCurses(self): """ L{reporter._AnsiColorizer.supported} returns C{False} if the curses module can't be imported. """ sys.modules["curses"] = None self.assertFalse(reporter._AnsiColorizer.supported(FakeStream())) def test_supportedSetupTerm(self): """ L{reporter._AnsiColorizer.supported} returns C{True} if C{curses.tigetnum} returns more than 2 supported colors. It only tries to call C{curses.setupterm} if C{curses.tigetnum} previously failed with a C{curses.error}. """ class fakecurses: error = RuntimeError setUp = 0 def setupterm(self): self.setUp += 1 def tigetnum(self, value): if self.setUp: return 3 else: raise self.error() sys.modules["curses"] = fakecurses() self.assertTrue(reporter._AnsiColorizer.supported(FakeStream())) self.assertTrue(reporter._AnsiColorizer.supported(FakeStream())) self.assertEqual(sys.modules["curses"].setUp, 1) def test_supportedTigetNumWrongError(self): """ L{reporter._AnsiColorizer.supported} returns C{False} and doesn't try to call C{curses.setupterm} if C{curses.tigetnum} returns something different than C{curses.error}. """ class fakecurses: error = RuntimeError def tigetnum(self, value): raise ValueError() sys.modules["curses"] = fakecurses() self.assertFalse(reporter._AnsiColorizer.supported(FakeStream())) def test_supportedTigetNumNotEnoughColor(self): """ L{reporter._AnsiColorizer.supported} returns C{False} if C{curses.tigetnum} returns less than 2 supported colors. """ class fakecurses: error = RuntimeError def tigetnum(self, value): return 1 sys.modules["curses"] = fakecurses() self.assertFalse(reporter._AnsiColorizer.supported(FakeStream())) def test_supportedTigetNumErrors(self): """ L{reporter._AnsiColorizer.supported} returns C{False} if C{curses.tigetnum} raises an error, and calls C{curses.setupterm} once. """ class fakecurses: error = RuntimeError setUp = 0 def setupterm(self): self.setUp += 1 def tigetnum(self, value): raise self.error() sys.modules["curses"] = fakecurses() self.assertFalse(reporter._AnsiColorizer.supported(FakeStream())) self.assertEqual(sys.modules["curses"].setUp, 1) class ExitWrapperTests(unittest.SynchronousTestCase): """ Tests for L{reporter._ExitWrapper}. """ def setUp(self): self.failure = Failure(Exception("I am a Failure")) self.test = sample.FooTest("test_foo") self.result = reporter.TestResult() self.wrapped = _ExitWrapper(self.result) self.assertFalse(self.wrapped.shouldStop) def test_stopOnFailure(self): """ L{reporter._ExitWrapper} causes a wrapped reporter to stop after its first failure. """ self.wrapped.addFailure(self.test, self.failure) self.assertTrue(self.wrapped.shouldStop) self.assertEqual(self.result.failures, [(self.test, self.failure)]) def test_stopOnError(self): """ L{reporter._ExitWrapper} causes a wrapped reporter to stop after its first error. """ self.wrapped.addError(self.test, self.failure) self.assertTrue(self.wrapped.shouldStop) self.assertEqual(self.result.errors, [(self.test, self.failure)]) def test_doesNotStopOnUnexpectedSuccess(self): """ L{reporter._ExitWrapper} does not cause a wrapped reporter to stop after an unexpected success. """ self.wrapped.addUnexpectedSuccess(self.test, self.failure) self.assertFalse(self.wrapped.shouldStop) self.assertEqual(self.result.unexpectedSuccesses, [(self.test, self.failure)]) PK b�Z�� �. . test/moduletest.pynu �[��� # -*- test-case-name: twisted.trial.test.test_log -*- # fodder for test_script, which parses files for emacs local variable # declarations. This one is supposed to have: # test-case-name: twisted.trial.test.test_log. # in the first line # The class declaration is irrelevant class Foo: pass PK b�Z�?\$ $ test/sample.pynu �[��� """This module is used by test_loader to test the Trial test loading functionality. Do NOT change the number of tests in this module. Do NOT change the names the tests in this module. """ import unittest as pyunit from twisted.python.util import mergeFunctionMetadata from twisted.trial import unittest class FooTest(unittest.SynchronousTestCase): def test_foo(self): pass def test_bar(self): pass def badDecorator(fn): """ Decorate a function without preserving the name of the original function. Always return a function with the same name. """ def nameCollision(*args, **kwargs): return fn(*args, **kwargs) return nameCollision def goodDecorator(fn): """ Decorate a function and preserve the original name. """ def nameCollision(*args, **kwargs): return fn(*args, **kwargs) return mergeFunctionMetadata(fn, nameCollision) class DecorationTest(unittest.SynchronousTestCase): def test_badDecorator(self): """ This test method is decorated in a way that gives it a confusing name that collides with another method. """ test_badDecorator = badDecorator(test_badDecorator) def test_goodDecorator(self): """ This test method is decorated in a way that preserves its name. """ test_goodDecorator = goodDecorator(test_goodDecorator) def renamedDecorator(self): """ This is secretly a test method and will be decorated and then renamed so test discovery can find it. """ test_renamedDecorator = goodDecorator(renamedDecorator) def nameCollision(self): """ This isn't a test, it's just here to collide with tests. """ class PyunitTest(pyunit.TestCase): def test_foo(self): pass def test_bar(self): pass class NotATest: def test_foo(self): pass class AlphabetTest(unittest.SynchronousTestCase): def test_a(self): pass def test_b(self): pass def test_c(self): pass PK b�Z�vOv" v" test/test_deferred.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for returning Deferreds from a TestCase. """ import unittest as pyunit from twisted.internet import defer from twisted.trial import reporter, unittest, util from twisted.trial.test import detests class SetUpTests(unittest.TestCase): def _loadSuite(self, klass): loader = pyunit.TestLoader() r = reporter.TestResult() s = loader.loadTestsFromTestCase(klass) return r, s def test_success(self): result, suite = self._loadSuite(detests.DeferredSetUpOK) suite(result) self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) def test_fail(self): self.assertFalse(detests.DeferredSetUpFail.testCalled) result, suite = self._loadSuite(detests.DeferredSetUpFail) suite(result) self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.errors), 1) self.assertFalse(detests.DeferredSetUpFail.testCalled) def test_callbackFail(self): self.assertFalse(detests.DeferredSetUpCallbackFail.testCalled) result, suite = self._loadSuite(detests.DeferredSetUpCallbackFail) suite(result) self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.errors), 1) self.assertFalse(detests.DeferredSetUpCallbackFail.testCalled) def test_error(self): self.assertFalse(detests.DeferredSetUpError.testCalled) result, suite = self._loadSuite(detests.DeferredSetUpError) suite(result) self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.errors), 1) self.assertFalse(detests.DeferredSetUpError.testCalled) def test_skip(self): self.assertFalse(detests.DeferredSetUpSkip.testCalled) result, suite = self._loadSuite(detests.DeferredSetUpSkip) suite(result) self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.errors), 0) self.assertEqual(len(result.skips), 1) self.assertFalse(detests.DeferredSetUpSkip.testCalled) class NeverFireTests(unittest.TestCase): def setUp(self): self._oldTimeout = util.DEFAULT_TIMEOUT_DURATION util.DEFAULT_TIMEOUT_DURATION = 0.1 def tearDown(self): util.DEFAULT_TIMEOUT_DURATION = self._oldTimeout def _loadSuite(self, klass): loader = pyunit.TestLoader() r = reporter.TestResult() s = loader.loadTestsFromTestCase(klass) return r, s def test_setUp(self): self.assertFalse(detests.DeferredSetUpNeverFire.testCalled) result, suite = self._loadSuite(detests.DeferredSetUpNeverFire) suite(result) self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.errors), 1) self.assertFalse(detests.DeferredSetUpNeverFire.testCalled) self.assertTrue(result.errors[0][1].check(defer.TimeoutError)) class TestTester(unittest.TestCase): def getTest(self, name): raise NotImplementedError("must override me") def runTest(self, name): result = reporter.TestResult() self.getTest(name).run(result) return result class DeferredTests(TestTester): def getTest(self, name): return detests.DeferredTests(name) def test_pass(self): result = self.runTest("test_pass") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) def test_passGenerated(self): result = self.runTest("test_passGenerated") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertTrue(detests.DeferredTests.touched) test_passGenerated.supress = [ # type: ignore[attr-defined] util.suppress(message="twisted.internet.defer.deferredGenerator is deprecated") ] def test_passInlineCallbacks(self): """ The body of a L{defer.inlineCallbacks} decorated test gets run. """ result = self.runTest("test_passInlineCallbacks") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertTrue(detests.DeferredTests.touched) def test_fail(self): result = self.runTest("test_fail") self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.failures), 1) def test_failureInCallback(self): result = self.runTest("test_failureInCallback") self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.failures), 1) def test_errorInCallback(self): result = self.runTest("test_errorInCallback") self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.errors), 1) def test_skip(self): result = self.runTest("test_skip") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.skips), 1) self.assertFalse(detests.DeferredTests.touched) def test_todo(self): result = self.runTest("test_expectedFailure") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.errors), 0) self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.expectedFailures), 1) def test_thread(self): result = self.runTest("test_thread") self.assertEqual(result.testsRun, 1) self.assertTrue(result.wasSuccessful(), result.errors) class TimeoutTests(TestTester): def getTest(self, name): return detests.TimeoutTests(name) def _wasTimeout(self, error): self.assertEqual(error.check(defer.TimeoutError), defer.TimeoutError) def test_pass(self): result = self.runTest("test_pass") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) def test_passDefault(self): result = self.runTest("test_passDefault") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) def test_timeout(self): result = self.runTest("test_timeout") self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.errors), 1) self._wasTimeout(result.errors[0][1]) def test_timeoutZero(self): result = self.runTest("test_timeoutZero") self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.errors), 1) self._wasTimeout(result.errors[0][1]) def test_skip(self): result = self.runTest("test_skip") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.skips), 1) def test_todo(self): result = self.runTest("test_expectedFailure") self.assertTrue(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self.assertEqual(len(result.expectedFailures), 1) self._wasTimeout(result.expectedFailures[0][1]) def test_errorPropagation(self): result = self.runTest("test_errorPropagation") self.assertFalse(result.wasSuccessful()) self.assertEqual(result.testsRun, 1) self._wasTimeout(detests.TimeoutTests.timedOut) def test_classTimeout(self): loader = pyunit.TestLoader() suite = loader.loadTestsFromTestCase(detests.TestClassTimeoutAttribute) result = reporter.TestResult() suite.run(result) self.assertEqual(len(result.errors), 1) self._wasTimeout(result.errors[0][1]) def test_callbackReturnsNonCallingDeferred(self): # hacky timeout # raises KeyboardInterrupt because Trial sucks from twisted.internet import reactor call = reactor.callLater(2, reactor.crash) result = self.runTest("test_calledButNeverCallback") if call.active(): call.cancel() self.assertFalse(result.wasSuccessful()) self._wasTimeout(result.errors[0][1]) # The test loader erroneously attempts to run this: del TestTester PK b�Z�=`\�D �D test/test_warning.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for Trial's interaction with the Python warning system. """ import sys import warnings from io import StringIO from unittest import TestResult from twisted.python.filepath import FilePath from twisted.trial._synctest import _collectWarnings, _setWarningRegistryToNone from twisted.trial.unittest import SynchronousTestCase class Mask: """ Hide a test case definition from trial's automatic discovery mechanism. """ class MockTests(SynchronousTestCase): """ A test case which is used by L{FlushWarningsTests} to verify behavior which cannot be verified by code inside a single test method. """ message = "some warning text" category = UserWarning def test_unflushed(self): """ Generate a warning and don't flush it. """ warnings.warn(self.message, self.category) def test_flushed(self): """ Generate a warning and flush it. """ warnings.warn(self.message, self.category) self.assertEqual(len(self.flushWarnings()), 1) class FlushWarningsTests(SynchronousTestCase): """ Tests for C{flushWarnings}, an API for examining the warnings emitted so far in a test. """ def assertDictSubset(self, set, subset): """ Assert that all the keys present in C{subset} are also present in C{set} and that the corresponding values are equal. """ for k, v in subset.items(): self.assertEqual(set[k], v) def assertDictSubsets(self, sets, subsets): """ For each pair of corresponding elements in C{sets} and C{subsets}, assert that the element from C{subsets} is a subset of the element from C{sets}. """ self.assertEqual(len(sets), len(subsets)) for a, b in zip(sets, subsets): self.assertDictSubset(a, b) def test_none(self): """ If no warnings are emitted by a test, C{flushWarnings} returns an empty list. """ self.assertEqual(self.flushWarnings(), []) def test_several(self): """ If several warnings are emitted by a test, C{flushWarnings} returns a list containing all of them. """ firstMessage = "first warning message" firstCategory = UserWarning warnings.warn(message=firstMessage, category=firstCategory) secondMessage = "second warning message" secondCategory = RuntimeWarning warnings.warn(message=secondMessage, category=secondCategory) self.assertDictSubsets( self.flushWarnings(), [ {"category": firstCategory, "message": firstMessage}, {"category": secondCategory, "message": secondMessage}, ], ) def test_repeated(self): """ The same warning triggered twice from the same place is included twice in the list returned by C{flushWarnings}. """ message = "the message" category = RuntimeWarning for i in range(2): warnings.warn(message=message, category=category) self.assertDictSubsets( self.flushWarnings(), [{"category": category, "message": message}] * 2 ) def test_cleared(self): """ After a particular warning event has been returned by C{flushWarnings}, it is not returned by subsequent calls. """ message = "the message" category = RuntimeWarning warnings.warn(message=message, category=category) self.assertDictSubsets( self.flushWarnings(), [{"category": category, "message": message}] ) self.assertEqual(self.flushWarnings(), []) def test_unflushed(self): """ Any warnings emitted by a test which are not flushed are emitted to the Python warning system. """ result = TestResult() case = Mask.MockTests("test_unflushed") case.run(result) warningsShown = self.flushWarnings([Mask.MockTests.test_unflushed]) self.assertEqual(warningsShown[0]["message"], "some warning text") self.assertIdentical(warningsShown[0]["category"], UserWarning) where = type(case).test_unflushed.__code__ filename = where.co_filename # If someone edits MockTests.test_unflushed, the value added to # firstlineno might need to change. lineno = where.co_firstlineno + 4 self.assertEqual(warningsShown[0]["filename"], filename) self.assertEqual(warningsShown[0]["lineno"], lineno) self.assertEqual(len(warningsShown), 1) def test_flushed(self): """ Any warnings emitted by a test which are flushed are not emitted to the Python warning system. """ result = TestResult() case = Mask.MockTests("test_flushed") output = StringIO() monkey = self.patch(sys, "stdout", output) case.run(result) monkey.restore() self.assertEqual(output.getvalue(), "") def test_warningsConfiguredAsErrors(self): """ If a warnings filter has been installed which turns warnings into exceptions, tests have an error added to the reporter for them for each unflushed warning. """ class CustomWarning(Warning): pass result = TestResult() case = Mask.MockTests("test_unflushed") case.category = CustomWarning originalWarnings = warnings.filters[:] try: warnings.simplefilter("error") case.run(result) self.assertEqual(len(result.errors), 1) self.assertIdentical(result.errors[0][0], case) self.assertTrue( # Different python versions differ in whether they report the # fully qualified class name or just the class name. result.errors[0][1] .splitlines()[-1] .endswith("CustomWarning: some warning text") ) finally: warnings.filters[:] = originalWarnings def test_flushedWarningsConfiguredAsErrors(self): """ If a warnings filter has been installed which turns warnings into exceptions, tests which emit those warnings but flush them do not have an error added to the reporter. """ class CustomWarning(Warning): pass result = TestResult() case = Mask.MockTests("test_flushed") case.category = CustomWarning originalWarnings = warnings.filters[:] try: warnings.simplefilter("error") case.run(result) self.assertEqual(result.errors, []) finally: warnings.filters[:] = originalWarnings def test_multipleFlushes(self): """ Any warnings emitted after a call to C{flushWarnings} can be flushed by another call to C{flushWarnings}. """ warnings.warn("first message") self.assertEqual(len(self.flushWarnings()), 1) warnings.warn("second message") self.assertEqual(len(self.flushWarnings()), 1) def test_filterOnOffendingFunction(self): """ The list returned by C{flushWarnings} includes only those warnings which refer to the source of the function passed as the value for C{offendingFunction}, if a value is passed for that parameter. """ firstMessage = "first warning text" firstCategory = UserWarning def one(): warnings.warn(firstMessage, firstCategory, stacklevel=1) secondMessage = "some text" secondCategory = RuntimeWarning def two(): warnings.warn(secondMessage, secondCategory, stacklevel=1) one() two() self.assertDictSubsets( self.flushWarnings(offendingFunctions=[one]), [{"category": firstCategory, "message": firstMessage}], ) self.assertDictSubsets( self.flushWarnings(offendingFunctions=[two]), [{"category": secondCategory, "message": secondMessage}], ) def test_functionBoundaries(self): """ Verify that warnings emitted at the very edges of a function are still determined to be emitted from that function. """ def warner(): warnings.warn("first line warning") warnings.warn("internal line warning") warnings.warn("last line warning") warner() self.assertEqual(len(self.flushWarnings(offendingFunctions=[warner])), 3) def test_invalidFilter(self): """ If an object which is neither a function nor a method is included in the C{offendingFunctions} list, C{flushWarnings} raises L{ValueError}. Such a call flushes no warnings. """ warnings.warn("oh no") self.assertRaises(ValueError, self.flushWarnings, [None]) self.assertEqual(len(self.flushWarnings()), 1) def test_missingSource(self): """ Warnings emitted by a function the source code of which is not available can still be flushed. """ package = FilePath(self.mktemp().encode("utf-8")).child( b"twisted_private_helper" ) package.makedirs() package.child(b"__init__.py").setContent(b"") package.child(b"missingsourcefile.py").setContent( b""" import warnings def foo(): warnings.warn("oh no") """ ) pathEntry = package.parent().path.decode("utf-8") sys.path.insert(0, pathEntry) self.addCleanup(sys.path.remove, pathEntry) from twisted_private_helper import missingsourcefile # type: ignore[import] self.addCleanup(sys.modules.pop, "twisted_private_helper") self.addCleanup(sys.modules.pop, missingsourcefile.__name__) package.child(b"missingsourcefile.py").remove() missingsourcefile.foo() self.assertEqual(len(self.flushWarnings([missingsourcefile.foo])), 1) def test_renamedSource(self): """ Warnings emitted by a function defined in a file which has been renamed since it was initially compiled can still be flushed. This is testing the code which specifically supports working around the unfortunate behavior of CPython to write a .py source file name into the .pyc files it generates and then trust that it is correct in various places. If source files are renamed, .pyc files may not be regenerated, but they will contain incorrect filenames. """ package = FilePath(self.mktemp().encode("utf-8")).child( b"twisted_private_helper" ) package.makedirs() package.child(b"__init__.py").setContent(b"") package.child(b"module.py").setContent( b""" import warnings def foo(): warnings.warn("oh no") """ ) pathEntry = package.parent().path.decode("utf-8") sys.path.insert(0, pathEntry) self.addCleanup(sys.path.remove, pathEntry) # Import it to cause pycs to be generated from twisted_private_helper import module # Clean up the state resulting from that import; we're not going to use # this module, so it should go away. del sys.modules["twisted_private_helper"] del sys.modules[module.__name__] # Some Python versions have extra state related to the just # imported/renamed package. Clean it up too. See also # http://bugs.python.org/issue15912 try: from importlib import invalidate_caches except ImportError: pass else: invalidate_caches() # Rename the source directory package.moveTo(package.sibling(b"twisted_renamed_helper")) # Import the newly renamed version from twisted_renamed_helper import module # type: ignore[import] self.addCleanup(sys.modules.pop, "twisted_renamed_helper") self.addCleanup(sys.modules.pop, module.__name__) # Generate the warning module.foo() # Flush it self.assertEqual(len(self.flushWarnings([module.foo])), 1) def test_offendingFunctions_deep_branch(self): """ In Python 3.6 the dis.findlinestarts documented behaviour was changed such that the reported lines might not be sorted ascending. In Python 3.10 PEP 626 introduced byte-code change such that the last line of a function wasn't always associated with the last byte-code. In the past flushWarning was not detecting that such a function was associated with any warnings. """ def foo(a=1, b=1): if a: if b: warnings.warn("oh no") else: pass # Generate the warning foo() # Flush it self.assertEqual(len(self.flushWarnings([foo])), 1) class FakeWarning(Warning): pass class CollectWarningsTests(SynchronousTestCase): """ Tests for L{_collectWarnings}. """ def test_callsObserver(self): """ L{_collectWarnings} calls the observer with each emitted warning. """ firstMessage = "dummy calls observer warning" secondMessage = firstMessage[::-1] thirdMessage = Warning(1, 2, 3) events = [] def f(): events.append("call") warnings.warn(firstMessage) warnings.warn(secondMessage) warnings.warn(thirdMessage) events.append("returning") _collectWarnings(events.append, f) self.assertEqual(events[0], "call") self.assertEqual(events[1].message, firstMessage) self.assertEqual(events[2].message, secondMessage) self.assertEqual(events[3].message, str(thirdMessage)) self.assertEqual(events[4], "returning") self.assertEqual(len(events), 5) def test_suppresses(self): """ Any warnings emitted by a call to a function passed to L{_collectWarnings} are not actually emitted to the warning system. """ output = StringIO() self.patch(sys, "stdout", output) _collectWarnings(lambda x: None, warnings.warn, "text") self.assertEqual(output.getvalue(), "") def test_callsFunction(self): """ L{_collectWarnings} returns the result of calling the callable passed to it with the parameters given. """ arguments = [] value = object() def f(*args, **kwargs): arguments.append((args, kwargs)) return value result = _collectWarnings(lambda x: None, f, 1, "a", b=2, c="d") self.assertEqual(arguments, [((1, "a"), {"b": 2, "c": "d"})]) self.assertIdentical(result, value) def test_duplicateWarningCollected(self): """ Subsequent emissions of a warning from a particular source site can be collected by L{_collectWarnings}. In particular, the per-module emitted-warning cache should be bypassed (I{__warningregistry__}). """ # Make sure the worst case is tested: if __warningregistry__ isn't in a # module's globals, then the warning system will add it and start using # it to avoid emitting duplicate warnings. Delete __warningregistry__ # to ensure that even modules which are first imported as a test is # running still interact properly with the warning system. global __warningregistry__ del __warningregistry__ def f(): warnings.warn("foo") warnings.simplefilter("default") f() events = [] _collectWarnings(events.append, f) self.assertEqual(len(events), 1) self.assertEqual(events[0].message, "foo") self.assertEqual(len(self.flushWarnings()), 1) def test_immutableObject(self): """ L{_collectWarnings}'s behavior is not altered by the presence of an object which cannot have attributes set on it as a value in C{sys.modules}. """ key = object() sys.modules[key] = key self.addCleanup(sys.modules.pop, key) self.test_duplicateWarningCollected() def test_setWarningRegistryChangeWhileIterating(self): """ If the dictionary passed to L{_setWarningRegistryToNone} changes size partway through the process, C{_setWarningRegistryToNone} continues to set C{__warningregistry__} to L{None} on the rest of the values anyway. This might be caused by C{sys.modules} containing something that's not really a module and imports things on setattr. py.test does this, as does L{twisted.python.deprecate.deprecatedModuleAttribute}. """ d = {} class A: def __init__(self, key): self.__dict__["_key"] = key def __setattr__(self, value, item): d[self._key] = None key1 = object() key2 = object() d[key1] = A(key2) key3 = object() key4 = object() d[key3] = A(key4) _setWarningRegistryToNone(d) # If both key2 and key4 were added, then both A instanced were # processed. self.assertEqual({key1, key2, key3, key4}, set(d.keys())) PK b�Z � test/test_suppression.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for warning suppression features of Trial. """ import unittest as pyunit from twisted.python.reflect import namedAny from twisted.trial import unittest from twisted.trial.test import suppression class SuppressionMixin: """ Tests for the warning suppression features of L{twisted.trial.unittest.SynchronousTestCase}. """ def runTests(self, suite): suite.run(pyunit.TestResult()) def _load(self, cls, methodName): """ Return a new L{unittest.TestSuite} with a single test method in it. @param cls: A L{TestCase} subclass defining a test method. @param methodName: The name of the test method from C{cls}. """ return pyunit.TestSuite([cls(methodName)]) def _assertWarnings(self, warnings, which): """ Assert that a certain number of warnings with certain messages were emitted in a certain order. @param warnings: A list of emitted warnings, as returned by C{flushWarnings}. @param which: A list of strings giving warning messages that should appear in C{warnings}. @raise self.failureException: If the warning messages given by C{which} do not match the messages in the warning information in C{warnings}, or if they do not appear in the same order. """ self.assertEqual([warning["message"] for warning in warnings], which) def test_setUpSuppression(self): """ Suppressions defined by the test method being run are applied to any warnings emitted while running the C{setUp} fixture. """ self.runTests(self._load(self.TestSetUpSuppression, "testSuppressMethod")) warningsShown = self.flushWarnings([self.TestSetUpSuppression._emit]) self._assertWarnings( warningsShown, [ suppression.CLASS_WARNING_MSG, suppression.MODULE_WARNING_MSG, suppression.CLASS_WARNING_MSG, suppression.MODULE_WARNING_MSG, ], ) def test_tearDownSuppression(self): """ Suppressions defined by the test method being run are applied to any warnings emitted while running the C{tearDown} fixture. """ self.runTests(self._load(self.TestTearDownSuppression, "testSuppressMethod")) warningsShown = self.flushWarnings([self.TestTearDownSuppression._emit]) self._assertWarnings( warningsShown, [ suppression.CLASS_WARNING_MSG, suppression.MODULE_WARNING_MSG, suppression.CLASS_WARNING_MSG, suppression.MODULE_WARNING_MSG, ], ) def test_suppressMethod(self): """ A suppression set on a test method prevents warnings emitted by that test method which the suppression matches from being emitted. """ self.runTests(self._load(self.TestSuppression, "testSuppressMethod")) warningsShown = self.flushWarnings([self.TestSuppression._emit]) self._assertWarnings( warningsShown, [suppression.CLASS_WARNING_MSG, suppression.MODULE_WARNING_MSG], ) def test_suppressClass(self): """ A suppression set on a L{SynchronousTestCase} subclass prevents warnings emitted by any test methods defined on that class which match the suppression from being emitted. """ self.runTests(self._load(self.TestSuppression, "testSuppressClass")) warningsShown = self.flushWarnings([self.TestSuppression._emit]) self.assertEqual(warningsShown[0]["message"], suppression.METHOD_WARNING_MSG) self.assertEqual(warningsShown[1]["message"], suppression.MODULE_WARNING_MSG) self.assertEqual(len(warningsShown), 2) def test_suppressModule(self): """ A suppression set on a module prevents warnings emitted by any test mewthods defined in that module which match the suppression from being emitted. """ self.runTests(self._load(self.TestSuppression2, "testSuppressModule")) warningsShown = self.flushWarnings([self.TestSuppression._emit]) self.assertEqual(warningsShown[0]["message"], suppression.METHOD_WARNING_MSG) self.assertEqual(warningsShown[1]["message"], suppression.CLASS_WARNING_MSG) self.assertEqual(len(warningsShown), 2) def test_overrideSuppressClass(self): """ The suppression set on a test method completely overrides a suppression with wider scope; if it does not match a warning emitted by that test method, the warning is emitted, even if a wider suppression matches. """ self.runTests(self._load(self.TestSuppression, "testOverrideSuppressClass")) warningsShown = self.flushWarnings([self.TestSuppression._emit]) self.assertEqual(warningsShown[0]["message"], suppression.METHOD_WARNING_MSG) self.assertEqual(warningsShown[1]["message"], suppression.CLASS_WARNING_MSG) self.assertEqual(warningsShown[2]["message"], suppression.MODULE_WARNING_MSG) self.assertEqual(len(warningsShown), 3) class SynchronousSuppressionTests(SuppressionMixin, unittest.SynchronousTestCase): """ @see: L{twisted.trial.test.test_tests} """ TestSetUpSuppression = namedAny( "twisted.trial.test.suppression.SynchronousTestSetUpSuppression" ) TestTearDownSuppression = namedAny( "twisted.trial.test.suppression.SynchronousTestTearDownSuppression" ) TestSuppression = namedAny( "twisted.trial.test.suppression.SynchronousTestSuppression" ) TestSuppression2 = namedAny( "twisted.trial.test.suppression.SynchronousTestSuppression2" ) PK b�Z �B�� � test/test_runner.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # # Maintainer: Jonathan Lange # Author: Robert Collins import os import pdb import sys import unittest as pyunit from io import StringIO from typing import List from zope.interface import implementer from zope.interface.verify import verifyObject from twisted import plugin from twisted.internet import defer from twisted.plugins import twisted_trial from twisted.python import failure, log, reflect from twisted.python.filepath import FilePath from twisted.python.reflect import namedAny from twisted.scripts import trial from twisted.trial import reporter, runner, unittest, util from twisted.trial._asyncrunner import _ForceGarbageCollectionDecorator from twisted.trial.itrial import IReporter, ITestCase class CapturingDebugger: def __init__(self): self._calls = [] def runcall(self, *args, **kwargs): self._calls.append("runcall") args[0](*args[1:], **kwargs) @implementer(IReporter) class CapturingReporter: """ Reporter that keeps a log of all actions performed on it. """ stream = None tbformat = None args = None separator = None testsRun = None def __init__(self, stream=None, tbformat=None, rterrors=None, publisher=None): """ Create a capturing reporter. """ self._calls = [] self.shouldStop = False self._stream = stream self._tbformat = tbformat self._rterrors = rterrors self._publisher = publisher def startTest(self, method): """ Report the beginning of a run of a single test method @param method: an object that is adaptable to ITestMethod """ self._calls.append("startTest") def stopTest(self, method): """ Report the status of a single test method @param method: an object that is adaptable to ITestMethod """ self._calls.append("stopTest") def cleanupErrors(self, errs): """called when the reactor has been left in a 'dirty' state @param errs: a list of L{twisted.python.failure.Failure}s """ self._calls.append("cleanupError") def addSuccess(self, test): self._calls.append("addSuccess") def done(self): """ Do nothing. These tests don't care about done. """ def addError(self, test, error): """ Do nothing. These tests don't care about addError. """ def addFailure(self, test, failure): """ Do nothing. These tests don't care about addFailure. """ def addExpectedFailure(self, test, failure, todo=None): """ Do nothing. These tests don't care about addExpectedFailure. """ def addUnexpectedSuccess(self, test, todo=None): """ Do nothing. These tests don't care about addUnexpectedSuccess. """ def addSkip(self, test, reason): """ Do nothing. These tests don't care about addSkip. """ def wasSuccessful(self): """ Do nothing. These tests don't care about wasSuccessful. """ class TrialRunnerTestsMixin: """ Mixin defining tests for L{runner.TrialRunner}. """ def tearDown(self): self.runner._tearDownLogFile() def test_empty(self): """ Empty test method, used by the other tests. """ def _getObservers(self): return log.theLogPublisher.observers def test_addObservers(self): """ Any log system observers L{TrialRunner.run} adds are removed by the time it returns. """ originalCount = len(self._getObservers()) self.runner.run(self.test) newCount = len(self._getObservers()) self.assertEqual(newCount, originalCount) def test_logFileAlwaysActive(self): """ Test that a new file is opened on each run. """ oldSetUpLogFile = self.runner._setUpLogFile l = [] def setUpLogFile(): oldSetUpLogFile() l.append(self.runner._logFileObserver) self.runner._setUpLogFile = setUpLogFile self.runner.run(self.test) self.runner.run(self.test) self.assertEqual(len(l), 2) self.assertFalse(l[0] is l[1], "Should have created a new file observer") def test_logFileGetsClosed(self): """ Test that file created is closed during the run. """ oldSetUpLogFile = self.runner._setUpLogFile l = [] def setUpLogFile(): oldSetUpLogFile() l.append(self.runner._logFileObject) self.runner._setUpLogFile = setUpLogFile self.runner.run(self.test) self.assertEqual(len(l), 1) self.assertTrue(l[0].closed) class TrialRunnerTests(TrialRunnerTestsMixin, unittest.SynchronousTestCase): """ Tests for L{runner.TrialRunner} with the feature to turn unclean errors into warnings disabled. """ def setUp(self): self.stream = StringIO() self.runner = runner.TrialRunner(CapturingReporter, stream=self.stream) self.test = TrialRunnerTests("test_empty") def test_publisher(self): """ The reporter constructed by L{runner.TrialRunner} is passed L{twisted.python.log} as the value for the C{publisher} parameter. """ result = self.runner._makeResult() self.assertIdentical(result._publisher, log) class TrialRunnerWithUncleanWarningsReporterTests( TrialRunnerTestsMixin, unittest.SynchronousTestCase ): """ Tests for the TrialRunner's interaction with an unclean-error suppressing reporter. """ def setUp(self): self.stream = StringIO() self.runner = runner.TrialRunner( CapturingReporter, stream=self.stream, uncleanWarnings=True ) self.test = TrialRunnerTests("test_empty") class DryRunMixin: """ Mixin for testing that 'dry run' mode works with various L{pyunit.TestCase} subclasses. """ def setUp(self): self.log = [] self.stream = StringIO() self.runner = runner.TrialRunner( CapturingReporter, runner.TrialRunner.DRY_RUN, stream=self.stream ) self.makeTestFixtures() def makeTestFixtures(self): """ Set C{self.test} and C{self.suite}, where C{self.suite} is an empty TestSuite. """ def test_empty(self): """ If there are no tests, the reporter should not receive any events to report. """ result = self.runner.run(runner.TestSuite()) self.assertEqual(result._calls, []) def test_singleCaseReporting(self): """ If we are running a single test, check the reporter starts, passes and then stops the test during a dry run. """ result = self.runner.run(self.test) self.assertEqual(result._calls, ["startTest", "addSuccess", "stopTest"]) def test_testsNotRun(self): """ When we are doing a dry run, the tests should not actually be run. """ self.runner.run(self.test) self.assertEqual(self.log, []) class SynchronousDryRunTests(DryRunMixin, unittest.SynchronousTestCase): """ Check that 'dry run' mode works well with trial's L{SynchronousTestCase}. """ def makeTestFixtures(self): class PyunitCase(unittest.SynchronousTestCase): def test_foo(self): pass self.test = PyunitCase("test_foo") self.suite = pyunit.TestSuite() class DryRunTests(DryRunMixin, unittest.SynchronousTestCase): """ Check that 'dry run' mode works well with Trial tests. """ def makeTestFixtures(self): class MockTest(unittest.TestCase): def test_foo(test): self.log.append("test_foo") self.test = MockTest("test_foo") self.suite = runner.TestSuite() class PyUnitDryRunTests(DryRunMixin, unittest.SynchronousTestCase): """ Check that 'dry run' mode works well with stdlib unittest tests. """ def makeTestFixtures(self): class PyunitCase(pyunit.TestCase): def test_foo(self): pass self.test = PyunitCase("test_foo") self.suite = pyunit.TestSuite() class RunnerTests(unittest.SynchronousTestCase): def setUp(self): self.config = trial.Options() # whitebox hack a reporter in, because plugins are CACHED and will # only reload if the FILE gets changed. parts = reflect.qual(CapturingReporter).split(".") package = ".".join(parts[:-1]) klass = parts[-1] plugins = [ twisted_trial._Reporter( "Test Helper Reporter", package, description="Utility for unit testing.", longOpt="capturing", shortOpt=None, klass=klass, ) ] # XXX There should really be a general way to hook the plugin system # for tests. def getPlugins(iface, *a, **kw): self.assertEqual(iface, IReporter) return plugins + list(self.original(iface, *a, **kw)) self.original = plugin.getPlugins plugin.getPlugins = getPlugins self.standardReport = [ "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", "startTest", "addSuccess", "stopTest", ] def tearDown(self): plugin.getPlugins = self.original def parseOptions(self, args): self.config.parseOptions(args) def getRunner(self): r = trial._makeRunner(self.config) r.stream = StringIO() # XXX The runner should always take care of cleaning this up itself. # It's not clear why this is necessary. The runner always tears down # its log file. self.addCleanup(r._tearDownLogFile) # XXX The runner should always take care of cleaning this up itself as # well. It's necessary because TrialRunner._setUpTestdir might raise # an exception preventing Reporter.done from being run, leaving the # observer added by Reporter.__init__ still present in the system. # Something better needs to happen inside # TrialRunner._runWithoutDecoration to remove the need for this cludge. r._log = log.LogPublisher() return r def test_runner_can_get_reporter(self): self.parseOptions([]) result = self.config["reporter"] runner = self.getRunner() self.assertEqual(result, runner._makeResult().__class__) def test_runner_get_result(self): self.parseOptions([]) runner = self.getRunner() result = runner._makeResult() self.assertEqual(result.__class__, self.config["reporter"]) def test_uncleanWarningsOffByDefault(self): """ By default Trial sets the 'uncleanWarnings' option on the runner to False. This means that dirty reactor errors will be reported as errors. See L{test_reporter.DirtyReactorTests}. """ self.parseOptions([]) runner = self.getRunner() self.assertNotIsInstance( runner._makeResult(), reporter.UncleanWarningsReporterWrapper ) def test_getsUncleanWarnings(self): """ Specifying '--unclean-warnings' on the trial command line will cause reporters to be wrapped in a device which converts unclean errors to warnings. See L{test_reporter.DirtyReactorTests} for implications. """ self.parseOptions(["--unclean-warnings"]) runner = self.getRunner() self.assertIsInstance( runner._makeResult(), reporter.UncleanWarningsReporterWrapper ) def test_runner_working_directory(self): self.parseOptions(["--temp-directory", "some_path"]) runner = self.getRunner() self.assertEqual(runner.workingDirectory, "some_path") def test_concurrentImplicitWorkingDirectory(self): """ If no working directory is explicitly specified and the default working directory is in use by another runner, L{TrialRunner.run} selects a different default working directory to use. """ self.parseOptions([]) # Make sure we end up with the same working directory after this test # as we had before it. self.addCleanup(os.chdir, os.getcwd()) # Make a new directory and change into it. This isolates us from state # that other tests might have dumped into this process's temp # directory. runDirectory = FilePath(self.mktemp()) runDirectory.makedirs() os.chdir(runDirectory.path) firstRunner = self.getRunner() secondRunner = self.getRunner() where = {} class ConcurrentCase(unittest.SynchronousTestCase): def test_first(self): """ Start a second test run which will have a default working directory which is the same as the working directory of the test run already in progress. """ # Change the working directory to the value it had before this # test suite was started. where["concurrent"] = subsequentDirectory = os.getcwd() os.chdir(runDirectory.path) self.addCleanup(os.chdir, subsequentDirectory) secondRunner.run(ConcurrentCase("test_second")) def test_second(self): """ Record the working directory for later analysis. """ where["record"] = os.getcwd() result = firstRunner.run(ConcurrentCase("test_first")) bad = result.errors + result.failures if bad: self.fail(bad[0][1]) self.assertEqual( where, { "concurrent": runDirectory.child("_trial_temp").path, "record": runDirectory.child("_trial_temp-1").path, }, ) def test_concurrentExplicitWorkingDirectory(self): """ If a working directory which is already in use is explicitly specified, L{TrialRunner.run} raises L{_WorkingDirectoryBusy}. """ self.parseOptions(["--temp-directory", os.path.abspath(self.mktemp())]) initialDirectory = os.getcwd() self.addCleanup(os.chdir, initialDirectory) firstRunner = self.getRunner() secondRunner = self.getRunner() class ConcurrentCase(unittest.SynchronousTestCase): def test_concurrent(self): """ Try to start another runner in the same working directory and assert that it raises L{_WorkingDirectoryBusy}. """ self.assertRaises( util._WorkingDirectoryBusy, secondRunner.run, ConcurrentCase("test_failure"), ) def test_failure(self): """ Should not be called, always fails. """ self.fail("test_failure should never be called.") result = firstRunner.run(ConcurrentCase("test_concurrent")) bad = result.errors + result.failures if bad: self.fail(bad[0][1]) def test_runner_normal(self): self.parseOptions( [ "--temp-directory", self.mktemp(), "--reporter", "capturing", "twisted.trial.test.sample", ] ) my_runner = self.getRunner() loader = runner.TestLoader() suite = loader.loadByName("twisted.trial.test.sample", True) result = my_runner.run(suite) self.assertEqual(self.standardReport, result._calls) def runSampleSuite(self, my_runner): loader = runner.TestLoader() suite = loader.loadByName("twisted.trial.test.sample", True) return my_runner.run(suite) def test_runnerDebug(self): """ Trial uses its debugger if the `--debug` option is passed. """ self.parseOptions( ["--reporter", "capturing", "--debug", "twisted.trial.test.sample"] ) my_runner = self.getRunner() debugger = my_runner.debugger = CapturingDebugger() result = self.runSampleSuite(my_runner) self.assertEqual(self.standardReport, result._calls) self.assertEqual(["runcall"], debugger._calls) def test_runnerDebuggerDefaultsToPdb(self): """ Trial uses pdb if no debugger is specified by `--debugger` """ self.parseOptions(["--debug", "twisted.trial.test.sample"]) pdbrcFile = FilePath("pdbrc") pdbrcFile.touch() self.runcall_called = False def runcall(pdb, suite, result): self.runcall_called = True self.patch(pdb.Pdb, "runcall", runcall) self.runSampleSuite(self.getRunner()) self.assertTrue(self.runcall_called) def test_runnerDebuggerWithExplicitlyPassedPdb(self): """ Trial uses pdb if pdb is passed explicitly to the `--debugger` arg. """ self.parseOptions( [ "--reporter", "capturing", "--debugger", "pdb", "--debug", "twisted.trial.test.sample", ] ) self.runcall_called = False def runcall(pdb, suite, result): self.runcall_called = True self.patch(pdb.Pdb, "runcall", runcall) self.runSampleSuite(self.getRunner()) self.assertTrue(self.runcall_called) cdebugger = CapturingDebugger() def test_runnerDebugger(self): """ Trial uses specified debugger if the debugger is available. """ self.parseOptions( [ "--reporter", "capturing", "--debugger", "twisted.trial.test.test_runner.RunnerTests.cdebugger", "--debug", "twisted.trial.test.sample", ] ) my_runner = self.getRunner() result = self.runSampleSuite(my_runner) self.assertEqual(self.standardReport, result._calls) self.assertEqual(["runcall"], my_runner.debugger._calls) def test_exitfirst(self): """ If trial was passed the C{--exitfirst} option, the constructed test result object is wrapped with L{reporter._ExitWrapper}. """ self.parseOptions(["--exitfirst"]) runner = self.getRunner() result = runner._makeResult() self.assertIsInstance(result, reporter._ExitWrapper) class TrialSuiteTests(unittest.SynchronousTestCase): def test_imports(self): # FIXME, HTF do you test the reactor can be cleaned up ?!!! namedAny("twisted.trial.runner.TrialSuite") class UntilFailureTests(unittest.SynchronousTestCase): class FailAfter(pyunit.TestCase): """ A test case that fails when run 3 times in a row. """ count: List[None] = [] def test_foo(self): self.count.append(None) if len(self.count) == 3: self.fail("Count reached 3") def setUp(self): UntilFailureTests.FailAfter.count = [] self.test = UntilFailureTests.FailAfter("test_foo") self.stream = StringIO() self.runner = runner.TrialRunner(reporter.Reporter, stream=self.stream) def test_runUntilFailure(self): """ Test that the runUntilFailure method of the runner actually fail after a few runs. """ result = self.runner.runUntilFailure(self.test) self.assertEqual(result.testsRun, 1) self.assertFalse(result.wasSuccessful()) self.assertEqual(self._getFailures(result), 1) def _getFailures(self, result): """ Get the number of failures that were reported to a result. """ return len(result.failures) def test_runUntilFailureDecorate(self): """ C{runUntilFailure} doesn't decorate the tests uselessly: it does it one time when run starts, but not at each turn. """ decorated = [] def decorate(test, interface): decorated.append((test, interface)) return test self.patch(unittest, "decorate", decorate) result = self.runner.runUntilFailure(self.test) self.assertEqual(result.testsRun, 1) self.assertEqual(len(decorated), 1) self.assertEqual(decorated, [(self.test, ITestCase)]) def test_runUntilFailureForceGCDecorate(self): """ C{runUntilFailure} applies the force-gc decoration after the standard L{ITestCase} decoration, but only one time. """ decorated = [] def decorate(test, interface): decorated.append((test, interface)) return test self.patch(unittest, "decorate", decorate) self.runner._forceGarbageCollection = True result = self.runner.runUntilFailure(self.test) self.assertEqual(result.testsRun, 1) self.assertEqual(len(decorated), 2) self.assertEqual( decorated, [(self.test, ITestCase), (self.test, _ForceGarbageCollectionDecorator)], ) class UncleanUntilFailureTests(UntilFailureTests): """ Test that the run-until-failure feature works correctly with the unclean error suppressor. """ def setUp(self): UntilFailureTests.setUp(self) self.runner = runner.TrialRunner( reporter.Reporter, stream=self.stream, uncleanWarnings=True ) def _getFailures(self, result): """ Get the number of failures that were reported to a result that is wrapped in an UncleanFailureWrapper. """ return len(result._originalReporter.failures) class BreakingSuite(runner.TestSuite): """ A L{TestSuite} that logs an error when it is run. """ def run(self, result): try: raise RuntimeError("error that occurs outside of a test") except RuntimeError: log.err(failure.Failure()) class LoggedErrorsTests(unittest.SynchronousTestCase): """ It is possible for an error generated by a test to be logged I{outside} of any test. The log observers constructed by L{TestCase} won't catch these errors. Here we try to generate such errors and ensure they are reported to a L{TestResult} object. """ def tearDown(self): self.flushLoggedErrors(RuntimeError) def test_construct(self): """ Check that we can construct a L{runner.LoggedSuite} and that it starts empty. """ suite = runner.LoggedSuite() self.assertEqual(suite.countTestCases(), 0) def test_capturesError(self): """ Chek that a L{LoggedSuite} reports any logged errors to its result. """ result = reporter.TestResult() suite = runner.LoggedSuite([BreakingSuite()]) suite.run(result) self.assertEqual(len(result.errors), 1) self.assertEqual(result.errors[0][0].id(), runner.NOT_IN_TEST) self.assertTrue(result.errors[0][1].check(RuntimeError)) class TestHolderTests(unittest.SynchronousTestCase): def setUp(self): self.description = "description" self.holder = runner.TestHolder(self.description) def test_holder(self): """ Check that L{runner.TestHolder} takes a description as a parameter and that this description is returned by the C{id} and C{shortDescription} methods. """ self.assertEqual(self.holder.id(), self.description) self.assertEqual(self.holder.shortDescription(), self.description) def test_holderImplementsITestCase(self): """ L{runner.TestHolder} implements L{ITestCase}. """ self.assertIdentical(self.holder, ITestCase(self.holder)) self.assertTrue( verifyObject(ITestCase, self.holder), "%r claims to provide %r but does not do so correctly." % (self.holder, ITestCase), ) def test_runsWithStandardResult(self): """ A L{runner.TestHolder} can run against the standard Python C{TestResult}. """ result = pyunit.TestResult() self.holder.run(result) self.assertTrue(result.wasSuccessful()) self.assertEqual(1, result.testsRun) class ErrorHolderTestsMixin: """ This mixin defines test methods which can be applied to a L{runner.ErrorHolder} constructed with either a L{Failure} or a C{exc_info}-style tuple. Subclass this and implement C{setUp} to create C{self.holder} referring to a L{runner.ErrorHolder} instance and C{self.error} referring to a L{Failure} which the holder holds. """ exceptionForTests = ZeroDivisionError("integer division or modulo by zero") class TestResultStub: """ Stub for L{TestResult}. """ def __init__(self): self.errors = [] def startTest(self, test): pass def stopTest(self, test): pass def addError(self, test, error): self.errors.append((test, error)) def test_runsWithStandardResult(self): """ A L{runner.ErrorHolder} can run against the standard Python C{TestResult}. """ result = pyunit.TestResult() self.holder.run(result) self.assertFalse(result.wasSuccessful()) self.assertEqual(1, result.testsRun) def test_run(self): """ L{runner.ErrorHolder} adds an error to the result when run. """ self.holder.run(self.result) self.assertEqual( self.result.errors, [(self.holder, (self.error.type, self.error.value, self.error.tb))], ) def test_call(self): """ L{runner.ErrorHolder} adds an error to the result when called. """ self.holder(self.result) self.assertEqual( self.result.errors, [(self.holder, (self.error.type, self.error.value, self.error.tb))], ) def test_countTestCases(self): """ L{runner.ErrorHolder.countTestCases} always returns 0. """ self.assertEqual(self.holder.countTestCases(), 0) def test_repr(self): """ L{runner.ErrorHolder.__repr__} returns a string describing the error it holds. """ expected = "<ErrorHolder description='description' " "error={}>".format( repr(self.holder.error[1]) ) self.assertEqual(repr(self.holder), expected) class FailureHoldingErrorHolderTests(ErrorHolderTestsMixin, TestHolderTests): """ Tests for L{runner.ErrorHolder} behaving similarly to L{runner.TestHolder} when constructed with a L{Failure} representing its error. """ def setUp(self): self.description = "description" # make a real Failure so we can construct ErrorHolder() try: raise self.exceptionForTests except ZeroDivisionError: self.error = failure.Failure() self.holder = runner.ErrorHolder(self.description, self.error) self.result = self.TestResultStub() class ExcInfoHoldingErrorHolderTests(ErrorHolderTestsMixin, TestHolderTests): """ Tests for L{runner.ErrorHolder} behaving similarly to L{runner.TestHolder} when constructed with a C{exc_info}-style tuple representing its error. """ def setUp(self): self.description = "description" # make a real Failure so we can construct ErrorHolder() try: raise self.exceptionForTests except ZeroDivisionError: exceptionInfo = sys.exc_info() self.error = failure.Failure() self.holder = runner.ErrorHolder(self.description, exceptionInfo) self.result = self.TestResultStub() class MalformedMethodTests(unittest.SynchronousTestCase): """ Test that trial manages when test methods don't have correct signatures. """ class ContainMalformed(pyunit.TestCase): """ This TestCase holds malformed test methods that trial should handle. """ def test_foo(self, blah): pass def test_bar(): # type: ignore[misc] pass test_spam = defer.inlineCallbacks(test_bar) def _test(self, method): """ Wrapper for one of the test method of L{ContainMalformed}. """ stream = StringIO() trialRunner = runner.TrialRunner(reporter.Reporter, stream=stream) test = MalformedMethodTests.ContainMalformed(method) result = trialRunner.run(test) self.assertEqual(result.testsRun, 1) self.assertFalse(result.wasSuccessful()) self.assertEqual(len(result.errors), 1) def test_extraArg(self): """ Test when the method has extra (useless) arguments. """ self._test("test_foo") def test_noArg(self): """ Test when the method doesn't have even self as argument. """ self._test("test_bar") def test_decorated(self): """ Test a decorated method also fails. """ self._test("test_spam") class DestructiveTestSuiteTests(unittest.SynchronousTestCase): """ Test for L{runner.DestructiveTestSuite}. """ def test_basic(self): """ Thes destructive test suite should run the tests normally. """ called = [] class MockTest(pyunit.TestCase): def test_foo(test): called.append(True) test = MockTest("test_foo") result = reporter.TestResult() suite = runner.DestructiveTestSuite([test]) self.assertEqual(called, []) suite.run(result) self.assertEqual(called, [True]) self.assertEqual(suite.countTestCases(), 0) def test_shouldStop(self): """ Test the C{shouldStop} management: raising a C{KeyboardInterrupt} must interrupt the suite. """ called = [] class MockTest(unittest.TestCase): def test_foo1(test): called.append(1) def test_foo2(test): raise KeyboardInterrupt() def test_foo3(test): called.append(2) result = reporter.TestResult() loader = runner.TestLoader() loader.suiteFactory = runner.DestructiveTestSuite suite = loader.loadClass(MockTest) self.assertEqual(called, []) suite.run(result) self.assertEqual(called, [1]) # The last test shouldn't have been run self.assertEqual(suite.countTestCases(), 1) def test_cleanup(self): """ Checks that the test suite cleanups its tests during the run, so that it ends empty. """ class MockTest(pyunit.TestCase): def test_foo(test): pass test = MockTest("test_foo") result = reporter.TestResult() suite = runner.DestructiveTestSuite([test]) self.assertEqual(suite.countTestCases(), 1) suite.run(result) self.assertEqual(suite.countTestCases(), 0) class RunnerDeprecationTests(unittest.SynchronousTestCase): class FakeReporter(reporter.Reporter): """ Fake reporter that does *not* implement done() but *does* implement printErrors, separator, printSummary, stream, write and writeln without deprecations. """ done = None separator = None stream = None def printErrors(self, *args): pass def printSummary(self, *args): pass def write(self, *args): pass def writeln(self, *args): pass def test_reporterDeprecations(self): """ The runner emits a warning if it is using a result that doesn't implement 'done'. """ trialRunner = runner.TrialRunner(None) result = self.FakeReporter() trialRunner._makeResult = lambda: result def f(): # We have to use a pyunit test, otherwise we'll get deprecation # warnings about using iterate() in a test. trialRunner.run(pyunit.TestCase("id")) f() warnings = self.flushWarnings([self.test_reporterDeprecations]) self.assertEqual(warnings[0]["category"], DeprecationWarning) self.assertEqual( warnings[0]["message"], "%s should implement done() but doesn't. Falling back to " "printErrors() and friends." % reflect.qual(result.__class__), ) self.assertTrue(__file__.startswith(warnings[0]["filename"])) self.assertEqual(len(warnings), 1) class QualifiedNameWalkerTests(unittest.SynchronousTestCase): """ Tests for L{twisted.trial.runner._qualNameWalker}. """ def test_walksDownPath(self): """ C{_qualNameWalker} is a generator that, when given a Python qualified name, yields that name, and then the parent of that name, and so forth, along with a list of the tried components, in a 2-tuple. """ walkerResults = list(runner._qualNameWalker("walker.texas.ranger")) self.assertEqual( walkerResults, [ ("walker.texas.ranger", []), ("walker.texas", ["ranger"]), ("walker", ["texas", "ranger"]), ], ) class TrialMainDoesNothingTests(unittest.SynchronousTestCase): """ Importing L{twisted.trial.__main__} will not run the script unless it is actually C{__main__}. """ def test_importDoesNothing(self): """ If we import L{twisted.trial.__main__}, it should do nothing. """ # We shouldn't suddenly drop into a script when we import this! __import__("twisted.trial.__main__") PK b�Z�zh h test/test_log.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test the interaction between trial and errors logged during test run. """ import time from twisted.internet import reactor, task from twisted.python import failure, log from twisted.trial import _synctest, reporter, unittest def makeFailure(): """ Return a new, realistic failure. """ try: 1 / 0 except ZeroDivisionError: f = failure.Failure() return f class Mask: """ Hide C{MockTest}s from Trial's automatic test finder. """ class FailureLoggingMixin: def test_silent(self): """ Don't log any errors. """ def test_single(self): """ Log a single error. """ log.err(makeFailure()) def test_double(self): """ Log two errors. """ log.err(makeFailure()) log.err(makeFailure()) def test_singleThenFail(self): """ Log a single error, then fail. """ log.err(makeFailure()) 1 + None class SynchronousFailureLogging(FailureLoggingMixin, unittest.SynchronousTestCase): pass class AsynchronousFailureLogging(FailureLoggingMixin, unittest.TestCase): def test_inCallback(self): """ Log an error in an asynchronous callback. """ return task.deferLater(reactor, 0, lambda: log.err(makeFailure())) class ObserverTests(unittest.SynchronousTestCase): """ Tests for L{_synctest._LogObserver}, a helper for the implementation of L{SynchronousTestCase.flushLoggedErrors}. """ def setUp(self): self.result = reporter.TestResult() self.observer = _synctest._LogObserver() def test_msg(self): """ Test that a standard log message doesn't go anywhere near the result. """ self.observer.gotEvent( { "message": ("some message",), "time": time.time(), "isError": 0, "system": "-", } ) self.assertEqual(self.observer.getErrors(), []) def test_error(self): """ Test that an observed error gets added to the result """ f = makeFailure() self.observer.gotEvent( { "message": (), "time": time.time(), "isError": 1, "system": "-", "failure": f, "why": None, } ) self.assertEqual(self.observer.getErrors(), [f]) def test_flush(self): """ Check that flushing the observer with no args removes all errors. """ self.test_error() flushed = self.observer.flushErrors() self.assertEqual(self.observer.getErrors(), []) self.assertEqual(len(flushed), 1) self.assertTrue(flushed[0].check(ZeroDivisionError)) def _makeRuntimeFailure(self): return failure.Failure(RuntimeError("test error")) def test_flushByType(self): """ Check that flushing the observer remove all failures of the given type. """ self.test_error() # log a ZeroDivisionError to the observer f = self._makeRuntimeFailure() self.observer.gotEvent( dict( message=(), time=time.time(), isError=1, system="-", failure=f, why=None ) ) flushed = self.observer.flushErrors(ZeroDivisionError) self.assertEqual(self.observer.getErrors(), [f]) self.assertEqual(len(flushed), 1) self.assertTrue(flushed[0].check(ZeroDivisionError)) def test_ignoreErrors(self): """ Check that C{_ignoreErrors} actually causes errors to be ignored. """ self.observer._ignoreErrors(ZeroDivisionError) f = makeFailure() self.observer.gotEvent( { "message": (), "time": time.time(), "isError": 1, "system": "-", "failure": f, "why": None, } ) self.assertEqual(self.observer.getErrors(), []) def test_clearIgnores(self): """ Check that C{_clearIgnores} ensures that previously ignored errors get captured. """ self.observer._ignoreErrors(ZeroDivisionError) self.observer._clearIgnores() f = makeFailure() self.observer.gotEvent( { "message": (), "time": time.time(), "isError": 1, "system": "-", "failure": f, "why": None, } ) self.assertEqual(self.observer.getErrors(), [f]) class LogErrorsMixin: """ High-level tests demonstrating the expected behaviour of logged errors during tests. """ def setUp(self): self.result = reporter.TestResult() def tearDown(self): self.flushLoggedErrors(ZeroDivisionError) def test_singleError(self): """ Test that a logged error gets reported as a test error. """ test = self.MockTest("test_single") test(self.result) self.assertEqual(len(self.result.errors), 1) self.assertTrue( self.result.errors[0][1].check(ZeroDivisionError), self.result.errors[0][1] ) self.assertEqual(0, self.result.successes) def test_twoErrors(self): """ Test that when two errors get logged, they both get reported as test errors. """ test = self.MockTest("test_double") test(self.result) self.assertEqual(len(self.result.errors), 2) self.assertEqual(0, self.result.successes) def test_errorsIsolated(self): """ Check that an error logged in one test doesn't fail the next test. """ t1 = self.MockTest("test_single") t2 = self.MockTest("test_silent") t1(self.result) t2(self.result) self.assertEqual(len(self.result.errors), 1) self.assertEqual(self.result.errors[0][0], t1) self.assertEqual(1, self.result.successes) def test_errorsIsolatedWhenTestFails(self): """ An error logged in a failed test doesn't fail the next test. """ t1 = self.MockTest("test_singleThenFail") t2 = self.MockTest("test_silent") t1(self.result) t2(self.result) self.assertEqual(len(self.result.errors), 2) self.assertEqual(self.result.errors[0][0], t1) self.result.errors[0][1].trap(TypeError) self.assertEqual(self.result.errors[1][0], t1) self.result.errors[1][1].trap(ZeroDivisionError) self.assertEqual(1, self.result.successes) def test_boundedObservers(self): """ There are no extra log observers after a test runs. """ # XXX trial is *all about* global log state. It should really be fixed. observer = _synctest._LogObserver() self.patch(_synctest, "_logObserver", observer) observers = log.theLogPublisher.observers[:] test = self.MockTest() test(self.result) self.assertEqual(observers, log.theLogPublisher.observers) class SynchronousLogErrorsTests(LogErrorsMixin, unittest.SynchronousTestCase): MockTest = Mask.SynchronousFailureLogging class AsynchronousLogErrorsTests(LogErrorsMixin, unittest.TestCase): MockTest = Mask.AsynchronousFailureLogging def test_inCallback(self): """ Test that errors logged in callbacks get reported as test errors. """ test = self.MockTest("test_inCallback") test(self.result) self.assertEqual(len(self.result.errors), 1) self.assertTrue( self.result.errors[0][1].check(ZeroDivisionError), self.result.errors[0][1] ) PK b�Z�G�� � test/moduleself.pynu �[��� # -*- test-case-name: twisted.trial.test.moduleself -*- from twisted.trial import unittest class Foo(unittest.SynchronousTestCase): def testFoo(self): pass PK b�Z�"h+ + test/packages.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # """ Classes and functions used by L{twisted.trial.test.test_util} and L{twisted.trial.test.test_loader}. """ import os import sys # Python 3 has some funny import caching, which we don't want. # invalidate_caches clears it out for us. from importlib import invalidate_caches as invalidateImportCaches from twisted.trial import unittest testModule = """ from twisted.trial import unittest class FooTest(unittest.SynchronousTestCase): def testFoo(self): pass """ dosModule = testModule.replace("\n", "\r\n") testSample = """ '''This module is used by test_loader to test the Trial test loading functionality. Do NOT change the number of tests in this module. Do NOT change the names the tests in this module. ''' import unittest as pyunit from twisted.trial import unittest class FooTest(unittest.SynchronousTestCase): def test_foo(self): pass def test_bar(self): pass class PyunitTest(pyunit.TestCase): def test_foo(self): pass def test_bar(self): pass class NotATest: def test_foo(self): pass class AlphabetTest(unittest.SynchronousTestCase): def test_a(self): pass def test_b(self): pass def test_c(self): pass """ testInheritanceSample = """ '''This module is used by test_loader to test the Trial test loading functionality. Do NOT change the number of tests in this module. Do NOT change the names the tests in this module. ''' from twisted.trial import unittest class X: def test_foo(self): pass class A(unittest.SynchronousTestCase, X): pass class B(unittest.SynchronousTestCase, X): pass """ class PackageTest(unittest.SynchronousTestCase): files = [ ("badpackage/__init__.py", "frotz\n"), ("badpackage/test_module.py", ""), ("unimportablepackage/__init__.py", ""), ("unimportablepackage/test_module.py", "import notarealmoduleok\n"), ("package2/__init__.py", ""), ("package2/test_module.py", "import frotz\n"), ("package/__init__.py", ""), ("package/frotz.py", "frotz\n"), ("package/test_bad_module.py", 'raise ZeroDivisionError("fake error")'), ("package/test_dos_module.py", dosModule), ("package/test_import_module.py", "import frotz"), ("package/test_module.py", testModule), ("goodpackage/__init__.py", ""), ("goodpackage/test_sample.py", testSample), ("goodpackage/sub/__init__.py", ""), ("goodpackage/sub/test_sample.py", testSample), ("inheritancepackage/__init__.py", ""), ("inheritancepackage/test_x.py", testInheritanceSample), ] def _toModuleName(self, filename): name = os.path.splitext(filename)[0] segs = name.split("/") if segs[-1] == "__init__": segs = segs[:-1] return ".".join(segs) def getModules(self): """ Return matching module names for files listed in C{self.files}. """ return [self._toModuleName(filename) for (filename, code) in self.files] def cleanUpModules(self): modules = self.getModules() modules.sort() modules.reverse() for module in modules: try: del sys.modules[module] except KeyError: pass def createFiles(self, files, parentDir="."): for filename, contents in self.files: filename = os.path.join(parentDir, filename) self._createDirectory(filename) with open(filename, "w") as fd: fd.write(contents) def _createDirectory(self, filename): directory = os.path.dirname(filename) if not os.path.exists(directory): os.makedirs(directory) def setUp(self, parentDir=None): invalidateImportCaches() if parentDir is None: parentDir = self.mktemp() self.parent = parentDir self.createFiles(self.files, parentDir) def tearDown(self): self.cleanUpModules() class SysPathManglingTest(PackageTest): def setUp(self, parent=None): invalidateImportCaches() self.oldPath = sys.path[:] self.newPath = sys.path[:] if parent is None: parent = self.mktemp() PackageTest.setUp(self, parent) self.newPath.append(self.parent) self.mangleSysPath(self.newPath) def tearDown(self): PackageTest.tearDown(self) self.mangleSysPath(self.oldPath) def mangleSysPath(self, pathVar): sys.path[:] = pathVar PK b�Z� �i\� \� test/test_tests.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for the behaviour of unit tests. Many tests in this module follow a simple pattern. A mixin is defined which includes test methods for a certain feature. The mixin is inherited from twice, once by a class also inheriting from SynchronousTestCase and once from a class inheriting from TestCase. These two subclasses are named like I{SynchronousFooTests} and I{AsynchronousFooTests}, where I{Foo} is related to the name of the mixin. Sometimes the mixin is defined in another module, along with the synchronous subclass. The mixin is imported into this module to define the asynchronous subclass. This pattern allows the same tests to be applied to the two base test case classes trial provides, ensuring their behavior is the same. Most new tests should be added in this pattern. Tests for functionality which is intentionally only provided by TestCase, not SynchronousTestCase, is excepted of course. """ import gc import sys import unittest as pyunit import weakref from io import StringIO from twisted.internet import defer, reactor from twisted.python.compat import _PYPY from twisted.python.reflect import namedAny from twisted.trial import reporter, runner, unittest, util from twisted.trial._asyncrunner import ( _clearSuite, _ForceGarbageCollectionDecorator, _iterateTests, ) from twisted.trial.test import erroneous from twisted.trial.test.test_suppression import SuppressionMixin class ResultsTestMixin: """ Provide useful APIs for test cases that are about test cases. """ def loadSuite(self, suite): """ Load tests from the given test case class and create a new reporter to use for running it. """ self.loader = pyunit.TestLoader() self.suite = self.loader.loadTestsFromTestCase(suite) self.reporter = reporter.TestResult() def test_setUp(self): """ test the setup """ self.assertTrue(self.reporter.wasSuccessful()) self.assertEqual(self.reporter.errors, []) self.assertEqual(self.reporter.failures, []) self.assertEqual(self.reporter.skips, []) def assertCount(self, numTests): """ Asserts that the test count is plausible """ self.assertEqual(self.suite.countTestCases(), numTests) self.suite(self.reporter) self.assertEqual(self.reporter.testsRun, numTests) class SuccessMixin: """ Tests for the reporting of successful tests in L{twisted.trial.unittest.TestCase}. """ def setUp(self): """ Setup our test case """ self.result = reporter.TestResult() def test_successful(self): """ A successful test, used by other tests. """ def assertSuccessful(self, test, result): """ Utility function -- assert there is one success and the state is plausible """ self.assertEqual(result.successes, 1) self.assertEqual(result.failures, []) self.assertEqual(result.errors, []) self.assertEqual(result.expectedFailures, []) self.assertEqual(result.unexpectedSuccesses, []) self.assertEqual(result.skips, []) def test_successfulIsReported(self): """ Test that when a successful test is run, it is reported as a success, and not as any other kind of result. """ test = self.__class__("test_successful") test.run(self.result) self.assertSuccessful(test, self.result) def test_defaultIsSuccessful(self): """ The test case type can be instantiated with no arguments, run, and reported as being successful. """ test = self.__class__() test.run(self.result) self.assertSuccessful(test, self.result) def test_noReference(self): """ Test that no reference is kept on a successful test. """ test = self.__class__("test_successful") ref = weakref.ref(test) test.run(self.result) self.assertSuccessful(test, self.result) del test gc.collect() self.assertIdentical(ref(), None) class SynchronousSuccessTests(SuccessMixin, unittest.SynchronousTestCase): """ Tests for the reporting of successful tests in the synchronous case. """ class AsynchronousSuccessTests(SuccessMixin, unittest.TestCase): """ Tests for the reporting of successful tests in the synchronous case. """ class SkipMethodsMixin(ResultsTestMixin): """ Tests for the reporting of skipping tests in L{twisted.trial.unittest.TestCase}. """ def setUp(self): """ Setup our test case """ self.loadSuite(self.Skipping) def test_counting(self): """ Assert that there are three tests. """ self.assertCount(3) def test_results(self): """ Running a suite in which all methods are individually set to skip produces a successful result with no recorded errors or failures, all the skipped methods recorded as skips, and no methods recorded as successes. """ self.suite(self.reporter) self.assertTrue(self.reporter.wasSuccessful()) self.assertEqual(self.reporter.errors, []) self.assertEqual(self.reporter.failures, []) self.assertEqual(len(self.reporter.skips), 3) self.assertEqual(self.reporter.successes, 0) def test_setUp(self): """ Running a suite in which all methods are skipped by C{setUp} raising L{SkipTest} produces a successful result with no recorded errors or failures, all skipped methods recorded as skips, and no methods recorded as successes. """ self.loadSuite(self.SkippingSetUp) self.suite(self.reporter) self.assertTrue(self.reporter.wasSuccessful()) self.assertEqual(self.reporter.errors, []) self.assertEqual(self.reporter.failures, []) self.assertEqual(len(self.reporter.skips), 2) self.assertEqual(self.reporter.successes, 0) def test_reasons(self): """ Test that reasons work """ self.suite(self.reporter) prefix = "test_" # whiteboxing reporter for test, reason in self.reporter.skips: self.assertEqual(test.shortDescription()[len(prefix) :], str(reason)) def test_deprecatedSkipWithoutReason(self): """ If a test method raises L{SkipTest} with no reason, a deprecation warning is emitted. """ self.loadSuite(self.DeprecatedReasonlessSkip) self.suite(self.reporter) warnings = self.flushWarnings([self.DeprecatedReasonlessSkip.test_1]) self.assertEqual(1, len(warnings)) self.assertEqual(DeprecationWarning, warnings[0]["category"]) self.assertEqual( "Do not raise unittest.SkipTest with no arguments! Give a reason " "for skipping tests!", warnings[0]["message"], ) class SynchronousSkipMethodTests(SkipMethodsMixin, unittest.SynchronousTestCase): """ Tests for the reporting of skipping tests in the synchronous case. See: L{twisted.trial.test.test_tests.SkipMethodsMixin} """ Skipping = namedAny("twisted.trial.test.skipping.SynchronousSkipping") SkippingSetUp = namedAny("twisted.trial.test.skipping.SynchronousSkippingSetUp") DeprecatedReasonlessSkip = namedAny( "twisted.trial.test.skipping.SynchronousDeprecatedReasonlessSkip" ) class AsynchronousSkipMethodTests(SkipMethodsMixin, unittest.TestCase): """ Tests for the reporting of skipping tests in the asynchronous case. See: L{twisted.trial.test.test_tests.SkipMethodsMixin} """ Skipping = namedAny("twisted.trial.test.skipping.AsynchronousSkipping") SkippingSetUp = namedAny("twisted.trial.test.skipping.AsynchronousSkippingSetUp") DeprecatedReasonlessSkip = namedAny( "twisted.trial.test.skipping.AsynchronousDeprecatedReasonlessSkip" ) class SkipClassesMixin(ResultsTestMixin): """ Test the class skipping features of L{twisted.trial.unittest.TestCase}. """ def setUp(self): """ Setup our test case """ self.loadSuite(self.SkippedClass) self.SkippedClass._setUpRan = False def test_counting(self): """ Skipped test methods still contribute to the total test count. """ self.assertCount(4) def test_setUpRan(self): """ The C{setUp} method is not called if the class is set to skip. """ self.suite(self.reporter) self.assertFalse(self.SkippedClass._setUpRan) def test_results(self): """ Skipped test methods don't cause C{wasSuccessful} to return C{False}, nor do they contribute to the C{errors} or C{failures} of the reporter, or to the count of successes. They do, however, add elements to the reporter's C{skips} list. """ self.suite(self.reporter) self.assertTrue(self.reporter.wasSuccessful()) self.assertEqual(self.reporter.errors, []) self.assertEqual(self.reporter.failures, []) self.assertEqual(len(self.reporter.skips), 4) self.assertEqual(self.reporter.successes, 0) def test_reasons(self): """ Test methods which raise L{unittest.SkipTest} or have their C{skip} attribute set to something are skipped. """ self.suite(self.reporter) expectedReasons = ["class", "skip2", "class", "class"] # whitebox reporter reasonsGiven = [reason for test, reason in self.reporter.skips] self.assertEqual(expectedReasons, reasonsGiven) class SynchronousSkipClassTests(SkipClassesMixin, unittest.SynchronousTestCase): """ Test the class skipping features in the synchronous case. See: L{twisted.trial.test.test_tests.SkipClassesMixin} """ SkippedClass = namedAny("twisted.trial.test.skipping.SynchronousSkippedClass") class AsynchronousSkipClassTests(SkipClassesMixin, unittest.TestCase): """ Test the class skipping features in the asynchronous case. See: L{twisted.trial.test.test_tests.SkipClassesMixin} """ SkippedClass = namedAny("twisted.trial.test.skipping.AsynchronousSkippedClass") class TodoMixin(ResultsTestMixin): """ Tests for the individual test method I{expected failure} features of L{twisted.trial.unittest.TestCase}. """ def setUp(self): """ Setup our test case """ self.loadSuite(self.Todo) def test_counting(self): """ Ensure that we've got three test cases. """ self.assertCount(3) def test_results(self): """ Running a suite in which all methods are individually marked as expected to fail produces a successful result with no recorded errors, failures, or skips, all methods which fail and were expected to fail recorded as C{expectedFailures}, and all methods which pass but which were expected to fail recorded as C{unexpectedSuccesses}. Additionally, no tests are recorded as successes. """ self.suite(self.reporter) self.assertTrue(self.reporter.wasSuccessful()) self.assertEqual(self.reporter.errors, []) self.assertEqual(self.reporter.failures, []) self.assertEqual(self.reporter.skips, []) self.assertEqual(len(self.reporter.expectedFailures), 2) self.assertEqual(len(self.reporter.unexpectedSuccesses), 1) self.assertEqual(self.reporter.successes, 0) def test_expectedFailures(self): """ Ensure that expected failures are handled properly. """ self.suite(self.reporter) expectedReasons = ["todo1", "todo2"] reasonsGiven = [r.reason for t, e, r in self.reporter.expectedFailures] self.assertEqual(expectedReasons, reasonsGiven) def test_unexpectedSuccesses(self): """ Ensure that unexpected successes are caught. """ self.suite(self.reporter) expectedReasons = ["todo3"] reasonsGiven = [r.reason for t, r in self.reporter.unexpectedSuccesses] self.assertEqual(expectedReasons, reasonsGiven) def test_expectedSetUpFailure(self): """ C{setUp} is excluded from the failure expectation defined by a C{todo} attribute on a test method. """ self.loadSuite(self.SetUpTodo) self.suite(self.reporter) self.assertFalse(self.reporter.wasSuccessful()) self.assertEqual(len(self.reporter.errors), 1) self.assertEqual(self.reporter.failures, []) self.assertEqual(self.reporter.skips, []) self.assertEqual(len(self.reporter.expectedFailures), 0) self.assertEqual(len(self.reporter.unexpectedSuccesses), 0) self.assertEqual(self.reporter.successes, 0) def test_expectedTearDownFailure(self): """ C{tearDown} is excluded from the failure expectation defined by a C{todo} attribute on a test method. """ self.loadSuite(self.TearDownTodo) self.suite(self.reporter) self.assertFalse(self.reporter.wasSuccessful()) self.assertEqual(len(self.reporter.errors), 1) self.assertEqual(self.reporter.failures, []) self.assertEqual(self.reporter.skips, []) self.assertEqual(len(self.reporter.expectedFailures), 0) # This seems strange, since tearDown raised an exception. However, the # test method did complete without error. The tearDown error is # reflected in the errors list, checked above. self.assertEqual(len(self.reporter.unexpectedSuccesses), 1) self.assertEqual(self.reporter.successes, 0) class SynchronousTodoTests(TodoMixin, unittest.SynchronousTestCase): """ Test the class skipping features in the synchronous case. See: L{twisted.trial.test.test_tests.TodoMixin} """ Todo = namedAny("twisted.trial.test.skipping.SynchronousTodo") SetUpTodo = namedAny("twisted.trial.test.skipping.SynchronousSetUpTodo") TearDownTodo = namedAny("twisted.trial.test.skipping.SynchronousTearDownTodo") class AsynchronousTodoTests(TodoMixin, unittest.TestCase): """ Test the class skipping features in the asynchronous case. See: L{twisted.trial.test.test_tests.TodoMixin} """ Todo = namedAny("twisted.trial.test.skipping.AsynchronousTodo") SetUpTodo = namedAny("twisted.trial.test.skipping.AsynchronousSetUpTodo") TearDownTodo = namedAny("twisted.trial.test.skipping.AsynchronousTearDownTodo") class ClassTodoMixin(ResultsTestMixin): """ Tests for the class-wide I{expected failure} features of L{twisted.trial.unittest.TestCase}. """ def setUp(self): """ Setup our test case """ self.loadSuite(self.TodoClass) def test_counting(self): """ Ensure that we've got four test cases. """ self.assertCount(4) def test_results(self): """ Running a suite in which an entire class is marked as expected to fail produces a successful result with no recorded errors, failures, or skips, all methods which fail and were expected to fail recorded as C{expectedFailures}, and all methods which pass but which were expected to fail recorded as C{unexpectedSuccesses}. Additionally, no tests are recorded as successes. """ self.suite(self.reporter) self.assertTrue(self.reporter.wasSuccessful()) self.assertEqual(self.reporter.errors, []) self.assertEqual(self.reporter.failures, []) self.assertEqual(self.reporter.skips, []) self.assertEqual(len(self.reporter.expectedFailures), 2) self.assertEqual(len(self.reporter.unexpectedSuccesses), 2) self.assertEqual(self.reporter.successes, 0) def test_expectedFailures(self): """ Ensure that expected failures are handled properly. """ self.suite(self.reporter) expectedReasons = ["method", "class"] reasonsGiven = [r.reason for t, e, r in self.reporter.expectedFailures] self.assertEqual(expectedReasons, reasonsGiven) def test_unexpectedSuccesses(self): """ Ensure that unexpected successes are caught. """ self.suite(self.reporter) expectedReasons = ["method", "class"] reasonsGiven = [r.reason for t, r in self.reporter.unexpectedSuccesses] self.assertEqual(expectedReasons, reasonsGiven) class SynchronousClassTodoTests(ClassTodoMixin, unittest.SynchronousTestCase): """ Tests for the class-wide I{expected failure} features in the synchronous case. See: L{twisted.trial.test.test_tests.ClassTodoMixin} """ TodoClass = namedAny("twisted.trial.test.skipping.SynchronousTodoClass") class AsynchronousClassTodoTests(ClassTodoMixin, unittest.TestCase): """ Tests for the class-wide I{expected failure} features in the asynchronous case. See: L{twisted.trial.test.test_tests.ClassTodoMixin} """ TodoClass = namedAny("twisted.trial.test.skipping.AsynchronousTodoClass") class StrictTodoMixin(ResultsTestMixin): """ Tests for the I{expected failure} features of L{twisted.trial.unittest.TestCase} in which the exact failure which is expected is indicated. """ def setUp(self): """ Setup our test case """ self.loadSuite(self.StrictTodo) def test_counting(self): """ Assert there are seven test cases """ self.assertCount(7) def test_results(self): """ A test method which is marked as expected to fail with a particular exception is only counted as an expected failure if it does fail with that exception, not if it fails with some other exception. """ self.suite(self.reporter) self.assertFalse(self.reporter.wasSuccessful()) self.assertEqual(len(self.reporter.errors), 2) self.assertEqual(len(self.reporter.failures), 1) self.assertEqual(len(self.reporter.expectedFailures), 3) self.assertEqual(len(self.reporter.unexpectedSuccesses), 1) self.assertEqual(self.reporter.successes, 0) self.assertEqual(self.reporter.skips, []) def test_expectedFailures(self): """ Ensure that expected failures are handled properly. """ self.suite(self.reporter) expectedReasons = ["todo1", "todo2", "todo5"] reasonsGotten = [r.reason for t, e, r in self.reporter.expectedFailures] self.assertEqual(expectedReasons, reasonsGotten) def test_unexpectedSuccesses(self): """ Ensure that unexpected successes are caught. """ self.suite(self.reporter) expectedReasons = [([RuntimeError], "todo7")] reasonsGotten = [ (r.errors, r.reason) for t, r in self.reporter.unexpectedSuccesses ] self.assertEqual(expectedReasons, reasonsGotten) class SynchronousStrictTodoTests(StrictTodoMixin, unittest.SynchronousTestCase): """ Tests for the expected failure case when the exact failure that is expected is indicated in the synchronous case See: L{twisted.trial.test.test_tests.StrictTodoMixin} """ StrictTodo = namedAny("twisted.trial.test.skipping.SynchronousStrictTodo") class AsynchronousStrictTodoTests(StrictTodoMixin, unittest.TestCase): """ Tests for the expected failure case when the exact failure that is expected is indicated in the asynchronous case See: L{twisted.trial.test.test_tests.StrictTodoMixin} """ StrictTodo = namedAny("twisted.trial.test.skipping.AsynchronousStrictTodo") class ReactorCleanupTests(unittest.SynchronousTestCase): """ Tests for cleanup and reporting of reactor event sources left behind by test methods. """ def setUp(self): """ Setup our test case """ self.result = reporter.Reporter(StringIO()) self.loader = runner.TestLoader() def test_leftoverSockets(self): """ Trial reports a L{util.DirtyReactorAggregateError} if a test leaves sockets behind. """ suite = self.loader.loadByName( "twisted.trial.test.erroneous.SocketOpenTest.test_socketsLeftOpen" ) suite.run(self.result) self.assertFalse(self.result.wasSuccessful()) # socket cleanup happens at end of class's tests. # all the tests in the class are successful, even if the suite # fails self.assertEqual(self.result.successes, 1) failure = self.result.errors[0][1] self.assertTrue(failure.check(util.DirtyReactorAggregateError)) def test_leftoverPendingCalls(self): """ Trial reports a L{util.DirtyReactorAggregateError} and fails the test if a test leaves a L{DelayedCall} hanging. """ suite = erroneous.ReactorCleanupTests("test_leftoverPendingCalls") suite.run(self.result) self.assertFalse(self.result.wasSuccessful()) failure = self.result.errors[0][1] self.assertEqual(self.result.successes, 0) self.assertTrue(failure.check(util.DirtyReactorAggregateError)) class FixtureMixin: """ Tests for fixture helper methods (e.g. setUp, tearDown). """ def setUp(self): """ Setup our test case """ self.reporter = reporter.Reporter() self.loader = pyunit.TestLoader() def test_brokenSetUp(self): """ When setUp fails, the error is recorded in the result object. """ suite = self.loader.loadTestsFromTestCase(self.TestFailureInSetUp) suite.run(self.reporter) self.assertTrue(len(self.reporter.errors) > 0) self.assertIsInstance(self.reporter.errors[0][1].value, erroneous.FoolishError) self.assertEqual(0, self.reporter.successes) def test_brokenTearDown(self): """ When tearDown fails, the error is recorded in the result object. """ suite = self.loader.loadTestsFromTestCase(self.TestFailureInTearDown) suite.run(self.reporter) errors = self.reporter.errors self.assertTrue(len(errors) > 0) self.assertIsInstance(errors[0][1].value, erroneous.FoolishError) self.assertEqual(0, self.reporter.successes) def test_tearDownRunsOnTestFailure(self): """ L{SynchronousTestCase.tearDown} runs when a test method fails. """ suite = self.loader.loadTestsFromTestCase(self.TestFailureButTearDownRuns) case = list(suite)[0] self.assertFalse(case.tornDown) suite.run(self.reporter) errors = self.reporter.errors self.assertTrue(len(errors) > 0) self.assertIsInstance(errors[0][1].value, erroneous.FoolishError) self.assertEqual(0, self.reporter.successes) self.assertTrue(case.tornDown) class SynchronousFixtureTests(FixtureMixin, unittest.SynchronousTestCase): """ Tests for broken fixture helper methods in the synchronous case See: L{twisted.trial.test.test_tests.FixtureMixin} """ TestFailureInSetUp = namedAny( "twisted.trial.test.erroneous.SynchronousTestFailureInSetUp" ) TestFailureInTearDown = namedAny( "twisted.trial.test.erroneous.SynchronousTestFailureInTearDown" ) TestFailureButTearDownRuns = namedAny( "twisted.trial.test.erroneous.SynchronousTestFailureButTearDownRuns" ) class AsynchronousFixtureTests(FixtureMixin, unittest.TestCase): """ Tests for broken fixture helper methods in the asynchronous case See: L{twisted.trial.test.test_tests.FixtureMixin} """ TestFailureInSetUp = namedAny( "twisted.trial.test.erroneous.AsynchronousTestFailureInSetUp" ) TestFailureInTearDown = namedAny( "twisted.trial.test.erroneous.AsynchronousTestFailureInTearDown" ) TestFailureButTearDownRuns = namedAny( "twisted.trial.test.erroneous.AsynchronousTestFailureButTearDownRuns" ) class AsynchronousSuppressionTests(SuppressionMixin, unittest.TestCase): """ Tests for the warning suppression features of L{twisted.trial.unittest.TestCase} See L{twisted.trial.test.test_suppression.SuppressionMixin} """ TestSetUpSuppression = namedAny( "twisted.trial.test.suppression.AsynchronousTestSetUpSuppression" ) TestTearDownSuppression = namedAny( "twisted.trial.test.suppression.AsynchronousTestTearDownSuppression" ) TestSuppression = namedAny( "twisted.trial.test.suppression.AsynchronousTestSuppression" ) TestSuppression2 = namedAny( "twisted.trial.test.suppression.AsynchronousTestSuppression2" ) class GCMixin: """ I provide a few mock tests that log setUp, tearDown, test execution and garbage collection. I'm used to test whether gc.collect gets called. """ class BasicTest(unittest.SynchronousTestCase): """ Mock test to run. """ def setUp(self): """ Mock setUp """ self._log("setUp") def test_foo(self): """ Mock test case """ self._log("test") def tearDown(self): """ Mock tear tearDown """ self._log("tearDown") def _log(self, msg): """ Log function """ self._collectCalled.append(msg) def collect(self): """Fake gc.collect""" self._log("collect") def setUp(self): """ Setup our test case """ self._collectCalled = [] self.BasicTest._log = self._log self._oldCollect = gc.collect gc.collect = self.collect def tearDown(self): """ Tear down the test """ gc.collect = self._oldCollect class GarbageCollectionDefaultTests(GCMixin, unittest.SynchronousTestCase): """ By default, tests should not force garbage collection. """ def test_collectNotDefault(self): """ By default, tests should not force garbage collection. """ test = self.BasicTest("test_foo") result = reporter.TestResult() test.run(result) self.assertEqual(self._collectCalled, ["setUp", "test", "tearDown"]) class GarbageCollectionTests(GCMixin, unittest.SynchronousTestCase): """ Test that, when force GC, it works. """ def test_collectCalled(self): """ test gc.collect is called before and after each test. """ test = GarbageCollectionTests.BasicTest("test_foo") test = _ForceGarbageCollectionDecorator(test) result = reporter.TestResult() test.run(result) self.assertEqual( self._collectCalled, ["collect", "setUp", "test", "tearDown", "collect"] ) class UnhandledDeferredTests(unittest.SynchronousTestCase): """ Test what happens when we have an unhandled deferred left around after a test. """ def setUp(self): """ Setup our test case """ from twisted.trial.test import weird # test_unhandledDeferred creates a cycle. we need explicit control of gc gc.disable() self.test1 = _ForceGarbageCollectionDecorator( weird.TestBleeding("test_unhandledDeferred") ) def test_isReported(self): """ Forcing garbage collection should cause unhandled Deferreds to be reported as errors. """ result = reporter.TestResult() self.test1(result) self.assertEqual( len(result.errors), 1, "Unhandled deferred passed without notice" ) @pyunit.skipIf(_PYPY, "GC works differently on PyPy.") def test_doesntBleed(self): """ Forcing garbage collection in the test should mean that there are no unreachable cycles immediately after the test completes. """ result = reporter.TestResult() self.test1(result) self.flushLoggedErrors() # test1 logs errors that get caught be us. # test1 created unreachable cycle. # it & all others should have been collected by now. n = len(gc.garbage) self.assertEqual(n, 0, "unreachable cycle still existed") # check that last gc.collect didn't log more errors x = self.flushLoggedErrors() self.assertEqual(len(x), 0, "Errors logged after gc.collect") def tearDown(self): """ Tear down the test """ gc.collect() gc.enable() self.flushLoggedErrors() class AddCleanupMixin: """ Test the addCleanup method of TestCase. """ def setUp(self): """ Setup our test case """ super().setUp() self.result = reporter.TestResult() self.test = self.AddCleanup() def test_addCleanupCalledIfSetUpFails(self): """ Callables added with C{addCleanup} are run even if setUp fails. """ self.test.setUp = self.test.brokenSetUp self.test.addCleanup(self.test.append, "foo") self.test.run(self.result) self.assertEqual(["setUp", "foo"], self.test.log) def test_addCleanupCalledIfSetUpSkips(self): """ Callables added with C{addCleanup} are run even if setUp raises L{SkipTest}. This allows test authors to reliably provide clean up code using C{addCleanup}. """ self.test.setUp = self.test.skippingSetUp self.test.addCleanup(self.test.append, "foo") self.test.run(self.result) self.assertEqual(["setUp", "foo"], self.test.log) def test_addCleanupCalledInReverseOrder(self): """ Callables added with C{addCleanup} should be called before C{tearDown} in reverse order of addition. """ self.test.addCleanup(self.test.append, "foo") self.test.addCleanup(self.test.append, "bar") self.test.run(self.result) self.assertEqual(["setUp", "runTest", "bar", "foo", "tearDown"], self.test.log) def test_errorInCleanupIsCaptured(self): """ Errors raised in cleanup functions should be treated like errors in C{tearDown}. They should be added as errors and fail the test. Skips, todos and failures are all treated as errors. """ self.test.addCleanup(self.test.fail, "foo") self.test.run(self.result) self.assertFalse(self.result.wasSuccessful()) self.assertEqual(1, len(self.result.errors)) [(test, error)] = self.result.errors self.assertEqual(test, self.test) self.assertEqual(error.getErrorMessage(), "foo") def test_cleanupsContinueRunningAfterError(self): """ If a cleanup raises an error then that does not stop the other cleanups from being run. """ self.test.addCleanup(self.test.append, "foo") self.test.addCleanup(self.test.fail, "bar") self.test.run(self.result) self.assertEqual(["setUp", "runTest", "foo", "tearDown"], self.test.log) self.assertEqual(1, len(self.result.errors)) [(test, error)] = self.result.errors self.assertEqual(test, self.test) self.assertEqual(error.getErrorMessage(), "bar") def test_multipleErrorsReported(self): """ If more than one cleanup fails, then the test should fail with more than one error. """ self.test.addCleanup(self.test.fail, "foo") self.test.addCleanup(self.test.fail, "bar") self.test.run(self.result) self.assertEqual(["setUp", "runTest", "tearDown"], self.test.log) self.assertEqual(2, len(self.result.errors)) [(test1, error1), (test2, error2)] = self.result.errors self.assertEqual(test1, self.test) self.assertEqual(test2, self.test) self.assertEqual(error1.getErrorMessage(), "bar") self.assertEqual(error2.getErrorMessage(), "foo") class SynchronousAddCleanupTests(AddCleanupMixin, unittest.SynchronousTestCase): """ Test the addCleanup method of TestCase in the synchronous case See: L{twisted.trial.test.test_tests.AddCleanupMixin} """ AddCleanup = namedAny("twisted.trial.test.skipping.SynchronousAddCleanup") class AsynchronousAddCleanupTests(AddCleanupMixin, unittest.TestCase): """ Test the addCleanup method of TestCase in the asynchronous case See: L{twisted.trial.test.test_tests.AddCleanupMixin} """ AddCleanup = namedAny("twisted.trial.test.skipping.AsynchronousAddCleanup") def test_addCleanupWaitsForDeferreds(self): """ If an added callable returns a L{Deferred}, then the test should wait until that L{Deferred} has fired before running the next cleanup method. """ def cleanup(message): d = defer.Deferred() reactor.callLater(0, d.callback, message) return d.addCallback(self.test.append) self.test.addCleanup(self.test.append, "foo") self.test.addCleanup(cleanup, "bar") self.test.run(self.result) self.assertEqual(["setUp", "runTest", "bar", "foo", "tearDown"], self.test.log) class SuiteClearingMixin: """ Tests for our extension that allows us to clear out a L{TestSuite}. """ def test_clearSuite(self): """ Calling L{_clearSuite} on a populated L{TestSuite} removes all tests. """ suite = unittest.TestSuite() suite.addTest(self.TestCase()) # Double check that the test suite actually has something in it. self.assertEqual(1, suite.countTestCases()) _clearSuite(suite) self.assertEqual(0, suite.countTestCases()) def test_clearPyunitSuite(self): """ Calling L{_clearSuite} on a populated standard library L{TestSuite} removes all tests. This test is important since C{_clearSuite} operates by mutating internal variables. """ suite = pyunit.TestSuite() suite.addTest(self.TestCase()) # Double check that the test suite actually has something in it. self.assertEqual(1, suite.countTestCases()) _clearSuite(suite) self.assertEqual(0, suite.countTestCases()) class SynchronousSuiteClearingTests(SuiteClearingMixin, unittest.SynchronousTestCase): """ Tests for our extension that allows us to clear out a L{TestSuite} in the synchronous case. See L{twisted.trial.test.test_tests.SuiteClearingMixin} """ TestCase = unittest.SynchronousTestCase class AsynchronousSuiteClearingTests(SuiteClearingMixin, unittest.TestCase): """ Tests for our extension that allows us to clear out a L{TestSuite} in the asynchronous case. See L{twisted.trial.test.test_tests.SuiteClearingMixin} """ TestCase = unittest.TestCase class TestDecoratorMixin: """ Tests for our test decoration features. """ def assertTestsEqual(self, observed, expected): """ Assert that the given decorated tests are equal. """ self.assertEqual(observed.__class__, expected.__class__, "Different class") observedOriginal = getattr(observed, "_originalTest", None) expectedOriginal = getattr(expected, "_originalTest", None) self.assertIdentical(observedOriginal, expectedOriginal) if observedOriginal is expectedOriginal is None: self.assertIdentical(observed, expected) def assertSuitesEqual(self, observed, expected): """ Assert that the given test suites with decorated tests are equal. """ self.assertEqual(observed.__class__, expected.__class__, "Different class") self.assertEqual( len(observed._tests), len(expected._tests), "Different number of tests." ) for observedTest, expectedTest in zip(observed._tests, expected._tests): if getattr(observedTest, "_tests", None) is not None: self.assertSuitesEqual(observedTest, expectedTest) else: self.assertTestsEqual(observedTest, expectedTest) def test_usesAdaptedReporterWithRun(self): """ For decorated tests, C{run} uses a result adapter that preserves the test decoration for calls to C{addError}, C{startTest} and the like. See L{reporter._AdaptedReporter}. """ test = self.TestCase() decoratedTest = unittest.TestDecorator(test) # Move to top in ticket #5964: from twisted.trial.test.test_reporter import LoggingReporter result = LoggingReporter() decoratedTest.run(result) self.assertTestsEqual(result.test, decoratedTest) def test_usesAdaptedReporterWithCall(self): """ For decorated tests, C{__call__} uses a result adapter that preserves the test decoration for calls to C{addError}, C{startTest} and the like. See L{reporter._AdaptedReporter}. """ test = self.TestCase() decoratedTest = unittest.TestDecorator(test) # Move to top in ticket #5964: from twisted.trial.test.test_reporter import LoggingReporter result = LoggingReporter() decoratedTest(result) self.assertTestsEqual(result.test, decoratedTest) def test_decorateSingleTest(self): """ Calling L{decorate} on a single test case returns the test case decorated with the provided decorator. """ test = self.TestCase() decoratedTest = unittest.decorate(test, unittest.TestDecorator) self.assertTestsEqual(unittest.TestDecorator(test), decoratedTest) def test_decorateTestSuite(self): """ Calling L{decorate} on a test suite will return a test suite with each test decorated with the provided decorator. """ test = self.TestCase() suite = unittest.TestSuite([test]) decoratedTest = unittest.decorate(suite, unittest.TestDecorator) self.assertSuitesEqual( decoratedTest, unittest.TestSuite([unittest.TestDecorator(test)]) ) def test_decorateInPlaceMutatesOriginal(self): """ Calling L{decorate} on a test suite will mutate the original suite. """ test = self.TestCase() suite = unittest.TestSuite([test]) decoratedTest = unittest.decorate(suite, unittest.TestDecorator) self.assertSuitesEqual( decoratedTest, unittest.TestSuite([unittest.TestDecorator(test)]) ) self.assertSuitesEqual( suite, unittest.TestSuite([unittest.TestDecorator(test)]) ) def test_decorateTestSuiteReferences(self): """ When decorating a test suite in-place, the number of references to the test objects in that test suite should stay the same. Previously, L{unittest.decorate} recreated a test suite, so the original suite kept references to the test objects. This test is here to ensure the problem doesn't reappear again. """ getrefcount = getattr(sys, "getrefcount", None) if getrefcount is None: # For example non CPython like _PYPY. raise unittest.SkipTest("getrefcount not supported on this platform") test = self.TestCase() suite = unittest.TestSuite([test]) count1 = getrefcount(test) unittest.decorate(suite, unittest.TestDecorator) count2 = getrefcount(test) self.assertEqual(count1, count2) def test_decorateNestedTestSuite(self): """ Calling L{decorate} on a test suite with nested suites will return a test suite that maintains the same structure, but with all tests decorated. """ test = self.TestCase() suite = unittest.TestSuite([unittest.TestSuite([test])]) decoratedTest = unittest.decorate(suite, unittest.TestDecorator) expected = unittest.TestSuite( [unittest.TestSuite([unittest.TestDecorator(test)])] ) self.assertSuitesEqual(decoratedTest, expected) def test_decorateDecoratedSuite(self): """ Calling L{decorate} on a test suite with already-decorated tests decorates all of the tests in the suite again. """ test = self.TestCase() decoratedTest = unittest.decorate(test, unittest.TestDecorator) redecoratedTest = unittest.decorate(decoratedTest, unittest.TestDecorator) self.assertTestsEqual(redecoratedTest, unittest.TestDecorator(decoratedTest)) def test_decoratePreservesSuite(self): """ Tests can be in non-standard suites. L{decorate} preserves the non-standard suites when it decorates the tests. """ test = self.TestCase() suite = runner.DestructiveTestSuite([test]) decorated = unittest.decorate(suite, unittest.TestDecorator) self.assertSuitesEqual( decorated, runner.DestructiveTestSuite([unittest.TestDecorator(test)]) ) class SynchronousTestDecoratorTests(TestDecoratorMixin, unittest.SynchronousTestCase): """ Tests for our test decoration features in the synchronous case. See L{twisted.trial.test.test_tests.TestDecoratorMixin} """ TestCase = unittest.SynchronousTestCase class AsynchronousTestDecoratorTests(TestDecoratorMixin, unittest.TestCase): """ Tests for our test decoration features in the asynchronous case. See L{twisted.trial.test.test_tests.TestDecoratorMixin} """ TestCase = unittest.TestCase class MonkeyPatchMixin: """ Tests for the patch() helper method in L{unittest.TestCase}. """ def setUp(self): """ Setup our test case """ self.originalValue = "original" self.patchedValue = "patched" self.objectToPatch = self.originalValue self.test = self.TestCase() def test_patch(self): """ Calling C{patch()} on a test monkey patches the specified object and attribute. """ self.test.patch(self, "objectToPatch", self.patchedValue) self.assertEqual(self.objectToPatch, self.patchedValue) def test_patchRestoredAfterRun(self): """ Any monkey patches introduced by a test using C{patch()} are reverted after the test has run. """ self.test.patch(self, "objectToPatch", self.patchedValue) self.test.run(reporter.Reporter()) self.assertEqual(self.objectToPatch, self.originalValue) def test_revertDuringTest(self): """ C{patch()} return a L{monkey.MonkeyPatcher} object that can be used to restore the original values before the end of the test. """ patch = self.test.patch(self, "objectToPatch", self.patchedValue) patch.restore() self.assertEqual(self.objectToPatch, self.originalValue) def test_revertAndRepatch(self): """ The returned L{monkey.MonkeyPatcher} object can re-apply the patch during the test run. """ patch = self.test.patch(self, "objectToPatch", self.patchedValue) patch.restore() patch.patch() self.assertEqual(self.objectToPatch, self.patchedValue) def test_successivePatches(self): """ Successive patches are applied and reverted just like a single patch. """ self.test.patch(self, "objectToPatch", self.patchedValue) self.assertEqual(self.objectToPatch, self.patchedValue) self.test.patch(self, "objectToPatch", "second value") self.assertEqual(self.objectToPatch, "second value") self.test.run(reporter.Reporter()) self.assertEqual(self.objectToPatch, self.originalValue) class SynchronousMonkeyPatchTests(MonkeyPatchMixin, unittest.SynchronousTestCase): """ Tests for the patch() helper method in the synchronous case. See L{twisted.trial.test.test_tests.MonkeyPatchMixin} """ TestCase = unittest.SynchronousTestCase class AsynchronousMonkeyPatchTests(MonkeyPatchMixin, unittest.TestCase): """ Tests for the patch() helper method in the asynchronous case. See L{twisted.trial.test.test_tests.MonkeyPatchMixin} """ TestCase = unittest.TestCase class IterateTestsMixin: """ L{_iterateTests} returns a list of all test cases in a test suite or test case. """ def test_iterateTestCase(self): """ L{_iterateTests} on a single test case returns a list containing that test case. """ test = self.TestCase() self.assertEqual([test], list(_iterateTests(test))) def test_iterateSingletonTestSuite(self): """ L{_iterateTests} on a test suite that contains a single test case returns a list containing that test case. """ test = self.TestCase() suite = runner.TestSuite([test]) self.assertEqual([test], list(_iterateTests(suite))) def test_iterateNestedTestSuite(self): """ L{_iterateTests} returns tests that are in nested test suites. """ test = self.TestCase() suite = runner.TestSuite([runner.TestSuite([test])]) self.assertEqual([test], list(_iterateTests(suite))) def test_iterateIsLeftToRightDepthFirst(self): """ L{_iterateTests} returns tests in left-to-right, depth-first order. """ test = self.TestCase() suite = runner.TestSuite([runner.TestSuite([test]), self]) self.assertEqual([test, self], list(_iterateTests(suite))) class SynchronousIterateTestsTests(IterateTestsMixin, unittest.SynchronousTestCase): """ Check that L{_iterateTests} returns a list of all test cases in a test suite or test case for synchronous tests. See L{twisted.trial.test.test_tests.IterateTestsMixin} """ TestCase = unittest.SynchronousTestCase class AsynchronousIterateTestsTests(IterateTestsMixin, unittest.TestCase): """ Check that L{_iterateTests} returns a list of all test cases in a test suite or test case for asynchronous tests. See L{twisted.trial.test.test_tests.IterateTestsMixin} """ TestCase = unittest.TestCase class TrialGeneratorFunctionTests(unittest.SynchronousTestCase): """ Tests for generator function methods in test cases. """ def test_errorOnGeneratorFunction(self): """ In a TestCase, a test method which is a generator function is reported as an error, as such a method will never run assertions. """ class GeneratorTestCase(unittest.TestCase): """ A fake TestCase for testing purposes. """ def test_generator(self): """ A method which is also a generator function, for testing purposes. """ self.fail("this should never be reached") yield testCase = GeneratorTestCase("test_generator") result = reporter.TestResult() testCase.run(result) self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.errors), 1) self.assertIn( "GeneratorTestCase.test_generator", result.errors[0][1].value.args[0] ) self.assertIn( "GeneratorTestCase testMethod=test_generator", result.errors[0][1].value.args[0], ) self.assertIn( "is a generator function and therefore will never run", result.errors[0][1].value.args[0], ) def test_synchronousTestCaseErrorOnGeneratorFunction(self): """ In a SynchronousTestCase, a test method which is a generator function is reported as an error, as such a method will never run assertions. """ class GeneratorSynchronousTestCase(unittest.SynchronousTestCase): """ A fake SynchronousTestCase for testing purposes. """ def test_generator(self): """ A method which is also a generator function, for testing purposes. """ self.fail("this should never be reached") yield testCase = GeneratorSynchronousTestCase("test_generator") result = reporter.TestResult() testCase.run(result) self.assertEqual(len(result.failures), 0) self.assertEqual(len(result.errors), 1) self.assertIn( "GeneratorSynchronousTestCase.test_generator", result.errors[0][1].value.args[0], ) self.assertIn( "GeneratorSynchronousTestCase testMethod=test_generator", result.errors[0][1].value.args[0], ) self.assertIn( "is a generator function and therefore will never run", result.errors[0][1].value.args[0], ) PK b�Z�=� � test/test_keyboard.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for interrupting tests with Control-C. """ from io import StringIO from twisted.trial import reporter, runner, unittest class TrialTest(unittest.SynchronousTestCase): def setUp(self): self.output = StringIO() self.reporter = reporter.TestResult() self.loader = runner.TestLoader() class InterruptInTestTests(TrialTest): class InterruptedTest(unittest.TestCase): def test_02_raiseInterrupt(self): raise KeyboardInterrupt def test_01_doNothing(self): pass def test_03_doNothing(self): InterruptInTestTests.test_03_doNothing_run = True def setUp(self): super().setUp() self.suite = self.loader.loadClass(InterruptInTestTests.InterruptedTest) InterruptInTestTests.test_03_doNothing_run = None def test_setUpOK(self): self.assertEqual(3, self.suite.countTestCases()) self.assertEqual(0, self.reporter.testsRun) self.assertFalse(self.reporter.shouldStop) def test_interruptInTest(self): runner.TrialSuite([self.suite]).run(self.reporter) self.assertTrue(self.reporter.shouldStop) self.assertEqual(2, self.reporter.testsRun) self.assertFalse( InterruptInTestTests.test_03_doNothing_run, "test_03_doNothing ran." ) class InterruptInSetUpTests(TrialTest): testsRun = 0 class InterruptedTest(unittest.TestCase): def setUp(self): if InterruptInSetUpTests.testsRun > 0: raise KeyboardInterrupt def test_01(self): InterruptInSetUpTests.testsRun += 1 def test_02(self): InterruptInSetUpTests.testsRun += 1 InterruptInSetUpTests.test_02_run = True def setUp(self): super().setUp() self.suite = self.loader.loadClass(InterruptInSetUpTests.InterruptedTest) InterruptInSetUpTests.test_02_run = False InterruptInSetUpTests.testsRun = 0 def test_setUpOK(self): self.assertEqual(0, InterruptInSetUpTests.testsRun) self.assertEqual(2, self.suite.countTestCases()) self.assertEqual(0, self.reporter.testsRun) self.assertFalse(self.reporter.shouldStop) def test_interruptInSetUp(self): runner.TrialSuite([self.suite]).run(self.reporter) self.assertTrue(self.reporter.shouldStop) self.assertEqual(2, self.reporter.testsRun) self.assertFalse(InterruptInSetUpTests.test_02_run, "test_02 ran") class InterruptInTearDownTests(TrialTest): testsRun = 0 class InterruptedTest(unittest.TestCase): def tearDown(self): if InterruptInTearDownTests.testsRun > 0: raise KeyboardInterrupt def test_01(self): InterruptInTearDownTests.testsRun += 1 def test_02(self): InterruptInTearDownTests.testsRun += 1 InterruptInTearDownTests.test_02_run = True def setUp(self): super().setUp() self.suite = self.loader.loadClass(InterruptInTearDownTests.InterruptedTest) InterruptInTearDownTests.testsRun = 0 InterruptInTearDownTests.test_02_run = False def test_setUpOK(self): self.assertEqual(0, InterruptInTearDownTests.testsRun) self.assertEqual(2, self.suite.countTestCases()) self.assertEqual(0, self.reporter.testsRun) self.assertFalse(self.reporter.shouldStop) def test_interruptInTearDown(self): runner.TrialSuite([self.suite]).run(self.reporter) self.assertEqual(1, self.reporter.testsRun) self.assertTrue(self.reporter.shouldStop) self.assertFalse(InterruptInTearDownTests.test_02_run, "test_02 ran") PK b�Z�}[�� � test/test_plugins.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # # Maintainer: Jonathan Lange """ Tests for L{twisted.plugins.twisted_trial}. """ from twisted.plugin import getPlugins from twisted.trial import unittest from twisted.trial.itrial import IReporter class PluginsTests(unittest.SynchronousTestCase): """ Tests for Trial's reporter plugins. """ def getPluginsByLongOption(self, longOption): """ Return the Trial reporter plugin with the given long option. If more than one is found, raise ValueError. If none are found, raise IndexError. """ plugins = [ plugin for plugin in getPlugins(IReporter) if plugin.longOpt == longOption ] if len(plugins) > 1: raise ValueError( "More than one plugin found with long option %r: %r" % (longOption, plugins) ) return plugins[0] def test_subunitPlugin(self): """ One of the reporter plugins is the subunit reporter plugin. """ subunitPlugin = self.getPluginsByLongOption("subunit") self.assertEqual("Subunit Reporter", subunitPlugin.name) self.assertEqual("twisted.trial.reporter", subunitPlugin.module) self.assertEqual("subunit", subunitPlugin.longOpt) self.assertIdentical(None, subunitPlugin.shortOpt) self.assertEqual("SubunitReporter", subunitPlugin.klass) PK b�Z�㽂 � test/__init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Unit tests for the Trial unit-testing framework. """ PK b�Z����� � _synctest.pynu �[��� # -*- test-case-name: twisted.trial.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Things likely to be used by writers of unit tests. Maintainer: Jonathan Lange """ import inspect import os import sys import tempfile import types import unittest as pyunit import warnings from dis import findlinestarts as _findlinestarts from typing import Optional, Tuple # Python 2.7 and higher has skip support built-in from unittest import SkipTest from twisted.internet.defer import ensureDeferred from twisted.python import failure, log, monkey from twisted.python.deprecate import ( DEPRECATION_WARNING_FORMAT, getDeprecationWarningString, getVersionString, warnAboutFunction, ) from twisted.python.reflect import fullyQualifiedName from twisted.python.util import runWithWarningsSuppressed from twisted.trial import itrial, util class FailTest(AssertionError): """ Raised to indicate the current test has failed to pass. """ class Todo: """ Internal object used to mark a L{TestCase} as 'todo'. Tests marked 'todo' are reported differently in Trial L{TestResult}s. If todo'd tests fail, they do not fail the suite and the errors are reported in a separate category. If todo'd tests succeed, Trial L{TestResult}s will report an unexpected success. """ def __init__(self, reason, errors=None): """ @param reason: A string explaining why the test is marked 'todo' @param errors: An iterable of exception types that the test is expected to raise. If one of these errors is raised by the test, it will be trapped. Raising any other kind of error will fail the test. If L{None} is passed, then all errors will be trapped. """ self.reason = reason self.errors = errors def __repr__(self) -> str: return f"<Todo reason={self.reason!r} errors={self.errors!r}>" def expected(self, failure): """ @param failure: A L{twisted.python.failure.Failure}. @return: C{True} if C{failure} is expected, C{False} otherwise. """ if self.errors is None: return True for error in self.errors: if failure.check(error): return True return False def makeTodo(value): """ Return a L{Todo} object built from C{value}. If C{value} is a string, return a Todo that expects any exception with C{value} as a reason. If C{value} is a tuple, the second element is used as the reason and the first element as the excepted error(s). @param value: A string or a tuple of C{(errors, reason)}, where C{errors} is either a single exception class or an iterable of exception classes. @return: A L{Todo} object. """ if isinstance(value, str): return Todo(reason=value) if isinstance(value, tuple): errors, reason = value try: errors = list(errors) except TypeError: errors = [errors] return Todo(reason=reason, errors=errors) class _Warning: """ A L{_Warning} instance represents one warning emitted through the Python warning system (L{warnings}). This is used to insulate callers of L{_collectWarnings} from changes to the Python warnings system which might otherwise require changes to the warning objects that function passes to the observer object it accepts. @ivar message: The string which was passed as the message parameter to L{warnings.warn}. @ivar category: The L{Warning} subclass which was passed as the category parameter to L{warnings.warn}. @ivar filename: The name of the file containing the definition of the code object which was C{stacklevel} frames above the call to L{warnings.warn}, where C{stacklevel} is the value of the C{stacklevel} parameter passed to L{warnings.warn}. @ivar lineno: The source line associated with the active instruction of the code object object which was C{stacklevel} frames above the call to L{warnings.warn}, where C{stacklevel} is the value of the C{stacklevel} parameter passed to L{warnings.warn}. """ def __init__(self, message, category, filename, lineno): self.message = message self.category = category self.filename = filename self.lineno = lineno def _setWarningRegistryToNone(modules): """ Disable the per-module cache for every module found in C{modules}, typically C{sys.modules}. @param modules: Dictionary of modules, typically sys.module dict """ for v in list(modules.values()): if v is not None: try: v.__warningregistry__ = None except BaseException: # Don't specify a particular exception type to handle in case # some wacky object raises some wacky exception in response to # the setattr attempt. pass def _collectWarnings(observeWarning, f, *args, **kwargs): """ Call C{f} with C{args} positional arguments and C{kwargs} keyword arguments and collect all warnings which are emitted as a result in a list. @param observeWarning: A callable which will be invoked with a L{_Warning} instance each time a warning is emitted. @return: The return value of C{f(*args, **kwargs)}. """ def showWarning(message, category, filename, lineno, file=None, line=None): assert isinstance(message, Warning) observeWarning(_Warning(str(message), category, filename, lineno)) # Disable the per-module cache for every module otherwise if the warning # which the caller is expecting us to collect was already emitted it won't # be re-emitted by the call to f which happens below. _setWarningRegistryToNone(sys.modules) origFilters = warnings.filters[:] origShow = warnings.showwarning warnings.simplefilter("always") try: warnings.showwarning = showWarning result = f(*args, **kwargs) finally: warnings.filters[:] = origFilters warnings.showwarning = origShow return result class UnsupportedTrialFeature(Exception): """A feature of twisted.trial was used that pyunit cannot support.""" class PyUnitResultAdapter: """ Wrap a C{TestResult} from the standard library's C{unittest} so that it supports the extended result types from Trial, and also supports L{twisted.python.failure.Failure}s being passed to L{addError} and L{addFailure}. """ def __init__(self, original): """ @param original: A C{TestResult} instance from C{unittest}. """ self.original = original def _exc_info(self, err): return util.excInfoOrFailureToExcInfo(err) def startTest(self, method): self.original.startTest(method) def stopTest(self, method): self.original.stopTest(method) def addFailure(self, test, fail): self.original.addFailure(test, self._exc_info(fail)) def addError(self, test, error): self.original.addError(test, self._exc_info(error)) def _unsupported(self, test, feature, info): self.original.addFailure( test, (UnsupportedTrialFeature, UnsupportedTrialFeature(feature, info), None), ) def addSkip(self, test, reason): """ Report the skip as a failure. """ self.original.addSkip(test, reason) def addUnexpectedSuccess(self, test, todo=None): """ Report the unexpected success as a failure. """ self._unsupported(test, "unexpected success", todo) def addExpectedFailure(self, test, error): """ Report the expected failure (i.e. todo) as a failure. """ self._unsupported(test, "expected failure", error) def addSuccess(self, test): self.original.addSuccess(test) def upDownError(self, method, error, warn, printStatus): pass class _AssertRaisesContext: """ A helper for implementing C{assertRaises}. This is a context manager and a helper method to support the non-context manager version of C{assertRaises}. @ivar _testCase: See C{testCase} parameter of C{__init__} @ivar _expected: See C{expected} parameter of C{__init__} @ivar _returnValue: The value returned by the callable being tested (only when not being used as a context manager). @ivar _expectedName: A short string describing the expected exception (usually the name of the exception class). @ivar exception: The exception which was raised by the function being tested (if it raised one). """ def __init__(self, testCase, expected): """ @param testCase: The L{TestCase} instance which is used to raise a test-failing exception when that is necessary. @param expected: The exception type expected to be raised. """ self._testCase = testCase self._expected = expected self._returnValue = None try: self._expectedName = self._expected.__name__ except AttributeError: self._expectedName = str(self._expected) def _handle(self, obj): """ Call the given object using this object as a context manager. @param obj: The object to call and which is expected to raise some exception. @type obj: L{object} @return: Whatever exception is raised by C{obj()}. @rtype: L{BaseException} """ with self as context: self._returnValue = obj() return context.exception def __enter__(self): return self def __exit__(self, exceptionType, exceptionValue, traceback): """ Check exit exception against expected exception. """ # No exception raised. if exceptionType is None: self._testCase.fail( "{} not raised ({} returned)".format( self._expectedName, self._returnValue ) ) if not isinstance(exceptionValue, exceptionType): # Support some Python 2.6 ridiculousness. Exceptions raised using # the C API appear here as the arguments you might pass to the # exception class to create an exception instance. So... do that # to turn them into the instances. if isinstance(exceptionValue, tuple): exceptionValue = exceptionType(*exceptionValue) else: exceptionValue = exceptionType(exceptionValue) # Store exception so that it can be access from context. self.exception = exceptionValue # Wrong exception raised. if not issubclass(exceptionType, self._expected): reason = failure.Failure(exceptionValue, exceptionType, traceback) self._testCase.fail( "{} raised instead of {}:\n {}".format( fullyQualifiedName(exceptionType), self._expectedName, reason.getTraceback(), ), ) # All good. return True class _Assertions(pyunit.TestCase): """ Replaces many of the built-in TestCase assertions. In general, these assertions provide better error messages and are easier to use in callbacks. """ def fail(self, msg=None): """ Absolutely fail the test. Do not pass go, do not collect $200. @param msg: the message that will be displayed as the reason for the failure """ raise self.failureException(msg) def assertFalse(self, condition, msg=None): """ Fail the test if C{condition} evaluates to True. @param condition: any object that defines __nonzero__ """ super().assertFalse(condition, msg) return condition assertNot = assertFalse failUnlessFalse = assertFalse failIf = assertFalse def assertTrue(self, condition, msg=None): """ Fail the test if C{condition} evaluates to False. @param condition: any object that defines __nonzero__ """ super().assertTrue(condition, msg) return condition assert_ = assertTrue failUnlessTrue = assertTrue failUnless = assertTrue def assertRaises(self, exception, f=None, *args, **kwargs): """ Fail the test unless calling the function C{f} with the given C{args} and C{kwargs} raises C{exception}. The failure will report the traceback and call stack of the unexpected exception. @param exception: exception type that is to be expected @param f: the function to call @return: If C{f} is L{None}, a context manager which will make an assertion about the exception raised from the suite it manages. If C{f} is not L{None}, the exception raised by C{f}. @raise self.failureException: Raised if the function call does not raise an exception or if it raises an exception of a different type. """ context = _AssertRaisesContext(self, exception) if f is None: return context return context._handle(lambda: f(*args, **kwargs)) # unittest.TestCase.assertRaises() is defined with 4 arguments # but we define it with 5 arguments. So we need to tell mypy # to ignore the following assignment to failUnlessRaises failUnlessRaises = assertRaises # type: ignore[assignment] def assertEqual(self, first, second, msg=None): """ Fail the test if C{first} and C{second} are not equal. @param msg: A string describing the failure that's included in the exception. """ super().assertEqual(first, second, msg) return first failUnlessEqual = assertEqual failUnlessEquals = assertEqual assertEquals = assertEqual def assertIs(self, first, second, msg=None): """ Fail the test if C{first} is not C{second}. This is an obect-identity-equality test, not an object equality (i.e. C{__eq__}) test. @param msg: if msg is None, then the failure message will be '%r is not %r' % (first, second) """ if first is not second: raise self.failureException(msg or f"{first!r} is not {second!r}") return first failUnlessIdentical = assertIs assertIdentical = assertIs def assertIsNot(self, first, second, msg=None): """ Fail the test if C{first} is C{second}. This is an obect-identity-equality test, not an object equality (i.e. C{__eq__}) test. @param msg: if msg is None, then the failure message will be '%r is %r' % (first, second) """ if first is second: raise self.failureException(msg or f"{first!r} is {second!r}") return first failIfIdentical = assertIsNot assertNotIdentical = assertIsNot def assertNotEqual(self, first, second, msg=None): """ Fail the test if C{first} == C{second}. @param msg: if msg is None, then the failure message will be '%r == %r' % (first, second) """ if not first != second: raise self.failureException(msg or f"{first!r} == {second!r}") return first assertNotEquals = assertNotEqual failIfEquals = assertNotEqual failIfEqual = assertNotEqual def assertIn(self, containee, container, msg=None): """ Fail the test if C{containee} is not found in C{container}. @param containee: the value that should be in C{container} @param container: a sequence type, or in the case of a mapping type, will follow semantics of 'if key in dict.keys()' @param msg: if msg is None, then the failure message will be '%r not in %r' % (first, second) """ if containee not in container: raise self.failureException(msg or f"{containee!r} not in {container!r}") return containee failUnlessIn = assertIn def assertNotIn(self, containee, container, msg=None): """ Fail the test if C{containee} is found in C{container}. @param containee: the value that should not be in C{container} @param container: a sequence type, or in the case of a mapping type, will follow semantics of 'if key in dict.keys()' @param msg: if msg is None, then the failure message will be '%r in %r' % (first, second) """ if containee in container: raise self.failureException(msg or f"{containee!r} in {container!r}") return containee failIfIn = assertNotIn def assertNotAlmostEqual(self, first, second, places=7, msg=None, delta=None): """ Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero. @note: decimal places (from zero) is usually not the same as significant digits (measured from the most significant digit). @note: included for compatibility with PyUnit test cases """ if round(second - first, places) == 0: raise self.failureException( msg or f"{first!r} == {second!r} within {places!r} places" ) return first assertNotAlmostEquals = assertNotAlmostEqual failIfAlmostEqual = assertNotAlmostEqual failIfAlmostEquals = assertNotAlmostEqual def assertAlmostEqual(self, first, second, places=7, msg=None, delta=None): """ Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero. @note: decimal places (from zero) is usually not the same as significant digits (measured from the most significant digit). @note: included for compatibility with PyUnit test cases """ if round(second - first, places) != 0: raise self.failureException( msg or f"{first!r} != {second!r} within {places!r} places" ) return first assertAlmostEquals = assertAlmostEqual failUnlessAlmostEqual = assertAlmostEqual def assertApproximates(self, first, second, tolerance, msg=None): """ Fail if C{first} - C{second} > C{tolerance} @param msg: if msg is None, then the failure message will be '%r ~== %r' % (first, second) """ if abs(first - second) > tolerance: raise self.failureException(msg or f"{first} ~== {second}") return first failUnlessApproximates = assertApproximates def assertSubstring(self, substring, astring, msg=None): """ Fail if C{substring} does not exist within C{astring}. """ return self.failUnlessIn(substring, astring, msg) failUnlessSubstring = assertSubstring def assertNotSubstring(self, substring, astring, msg=None): """ Fail if C{astring} contains C{substring}. """ return self.failIfIn(substring, astring, msg) failIfSubstring = assertNotSubstring def assertWarns(self, category, message, filename, f, *args, **kwargs): """ Fail if the given function doesn't generate the specified warning when called. It calls the function, checks the warning, and forwards the result of the function if everything is fine. @param category: the category of the warning to check. @param message: the output message of the warning to check. @param filename: the filename where the warning should come from. @param f: the function which is supposed to generate the warning. @type f: any callable. @param args: the arguments to C{f}. @param kwargs: the keywords arguments to C{f}. @return: the result of the original function C{f}. """ warningsShown = [] result = _collectWarnings(warningsShown.append, f, *args, **kwargs) if not warningsShown: self.fail("No warnings emitted") first = warningsShown[0] for other in warningsShown[1:]: if (other.message, other.category) != (first.message, first.category): self.fail("Can't handle different warnings") self.assertEqual(first.message, message) self.assertIdentical(first.category, category) # Use starts with because of .pyc/.pyo issues. self.assertTrue( filename.startswith(first.filename), f"Warning in {first.filename!r}, expected {filename!r}", ) # It would be nice to be able to check the line number as well, but # different configurations actually end up reporting different line # numbers (generally the variation is only 1 line, but that's enough # to fail the test erroneously...). # self.assertEqual(lineno, xxx) return result failUnlessWarns = assertWarns def assertIsInstance(self, instance, classOrTuple, message=None): """ Fail if C{instance} is not an instance of the given class or of one of the given classes. @param instance: the object to test the type (first argument of the C{isinstance} call). @type instance: any. @param classOrTuple: the class or classes to test against (second argument of the C{isinstance} call). @type classOrTuple: class, type, or tuple. @param message: Custom text to include in the exception text if the assertion fails. """ if not isinstance(instance, classOrTuple): if message is None: suffix = "" else: suffix = ": " + message self.fail(f"{instance!r} is not an instance of {classOrTuple}{suffix}") failUnlessIsInstance = assertIsInstance def assertNotIsInstance(self, instance, classOrTuple): """ Fail if C{instance} is an instance of the given class or of one of the given classes. @param instance: the object to test the type (first argument of the C{isinstance} call). @type instance: any. @param classOrTuple: the class or classes to test against (second argument of the C{isinstance} call). @type classOrTuple: class, type, or tuple. """ if isinstance(instance, classOrTuple): self.fail(f"{instance!r} is an instance of {classOrTuple}") failIfIsInstance = assertNotIsInstance def successResultOf(self, deferred): """ Return the current success result of C{deferred} or raise C{self.failureException}. @param deferred: A L{Deferred<twisted.internet.defer.Deferred>} which has a success result. This means L{Deferred.callback<twisted.internet.defer.Deferred.callback>} or L{Deferred.errback<twisted.internet.defer.Deferred.errback>} has been called on it and it has reached the end of its callback chain and the last callback or errback returned a non-L{failure.Failure}. @type deferred: L{Deferred<twisted.internet.defer.Deferred>} @raise SynchronousTestCase.failureException: If the L{Deferred<twisted.internet.defer.Deferred>} has no result or has a failure result. @return: The result of C{deferred}. """ deferred = ensureDeferred(deferred) result = [] deferred.addBoth(result.append) if not result: self.fail( "Success result expected on {!r}, found no result instead".format( deferred ) ) result = result[0] if isinstance(result, failure.Failure): self.fail( "Success result expected on {!r}, " "found failure result instead:\n{}".format( deferred, result.getTraceback() ) ) return result def failureResultOf(self, deferred, *expectedExceptionTypes): """ Return the current failure result of C{deferred} or raise C{self.failureException}. @param deferred: A L{Deferred<twisted.internet.defer.Deferred>} which has a failure result. This means L{Deferred.callback<twisted.internet.defer.Deferred.callback>} or L{Deferred.errback<twisted.internet.defer.Deferred.errback>} has been called on it and it has reached the end of its callback chain and the last callback or errback raised an exception or returned a L{failure.Failure}. @type deferred: L{Deferred<twisted.internet.defer.Deferred>} @param expectedExceptionTypes: Exception types to expect - if provided, and the exception wrapped by the failure result is not one of the types provided, then this test will fail. @raise SynchronousTestCase.failureException: If the L{Deferred<twisted.internet.defer.Deferred>} has no result, has a success result, or has an unexpected failure result. @return: The failure result of C{deferred}. @rtype: L{failure.Failure} """ deferred = ensureDeferred(deferred) result = [] deferred.addBoth(result.append) if not result: self.fail( "Failure result expected on {!r}, found no result instead".format( deferred ) ) result = result[0] if not isinstance(result, failure.Failure): self.fail( "Failure result expected on {!r}, " "found success result ({!r}) instead".format(deferred, result) ) if expectedExceptionTypes and not result.check(*expectedExceptionTypes): expectedString = " or ".join( [".".join((t.__module__, t.__name__)) for t in expectedExceptionTypes] ) self.fail( "Failure of type ({}) expected on {!r}, " "found type {!r} instead: {}".format( expectedString, deferred, result.type, result.getTraceback() ) ) return result def assertNoResult(self, deferred): """ Assert that C{deferred} does not have a result at this point. If the assertion succeeds, then the result of C{deferred} is left unchanged. Otherwise, any L{failure.Failure} result is swallowed. @param deferred: A L{Deferred<twisted.internet.defer.Deferred>} without a result. This means that neither L{Deferred.callback<twisted.internet.defer.Deferred.callback>} nor L{Deferred.errback<twisted.internet.defer.Deferred.errback>} has been called, or that the L{Deferred<twisted.internet.defer.Deferred>} is waiting on another L{Deferred<twisted.internet.defer.Deferred>} for a result. @type deferred: L{Deferred<twisted.internet.defer.Deferred>} @raise SynchronousTestCase.failureException: If the L{Deferred<twisted.internet.defer.Deferred>} has a result. """ deferred = ensureDeferred(deferred) result = [] def cb(res): result.append(res) return res deferred.addBoth(cb) if result: # If there is already a failure, the self.fail below will # report it, so swallow it in the deferred deferred.addErrback(lambda _: None) self.fail( "No result expected on {!r}, found {!r} instead".format( deferred, result[0] ) ) class _LogObserver: """ Observes the Twisted logs and catches any errors. @ivar _errors: A C{list} of L{Failure} instances which were received as error events from the Twisted logging system. @ivar _added: A C{int} giving the number of times C{_add} has been called less the number of times C{_remove} has been called; used to only add this observer to the Twisted logging since once, regardless of the number of calls to the add method. @ivar _ignored: A C{list} of exception types which will not be recorded. """ def __init__(self): self._errors = [] self._added = 0 self._ignored = [] def _add(self): if self._added == 0: log.addObserver(self.gotEvent) self._added += 1 def _remove(self): self._added -= 1 if self._added == 0: log.removeObserver(self.gotEvent) def _ignoreErrors(self, *errorTypes): """ Do not store any errors with any of the given types. """ self._ignored.extend(errorTypes) def _clearIgnores(self): """ Stop ignoring any errors we might currently be ignoring. """ self._ignored = [] def flushErrors(self, *errorTypes): """ Flush errors from the list of caught errors. If no arguments are specified, remove all errors. If arguments are specified, only remove errors of those types from the stored list. """ if errorTypes: flushed = [] remainder = [] for f in self._errors: if f.check(*errorTypes): flushed.append(f) else: remainder.append(f) self._errors = remainder else: flushed = self._errors self._errors = [] return flushed def getErrors(self): """ Return a list of errors caught by this observer. """ return self._errors def gotEvent(self, event): """ The actual observer method. Called whenever a message is logged. @param event: A dictionary containing the log message. Actual structure undocumented (see source for L{twisted.python.log}). """ if event.get("isError", False) and "failure" in event: f = event["failure"] if len(self._ignored) == 0 or not f.check(*self._ignored): self._errors.append(f) _logObserver = _LogObserver() class SynchronousTestCase(_Assertions): """ A unit test. The atom of the unit testing universe. This class extends C{unittest.TestCase} from the standard library. A number of convenient testing helpers are added, including logging and warning integration, monkey-patching support, and more. To write a unit test, subclass C{SynchronousTestCase} and define a method (say, 'test_foo') on the subclass. To run the test, instantiate your subclass with the name of the method, and call L{run} on the instance, passing a L{TestResult} object. The C{trial} script will automatically find any C{SynchronousTestCase} subclasses defined in modules beginning with 'test_' and construct test cases for all methods beginning with 'test'. If an error is logged during the test run, the test will fail with an error. See L{log.err}. @ivar failureException: An exception class, defaulting to C{FailTest}. If the test method raises this exception, it will be reported as a failure, rather than an exception. All of the assertion methods raise this if the assertion fails. @ivar skip: L{None} or a string explaining why this test is to be skipped. If defined, the test will not be run. Instead, it will be reported to the result object as 'skipped' (if the C{TestResult} supports skipping). @ivar todo: L{None}, a string or a tuple of C{(errors, reason)} where C{errors} is either an exception class or an iterable of exception classes, and C{reason} is a string. See L{Todo} or L{makeTodo} for more information. @ivar suppress: L{None} or a list of tuples of C{(args, kwargs)} to be passed to C{warnings.filterwarnings}. Use these to suppress warnings raised in a test. Useful for testing deprecated code. See also L{util.suppress}. """ failureException = FailTest def __init__(self, methodName="runTest"): super().__init__(methodName) self._passed = False self._cleanups = [] self._testMethodName = methodName testMethod = getattr(self, methodName) self._parents = [testMethod, self, sys.modules.get(self.__class__.__module__)] def __eq__(self, other: object) -> bool: """ Override the comparison defined by the base TestCase which considers instances of the same class with the same _testMethodName to be equal. Since trial puts TestCase instances into a set, that definition of comparison makes it impossible to run the same test method twice. Most likely, trial should stop using a set to hold tests, but until it does, this is necessary on Python 2.6. -exarkun """ if isinstance(other, SynchronousTestCase): return self is other else: return NotImplemented def __hash__(self): return hash((self.__class__, self._testMethodName)) def shortDescription(self): desc = super().shortDescription() if desc is None: return self._testMethodName return desc def getSkip(self) -> Tuple[bool, Optional[str]]: """ Return the skip reason set on this test, if any is set. Checks on the instance first, then the class, then the module, then packages. As soon as it finds something with a C{skip} attribute, returns that in a tuple (L{True}, L{str}). If the C{skip} attribute does not exist, look for C{__unittest_skip__} and C{__unittest_skip_why__} attributes which are set by the standard library L{unittest.skip} function. Returns (L{False}, L{None}) if it cannot find anything. See L{TestCase} docstring for more details. """ skipReason = util.acquireAttribute(self._parents, "skip", None) doSkip = skipReason is not None if skipReason is None: doSkip = getattr(self, "__unittest_skip__", False) if doSkip: skipReason = getattr(self, "__unittest_skip_why__", "") return (doSkip, skipReason) def getTodo(self): """ Return a L{Todo} object if the test is marked todo. Checks on the instance first, then the class, then the module, then packages. As soon as it finds something with a C{todo} attribute, returns that. Returns L{None} if it cannot find anything. See L{TestCase} docstring for more details. """ todo = util.acquireAttribute(self._parents, "todo", None) if todo is None: return None return makeTodo(todo) def runTest(self): """ If no C{methodName} argument is passed to the constructor, L{run} will treat this method as the thing with the actual test inside. """ def run(self, result): """ Run the test case, storing the results in C{result}. First runs C{setUp} on self, then runs the test method (defined in the constructor), then runs C{tearDown}. As with the standard library L{unittest.TestCase}, the return value of these methods is disregarded. In particular, returning a L{Deferred<twisted.internet.defer.Deferred>} has no special additional consequences. @param result: A L{TestResult} object. """ log.msg("--> %s <--" % (self.id())) new_result = itrial.IReporter(result, None) if new_result is None: result = PyUnitResultAdapter(result) else: result = new_result result.startTest(self) (doSkip, skipReason) = self.getSkip() if doSkip: # don't run test methods that are marked as .skip result.addSkip(self, skipReason) result.stopTest(self) return self._passed = False self._warnings = [] self._installObserver() # All the code inside _runFixturesAndTest will be run such that warnings # emitted by it will be collected and retrievable by flushWarnings. _collectWarnings(self._warnings.append, self._runFixturesAndTest, result) # Any collected warnings which the test method didn't flush get # re-emitted so they'll be logged or show up on stdout or whatever. for w in self.flushWarnings(): try: warnings.warn_explicit(**w) except BaseException: result.addError(self, failure.Failure()) result.stopTest(self) def addCleanup(self, f, *args, **kwargs): """ Add the given function to a list of functions to be called after the test has run, but before C{tearDown}. Functions will be run in reverse order of being added. This helps ensure that tear down complements set up. As with all aspects of L{SynchronousTestCase}, Deferreds are not supported in cleanup functions. """ self._cleanups.append((f, args, kwargs)) def patch(self, obj, attribute, value): """ Monkey patch an object for the duration of the test. The monkey patch will be reverted at the end of the test using the L{addCleanup} mechanism. The L{monkey.MonkeyPatcher} is returned so that users can restore and re-apply the monkey patch within their tests. @param obj: The object to monkey patch. @param attribute: The name of the attribute to change. @param value: The value to set the attribute to. @return: A L{monkey.MonkeyPatcher} object. """ monkeyPatch = monkey.MonkeyPatcher((obj, attribute, value)) monkeyPatch.patch() self.addCleanup(monkeyPatch.restore) return monkeyPatch def flushLoggedErrors(self, *errorTypes): """ Remove stored errors received from the log. C{TestCase} stores each error logged during the run of the test and reports them as errors during the cleanup phase (after C{tearDown}). @param errorTypes: If unspecified, flush all errors. Otherwise, only flush errors that match the given types. @return: A list of failures that have been removed. """ return self._observer.flushErrors(*errorTypes) def flushWarnings(self, offendingFunctions=None): """ Remove stored warnings from the list of captured warnings and return them. @param offendingFunctions: If L{None}, all warnings issued during the currently running test will be flushed. Otherwise, only warnings which I{point} to a function included in this list will be flushed. All warnings include a filename and source line number; if these parts of a warning point to a source line which is part of a function, then the warning I{points} to that function. @type offendingFunctions: L{None} or L{list} of functions or methods. @raise ValueError: If C{offendingFunctions} is not L{None} and includes an object which is not a L{types.FunctionType} or L{types.MethodType} instance. @return: A C{list}, each element of which is a C{dict} giving information about one warning which was flushed by this call. The keys of each C{dict} are: - C{'message'}: The string which was passed as the I{message} parameter to L{warnings.warn}. - C{'category'}: The warning subclass which was passed as the I{category} parameter to L{warnings.warn}. - C{'filename'}: The name of the file containing the definition of the code object which was C{stacklevel} frames above the call to L{warnings.warn}, where C{stacklevel} is the value of the C{stacklevel} parameter passed to L{warnings.warn}. - C{'lineno'}: The source line associated with the active instruction of the code object object which was C{stacklevel} frames above the call to L{warnings.warn}, where C{stacklevel} is the value of the C{stacklevel} parameter passed to L{warnings.warn}. """ if offendingFunctions is None: toFlush = self._warnings[:] self._warnings[:] = [] else: toFlush = [] for aWarning in self._warnings: for aFunction in offendingFunctions: if not isinstance( aFunction, (types.FunctionType, types.MethodType) ): raise ValueError(f"{aFunction!r} is not a function or method") # inspect.getabsfile(aFunction) sometimes returns a # filename which disagrees with the filename the warning # system generates. This seems to be because a # function's code object doesn't deal with source files # being renamed. inspect.getabsfile(module) seems # better (or at least agrees with the warning system # more often), and does some normalization for us which # is desirable. inspect.getmodule() is attractive, but # somewhat broken in Python < 2.6. See Python bug 4845. aModule = sys.modules[aFunction.__module__] filename = inspect.getabsfile(aModule) if filename != os.path.normcase(aWarning.filename): continue lineNumbers = [ lineNumber for _, lineNumber in _findlinestarts(aFunction.__code__) ] if not (min(lineNumbers) <= aWarning.lineno <= max(lineNumbers)): continue # The warning points to this function, flush it and move on # to the next warning. toFlush.append(aWarning) break # Remove everything which is being flushed. list(map(self._warnings.remove, toFlush)) return [ { "message": w.message, "category": w.category, "filename": w.filename, "lineno": w.lineno, } for w in toFlush ] def getDeprecatedModuleAttribute(self, moduleName, name, version, message=None): """ Retrieve a module attribute which should have been deprecated, and assert that we saw the appropriate deprecation warning. @type moduleName: C{str} @param moduleName: Fully-qualified Python name of the module containing the deprecated attribute; if called from the same module as the attributes are being deprecated in, using the C{__name__} global can be helpful @type name: C{str} @param name: Attribute name which we expect to be deprecated @param version: The first L{version<twisted.python.versions.Version>} that the module attribute was deprecated. @type message: C{str} @param message: (optional) The expected deprecation message for the module attribute @return: The given attribute from the named module @raise FailTest: if no warnings were emitted on getattr, or if the L{DeprecationWarning} emitted did not produce the canonical please-use-something-else message that is standard for Twisted deprecations according to the given version and replacement. @since: Twisted 21.2.0 """ fqpn = moduleName + "." + name module = sys.modules[moduleName] attr = getattr(module, name) warningsShown = self.flushWarnings([self.getDeprecatedModuleAttribute]) if len(warningsShown) == 0: self.fail(f"{fqpn} is not deprecated.") observedWarning = warningsShown[0]["message"] expectedWarning = DEPRECATION_WARNING_FORMAT % { "fqpn": fqpn, "version": getVersionString(version), } if message is not None: expectedWarning = expectedWarning + ": " + message self.assert_( observedWarning.startswith(expectedWarning), f"Expected {observedWarning!r} to start with {expectedWarning!r}", ) return attr def callDeprecated(self, version, f, *args, **kwargs): """ Call a function that should have been deprecated at a specific version and in favor of a specific alternative, and assert that it was thusly deprecated. @param version: A 2-sequence of (since, replacement), where C{since} is a the first L{version<incremental.Version>} that C{f} should have been deprecated since, and C{replacement} is a suggested replacement for the deprecated functionality, as described by L{twisted.python.deprecate.deprecated}. If there is no suggested replacement, this parameter may also be simply a L{version<incremental.Version>} by itself. @param f: The deprecated function to call. @param args: The arguments to pass to C{f}. @param kwargs: The keyword arguments to pass to C{f}. @return: Whatever C{f} returns. @raise Exception: Whatever C{f} raises. If any exception is raised by C{f}, though, no assertions will be made about emitted deprecations. @raise FailTest: if no warnings were emitted by C{f}, or if the L{DeprecationWarning} emitted did not produce the canonical please-use-something-else message that is standard for Twisted deprecations according to the given version and replacement. """ result = f(*args, **kwargs) warningsShown = self.flushWarnings([self.callDeprecated]) try: info = list(version) except TypeError: since = version replacement = None else: [since, replacement] = info if len(warningsShown) == 0: self.fail(f"{f!r} is not deprecated.") observedWarning = warningsShown[0]["message"] expectedWarning = getDeprecationWarningString(f, since, replacement=replacement) self.assertEqual(expectedWarning, observedWarning) return result def mktemp(self): """ Create a new path name which can be used for a new file or directory. The result is a relative path that is guaranteed to be unique within the current working directory. The parent of the path will exist, but the path will not. For a temporary directory call os.mkdir on the path. For a temporary file just create the file (e.g. by opening the path for writing and then closing it). @return: The newly created path @rtype: C{str} """ MAX_FILENAME = 32 # some platforms limit lengths of filenames base = os.path.join( self.__class__.__module__[:MAX_FILENAME], self.__class__.__name__[:MAX_FILENAME], self._testMethodName[:MAX_FILENAME], ) if not os.path.exists(base): os.makedirs(base) dirname = tempfile.mkdtemp("", "", base) return os.path.join(dirname, "temp") def _getSuppress(self): """ Returns any warning suppressions set for this test. Checks on the instance first, then the class, then the module, then packages. As soon as it finds something with a C{suppress} attribute, returns that. Returns any empty list (i.e. suppress no warnings) if it cannot find anything. See L{TestCase} docstring for more details. """ return util.acquireAttribute(self._parents, "suppress", []) def _getSkipReason(self, method, skip): """ Return the reason to use for skipping a test method. @param method: The method which produced the skip. @param skip: A L{unittest.SkipTest} instance raised by C{method}. """ if len(skip.args) > 0: return skip.args[0] warnAboutFunction( method, "Do not raise unittest.SkipTest with no arguments! Give a reason " "for skipping tests!", ) return skip def _run(self, suppress, todo, method, result): """ Run a single method, either a test method or fixture. @param suppress: Any warnings to suppress, as defined by the C{suppress} attribute on this method, test case, or the module it is defined in. @param todo: Any expected failure or failures, as defined by the C{todo} attribute on this method, test case, or the module it is defined in. @param method: The method to run. @param result: The TestResult instance to which to report results. @return: C{True} if the method fails and no further method/fixture calls should be made, C{False} otherwise. """ if inspect.isgeneratorfunction(method): exc = TypeError( "{!r} is a generator function and therefore will never run".format( method ) ) result.addError(self, failure.Failure(exc)) return True try: runWithWarningsSuppressed(suppress, method) except SkipTest as e: result.addSkip(self, self._getSkipReason(method, e)) except BaseException: reason = failure.Failure() if todo is None or not todo.expected(reason): if reason.check(self.failureException): addResult = result.addFailure else: addResult = result.addError addResult(self, reason) else: result.addExpectedFailure(self, reason, todo) else: return False return True def _runFixturesAndTest(self, result): """ Run C{setUp}, a test method, test cleanups, and C{tearDown}. @param result: The TestResult instance to which to report results. """ suppress = self._getSuppress() try: if self._run(suppress, None, self.setUp, result): return todo = self.getTodo() method = getattr(self, self._testMethodName) failed = self._run(suppress, todo, method, result) finally: self._runCleanups(result) if todo and not failed: result.addUnexpectedSuccess(self, todo) if self._run(suppress, None, self.tearDown, result): failed = True for error in self._observer.getErrors(): result.addError(self, error) failed = True self._observer.flushErrors() self._removeObserver() if not (failed or todo): result.addSuccess(self) def _runCleanups(self, result): """ Synchronously run any cleanups which have been added. """ while len(self._cleanups) > 0: f, args, kwargs = self._cleanups.pop() try: f(*args, **kwargs) except BaseException: f = failure.Failure() result.addError(self, f) def _installObserver(self): self._observer = _logObserver self._observer._add() def _removeObserver(self): self._observer._remove() PK b�Z�}�� � __main__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. if __name__ == "__main__": import sys from pkg_resources import load_entry_point sys.exit(load_entry_point("Twisted", "console_scripts", "trial")()) PK b�Z��nX@7 @7 _asynctest.pynu �[��� # -*- test-case-name: twisted.trial.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Things likely to be used by writers of unit tests. Maintainer: Jonathan Lange """ import inspect import warnings from typing import List from zope.interface import implementer # We can't import reactor at module-level because this code runs before trial # installs a user-specified reactor, installing the default reactor and # breaking reactor installation. See also #6047. from twisted.internet import defer, utils from twisted.python import failure from twisted.trial import itrial, util from twisted.trial._synctest import FailTest, SkipTest, SynchronousTestCase _wait_is_running: List[None] = [] @implementer(itrial.ITestCase) class TestCase(SynchronousTestCase): """ A unit test. The atom of the unit testing universe. This class extends L{SynchronousTestCase} which extends C{unittest.TestCase} from the standard library. The main feature is the ability to return C{Deferred}s from tests and fixture methods and to have the suite wait for those C{Deferred}s to fire. Also provides new assertions such as L{assertFailure}. @ivar timeout: A real number of seconds. If set, the test will raise an error if it takes longer than C{timeout} seconds. If not set, util.DEFAULT_TIMEOUT_DURATION is used. """ def __init__(self, methodName="runTest"): """ Construct an asynchronous test case for C{methodName}. @param methodName: The name of a method on C{self}. This method should be a unit test. That is, it should be a short method that calls some of the assert* methods. If C{methodName} is unspecified, L{SynchronousTestCase.runTest} will be used as the test method. This is mostly useful for testing Trial. """ super().__init__(methodName) def assertFailure(self, deferred, *expectedFailures): """ Fail if C{deferred} does not errback with one of C{expectedFailures}. Returns the original Deferred with callbacks added. You will need to return this Deferred from your test case. """ def _cb(ignore): raise self.failureException( f"did not catch an error, instead got {ignore!r}" ) def _eb(failure): if failure.check(*expectedFailures): return failure.value else: output = "\nExpected: {!r}\nGot:\n{}".format( expectedFailures, str(failure) ) raise self.failureException(output) return deferred.addCallbacks(_cb, _eb) failUnlessFailure = assertFailure def _run(self, methodName, result): from twisted.internet import reactor timeout = self.getTimeout() def onTimeout(d): e = defer.TimeoutError( f"{self!r} ({methodName}) still running at {timeout} secs" ) f = failure.Failure(e) # try to errback the deferred that the test returns (for no gorram # reason) (see issue1005 and test_errorPropagation in # test_deferred) try: d.errback(f) except defer.AlreadyCalledError: # if the deferred has been called already but the *back chain # is still unfinished, crash the reactor and report timeout # error ourself. reactor.crash() self._timedOut = True # see self._wait todo = self.getTodo() if todo is not None and todo.expected(f): result.addExpectedFailure(self, f, todo) else: result.addError(self, f) onTimeout = utils.suppressWarnings( onTimeout, util.suppress(category=DeprecationWarning) ) method = getattr(self, methodName) if inspect.isgeneratorfunction(method): exc = TypeError( "{!r} is a generator function and therefore will never run".format( method ) ) return defer.fail(exc) d = defer.maybeDeferred( utils.runWithWarningsSuppressed, self._getSuppress(), method ) call = reactor.callLater(timeout, onTimeout, d) d.addBoth(lambda x: call.active() and call.cancel() or x) return d def __call__(self, *args, **kwargs): return self.run(*args, **kwargs) def deferSetUp(self, ignored, result): d = self._run("setUp", result) d.addCallbacks( self.deferTestMethod, self._ebDeferSetUp, callbackArgs=(result,), errbackArgs=(result,), ) return d def _ebDeferSetUp(self, failure, result): if failure.check(SkipTest): result.addSkip(self, self._getSkipReason(self.setUp, failure.value)) else: result.addError(self, failure) if failure.check(KeyboardInterrupt): result.stop() return self.deferRunCleanups(None, result) def deferTestMethod(self, ignored, result): d = self._run(self._testMethodName, result) d.addCallbacks( self._cbDeferTestMethod, self._ebDeferTestMethod, callbackArgs=(result,), errbackArgs=(result,), ) d.addBoth(self.deferRunCleanups, result) d.addBoth(self.deferTearDown, result) return d def _cbDeferTestMethod(self, ignored, result): if self.getTodo() is not None: result.addUnexpectedSuccess(self, self.getTodo()) else: self._passed = True return ignored def _ebDeferTestMethod(self, f, result): todo = self.getTodo() if todo is not None and todo.expected(f): result.addExpectedFailure(self, f, todo) elif f.check(self.failureException, FailTest): result.addFailure(self, f) elif f.check(KeyboardInterrupt): result.addError(self, f) result.stop() elif f.check(SkipTest): result.addSkip( self, self._getSkipReason(getattr(self, self._testMethodName), f.value) ) else: result.addError(self, f) def deferTearDown(self, ignored, result): d = self._run("tearDown", result) d.addErrback(self._ebDeferTearDown, result) return d def _ebDeferTearDown(self, failure, result): result.addError(self, failure) if failure.check(KeyboardInterrupt): result.stop() self._passed = False @defer.inlineCallbacks def deferRunCleanups(self, ignored, result): """ Run any scheduled cleanups and report errors (if any) to the result. object. """ failures = [] for func, args, kwargs in self._cleanups[::-1]: try: yield func(*args, **kwargs) except Exception: failures.append(failure.Failure()) for f in failures: result.addError(self, f) self._passed = False def _cleanUp(self, result): try: clean = util._Janitor(self, result).postCaseCleanup() if not clean: self._passed = False except BaseException: result.addError(self, failure.Failure()) self._passed = False for error in self._observer.getErrors(): result.addError(self, error) self._passed = False self.flushLoggedErrors() self._removeObserver() if self._passed: result.addSuccess(self) def _classCleanUp(self, result): try: util._Janitor(self, result).postClassCleanup() except BaseException: result.addError(self, failure.Failure()) def _makeReactorMethod(self, name): """ Create a method which wraps the reactor method C{name}. The new method issues a deprecation warning and calls the original. """ def _(*a, **kw): warnings.warn( "reactor.%s cannot be used inside unit tests. " "In the future, using %s will fail the test and may " "crash or hang the test run." % (name, name), stacklevel=2, category=DeprecationWarning, ) return self._reactorMethods[name](*a, **kw) return _ def _deprecateReactor(self, reactor): """ Deprecate C{iterate}, C{crash} and C{stop} on C{reactor}. That is, each method is wrapped in a function that issues a deprecation warning, then calls the original. @param reactor: The Twisted reactor. """ self._reactorMethods = {} for name in ["crash", "iterate", "stop"]: self._reactorMethods[name] = getattr(reactor, name) setattr(reactor, name, self._makeReactorMethod(name)) def _undeprecateReactor(self, reactor): """ Restore the deprecated reactor methods. Undoes what L{_deprecateReactor} did. @param reactor: The Twisted reactor. """ for name, method in self._reactorMethods.items(): setattr(reactor, name, method) self._reactorMethods = {} def _runFixturesAndTest(self, result): """ Really run C{setUp}, the test method, and C{tearDown}. Any of these may return L{defer.Deferred}s. After they complete, do some reactor cleanup. @param result: A L{TestResult} object. """ from twisted.internet import reactor self._deprecateReactor(reactor) self._timedOut = False try: d = self.deferSetUp(None, result) try: self._wait(d) finally: self._cleanUp(result) self._classCleanUp(result) finally: self._undeprecateReactor(reactor) def addCleanup(self, f, *args, **kwargs): """ Extend the base cleanup feature with support for cleanup functions which return Deferreds. If the function C{f} returns a Deferred, C{TestCase} will wait until the Deferred has fired before proceeding to the next function. """ return super().addCleanup(f, *args, **kwargs) def getSuppress(self): return self._getSuppress() def getTimeout(self): """ Returns the timeout value set on this test. Checks on the instance first, then the class, then the module, then packages. As soon as it finds something with a C{timeout} attribute, returns that. Returns L{util.DEFAULT_TIMEOUT_DURATION} if it cannot find anything. See L{TestCase} docstring for more details. """ timeout = util.acquireAttribute( self._parents, "timeout", util.DEFAULT_TIMEOUT_DURATION ) try: return float(timeout) except (ValueError, TypeError): # XXX -- this is here because sometimes people will have methods # called 'timeout', or set timeout to 'orange', or something # Particularly, test_news.NewsTestCase and ReactorCoreTestCase # both do this. warnings.warn( "'timeout' attribute needs to be a number.", category=DeprecationWarning ) return util.DEFAULT_TIMEOUT_DURATION def _wait(self, d, running=_wait_is_running): """Take a Deferred that only ever callbacks. Block until it happens.""" if running: raise RuntimeError("_wait is not reentrant") from twisted.internet import reactor results = [] def append(any): if results is not None: results.append(any) def crash(ign): if results is not None: reactor.crash() crash = utils.suppressWarnings( crash, util.suppress( message=r"reactor\.crash cannot be used.*", category=DeprecationWarning ), ) def stop(): reactor.crash() stop = utils.suppressWarnings( stop, util.suppress( message=r"reactor\.crash cannot be used.*", category=DeprecationWarning ), ) running.append(None) try: d.addBoth(append) if results: # d might have already been fired, in which case append is # called synchronously. Avoid any reactor stuff. return d.addBoth(crash) reactor.stop = stop try: reactor.run() finally: del reactor.stop # If the reactor was crashed elsewhere due to a timeout, hopefully # that crasher also reported an error. Just return. # _timedOut is most likely to be set when d has fired but hasn't # completed its callback chain (see self._run) if results or self._timedOut: # defined in run() and _run() return # If the timeout didn't happen, and we didn't get a result or # a failure, then the user probably aborted the test, so let's # just raise KeyboardInterrupt. # FIXME: imagine this: # web/test/test_webclient.py: # exc = self.assertRaises(error.Error, wait, method(url)) # # wait() will raise KeyboardInterrupt, and assertRaises will # swallow it. Therefore, wait() raising KeyboardInterrupt is # insufficient to stop trial. A suggested solution is to have # this code set a "stop trial" flag, or otherwise notify trial # that it should really try to stop as soon as possible. raise KeyboardInterrupt() finally: results = None running.pop() PK b�Z�Ֆ� � unittest.pynu �[��� # -*- test-case-name: twisted.trial.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Things likely to be used by writers of unit tests. """ from twisted.trial._asyncrunner import TestDecorator, TestSuite, decorate from twisted.trial._asynctest import TestCase # Define the public API from the two implementation modules from twisted.trial._synctest import ( FailTest, PyUnitResultAdapter, SkipTest, SynchronousTestCase, Todo, makeTodo, ) # Further obscure the origins of these objects, to reduce surprise (and this is # what the values were before code got shuffled around between files, but was # otherwise unchanged). FailTest.__module__ = SkipTest.__module__ = __name__ __all__ = [ "decorate", "FailTest", "makeTodo", "PyUnitResultAdapter", "SkipTest", "SynchronousTestCase", "TestCase", "TestDecorator", "TestSuite", "Todo", ] PK b�Z��O��0 �0 util.pynu �[��� # -*- test-case-name: twisted.trial.test.test_util -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # """ A collection of utility functions and classes, used internally by Trial. This code is for Trial's internal use. Do NOT use this code if you are writing tests. It is subject to change at the Trial maintainer's whim. There is nothing here in this module for you to use unless you are maintaining Trial. Any non-Trial Twisted code that uses this module will be shot. Maintainer: Jonathan Lange @var DEFAULT_TIMEOUT_DURATION: The default timeout which will be applied to asynchronous (ie, Deferred-returning) test methods, in seconds. """ from random import randrange from twisted.internet import interfaces, utils from twisted.python.failure import Failure from twisted.python.filepath import FilePath from twisted.python.lockfile import FilesystemLock __all__ = [ "DEFAULT_TIMEOUT_DURATION", "excInfoOrFailureToExcInfo", "suppress", "acquireAttribute", ] DEFAULT_TIMEOUT = object() DEFAULT_TIMEOUT_DURATION = 120.0 class DirtyReactorAggregateError(Exception): """ Passed to L{twisted.trial.itrial.IReporter.addError} when the reactor is left in an unclean state after a test. @ivar delayedCalls: The L{DelayedCall<twisted.internet.base.DelayedCall>} objects which weren't cleaned up. @ivar selectables: The selectables which weren't cleaned up. """ def __init__(self, delayedCalls, selectables=None): self.delayedCalls = delayedCalls self.selectables = selectables def __str__(self) -> str: """ Return a multi-line message describing all of the unclean state. """ msg = "Reactor was unclean." if self.delayedCalls: msg += ( "\nDelayedCalls: (set " "twisted.internet.base.DelayedCall.debug = True to " "debug)\n" ) msg += "\n".join(map(str, self.delayedCalls)) if self.selectables: msg += "\nSelectables:\n" msg += "\n".join(map(str, self.selectables)) return msg class _Janitor: """ The guy that cleans up after you. @ivar test: The L{TestCase} to report errors about. @ivar result: The L{IReporter} to report errors to. @ivar reactor: The reactor to use. If None, the global reactor will be used. """ def __init__(self, test, result, reactor=None): """ @param test: See L{_Janitor.test}. @param result: See L{_Janitor.result}. @param reactor: See L{_Janitor.reactor}. """ self.test = test self.result = result self.reactor = reactor def postCaseCleanup(self): """ Called by L{unittest.TestCase} after a test to catch any logged errors or pending L{DelayedCall<twisted.internet.base.DelayedCall>}s. """ calls = self._cleanPending() if calls: aggregate = DirtyReactorAggregateError(calls) self.result.addError(self.test, Failure(aggregate)) return False return True def postClassCleanup(self): """ Called by L{unittest.TestCase} after the last test in a C{TestCase} subclass. Ensures the reactor is clean by murdering the threadpool, catching any pending L{DelayedCall<twisted.internet.base.DelayedCall>}s, open sockets etc. """ selectables = self._cleanReactor() calls = self._cleanPending() if selectables or calls: aggregate = DirtyReactorAggregateError(calls, selectables) self.result.addError(self.test, Failure(aggregate)) self._cleanThreads() def _getReactor(self): """ Get either the passed-in reactor or the global reactor. """ if self.reactor is not None: reactor = self.reactor else: from twisted.internet import reactor return reactor def _cleanPending(self): """ Cancel all pending calls and return their string representations. """ reactor = self._getReactor() # flush short-range timers reactor.iterate(0) reactor.iterate(0) delayedCallStrings = [] for p in reactor.getDelayedCalls(): if p.active(): delayedString = str(p) p.cancel() else: print("WEIRDNESS! pending timed call not active!") delayedCallStrings.append(delayedString) return delayedCallStrings _cleanPending = utils.suppressWarnings( _cleanPending, ( ("ignore",), { "category": DeprecationWarning, "message": r"reactor\.iterate cannot be used.*", }, ), ) def _cleanThreads(self): reactor = self._getReactor() if interfaces.IReactorThreads.providedBy(reactor): if reactor.threadpool is not None: # Stop the threadpool now so that a new one is created. # This improves test isolation somewhat (although this is a # post class cleanup hook, so it's only isolating classes # from each other, not methods from each other). reactor._stopThreadPool() def _cleanReactor(self): """ Remove all selectables from the reactor, kill any of them that were processes, and return their string representation. """ reactor = self._getReactor() selectableStrings = [] for sel in reactor.removeAll(): if interfaces.IProcessTransport.providedBy(sel): sel.signalProcess("KILL") selectableStrings.append(repr(sel)) return selectableStrings _DEFAULT = object() def acquireAttribute(objects, attr, default=_DEFAULT): """ Go through the list 'objects' sequentially until we find one which has attribute 'attr', then return the value of that attribute. If not found, return 'default' if set, otherwise, raise AttributeError. """ for obj in objects: if hasattr(obj, attr): return getattr(obj, attr) if default is not _DEFAULT: return default raise AttributeError(f"attribute {attr!r} not found in {objects!r}") def excInfoOrFailureToExcInfo(err): """ Coerce a Failure to an _exc_info, if err is a Failure. @param err: Either a tuple such as returned by L{sys.exc_info} or a L{Failure} object. @return: A tuple like the one returned by L{sys.exc_info}. e.g. C{exception_type, exception_object, traceback_object}. """ if isinstance(err, Failure): # Unwrap the Failure into an exc_info tuple. err = (err.type, err.value, err.getTracebackObject()) return err def suppress(action="ignore", **kwarg): """ Sets up the .suppress tuple properly, pass options to this method as you would the stdlib warnings.filterwarnings() So, to use this with a .suppress magic attribute you would do the following: >>> from twisted.trial import unittest, util >>> import warnings >>> >>> class TestFoo(unittest.TestCase): ... def testFooBar(self): ... warnings.warn("i am deprecated", DeprecationWarning) ... testFooBar.suppress = [util.suppress(message='i am deprecated')] ... >>> Note that as with the todo and timeout attributes: the module level attribute acts as a default for the class attribute which acts as a default for the method attribute. The suppress attribute can be overridden at any level by specifying C{.suppress = []} """ return ((action,), kwarg) # This should be deleted, and replaced with twisted.application's code; see # #6016: def profiled(f, outputFile): def _(*args, **kwargs): import profile prof = profile.Profile() try: result = prof.runcall(f, *args, **kwargs) prof.dump_stats(outputFile) except SystemExit: pass prof.print_stats() return result return _ class _NoTrialMarker(Exception): """ No trial marker file could be found. Raised when trial attempts to remove a trial temporary working directory that does not contain a marker file. """ def _removeSafely(path): """ Safely remove a path, recursively. If C{path} does not contain a node named C{_trial_marker}, a L{_NoTrialMarker} exception is raised and the path is not removed. """ if not path.child(b"_trial_marker").exists(): raise _NoTrialMarker( f"{path!r} is not a trial temporary path, refusing to remove it" ) try: path.remove() except OSError as e: print( "could not remove %r, caught OSError [Errno %s]: %s" % (path, e.errno, e.strerror) ) try: newPath = FilePath( b"_trial_temp_old" + str(randrange(10000000)).encode("utf-8") ) path.moveTo(newPath) except OSError as e: print( "could not rename path, caught OSError [Errno %s]: %s" % (e.errno, e.strerror) ) raise class _WorkingDirectoryBusy(Exception): """ A working directory was specified to the runner, but another test run is currently using that directory. """ def _unusedTestDirectory(base): """ Find an unused directory named similarly to C{base}. Once a directory is found, it will be locked and a marker dropped into it to identify it as a trial temporary directory. @param base: A template path for the discovery process. If this path exactly cannot be used, a path which varies only in a suffix of the basename will be used instead. @type base: L{FilePath} @return: A two-tuple. The first element is a L{FilePath} representing the directory which was found and created. The second element is a locked L{FilesystemLock<twisted.python.lockfile.FilesystemLock>}. Another call to C{_unusedTestDirectory} will not be able to reused the same name until the lock is released, either explicitly or by this process exiting. """ counter = 0 while True: if counter: testdir = base.sibling("%s-%d" % (base.basename(), counter)) else: testdir = base testDirLock = FilesystemLock(testdir.path + ".lock") if testDirLock.lock(): # It is not in use if testdir.exists(): # It exists though - delete it _removeSafely(testdir) # Create it anew and mark it as ours so the next _removeSafely on # it succeeds. testdir.makedirs() testdir.child(b"_trial_marker").setContent(b"") return testdir, testDirLock else: # It is in use if base.basename() == "_trial_temp": counter += 1 else: raise _WorkingDirectoryBusy() def _listToPhrase(things, finalDelimiter, delimiter=", "): """ Produce a string containing each thing in C{things}, separated by a C{delimiter}, with the last couple being separated by C{finalDelimiter} @param things: The elements of the resulting phrase @type things: L{list} or L{tuple} @param finalDelimiter: What to put between the last two things (typically 'and' or 'or') @type finalDelimiter: L{str} @param delimiter: The separator to use between each thing, not including the last two. Should typically include a trailing space. @type delimiter: L{str} @return: The resulting phrase @rtype: L{str} """ if not isinstance(things, (list, tuple)): raise TypeError("Things must be a list or a tuple") if not things: return "" if len(things) == 1: return str(things[0]) if len(things) == 2: return f"{str(things[0])} {finalDelimiter} {str(things[1])}" else: strThings = [] for thing in things: strThings.append(str(thing)) return "{}{}{} {}".format( delimiter.join(strThings[:-1]), delimiter, finalDelimiter, strThings[-1], ) PK b�Z�Ȧ/ / _dist/workerreporter.pynu �[��� # -*- test-case-name: twisted.trial._dist.test.test_workerreporter -*- # # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test reporter forwarding test results over trial distributed AMP commands. @since: 12.3 """ from twisted.python.failure import Failure from twisted.python.reflect import qual from twisted.trial._dist import managercommands from twisted.trial.reporter import TestResult class WorkerReporter(TestResult): """ Reporter for trial's distributed workers. We send things not through a stream, but through an C{AMP} protocol's C{callRemote} method. @ivar _DEFAULT_TODO: Default message for expected failures and unexpected successes, used only if a C{Todo} is not provided. """ _DEFAULT_TODO = "Test expected to fail" def __init__(self, ampProtocol): """ @param ampProtocol: The communication channel with the trial distributed manager which collects all test results. @type ampProtocol: C{AMP} """ super().__init__() self.ampProtocol = ampProtocol def _getFailure(self, error): """ Convert a C{sys.exc_info()}-style tuple to a L{Failure}, if necessary. """ if isinstance(error, tuple): return Failure(error[1], error[0], error[2]) return error def _getFrames(self, failure): """ Extract frames from a C{Failure} instance. """ frames = [] for frame in failure.frames: frames.extend([frame[0], frame[1], str(frame[2])]) return frames def addSuccess(self, test): """ Send a success over. """ super().addSuccess(test) testName = test.id() self.ampProtocol.callRemote(managercommands.AddSuccess, testName=testName) def addError(self, test, error): """ Send an error over. """ super().addError(test, error) testName = test.id() failure = self._getFailure(error) error = failure.getErrorMessage() errorClass = qual(failure.type) frames = [frame for frame in self._getFrames(failure)] self.ampProtocol.callRemote( managercommands.AddError, testName=testName, error=error, errorClass=errorClass, frames=frames, ) def addFailure(self, test, fail): """ Send a Failure over. """ super().addFailure(test, fail) testName = test.id() failure = self._getFailure(fail) fail = failure.getErrorMessage() failClass = qual(failure.type) frames = [frame for frame in self._getFrames(failure)] self.ampProtocol.callRemote( managercommands.AddFailure, testName=testName, fail=fail, failClass=failClass, frames=frames, ) def addSkip(self, test, reason): """ Send a skip over. """ super().addSkip(test, reason) reason = str(reason) testName = test.id() self.ampProtocol.callRemote( managercommands.AddSkip, testName=testName, reason=reason ) def _getTodoReason(self, todo): """ Get the reason for a C{Todo}. If C{todo} is L{None}, return a sensible default. """ if todo is None: return self._DEFAULT_TODO else: return todo.reason def addExpectedFailure(self, test, error, todo=None): """ Send an expected failure over. """ super().addExpectedFailure(test, error, todo) errorMessage = error.getErrorMessage() testName = test.id() self.ampProtocol.callRemote( managercommands.AddExpectedFailure, testName=testName, error=errorMessage, todo=self._getTodoReason(todo), ) def addUnexpectedSuccess(self, test, todo=None): """ Send an unexpected success over. """ super().addUnexpectedSuccess(test, todo) testName = test.id() self.ampProtocol.callRemote( managercommands.AddUnexpectedSuccess, testName=testName, todo=self._getTodoReason(todo), ) def printSummary(self): """ I{Don't} print a summary """ PK b�ZԖa�: : - _dist/__pycache__/workertrial.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlZddlZddlZdd� Zeej� ddlmZ ddlm Z m Z ddl m Z m Z ddlmZ G d d � d �Zejfd d �Zed krJe� dS dS )zj Implementation of C{AMP} worker commands, and main executable entry point for the workers. @since: 12.3 � Nc C s* d| v r| d � tj�tjdd�< dS dS )z� Override C{sys.path} with what the parent passed in B{TRIAL_PYTHONPATH}. @see: twisted.trial._dist.disttrial.DistTrialRunner.launchWorkerProcesses �TRIAL_PYTHONPATHN)�split�os�pathsep�sys�path)�environ� r �A/usr/lib/python3/dist-packages/twisted/trial/_dist/workertrial.py� _setupPath s �r )� FileWrapper)�startLoggingWithObserver�textFromEventDict)�_WORKER_AMP_STDIN�_WORKER_AMP_STDOUT)� WorkerOptionsc @ s e Zd ZdZdd� Zdd� ZdS )�WorkerLogObserverzF A log observer that forward its output to a C{AMP} protocol. c C s || _ dS )zg @param protocol: a connected C{AMP} protocol instance. @type protocol: C{AMP} N)�protocol)�selfr r r r �__init__* s zWorkerLogObserver.__init__c C s6 ddl m} t|�}|du rdS | jj|j|d� dS )z' Produce a log output. r )�managercommandsN)�out)�twisted.trial._distr r r � callRemote� TestWrite)r � eventDictr �textr r r �emit1 s zWorkerLogObserver.emitN)�__name__� __module__� __qualname__�__doc__r r r r r r r % s r c C s t � }|�� ddlm} ||d �}| td�}| td�}|�t|�� t|�}t |j d� z|� d�}W n t yQ } z|j d tjkrLW Y d }~q.� d }~ww |d krWn|�|� |�� tj�� tj�� q/|jr�t�d � |j�� } | jdd|�� jd � d S d S ) z� Main function to be run if __name__ == "__main__". @param _fdopen: If specified, the function to use in place of C{os.fdopen}. @type _fdopen: C{callable} r )�WorkerProtocolzforce-gc�rb�wbFT� N� )� show_missing�summary�coverdir)r � parseOptions�twisted.trial._dist.workerr" r r �makeConnectionr r r r �read�OSError�args�errno�EINTR� dataReceived�flushr �stdout�stderr�tracer�settrace�results� write_resultsr) r ) �_fdopen�configr" �workerProtocol� protocolIn� protocolOut�observer�r�er8 r r r �main= s@ �� � ��rB �__main__)r! r0 r r r r �twisted.internet.protocolr �twisted.python.logr r r r r �twisted.trial._dist.optionsr r �fdopenrB r r r r r �<module> s - �PK b�ZP��� � * _dist/__pycache__/__init__.cpython-310.pycnu �[��� o �b� � @ s d Z dZdZdS )a� This package implements the distributed Trial test runner: - The L{twisted.trial._dist.disttrial} module implements a test runner which runs in a manager process and can launch additional worker processes in which to run tests and gather up results from all of them. - The L{twisted.trial._dist.options} module defines command line options used to configure the distributed test runner. - The L{twisted.trial._dist.managercommands} module defines AMP commands which are sent from worker processes back to the manager process to report the results of tests. - The L{twisted.trial._dist.workercommands} module defines AMP commands which are sent from the manager process to the worker processes to control the execution of tests there. - The L{twisted.trial._dist.distreporter} module defines a proxy for L{twisted.trial.itrial.IReporter} which enforces the typical requirement that results be passed to a reporter for only one test at a time, allowing any reporter to be used with despite disttrial's simultaneously running tests. - The L{twisted.trial._dist.workerreporter} module implements a L{twisted.trial.itrial.IReporter} which is used by worker processes and reports results back to the manager process using AMP commands. - The L{twisted.trial._dist.workertrial} module is a runnable script which is the main point for worker processes. - The L{twisted.trial._dist.worker} process defines the manager's AMP protocol for accepting results from worker processes and a process protocol for use running workers as local child processes (as opposed to distributing them to another host). @since: 12.3 � � N)�__doc__�_WORKER_AMP_STDIN�_WORKER_AMP_STDOUT� r r �>/usr/lib/python3/dist-packages/twisted/trial/_dist/__init__.py�<module> s (PK b�Z��_;� � 1 _dist/__pycache__/managercommands.cpython-310.pycnu �[��� o �b� � @ s� d Z ddlmZmZmZmZ eZG dd� de�ZG dd� de�ZG dd� de�Z G d d � d e�Z G d d � d e�Z G d d� de�Z G dd� de�Z dS )zN Commands for reporting test success of failure to the manager. @since: 12.3 � )�Boolean�Command�ListOf�Unicodec @ �( e Zd ZdZde� fgZde� fgZdS )� AddSuccessz Add a success. � testName� successN��__name__� __module__� __qualname__�__doc__� NativeString� argumentsr �response� r r �E/usr/lib/python3/dist-packages/twisted/trial/_dist/managercommands.pyr � r c @ �D e Zd ZdZde� fde� fde� fdee� �fgZde� fgZdS )�AddErrorz Add an error. r � errors errorClass� framesr N� r r r r r r r r r r r r r r � �r c @ r )� AddFailurez Add a failure. r s fails failClassr r Nr r r r r r & r r c @ �0 e Zd ZdZde� fde� fgZde� fgZdS )�AddSkipz Add a skip. r s reasonr Nr r r r r r 4 � r c @ s8 e Zd ZdZde� fde� fde� fgZde� fgZdS )�AddExpectedFailurez" Add an expected failure. r r � todor Nr r r r r r = s �r c @ r )�AddUnexpectedSuccessz$ Add an unexpected success. r r r Nr r r r r r! J r r! c @ r )� TestWritez Write test log. s outr Nr r r r r r" S r r" N)r �twisted.protocols.ampr r r r r r r r r r r! r" r r r r �<module> s PK b�Z�v~8 8 0 _dist/__pycache__/workercommands.cpython-310.pycnu �[��� o �b> � @ s@ d Z ddlmZmZmZ eZG dd� de�ZG dd� de�ZdS )zI Commands for telling a worker to load tests or run tests. @since: 12.3 � )�Boolean�Command�Unicodec @ �( e Zd ZdZde� fgZde� fgZdS )�Runz Run a test. s testCase� successN��__name__� __module__� __qualname__�__doc__� NativeString� argumentsr �response� r r �D/usr/lib/python3/dist-packages/twisted/trial/_dist/workercommands.pyr � r c @ r )�StartzB Set up the worker process, giving the running directory. s directoryr Nr r r r r r r r N)r �twisted.protocols.ampr r r r r r r r r r �<module> s PK b�Z���� � ) _dist/__pycache__/options.cpython-310.pycnu �[��� o �b� � @ sL d Z ddlmZ ddlmZ ddlmZ ddlmZ G dd� deee�Z dS ) z= Options handling specific to trial's workers. @since: 12.3 � )�ReactorSelectionMixin��FilePath)�Options)� _BasicOptionsc @ s e Zd ZdZdd� ZdS )� WorkerOptionsz< Options forwarded to the trial distributed worker. c C s t d�S )zx Return a L{FilePath} representing the directory into which coverage results should be written. �coverager )�self� r �=/usr/lib/python3/dist-packages/twisted/trial/_dist/options.py�coverdir s zWorkerOptions.coverdirN)�__name__� __module__� __qualname__�__doc__r r r r r r s r N) r �twisted.application.appr �twisted.python.filepathr �twisted.python.usager �twisted.scripts.trialr r r r r r �<module> s PK b�Z�9�w w 0 _dist/__pycache__/workerreporter.cpython-310.pycnu �[��� o �b/ � @ sH d Z ddlmZ ddlmZ ddlmZ ddlmZ G dd� de�Z dS ) zZ Test reporter forwarding test results over trial distributed AMP commands. @since: 12.3 � )�Failure)�qual)�managercommands)� TestResultc s� e Zd ZdZdZ� fdd�Zdd� Zdd� Z� fd d �Z� fd d �Z � fd d�Z � fdd�Z dd� Z d� fdd� Z d� fdd� Zdd� Z� ZS )�WorkerReportera Reporter for trial's distributed workers. We send things not through a stream, but through an C{AMP} protocol's C{callRemote} method. @ivar _DEFAULT_TODO: Default message for expected failures and unexpected successes, used only if a C{Todo} is not provided. zTest expected to failc s t � �� || _dS )z� @param ampProtocol: The communication channel with the trial distributed manager which collects all test results. @type ampProtocol: C{AMP} N)�super�__init__� ampProtocol)�selfr �� __class__� �D/usr/lib/python3/dist-packages/twisted/trial/_dist/workerreporter.pyr s zWorkerReporter.__init__c C s& t |t�rt|d |d |d �S |S )zX Convert a C{sys.exc_info()}-style tuple to a L{Failure}, if necessary. � r � )� isinstance�tupler )r �errorr r r � _getFailure& s zWorkerReporter._getFailurec C s4 g }|j D ]}|�|d |d t|d �g� q|S )z< Extract frames from a C{Failure} instance. r r r )�frames�extend�str)r �failurer �framer r r � _getFrames. s "zWorkerReporter._getFramesc s* t � �|� |�� }| jjtj|d� dS )z& Send a success over. )�testNameN)r � addSuccess�idr � callRemoter � AddSuccess)r �testr r r r r 7 s zWorkerReporter.addSuccessc �b t � �||� |�� }| �|�}|�� }t|j�}dd� | �|�D �}| jj t j ||||d� dS )z% Send an error over. c S � g | ]}|�qS r r ��.0r r r r � <listcomp>H � z+WorkerReporter.addError.<locals>.<listcomp>)r r � errorClassr N) r �addErrorr r �getErrorMessager �typer r r r �AddError)r r r r r r' r r r r r( ? � �zWorkerReporter.addErrorc r! )z& Send a Failure over. c S r" r r r# r r r r% Z r& z-WorkerReporter.addFailure.<locals>.<listcomp>)r �fail� failClassr N) r � addFailurer r r) r r* r r r r � AddFailure)r r r- r r r. r r r r r/ Q r, zWorkerReporter.addFailurec s6 t � �||� t|�}|�� }| jjtj||d� dS )z# Send a skip over. )r �reasonN)r �addSkipr r r r r �AddSkip)r r r1 r r r r r2 c s �zWorkerReporter.addSkipc C s |du r| j S |jS )zj Get the reason for a C{Todo}. If C{todo} is L{None}, return a sensible default. N)� _DEFAULT_TODOr1 )r �todor r r �_getTodoReasonn s z WorkerReporter._getTodoReasonNc s@ t � �|||� |�� }|�� }| jjtj||| �|�d� dS )z0 Send an expected failure over. )r r r5 N) r �addExpectedFailurer) r r r r �AddExpectedFailurer6 )r r r r5 � errorMessager r r r r7 y s �z!WorkerReporter.addExpectedFailurec s4 t � �||� |�� }| jjtj|| �|�d� dS )z2 Send an unexpected success over. )r r5 N)r �addUnexpectedSuccessr r r r �AddUnexpectedSuccessr6 )r r r5 r r r r r: � s �z#WorkerReporter.addUnexpectedSuccessc C s dS )z* I{Don't} print a summary Nr )r r r r � printSummary� s zWorkerReporter.printSummary)N)�__name__� __module__� __qualname__�__doc__r4 r r r r r( r/ r2 r6 r7 r: r< � __classcell__r r r r r s r N) r@ �twisted.python.failurer �twisted.python.reflectr �twisted.trial._distr �twisted.trial.reporterr r r r r r �<module> s PK b�Z���e�' �' ( _dist/__pycache__/worker.cpython-310.pycnu �[��� o �b�$ � @ s d Z ddlZddlmZ ddlmZ ddlmZmZ ddl m Z ddl m Z ddl mZ dd lmZ dd lmZmZmZmZ dd lmZ dd lmZmZ dd lm Z G dd� de �Z G dd� de �Z ee�G dd� d��Z ee�G dd� d��Z G dd� de �Z!dS )z: This module implements the worker classes. @since: 12.3 � N)� implementer)�Deferred)�IAddress� ITransport)�ProcessProtocol)�AMP)�Failure)� namedObject)�_WORKER_AMP_STDIN�_WORKER_AMP_STDOUT�managercommands�workercommands)�WorkerReporter)� TestLoader� TrialSuite)�Todoc @ sB e Zd ZdZd dd�Zdd� Zej�e� dd� Z ej �e � d S ) �WorkerProtocolz5 The worker-side trial distributed protocol. Fc C s t � | _t| �| _|| _d S �N)r �_loaderr �_result�_forceGarbageCollection)�self�forceGarbageCollection� r �</usr/lib/python3/dist-packages/twisted/trial/_dist/worker.py�__init__& s zWorkerProtocol.__init__c C s. | j �|�}t|g| j�}|�| j� ddiS )z* Run a test case by name. �successT)r � loadByNamer r �runr )r �testCase�case�suiter r r r + s zWorkerProtocol.runc C s t �|� ddiS )zb Set up the worker, moving into given directory for tests to run in them. r T)�os�chdir)r � directoryr r r �start6 s zWorkerProtocol.startN)F) �__name__� __module__� __qualname__�__doc__r r r �Run� responderr% �Startr r r r r ! s r c @ s� e Zd ZdZdd� Zej�e� dd� Zdd� Z ej �e � dd � Z ej �e � d d � Z ej�e � d d � Zej�e� dd� Zej�e� dd� Zej�e� dd� Zdd� Zdd� ZdS )�LocalWorkerAMPz7 Local implementation of the manager commands. c C s | j �| j� ddiS )z0 Add a success to the reporter. r T)r � addSuccess� _testCase)r �testNamer r r r. F s zLocalWorkerAMP.addSuccessc C sZ t |�}t||�}tdt|�d�D ]}|j�|| ||d t||d �g g f� q|S )a� Helper to build a C{Failure} with some traceback. @param error: An C{Exception} instance. @param errorClass: The class name of the C{error} class. @param frames: A flat list of strings representing the information need to approximatively rebuild C{Failure} frames. @return: A L{Failure} instance with enough information about a test error. r � � � )r r �range�len�frames�append�int)r �error� errorClassr6 � errorType�failure�ir r r � _buildFailureO s $�z LocalWorkerAMP._buildFailurec C �& | � |||�}| j�| j|� ddiS )z/ Add an error to the reporter. r T)r> r �addErrorr/ )r r0 r9 r: r6 r< r r r r@ e � zLocalWorkerAMP.addErrorc C r? )z0 Add a failure to the reporter. r T)r> r � addFailurer/ )r r0 �fail� failClassr6 r< r r r rB o rA zLocalWorkerAMP.addFailurec C � | j �| j|� ddiS )z- Add a skip to the reporter. r T)r �addSkipr/ )r r0 �reasonr r r rF y � zLocalWorkerAMP.addSkipc C s" t |�}| j�| j||� ddiS )z: Add an expected failure to the reporter. r T)r r �addExpectedFailurer/ )r r0 r9 �todo�_todor r r rI � s z!LocalWorkerAMP.addExpectedFailurec C rE )z< Add an unexpected success to the reporter. r T)r �addUnexpectedSuccessr/ )r r0 rJ r r r rL � rH z#LocalWorkerAMP.addUnexpectedSuccessc C s" | j �|d � | j �� ddiS )z4 Print test output from the worker. � r T)� _testStream�write�flush)r �outr r r � testWrite� s zLocalWorkerAMP.testWritec C s | j �| j� |S )zL Stop the current running test case, forwarding the result. )r �stopTestr/ )r �resultr r r � _stopTest� s zLocalWorkerAMP._stopTestc C s< || _ || _| j�|� |�� }| jtj|d�}|�| j�S )z Run a test. )r ) r/ r � startTest�id� callRemoter r* � addCallbackrU )r r rT � testCaseId�dr r r r � s zLocalWorkerAMP.runc C s || _ dS )z? Set the stream used to log output from tests. N)rN )r �streamr r r � setTestStream� s z LocalWorkerAMP.setTestStreamN)r& r' r( r) r. r � AddSuccessr+ r> r@ �AddErrorrB � AddFailurerF �AddSkiprI �AddExpectedFailurerL �AddUnexpectedSuccessrR � TestWriterU r r] r r r r r- A s( r- c @ s e Zd ZdZdS )�LocalWorkerAddressz A L{IAddress} implementation meant to provide stub addresses for L{ITransport.getPeer} and L{ITransport.getHost}. N)r& r' r( r) r r r r re � s re c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�LocalWorkerTransportzi A stub transport implementation used to support L{AMP} over a L{ProcessProtocol} transport. c C s || _ d S r )� _transport)r � transportr r r r � s z LocalWorkerTransport.__init__c C s | j �t|� dS )z, Forward data to transport. N�rg � writeToChildr �r �datar r r rO � s zLocalWorkerTransport.writec C s |D ] }| j �t|� qdS )zP Emulate C{writeSequence} by iterating data in the C{sequence}. Nri )r �sequencerl r r r � writeSequence� s �z"LocalWorkerTransport.writeSequencec C s | j �� dS )z' Closes the transport. N)rg �loseConnection�r r r r ro � s z#LocalWorkerTransport.loseConnectionc C � t � S �z: Return a L{LocalWorkerAddress} instance. �re rp r r r �getHost� � z LocalWorkerTransport.getHostc C rq rr rs rp r r r �getPeer� ru z LocalWorkerTransport.getPeerN) r& r' r( r) r rO rn ro rt rv r r r r rf � s rf c @ sH e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dS )� LocalWorkeraX Local process worker protocol. This worker runs as a local process and communicates via stdin/out. @ivar _ampProtocol: The L{AMP} protocol instance used to communicate with the worker. @ivar _logDirectory: The directory where logs will reside. @ivar _logFile: The name of the main log file for tests output. c C s || _ || _|| _t� | _d S r )� _ampProtocol� _logDirectory�_logFiler � endDeferred)r � ampProtocol� logDirectory�logFiler r r r � s zLocalWorker.__init__c C s� | j �t| j�� tj�| j�st�| j� t tj� | jd�d�| _ t tj� | jd�d�| _ t tj� | j| j �dddd�| _| j �| j� | j}| j jtj|d�}|�d d � � d S ) zL When connection is made, create the AMP protocol instance. zout.log�wbzerr.log�wzutf-8�strict)�encoding�errors)r$ c S s d S r r )�xr r r �<lambda> s z,LocalWorker.connectionMade.<locals>.<lambda>N)rx �makeConnectionrf rh r" �path�existsry �makedirs�open�join�_outLog�_errLogrz �_testLogr] rX r r, � addErrback)r r} r[ r r r �connectionMade� s �zLocalWorker.connectionMadec C s" | j �� | j�� | j�� dS )zk On connection lost, close the log files that we're managing for stdin and stdout. N)r� �closer� r� �r rG r r r �connectionLost s zLocalWorker.connectionLostc C s& | � |� | j� |� | j�|� dS )z� When the process closes, call C{connectionLost} for cleanup purposes and forward the information to the C{_ampProtocol}. N)r� rx r{ �callbackr� r r r � processEnded s zLocalWorker.processEndedc C � | j �|� dS )z8 Send data received from stdout to log. N)r� rO rk r r r � outReceived( s zLocalWorker.outReceivedc C r� )z* Write error data to log. N)r� rO rk r r r � errReceived/ s zLocalWorker.errReceivedc C s* |t kr | j�|� dS t�| ||� dS )zT Handle data received on the specific pipe for the C{_ampProtocol}. N)r rx � dataReceivedr �childDataReceived)r �childFDrl r r r r� 5 s z LocalWorker.childDataReceivedN) r& r' r( r) r r� r� r� r� r� r� r r r r rw � s rw )"r) r" �zope.interfacer �twisted.internet.deferr �twisted.internet.interfacesr r �twisted.internet.protocolr �twisted.protocols.ampr �twisted.python.failurer �twisted.python.reflectr �twisted.trial._distr r r r �"twisted.trial._dist.workerreporterr �twisted.trial.runnerr r �twisted.trial.unittestr r r- re rf rw r r r r �<module> s( w)PK b�Z�6ol�" �" + _dist/__pycache__/disttrial.cpython-310.pycnu �[��� o �bn! � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ ddl m Z ddl m Z ddl mZmZ dd lmZ dd lmZmZ dd lmZ dd lmZ G d d� d�ZdS )z� This module contains the trial distributed runner, the management class responsible for coordinating all of trial's behavior at the highest level. @since: 12.3 � N)� DeferredList�� cooperate)�FilePath)� theSystemPath)� _iterateTests)�_WORKER_AMP_STDIN�_WORKER_AMP_STDOUT)� DistReporter)� LocalWorker�LocalWorkerAMP)� UncleanWarningsReporterWrapper)�_unusedTestDirectoryc @ sj e Zd ZdZeZdd� Z dd d �Zd d � Zd d� Z dd� Z dd� Z de dfdd�Z dd� ZdS )�DistTrialRunneraY A specialized runner for distributed trial. The runner launches a number of local worker processes which will run tests. @ivar _workerNumber: the number of workers to be spawned. @type _workerNumber: C{int} @ivar _stream: stream which the reporter will use. @ivar _reporterFactory: the reporter class to be used. c C s. | j | j| j| jd�}| jrt|�}| �|�S )zL Make reporter factory, and wrap it with a L{DistReporter}. )�realtime)�_reporterFactory�_stream� _tbformat� _rterrors�_uncleanWarningsr �_distReporterFactory)�self�reporter� r �?/usr/lib/python3/dist-packages/twisted/trial/_dist/disttrial.py� _makeResult* s � zDistTrialRunner._makeResultN�defaultF�test.log� _trial_tempc C s` || _ || _|| _|d u rtj}|| _|| _|| _|| _d | _ | | _ || _ d | _ d | _ d| _d S )NF)� _workerNumber�_workerArgumentsr �sys�stdoutr r r r �_result�_workingDirectory�_logFile�_logFileObserver�_logFileObject� _logWarnings) r �reporterFactory� workerNumber�workerArguments�stream�tracebackFormat�realTimeErrors�uncleanWarnings�logfile�workingDirectoryr r r �__init__5 s zDistTrialRunner.__init__c C s |� � dS )z� Write test run final outcome to result. @param result: A C{TestResult} which will print errors and the summary. N)�done)r �resultr r r � writeResultsQ s z DistTrialRunner.writeResultsc s � �fdd�t |�D �S )aY Create local worker protocol instances and return them. @param protocols: An iterable of L{LocalWorkerAMP} instances. @param workingDirectory: The base path in which we should run the workers. @type workingDirectory: C{str} @return: A list of C{quantity} C{LocalWorker} instances. c s, g | ]\}}t |tj��t|��� j��qS r )r �os�path�join�strr% )�.0�x�protocol�r r1 r r � <listcomp>e s ��z6DistTrialRunner.createLocalWorkers.<locals>.<listcomp>)� enumerate)r � protocolsr1 r r= r �createLocalWorkersY s �z"DistTrialRunner.createLocalWorkersc C sv t d jj}ddddddtdtdi}tj�� }tj� t j�|d< |D ]}t j |g}|� |� ||t j |||d� q"d S ) a Spawn processes from a list of process protocols. @param spawner: A C{IReactorProcess.spawnProcess} implementation. @param protocols: An iterable of C{ProcessProtocol} instances. @param arguments: Extra arguments passed to the processes. z twisted.trial._dist.workertrialr �w� �r� �TRIAL_PYTHONPATH)�args�childFDs�envN) r �filePathr7 r r r6 �environ�copy�pathsepr8 r! � executable�extend) r �spawnerr@ � arguments�workertrialPathrH rK �workerrG r r r �launchWorkerProcessesj s � �z%DistTrialRunner.launchWorkerProcessesc s6 � fdd��� ��fdd��|�fdd�|D ��� � S )a� Drive a L{LocalWorkerAMP} instance, iterating the tests and calling C{run} for every one of them. @param worker: The L{LocalWorkerAMP} to drive. @param result: The global L{DistReporter} instance. @param testCases: The global list of tests to iterate. @param cooperate: The cooperate function to use, to be customized in tests. @type cooperate: C{function} @return: A C{Deferred} firing when all the tests are finished. c s � j �|| � | S �N)�original� addFailure)�error�case)r4 r r � resultErrback� s z3DistTrialRunner._driveWorker.<locals>.resultErrbackc s �� | � �}|��| � |S rU )�run� addErrback)rY �d)r4 rZ rS r r �task� s z*DistTrialRunner._driveWorker.<locals>.taskc 3 s � | ]}� |�V qd S rU r )r: rY )r^ r r � <genexpr>� s � z/DistTrialRunner._driveWorker.<locals>.<genexpr>)�whenDone)r rS r4 � testCasesr r )r4 rZ r^ rS r � _driveWorker� s z DistTrialRunner._driveWorkerc s@ �du r ddl m� ��� �� �� }�j�d|f � |s*� ��j� ���� �S t t �j ��\}� t |�j �}dd� t|�D �� ��� |j�}dd� |D �����j|�j� � ���� fdd ��g � ����� fd d ���� � fd d �} ��� fdd�} ��fdd���� } | ��� | �| � ��dd| � ��� �S )a{ Spawn local worker processes and load tests. After that, run them. @param suite: A tests suite to be run. @param reactor: The reactor to use, to be customized in tests. @type reactor: A provider of L{twisted.internet.interfaces.IReactorProcess} @param cooperate: The cooperate function to use, to be customized in tests. @type cooperate: C{function} @param untilFailure: If C{True}, continue to run the tests until they fail. @type untilFailure: C{bool}. @return: The test result. @rtype: L{DistReporter} Nr )�reactorzRunning %d tests. c S s g | ]}t � �qS r )r )r: r; r r r r> � � z'DistTrialRunner.run.<locals>.<listcomp>c S s g | ]}|j �qS r )� endDeferred)r: rS r r r r> � rd c sD t tt����} g }� D ]}|��j|�| �d�� q t|ddd�S )Nr T)� consumeErrors�fireOnOneErrback)�iter�listr �appendrb r )ra �workerDeferredsrS )� ampWorkersr r4 r �suiter r �runTests� s ��z%DistTrialRunner.run.<locals>.runTestsc s. �� �� �s d S ��� sd S �� }|�� �S rU )r5 � wasSuccessful� addCallback)�ignr] )�nextRunr4 rn r � untilFailurer r rr � s z$DistTrialRunner.run.<locals>.nextRunc s& �� � �s��d � � �� d S d S rU )�unlockrj �stop�rq )rc �stopping� testDirLockr r ru � s �z!DistTrialRunner.run.<locals>.stopc s( �s�� d � t�dd�} | �� �S d S )NT)rf )rj r rp )r] )�continueShutdown�processEndDeferredsrw r r �beforeShutDown� s �z+DistTrialRunner.run.<locals>.beforeShutDownc s �� � � | S rU )r5 rv )r4 r r r ry � s z-DistTrialRunner.run.<locals>.continueShutdown�before�shutdown)�twisted.internetrc r �countTestCasesr �writer[ rV r5 r r r$ �minr �rangerA r7 rT � spawnProcessr rp �addBoth�addSystemEventTrigger) r rm rc r rs �count�testDirr* �workersru r{ r] r ) rl ry r rr rz rc r4 rn r rw rm rx rs r r[ � s6 zDistTrialRunner.runc C s | j |dd�S )z| Run the tests with local worker processes until they fail. @param suite: A tests suite to be run. T)rs )r[ )r rm r r r �runUntilFailure� s z DistTrialRunner.runUntilFailure)Nr FFr r )�__name__� __module__� __qualname__�__doc__r r r r2 r5 rA rT rb r r[ r� r r r r r s" � Xr )r� r6 r! �twisted.internet.deferr �twisted.internet.taskr �twisted.python.filepathr �twisted.python.modulesr �twisted.trial._asyncrunnerr �twisted.trial._distr r � twisted.trial._dist.distreporterr �twisted.trial._dist.workerr r �twisted.trial.reporterr �twisted.trial.utilr r r r r r �<module> s PK b�Z4�W� . _dist/__pycache__/distreporter.cpython-310.pycnu �[��� o �b � @ sH d Z ddlmZ ddlmZ ddlmZ ee�G dd� dee���ZdS )z� The reporter is not made to support concurrent test running, so we will hold test results in here and only send them to the reporter once the test is over. @since: 12.3 � )� implementer)�proxyForInterface)� IReporterc sd e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Zd d � Zdd d�Z ddd�Z dd� Z dd� Z � Z S )� DistReporterz See module docstring. c s t � �|� i | _d S �N)�super�__init__�running)�self�original�� __class__� �B/usr/lib/python3/dist-packages/twisted/trial/_dist/distreporter.pyr s zDistReporter.__init__c C s. g | j |�� < | j |�� �| jj|f� dS )z& Queue test starting. N)r �id�appendr � startTest�r �testr r r r s zDistReporter.startTestc C �" | j |�� �| jj||f� dS )z) Queue adding a failure. N)r r r r � addFailure)r r �failr r r r % � "zDistReporter.addFailurec C r )z% Queue error adding. N)r r r r �addError)r r �errorr r r r + r zDistReporter.addErrorc C r )z& Queue adding a skip. N)r r r r �addSkip)r r �reasonr r r r 1 r zDistReporter.addSkipNc C r )z5 Queue adding an unexpected success. N)r r r r �addUnexpectedSuccess)r r �todor r r r 7 r z!DistReporter.addUnexpectedSuccessc C s$ | j |�� �| jj|||f� dS )z5 Queue adding an unexpected failure. N)r r r r �addExpectedFailure)r r r r r r r r = s �z DistReporter.addExpectedFailurec C s | j |�� �| jj|f� dS )z) Queue adding a success. N)r r r r � addSuccessr r r r r E s zDistReporter.addSuccessc C sT | j |�� �| jj|f� | j |�� D ] }|d |dd� � q| j |�� = dS )zA Queue stopping the test, then unroll the queue. r � N)r r r r �stopTest)r r �stepr r r r" K s zDistReporter.stopTestr )�__name__� __module__� __qualname__�__doc__r r r r r r r r r" � __classcell__r r r r r s r N)r' �zope.interfacer �twisted.python.componentsr �twisted.trial.itrialr r r r r r �<module> s PK b�Z�g�$ �$ _dist/worker.pynu �[��� # -*- test-case-name: twisted.trial._dist.test.test_worker -*- # # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ This module implements the worker classes. @since: 12.3 """ import os from zope.interface import implementer from twisted.internet.defer import Deferred from twisted.internet.interfaces import IAddress, ITransport from twisted.internet.protocol import ProcessProtocol from twisted.protocols.amp import AMP from twisted.python.failure import Failure from twisted.python.reflect import namedObject from twisted.trial._dist import ( _WORKER_AMP_STDIN, _WORKER_AMP_STDOUT, managercommands, workercommands, ) from twisted.trial._dist.workerreporter import WorkerReporter from twisted.trial.runner import TestLoader, TrialSuite from twisted.trial.unittest import Todo class WorkerProtocol(AMP): """ The worker-side trial distributed protocol. """ def __init__(self, forceGarbageCollection=False): self._loader = TestLoader() self._result = WorkerReporter(self) self._forceGarbageCollection = forceGarbageCollection def run(self, testCase): """ Run a test case by name. """ case = self._loader.loadByName(testCase) suite = TrialSuite([case], self._forceGarbageCollection) suite.run(self._result) return {"success": True} workercommands.Run.responder(run) def start(self, directory): """ Set up the worker, moving into given directory for tests to run in them. """ os.chdir(directory) return {"success": True} workercommands.Start.responder(start) class LocalWorkerAMP(AMP): """ Local implementation of the manager commands. """ def addSuccess(self, testName): """ Add a success to the reporter. """ self._result.addSuccess(self._testCase) return {"success": True} managercommands.AddSuccess.responder(addSuccess) def _buildFailure(self, error, errorClass, frames): """ Helper to build a C{Failure} with some traceback. @param error: An C{Exception} instance. @param errorClass: The class name of the C{error} class. @param frames: A flat list of strings representing the information need to approximatively rebuild C{Failure} frames. @return: A L{Failure} instance with enough information about a test error. """ errorType = namedObject(errorClass) failure = Failure(error, errorType) for i in range(0, len(frames), 3): failure.frames.append( (frames[i], frames[i + 1], int(frames[i + 2]), [], []) ) return failure def addError(self, testName, error, errorClass, frames): """ Add an error to the reporter. """ failure = self._buildFailure(error, errorClass, frames) self._result.addError(self._testCase, failure) return {"success": True} managercommands.AddError.responder(addError) def addFailure(self, testName, fail, failClass, frames): """ Add a failure to the reporter. """ failure = self._buildFailure(fail, failClass, frames) self._result.addFailure(self._testCase, failure) return {"success": True} managercommands.AddFailure.responder(addFailure) def addSkip(self, testName, reason): """ Add a skip to the reporter. """ self._result.addSkip(self._testCase, reason) return {"success": True} managercommands.AddSkip.responder(addSkip) def addExpectedFailure(self, testName, error, todo): """ Add an expected failure to the reporter. """ _todo = Todo(todo) self._result.addExpectedFailure(self._testCase, error, _todo) return {"success": True} managercommands.AddExpectedFailure.responder(addExpectedFailure) def addUnexpectedSuccess(self, testName, todo): """ Add an unexpected success to the reporter. """ self._result.addUnexpectedSuccess(self._testCase, todo) return {"success": True} managercommands.AddUnexpectedSuccess.responder(addUnexpectedSuccess) def testWrite(self, out): """ Print test output from the worker. """ self._testStream.write(out + "\n") self._testStream.flush() return {"success": True} managercommands.TestWrite.responder(testWrite) def _stopTest(self, result): """ Stop the current running test case, forwarding the result. """ self._result.stopTest(self._testCase) return result def run(self, testCase, result): """ Run a test. """ self._testCase = testCase self._result = result self._result.startTest(testCase) testCaseId = testCase.id() d = self.callRemote(workercommands.Run, testCase=testCaseId) return d.addCallback(self._stopTest) def setTestStream(self, stream): """ Set the stream used to log output from tests. """ self._testStream = stream @implementer(IAddress) class LocalWorkerAddress: """ A L{IAddress} implementation meant to provide stub addresses for L{ITransport.getPeer} and L{ITransport.getHost}. """ @implementer(ITransport) class LocalWorkerTransport: """ A stub transport implementation used to support L{AMP} over a L{ProcessProtocol} transport. """ def __init__(self, transport): self._transport = transport def write(self, data): """ Forward data to transport. """ self._transport.writeToChild(_WORKER_AMP_STDIN, data) def writeSequence(self, sequence): """ Emulate C{writeSequence} by iterating data in the C{sequence}. """ for data in sequence: self._transport.writeToChild(_WORKER_AMP_STDIN, data) def loseConnection(self): """ Closes the transport. """ self._transport.loseConnection() def getHost(self): """ Return a L{LocalWorkerAddress} instance. """ return LocalWorkerAddress() def getPeer(self): """ Return a L{LocalWorkerAddress} instance. """ return LocalWorkerAddress() class LocalWorker(ProcessProtocol): """ Local process worker protocol. This worker runs as a local process and communicates via stdin/out. @ivar _ampProtocol: The L{AMP} protocol instance used to communicate with the worker. @ivar _logDirectory: The directory where logs will reside. @ivar _logFile: The name of the main log file for tests output. """ def __init__(self, ampProtocol, logDirectory, logFile): self._ampProtocol = ampProtocol self._logDirectory = logDirectory self._logFile = logFile self.endDeferred = Deferred() def connectionMade(self): """ When connection is made, create the AMP protocol instance. """ self._ampProtocol.makeConnection(LocalWorkerTransport(self.transport)) if not os.path.exists(self._logDirectory): os.makedirs(self._logDirectory) self._outLog = open(os.path.join(self._logDirectory, "out.log"), "wb") self._errLog = open(os.path.join(self._logDirectory, "err.log"), "wb") # Log data is received via AMP which is UTF-8 unicode. # The log file should be written using a Unicode encoding, and not # the default system encoding which might not be Unicode compatible. self._testLog = open( os.path.join(self._logDirectory, self._logFile), "w", encoding="utf-8", errors="strict", ) self._ampProtocol.setTestStream(self._testLog) logDirectory = self._logDirectory d = self._ampProtocol.callRemote(workercommands.Start, directory=logDirectory) # Ignore the potential errors, the test suite will fail properly and it # would just print garbage. d.addErrback(lambda x: None) def connectionLost(self, reason): """ On connection lost, close the log files that we're managing for stdin and stdout. """ self._outLog.close() self._errLog.close() self._testLog.close() def processEnded(self, reason): """ When the process closes, call C{connectionLost} for cleanup purposes and forward the information to the C{_ampProtocol}. """ self.connectionLost(reason) self._ampProtocol.connectionLost(reason) self.endDeferred.callback(reason) def outReceived(self, data): """ Send data received from stdout to log. """ self._outLog.write(data) def errReceived(self, data): """ Write error data to log. """ self._errLog.write(data) def childDataReceived(self, childFD, data): """ Handle data received on the specific pipe for the C{_ampProtocol}. """ if childFD == _WORKER_AMP_STDOUT: self._ampProtocol.dataReceived(data) else: ProcessProtocol.childDataReceived(self, childFD, data) PK b�Zb�� lA lA _dist/test/test_disttrial.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.trial._dist.disttrial}. """ import os import sys from io import StringIO from zope.interface import implementer, verify from twisted.internet import error, interfaces, reactor from twisted.internet.defer import fail, gatherResults, maybeDeferred, succeed from twisted.internet.main import CONNECTION_DONE from twisted.internet.protocol import ProcessProtocol, Protocol from twisted.internet.task import Cooperator, deferLater from twisted.python.failure import Failure from twisted.python.lockfile import FilesystemLock from twisted.test.proto_helpers import MemoryReactorClock from twisted.test.test_cooperator import FakeScheduler from twisted.trial._dist.distreporter import DistReporter from twisted.trial._dist.disttrial import DistTrialRunner from twisted.trial._dist.worker import LocalWorker from twisted.trial.reporter import ( Reporter, TreeReporter, UncleanWarningsReporterWrapper, ) from twisted.trial.runner import ErrorHolder, TrialSuite from twisted.trial.unittest import SynchronousTestCase, TestCase class FakeTransport: """ A simple fake process transport. """ def writeToChild(self, fd, data): """ Ignore write calls. """ @implementer(interfaces.IReactorProcess) class CountingReactor(MemoryReactorClock): """ A fake reactor that counts the calls to L{IReactorCore.run}, L{IReactorCore.stop}, and L{IReactorProcess.spawnProcess}. """ spawnCount = 0 stopCount = 0 runCount = 0 def __init__(self, workers): MemoryReactorClock.__init__(self) self._workers = workers def spawnProcess( self, workerProto, executable, args=(), env={}, path=None, uid=None, gid=None, usePTY=0, childFDs=None, ): """ See L{IReactorProcess.spawnProcess}. @param workerProto: See L{IReactorProcess.spawnProcess}. @param args: See L{IReactorProcess.spawnProcess}. @param kwargs: See L{IReactorProcess.spawnProcess}. """ self._workers.append(workerProto) workerProto.makeConnection(FakeTransport()) self.spawnCount += 1 def stop(self): """ See L{IReactorCore.stop}. """ MemoryReactorClock.stop(self) self.stopCount += 1 def run(self): """ See L{IReactorCore.run}. """ self.runCount += 1 # The same as IReactorCore.run, except no stop. self.running = True self.hasRun = True for f, args, kwargs in self.whenRunningHooks: f(*args, **kwargs) class CountingReactorTests(SynchronousTestCase): """ Tests for L{CountingReactor}. """ def setUp(self): self.workers = [] self.reactor = CountingReactor(self.workers) def test_providesIReactorProcess(self): """ L{CountingReactor} instances provide L{IReactorProcess}. """ verify.verifyObject(interfaces.IReactorProcess, self.reactor) def test_spawnProcess(self): """ The process protocol for a spawned process is connected to a transport and appended onto the provided C{workers} list, and the reactor's C{spawnCount} increased. """ self.assertFalse(self.reactor.spawnCount) proto = Protocol() for count in [1, 2]: self.reactor.spawnProcess(proto, sys.executable, args=[sys.executable]) self.assertTrue(proto.transport) self.assertEqual(self.workers, [proto] * count) self.assertEqual(self.reactor.spawnCount, count) def test_stop(self): """ Stopping the reactor increments its C{stopCount} """ self.assertFalse(self.reactor.stopCount) for count in [1, 2]: self.reactor.stop() self.assertEqual(self.reactor.stopCount, count) def test_run(self): """ Running the reactor increments its C{runCount}, does not imply C{stop}, and calls L{IReactorCore.callWhenRunning} hooks. """ self.assertFalse(self.reactor.runCount) whenRunningCalls = [] self.reactor.callWhenRunning(whenRunningCalls.append, None) for count in [1, 2]: self.reactor.run() self.assertEqual(self.reactor.runCount, count) self.assertEqual(self.reactor.stopCount, 0) self.assertEqual(len(whenRunningCalls), count) class EternalTerminationPredicateFactory: """ A rigged terminationPredicateFactory for which time never pass. """ def __call__(self): """ See: L{task._Timer} """ return False class DistTrialRunnerTests(TestCase): """ Tests for L{DistTrialRunner}. """ def setUp(self): """ Create a runner for testing. """ self.runner = DistTrialRunner( TreeReporter, 4, [], workingDirectory=self.mktemp() ) self.runner._stream = StringIO() def reap(self, workers): """ Reap the workers and trap L{ConnectionDone} failures on their C{endDeferred}s. @param workers: The workers to reap. @type workers: An iterable of L{LocalWorker} """ for worker in workers: worker.endDeferred.addErrback(Failure.trap, error.ConnectionDone) worker.processEnded(Failure(CONNECTION_DONE)) def getFakeSchedulerAndEternalCooperator(self): """ Helper to create fake scheduler and cooperator in tests. The cooperator has a termination timer which will never inform the scheduler that the task needs to be terminated. @return: L{tuple} of (scheduler, cooperator) """ scheduler = FakeScheduler() cooperator = Cooperator( scheduler=scheduler, terminationPredicateFactory=EternalTerminationPredicateFactory, ) return scheduler, cooperator def test_writeResults(self): """ L{DistTrialRunner.writeResults} writes to the stream specified in the init. """ stringIO = StringIO() result = DistReporter(Reporter(stringIO)) self.runner.writeResults(result) self.assertTrue(stringIO.tell() > 0) def test_createLocalWorkers(self): """ C{createLocalWorkers} iterates the list of protocols and create one L{LocalWorker} for each. """ protocols = [object() for x in range(4)] workers = self.runner.createLocalWorkers(protocols, "path") for s in workers: self.assertIsInstance(s, LocalWorker) self.assertEqual(4, len(workers)) def test_launchWorkerProcesses(self): """ Given a C{spawnProcess} function, C{launchWorkerProcess} launches a python process with an existing path as its argument. """ protocols = [ProcessProtocol() for i in range(4)] arguments = [] environment = {} def fakeSpawnProcess( processProtocol, executable, args=(), env={}, path=None, uid=None, gid=None, usePTY=0, childFDs=None, ): arguments.append(executable) arguments.extend(args) environment.update(env) self.runner.launchWorkerProcesses(fakeSpawnProcess, protocols, ["foo"]) self.assertEqual(arguments[0], arguments[1]) self.assertTrue(os.path.exists(arguments[2])) self.assertEqual("foo", arguments[3]) self.assertEqual(os.pathsep.join(sys.path), environment["TRIAL_PYTHONPATH"]) def test_run(self): """ C{run} starts the reactor exactly once and spawns each of the workers exactly once. """ workers = [] fakeReactor = CountingReactor(workers) self.addCleanup(self.reap, workers) suite = TrialSuite() for i in range(10): suite.addTest(TestCase()) self.runner.run(suite, fakeReactor) self.assertEqual(fakeReactor.runCount, 1) self.assertEqual(fakeReactor.spawnCount, self.runner._workerNumber) def test_runUsedDirectory(self): """ L{DistTrialRunner} checks if the test directory is already locked, and if it is generates a name based on it. """ class CountingReactorWithLock(CountingReactor): def spawnProcess(oself, worker, *args, **kwargs): oself._workers.append(worker) self.assertEqual( os.path.abspath(worker._logDirectory), os.path.abspath( os.path.join(workingDirectory + "-1", str(oself.spawnCount)) ), ) localLock = FilesystemLock(workingDirectory + "-1.lock") self.assertFalse(localLock.lock()) oself.spawnCount += 1 worker.makeConnection(FakeTransport()) worker._ampProtocol.run = lambda *args: succeed(None) newDirectory = self.mktemp() os.mkdir(newDirectory) workingDirectory = os.path.join(newDirectory, "_trial_temp") lock = FilesystemLock(workingDirectory + ".lock") lock.lock() self.addCleanup(lock.unlock) self.runner._workingDirectory = workingDirectory workers = [] fakeReactor = CountingReactorWithLock(workers) self.addCleanup(self.reap, workers) suite = TrialSuite() for i in range(10): suite.addTest(TestCase()) self.runner.run(suite, fakeReactor) def test_minimalWorker(self): """ L{DistTrialRunner} doesn't try to start more workers than the number of tests. """ workers = [] fakeReactor = CountingReactor(workers) self.addCleanup(self.reap, workers) self.runner.run(TestCase(), fakeReactor) self.assertEqual(fakeReactor.runCount, 1) self.assertEqual(fakeReactor.spawnCount, 1) def test_runUncleanWarnings(self): """ Running with the C{unclean-warnings} option makes L{DistTrialRunner} uses the L{UncleanWarningsReporterWrapper}. """ workers = [] fakeReactor = CountingReactor(workers) self.addCleanup(self.reap, workers) self.runner._uncleanWarnings = True result = self.runner.run(TestCase(), fakeReactor) self.assertIsInstance(result, DistReporter) self.assertIsInstance(result.original, UncleanWarningsReporterWrapper) def test_runWithoutTest(self): """ When the suite contains no test, L{DistTrialRunner} takes a shortcut path without launching any process or starting the reactor. """ fakeReactor = object() suite = TrialSuite() result = self.runner.run(suite, fakeReactor) self.assertIsInstance(result, DistReporter) output = self.runner._stream.getvalue() self.assertIn("Running 0 test", output) self.assertIn("PASSED", output) def test_runWithoutTestButWithAnError(self): """ Even if there is no test, the suite can contain an error (most likely, an import error): this should make the run fail, and the error should be printed. """ fakeReactor = object() error = ErrorHolder("an error", Failure(RuntimeError("foo bar"))) result = self.runner.run(error, fakeReactor) self.assertIsInstance(result, DistReporter) output = self.runner._stream.getvalue() self.assertIn("Running 0 test", output) self.assertIn("foo bar", output) self.assertIn("an error", output) self.assertIn("errors=1", output) self.assertIn("FAILED", output) def test_runUnexpectedError(self): """ If for some reasons we can't connect to the worker process, the test suite catches and fails. """ class CountingReactorWithFail(CountingReactor): def spawnProcess(self, worker, *args, **kwargs): self._workers.append(worker) worker.makeConnection(FakeTransport()) self.spawnCount += 1 worker._ampProtocol.run = self.failingRun def failingRun(self, case, result): return fail(RuntimeError("oops")) scheduler, cooperator = self.getFakeSchedulerAndEternalCooperator() workers = [] fakeReactor = CountingReactorWithFail(workers) self.addCleanup(self.reap, workers) result = self.runner.run(TestCase(), fakeReactor, cooperator.cooperate) self.assertEqual(fakeReactor.runCount, 1) self.assertEqual(fakeReactor.spawnCount, 1) scheduler.pump() self.assertEqual(1, len(result.original.failures)) def test_runStopAfterTests(self): """ L{DistTrialRunner} calls C{reactor.stop} and unlocks the test directory once the tests have run. """ class CountingReactorWithSuccess(CountingReactor): def spawnProcess(self, worker, *args, **kwargs): self._workers.append(worker) worker.makeConnection(FakeTransport()) self.spawnCount += 1 worker._ampProtocol.run = self.succeedingRun def succeedingRun(self, case, result): return succeed(None) workingDirectory = self.runner._workingDirectory workers = [] fakeReactor = CountingReactorWithSuccess(workers) self.runner.run(TestCase(), fakeReactor) def check(): localLock = FilesystemLock(workingDirectory + ".lock") self.assertTrue(localLock.lock()) self.assertEqual(1, fakeReactor.stopCount) self.assertEqual(list(fakeReactor.triggers.keys()), ["before"]) self.assertEqual(list(fakeReactor.triggers["before"]), ["shutdown"]) self.reap(workers) return deferLater(reactor, 0, check) def test_runWaitForProcessesDeferreds(self): """ L{DistTrialRunner} waits for the worker processes to stop when the reactor is stopping, and then unlocks the test directory, not trying to stop the reactor again. """ workers = [] workingDirectory = self.runner._workingDirectory fakeReactor = CountingReactor(workers) self.runner.run(TestCase(), fakeReactor) def check(ign): # Let the AMP deferreds fire return deferLater(reactor, 0, realCheck) def realCheck(): localLock = FilesystemLock(workingDirectory + ".lock") self.assertTrue(localLock.lock()) # Stop is not called, as it ought to have been called before self.assertEqual(0, fakeReactor.stopCount) self.assertEqual(list(fakeReactor.triggers.keys()), ["before"]) self.assertEqual(list(fakeReactor.triggers["before"]), ["shutdown"]) self.reap(workers) return gatherResults( [ maybeDeferred(f, *a, **kw) for f, a, kw in fakeReactor.triggers["before"]["shutdown"] ] ).addCallback(check) def test_runUntilFailure(self): """ L{DistTrialRunner} can run in C{untilFailure} mode where it will run the given tests until they fail. """ called = [] class CountingReactorWithSuccess(CountingReactor): def spawnProcess(self, worker, *args, **kwargs): self._workers.append(worker) worker.makeConnection(FakeTransport()) self.spawnCount += 1 worker._ampProtocol.run = self.succeedingRun def succeedingRun(self, case, result): called.append(None) if len(called) == 5: return fail(RuntimeError("oops")) return succeed(None) workers = [] fakeReactor = CountingReactorWithSuccess(workers) self.addCleanup(self.reap, workers) scheduler, cooperator = self.getFakeSchedulerAndEternalCooperator() result = self.runner.run( TestCase(), fakeReactor, cooperate=cooperator.cooperate, untilFailure=True ) scheduler.pump() self.assertEqual(5, len(called)) self.assertFalse(result.wasSuccessful()) output = self.runner._stream.getvalue() self.assertIn("PASSED", output) self.assertIn("FAIL", output) PK b�Z�j0� � 3 _dist/test/__pycache__/test_options.cpython-310.pycnu �[��� o �b3 � @ sH d Z ddlZddlZddlZddlmZ ddlmZ G dd� de�ZdS )z3 Tests for distributed trial's options management. � N)� WorkerOptions)�TestCasec @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �WorkerOptionsTestsz% Tests for L{WorkerOptions}. c C s t � | _dS )zK Build an L{WorkerOptions} object to be used in the tests. N)r �options��self� r �G/usr/lib/python3/dist-packages/twisted/trial/_dist/test/test_options.py�setUp s zWorkerOptionsTests.setUpc C s` | � tjt�� � t�� r| � tj� t�� | j�g d�� | � dt�� � | � t�� � dS )zd L{WorkerOptions} supports a subset of standard options supported by trial. )z--recursionlimit�2000z --disablegci� N) � addCleanup�sys�setrecursionlimit�getrecursionlimit�gc� isenabled�enabler � parseOptions� assertEqual� assertFalser r r r �test_standardOptions s z'WorkerOptionsTests.test_standardOptionsc C s. | � tj�tj�t�� d��| j�� j� dS )z� L{WorkerOptions.coverdir} returns the C{coverage} child directory of the current directory to be used for storing coverage data. �coverageN)r �os�path�realpath�join�getcwdr �coverdirr r r r � test_coverage( s �z WorkerOptionsTests.test_coverageN)�__name__� __module__� __qualname__�__doc__r r r r r r r r s r ) r" r r r �twisted.trial._dist.optionsr �twisted.trial.unittestr r r r r r �<module> s PK b�Z�C�� � 8 _dist/test/__pycache__/test_distreporter.cpython-310.pycnu �[��� o �b� � @ sH d Z ddlmZ ddlmZ ddlmZ ddlmZ G dd� de�Z dS ) z0 Tests for L{twisted.trial._dist.distreporter}. � )�StringIO)� DistReporter)� TreeReporter)�TestCasec @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd S ) �DistReporterTestsz$ Tests for L{DistReporter}. c C s$ t � | _tt| j��| _t� | _d S )N)r �streamr r � distReporterr �test��self� r �L/usr/lib/python3/dist-packages/twisted/trial/_dist/test/test_distreporter.py�setUp s zDistReporterTests.setUpc C sd | j �| j� | �| j�� d� | j �| j� | �| j�� d� | j �| j� | �| j�� d� dS )zY Success output only gets sent to the stream after the test has stopped. � N) r � startTestr � assertEqualr �getvalue� addSuccess�stopTest�assertNotEqualr r r r �test_startSuccessStop s z'DistReporterTests.test_startSuccessStopc C sf | j �| j� | �| j�� d� | j �| jd� | �| j�� d� | j �| j� | �| j�� d� dS )zW Error output only gets sent to the stream after the test has stopped. r �errorN) r r r r r r �addErrorr r r r r r �test_startErrorStop$ s z%DistReporterTests.test_startErrorStopc C s� | j �| j� | j �| jd� | j �| jd� | j �| jd� | j �| jd� | j �| jdd� | �t | j j | j� � �d� dS )zh Calling methods of L{DistReporter} add calls to the running queue of the test. �foo�bar�egg�spam�err� N) r r r � addFailurer �addSkip�addUnexpectedSuccess�addExpectedFailurer �len�running�idr r r r �test_forwardedMethods/ s "z'DistReporterTests.test_forwardedMethodsN)�__name__� __module__� __qualname__�__doc__r r r r' r r r r r s r N) r+ �ior � twisted.trial._dist.distreporterr �twisted.trial.reporterr �twisted.trial.unittestr r r r r r �<module> s PK b�Z P � � / _dist/test/__pycache__/__init__.cpython-310.pycnu �[��� o �bv � @ s d Z dS )z& Distributed trial test runner tests. N)�__doc__� r r �C/usr/lib/python3/dist-packages/twisted/trial/_dist/test/__init__.py�<module> s PK b�Z���ЪH �H 5 _dist/test/__pycache__/test_disttrial.cpython-310.pycnu �[��� o �blA � @ sj d Z ddlZddlZddlmZ ddlmZmZ ddlm Z m Z m Z ddl m Z mZmZmZ ddlmZ ddlmZmZ dd lmZmZ dd lmZ dd lm Z dd l m Z dd l m Z ddl!m"Z" ddl#m$Z$ ddl%m&Z& ddl'm(Z(m)Z)m*Z* ddl+m,Z,m-Z- ddl.m/Z/m0Z0 G dd� d�Z1ee j2�G dd� de ��Z3G dd� de/�Z4G dd� d�Z5G d d � d e0�Z6dS ) z- Tests for L{twisted.trial._dist.disttrial}. � N)�StringIO)� implementer�verify)�error� interfaces�reactor)�fail� gatherResults� maybeDeferred�succeed)�CONNECTION_DONE)�ProcessProtocol�Protocol)� Cooperator� deferLater)�Failure)�FilesystemLock)�MemoryReactorClock)� FakeScheduler)� DistReporter)�DistTrialRunner)� LocalWorker)�Reporter� TreeReporter� UncleanWarningsReporterWrapper)� ErrorHolder� TrialSuite)�SynchronousTestCase�TestCasec @ � e Zd ZdZdd� ZdS )� FakeTransportz* A simple fake process transport. c C � dS )z% Ignore write calls. N� )�self�fd�datar" r" �I/usr/lib/python3/dist-packages/twisted/trial/_dist/test/test_disttrial.py� writeToChild( s zFakeTransport.writeToChildN)�__name__� __module__� __qualname__�__doc__r' r" r" r" r& r # � r c @ sL e Zd ZdZdZdZdZdd� Zdi dddddfdd�Zd d � Z d d � Z dS ) �CountingReactorz� A fake reactor that counts the calls to L{IReactorCore.run}, L{IReactorCore.stop}, and L{IReactorProcess.spawnProcess}. r c C s t �| � || _d S �N)r �__init__�_workers)r# �workersr" r" r& r/ 9 s zCountingReactor.__init__r" Nc C s* | j �|� |�t� � | jd7 _dS )z� See L{IReactorProcess.spawnProcess}. @param workerProto: See L{IReactorProcess.spawnProcess}. @param args: See L{IReactorProcess.spawnProcess}. @param kwargs: See L{IReactorProcess.spawnProcess}. � N)r0 �append�makeConnectionr � spawnCount) r# � workerProto� executable�args�env�path�uid�gid�usePTY�childFDsr" r" r& � spawnProcess= s z CountingReactor.spawnProcessc C s t �| � | jd7 _dS )z+ See L{IReactorCore.stop}. r2 N)r �stop� stopCount�r# r" r" r& r@ T s zCountingReactor.stopc C s> | j d7 _ d| _d| _| jD ] \}}}||i |�� qdS )z* See L{IReactorCore.run}. r2 TN)�runCount�running�hasRun�whenRunningHooks)r# �fr8 �kwargsr" r" r& �run[ s �zCountingReactor.run) r( r) r* r+ r5 rA rC r/ r? r@ rI r" r" r" r& r- . s � r- c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd S ) �CountingReactorTestsz' Tests for L{CountingReactor}. c C s g | _ t| j �| _d S r. )r1 r- r rB r" r" r& �setUpn s zCountingReactorTests.setUpc C s t �tj| j� dS )zJ L{CountingReactor} instances provide L{IReactorProcess}. N)r � verifyObjectr �IReactorProcessr rB r" r" r& � test_providesIReactorProcessr s z1CountingReactorTests.test_providesIReactorProcessc C sj | � | jj� t� }dD ]&}| jj|tjtjgd� | �|j� | � | j |g| � | � | jj|� q dS )z� The process protocol for a spawned process is connected to a transport and appended onto the provided C{workers} list, and the reactor's C{spawnCount} increased. �r2 � �r8 N) � assertFalser r5 r r? �sysr7 � assertTrue� transport� assertEqualr1 )r# �proto�countr" r" r& �test_spawnProcessx s �z&CountingReactorTests.test_spawnProcessc C s6 | � | jj� dD ]}| j�� | �| jj|� q dS )zB Stopping the reactor increments its C{stopCount} rO N)rR r rA r@ rV )r# rX r" r" r& � test_stop� s �z CountingReactorTests.test_stopc C sj | � | jj� g }| j�|jd� dD ] }| j�� | �| jj|� | �| jjd� | �t|�|� qdS )z� Running the reactor increments its C{runCount}, does not imply C{stop}, and calls L{IReactorCore.callWhenRunning} hooks. NrO r ) rR r rC �callWhenRunningr3 rI rV rA �len)r# �whenRunningCallsrX r" r" r& �test_run� s �z CountingReactorTests.test_runN) r( r) r* r+ rK rN rY rZ r^ r" r" r" r& rJ i s rJ c @ r )�"EternalTerminationPredicateFactoryzI A rigged terminationPredicateFactory for which time never pass. c C r! )z% See: L{task._Timer} Fr" rB r" r" r& �__call__� s z+EternalTerminationPredicateFactory.__call__N)r( r) r* r+ r` r" r" r" r& r_ � r, r_ c @ 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"S )#�DistTrialRunnerTestsz' Tests for L{DistTrialRunner}. c C s$ t tdg | �� d�| _t� | j_dS )z. Create a runner for testing. � )�workingDirectoryN)r r �mktemp�runnerr �_streamrB r" r" r& rK � s �zDistTrialRunnerTests.setUpc C s. |D ]}|j �tjtj� |�tt�� qdS )z� Reap the workers and trap L{ConnectionDone} failures on their C{endDeferred}s. @param workers: The workers to reap. @type workers: An iterable of L{LocalWorker} N)� endDeferred� addErrbackr �trapr �ConnectionDone� processEndedr )r# r1 �workerr" r" r& �reap� s �zDistTrialRunnerTests.reapc C s t � }t|td�}||fS )a Helper to create fake scheduler and cooperator in tests. The cooperator has a termination timer which will never inform the scheduler that the task needs to be terminated. @return: L{tuple} of (scheduler, cooperator) )� scheduler�terminationPredicateFactory)r r r_ )r# rn � cooperatorr" r" r& �$getFakeSchedulerAndEternalCooperator� s �z9DistTrialRunnerTests.getFakeSchedulerAndEternalCooperatorc C s4 t � }tt|��}| j�|� | �|�� dk� dS )ze L{DistTrialRunner.writeResults} writes to the stream specified in the init. r N)r r r re � writeResultsrT �tell)r# �stringIO�resultr" r" r& �test_writeResults� s z&DistTrialRunnerTests.test_writeResultsc C sJ dd� t d�D �}| j�|d�}|D ]}| �|t� q| �dt|�� dS )zv C{createLocalWorkers} iterates the list of protocols and create one L{LocalWorker} for each. c S � g | ]}t � �qS r" )�object)�.0�xr" r" r& � <listcomp>� � z@DistTrialRunnerTests.test_createLocalWorkers.<locals>.<listcomp>rb r: N)�rangere �createLocalWorkers�assertIsInstancer rV r\ )r# � protocolsr1 �sr" r" r& �test_createLocalWorkers� s z,DistTrialRunnerTests.test_createLocalWorkersc s� dd� t d�D �}g � i �di dddddf� �fdd� }| j�||d g� | �� d � d � | �tj�� d �� | �d � d � | �tj� t j��d � dS )z� Given a C{spawnProcess} function, C{launchWorkerProcess} launches a python process with an existing path as its argument. c S rw r" )r )ry �ir" r" r& r{ � r| zCDistTrialRunnerTests.test_launchWorkerProcesses.<locals>.<listcomp>rb r" Nr c s" � � |� � �|� ��|� d S r. )r3 �extend�update) �processProtocolr7 r8 r9 r: r; r< r= r> �� arguments� environmentr" r& �fakeSpawnProcess� s zIDistTrialRunnerTests.test_launchWorkerProcesses.<locals>.fakeSpawnProcess�foor2 rP � �TRIAL_PYTHONPATH) r} re �launchWorkerProcessesrV rT �osr: �exists�pathsep�joinrS )r# r� r� r" r� r& �test_launchWorkerProcesses� s � z/DistTrialRunnerTests.test_launchWorkerProcessesc C sl g }t |�}| �| j|� t� }td�D ]}|�t� � q| j�||� | � |j d� | � |j | jj � dS )zm C{run} starts the reactor exactly once and spawns each of the workers exactly once. � r2 N) r- � addCleanuprm r r} �addTestr re rI rV rC r5 � _workerNumber)r# r1 � fakeReactor�suiter� r" r" r& r^ s z DistTrialRunnerTests.test_runc s� G � �fdd�dt �}� �� }t�|� tj�|d��t�d �}|�� � �|j � �� j _ g }||�}� �� j |� t � }td�D ]}|�t� � qC� j �||� dS )z� L{DistTrialRunner} checks if the test directory is already locked, and if it is generates a name based on it. c s e Zd Z� �fdd�ZdS )zKDistTrialRunnerTests.test_runUsedDirectory.<locals>.CountingReactorWithLockc s� | j �|� � �tj�|j�tj�tj��d t| j ���� t �d �}� � |� � � | j d7 _ |� t� � dd� |j_d S )Nz-1z-1.lockr2 c W � t d �S r. �r rQ r" r" r& �<lambda>. s zjDistTrialRunnerTests.test_runUsedDirectory.<locals>.CountingReactorWithLock.spawnProcess.<locals>.<lambda>)r0 r3 rV r� r: �abspath� _logDirectoryr� �strr5 r rR �lockr4 r � _ampProtocolrI )�oselfrl r8 rH � localLock�r# rc r" r& r? " s �� zXDistTrialRunnerTests.test_runUsedDirectory.<locals>.CountingReactorWithLock.spawnProcessN)r( r) r* r? r" r� r" r& �CountingReactorWithLock! s r� � _trial_temp�.lockr� N)r- rd r� �mkdirr: r� r r� r� �unlockre �_workingDirectoryrm r r} r� r rI )r# r� � newDirectoryr� r1 r� r� r� r" r� r& �test_runUsedDirectory s z*DistTrialRunnerTests.test_runUsedDirectoryc C sJ g }t |�}| �| j|� | j�t� |� | �|jd� | �|jd� dS )zh L{DistTrialRunner} doesn't try to start more workers than the number of tests. r2 N) r- r� rm re rI r rV rC r5 )r# r1 r� r" r" r& �test_minimalWorkerC s z'DistTrialRunnerTests.test_minimalWorkerc C sP g }t |�}| �| j|� d| j_| j�t� |�}| �|t� | �|j t � dS )z� Running with the C{unclean-warnings} option makes L{DistTrialRunner} uses the L{UncleanWarningsReporterWrapper}. TN) r- r� rm re �_uncleanWarningsrI r r r �originalr )r# r1 r� ru r" r" r& �test_runUncleanWarningsP s z,DistTrialRunnerTests.test_runUncleanWarningsc C sN t � }t� }| j�||�}| �|t� | jj�� }| �d|� | �d|� dS )z� When the suite contains no test, L{DistTrialRunner} takes a shortcut path without launching any process or starting the reactor. �Running 0 test�PASSEDN) rx r re rI r r rf �getvalue�assertIn)r# r� r� ru �outputr" r" r& �test_runWithoutTest^ s z(DistTrialRunnerTests.test_runWithoutTestc C s~ t � }tdttd���}| j�||�}| �|t� | jj� � }| � d|� | � d|� | � d|� | � d|� | � d|� dS )z� Even if there is no test, the suite can contain an error (most likely, an import error): this should make the run fail, and the error should be printed. zan errorzfoo barr� zerrors=1�FAILEDN) rx r r � RuntimeErrorre rI r r rf r� r� )r# r� r ru r� r" r" r& �!test_runWithoutTestButWithAnErrork s z6DistTrialRunnerTests.test_runWithoutTestButWithAnErrorc C s� G dd� dt �}| �� \}}g }||�}| �| j|� | j�t� ||j�}| �|j d� | �|j d� |� � | �dt |j j�� dS )zw If for some reasons we can't connect to the worker process, the test suite catches and fails. c @ � e Zd Zdd� Zdd� ZdS )zMDistTrialRunnerTests.test_runUnexpectedError.<locals>.CountingReactorWithFailc _ �4 | j �|� |�t� � | jd7 _| j|j_d S �Nr2 )r0 r3 r4 r r5 � failingRunr� rI �r# rl r8 rH r" r" r& r? � � zZDistTrialRunnerTests.test_runUnexpectedError.<locals>.CountingReactorWithFail.spawnProcessc S s t td��S )N�oops)r r� �r# �caseru r" r" r& r� � s zXDistTrialRunnerTests.test_runUnexpectedError.<locals>.CountingReactorWithFail.failingRunN)r( r) r* r? r� r" r" r" r& �CountingReactorWithFail� � r� r2 N)r- rq r� rm re rI r � cooperaterV rC r5 �pumpr\ r� �failures)r# r� rn rp r1 r� ru r" r" r& �test_runUnexpectedError| s z,DistTrialRunnerTests.test_runUnexpectedErrorc s� G dd� dt �}�jj�g }||�� �j�t� � � � ��fdd�}��t� j�� �dg� ��t� jd �dg� �� |� t t d|�S )zz L{DistTrialRunner} calls C{reactor.stop} and unlocks the test directory once the tests have run. c @ r� )zODistTrialRunnerTests.test_runStopAfterTests.<locals>.CountingReactorWithSuccessc _ r� r� �r0 r3 r4 r r5 � succeedingRunr� rI r� r" r" r& r? � r� z\DistTrialRunnerTests.test_runStopAfterTests.<locals>.CountingReactorWithSuccess.spawnProcessc S r� r. r� r� r" r" r& r� � s z]DistTrialRunnerTests.test_runStopAfterTests.<locals>.CountingReactorWithSuccess.succeedingRunN�r( r) r* r? r� r" r" r" r& �CountingReactorWithSuccess� r� r� c �, t �d �} ��| �� � ��d� j� d S )Nr� r2 �r rT r� rV rA �r� �r� r# rc r" r& �check� s z:DistTrialRunnerTests.test_runStopAfterTests.<locals>.check�before�shutdownr ) r- re r� rI r rV �list�triggers�keysrm r r )r# r� r1 r� r" r� r& �test_runStopAfterTests� s z+DistTrialRunnerTests.test_runStopAfterTestsc s� g }�j j�t|�� �j �t� � � �fdd�}� ��fdd����t� j�� �dg� ��t� jd �dg� �� |� t dd� � jd d D ��� |�S ) z� L{DistTrialRunner} waits for the worker processes to stop when the reactor is stopping, and then unlocks the test directory, not trying to stop the reactor again. c s t td� �S )Nr )r r )�ign)� realCheckr" r& r� � s zEDistTrialRunnerTests.test_runWaitForProcessesDeferreds.<locals>.checkc r� )Nr� r r� r� r� r" r& r� � s zIDistTrialRunnerTests.test_runWaitForProcessesDeferreds.<locals>.realCheckr� r� c S s( g | ]\}}}t |g|�R i |���qS r" )r )ry rG �a�kwr" r" r& r{ � s ��zJDistTrialRunnerTests.test_runWaitForProcessesDeferreds.<locals>.<listcomp>) re r� r- rI r rV r� r� r� rm r � addCallback)r# r1 r� r" )r� r� r# rc r& �!test_runWaitForProcessesDeferreds� s ���z6DistTrialRunnerTests.test_runWaitForProcessesDeferredsc s� g � G � fdd�dt �}g }||�}| �| j|� | �� \}}| jjt� ||jdd�}|�� | � dt � �� | � |� � � | jj �� }| �d|� | �d|� dS ) z L{DistTrialRunner} can run in C{untilFailure} mode where it will run the given tests until they fail. c s e Zd Zdd� Z� fdd�ZdS )zMDistTrialRunnerTests.test_runUntilFailure.<locals>.CountingReactorWithSuccessc _ r� r� r� r� r" r" r& r? � r� zZDistTrialRunnerTests.test_runUntilFailure.<locals>.CountingReactorWithSuccess.spawnProcessc s* � � d � t� �dkrttd��S td �S )N� r� )r3 r\ r r� r r� ��calledr" r& r� � s z[DistTrialRunnerTests.test_runUntilFailure.<locals>.CountingReactorWithSuccess.succeedingRunNr� r" r� r" r& r� � s r� T)r� � untilFailurer� r� �FAILN)r- r� rm rq re rI r r� r� rV r\ rR � wasSuccessfulrf r� r� )r# r� r1 r� rn rp ru r� r" r� r& �test_runUntilFailure� s � z)DistTrialRunnerTests.test_runUntilFailureN)r( r) r* r+ rK rm rq rv r� r� r^ r� r� r� r� r� r� r� r� r� r" r" r" r& ra � s$ ( " !ra )7r+ r� rS �ior �zope.interfacer r �twisted.internetr r r �twisted.internet.deferr r r r �twisted.internet.mainr �twisted.internet.protocolr r �twisted.internet.taskr r �twisted.python.failurer �twisted.python.lockfiler �twisted.test.proto_helpersr � twisted.test.test_cooperatorr � twisted.trial._dist.distreporterr � twisted.trial._dist.disttrialr �twisted.trial._dist.workerr �twisted.trial.reporterr r r �twisted.trial.runnerr r �twisted.trial.unittestr r r rM r- rJ r_ ra r" r" r" r& �<module> s4 :8 PK b�Z#�� A A 2 _dist/test/__pycache__/test_worker.cpython-310.pycnu �[��� o 5�@gn= � @ sR d Z ddlZddlZddlmZmZ ddlmZ ddlm Z m Z ddl m Z ddl mZmZ ddlmZ dd lmZ dd lmZ dd lmZ dd lmZ dd lmZ ddl m Z ddl m Z m Z ddl!m"Z"m#Z#m$Z$m%Z% ddl&m'Z' ddl(m)Z) G dd� de�Z*G dd� de)�Z+G dd� de)�Z,G dd� de#�Z-G dd � d �Z.G d d � d e)�Z/dS ) z) Test for distributed trial worker side. � N)�BytesIO�StringIO)� verifyObject)�fail�succeed)�ConnectionDone)�IAddress� ITransport)�CONNECTION_DONE)�AMP)�Failure)�FilePath)�fullyQualifiedName)�trial)�StringTransport)�managercommands�workercommands)� LocalWorker�LocalWorkerAMP�LocalWorkerTransport�WorkerProtocol)� TestResult)�TestCasec @ s e Zd ZdZdS )�FakeAMPz A fake amp protocol. N)�__name__� __module__� __qualname__�__doc__� r r �F/usr/lib/python3/dist-packages/twisted/trial/_dist/test/test_worker.pyr # s r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �WorkerProtocolTestsz& Tests for L{WorkerProtocol}. c C s@ t � | _t � | _t� | _| j�| j� t� | _| j�| j� dS )zN Set up a transport, a result stream and a protocol instance. N)r �serverTransport�clientTransportr �server�makeConnectionr �client��selfr r r �setUp. s zWorkerProtocolTests.setUpc sd � j jtjdd�}� fdd�}|�|� � j�� j�� � � j� � � j �� j �� � � j � � |S )z� Calling the L{workercommands.Run} command on the client returns a response with C{success} sets to C{True}. � doesntexist)�testCasec s � � | d � d S �N�success)� assertTrue��resultr& r r �check@ � z+WorkerProtocolTests.test_run.<locals>.check) r% � callRemoter �Run� addCallbackr# � dataReceivedr" �value�clearr! )r' �dr0 r r& r �test_run9 s z WorkerProtocolTests.test_runc C sF t j�t jj�}| �t j|� | j�d� | �t j�t jj�|� dS )z@ The C{start} command changes the current path. z..N) �os�path�realpath�curdir� addCleanup�chdirr# �start�assertNotEqual)r' r= r r r � test_startJ s z WorkerProtocolTests.test_startN)r r r r r( r9 rB r r r r r ) s r c @ sh e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )�LocalWorkerAMPTestszR Test case for distributed trial's manager-side local worker AMP protocol c C s� t � | _t� | _| j�| j� t� | _t � | _t� | _ | j �| j� t � � }d| _ |d � | j � t �|�j�� | _| j�| j| j� | j�� d S )Nztwisted.doesnexist�tests)r �managerTransportr � managerAMPr$ r r/ �workerTransportr �workerr �Options�testName�append� _getSuite�_tests�popr* �runr7 )r' �configr r r r( Y s zLocalWorkerAMPTests.setUpc C s2 | j �| j�� � | j�� | j�| j�� � dS )z� Sends data from C{self.workerTransport} to C{self.managerAMP}, and then data from C{self.managerTransport} back to C{self.worker}. N)rF r5 rG r6 r7 rH rE r& r r r �pumpTransportsj s z"LocalWorkerAMPTests.pumpTransportsc s@ g � | j jtj| jd�}|�� fdd�� | �� | �� � dS )z* Run a test, and succeed. )rJ c � � � | d �S r+ �rK r. ��resultsr r �<lambda>z � z5LocalWorkerAMPTests.test_runSuccess.<locals>.<lambda>N)rH r2 r � AddSuccessrJ r4 rQ r- �r' r8 r rT r �test_runSuccesss s z#LocalWorkerAMPTests.test_runSuccessc s^ g � | j jtj| jddd�}|�� fdd�� | �� | �| j| j j d d � | � � � dS )z2 Run a test, and fail expectedly. �error� todoReason)rJ r[ �todoc rR r+ rS r. rT r r rV � rW z=LocalWorkerAMPTests.test_runExpectedFailure.<locals>.<lambda>r N) rH r2 r �AddExpectedFailurerJ r4 rQ � assertEqualr* r/ �expectedFailuresr- rY r rT r �test_runExpectedFailure s �z+LocalWorkerAMPTests.test_runExpectedFailurec �h g � t t�}| jjtj| jd|g d�}|�� fdd�� | �� | � | j | j j d d � | � � � dS )z5 Run a test, and encounter an error. r[ �rJ r[ � errorClass�framesc rR r+ rS r. rT r r rV � rW z3LocalWorkerAMPTests.test_runError.<locals>.<lambda>r N)r � ValueErrorrH r2 r �AddErrorrJ r4 rQ r_ r* r/ �errorsr- �r' rd r8 r rT r � test_runError� � �z!LocalWorkerAMPTests.test_runErrorc s� g � t t�}| jjtj| jd|g d�d�}|�� fdd�� | �� | � | j | j j d d � | � ddd g g fg| j j d d j � | �� � d S ) z� L{LocalWorkerAMP._buildFailure} recreates the C{Failure.frames} from the C{frames} argument passed to C{AddError}. r[ )�file.py� invalid code�3rc c rR r+ rS r. rT r r rV � rW z=LocalWorkerAMPTests.test_runErrorWithFrames.<locals>.<lambda>r rl rm � � N)r rf rH r2 r rg rJ r4 rQ r_ r* r/ rh re r- ri r rT r �test_runErrorWithFrames� s � �z+LocalWorkerAMPTests.test_runErrorWithFramesc rb )z' Run a test, and fail. r )rJ r � failClassre c rR r+ rS r. rT r r rV � rW z5LocalWorkerAMPTests.test_runFailure.<locals>.<lambda>r N)r � RuntimeErrorrH r2 r � AddFailurerJ r4 rQ r_ r* r/ �failuresr- )r' rr r8 r rT r �test_runFailure� rk z#LocalWorkerAMPTests.test_runFailurec �\ g � | j jtj| jdd�}|�� fdd�� | �� | �| j| j j d d � | � � � dS )z* Run a test, but skip it. �reason)rJ rx c rR r+ rS r. rT r r rV � rW z2LocalWorkerAMPTests.test_runSkip.<locals>.<lambda>r N) rH r2 r �AddSkiprJ r4 rQ r_ r* r/ �skipsr- rY r rT r � test_runSkip� � �z LocalWorkerAMPTests.test_runSkipc rw )z7 Run a test, and succeed unexpectedly. r] )rJ r] c rR r+ rS r. rT r r rV � rW zALocalWorkerAMPTests.test_runUnexpectedSuccesses.<locals>.<lambda>r N) rH r2 r �AddUnexpectedSuccessrJ r4 rQ r_ r* r/ �unexpectedSuccessesr- rY r rT r �test_runUnexpectedSuccesses� r| z/LocalWorkerAMPTests.test_runUnexpectedSuccessesc sd g � t � }| j�|� tj}| jj|dd�}|�� fdd�� | �� | � d|� � � | � � � dS )zb L{LocalWorkerAMP.testWrite} writes the data received to its test stream. z Some output)�outc rR r+ rS r. rT r r rV � rW z4LocalWorkerAMPTests.test_testWrite.<locals>.<lambda>z Some output N) r rF � setTestStreamr � TestWriterH r2 r4 rQ r_ �getvaluer- )r' �stream�commandr8 r rT r �test_testWrite� s z"LocalWorkerAMPTests.test_testWritec sb t � � g �� fdd�}|| j_G �fdd�dt�}| j�| j|� �}| �| jg�� |�| j� �S )z| L{LocalWorkerAMP.run} calls C{stopTest} on its test result once the C{Run} commands has succeeded. c s t � �S �N)r )r� r* r. r r �fakeCallRemote s z=LocalWorkerAMPTests.test_stopAfterRun.<locals>.fakeCallRemotec s e Zd Z� fdd�ZdS )z=LocalWorkerAMPTests.test_stopAfterRun.<locals>.StopTestResultc s � � |� d S r� rS )r' �test��stoppedr r �stopTest s zFLocalWorkerAMPTests.test_stopAfterRun.<locals>.StopTestResult.stopTestN)r r r r� r r� r r �StopTestResult s r� ) �objectrF r2 r rO r* r_ r4 �assertIdentical)r' r� r� r8 r )r/ r� r �test_stopAfterRun� s z%LocalWorkerAMPTests.test_stopAfterRunN)r r r r r( rQ rZ ra rj rq rv r{ r r� r� r r r r rC T s rC c @ s e Zd ZdZdZdZdd� ZdS )�SpyDataLocalWorkerAMPz� A fake implementation of L{LocalWorkerAMP} that records the received data and doesn't automatically dispatch any command.. r � c C s | j |7 _ d S r� �� dataString)r' �datar r r r5 r1 z"SpyDataLocalWorkerAMP.dataReceivedN)r r r r �idr� r5 r r r r r� s r� c @ s( e Zd ZdZdZdZdd� Zdd� ZdS ) � FakeTransportz> A fake process transport implementation for testing. r� r c C s | j |7 _ d S r� r� )r' �fdr� r r r � writeToChild( r1 zFakeTransport.writeToChildc C s | j d7 _ d S )Nrp )�callsr& r r r �loseConnection+ r1 z FakeTransport.loseConnectionN)r r r r r� r� r� r� 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 ) �LocalWorkerTestsz? Tests for L{LocalWorker} and L{LocalWorkerTransport}. c O sH t |i |��}|�t� � | �|jj� | �|jj� | �|jj� |S )z� Create a L{LocalWorker}, connect it to a transport, and ensure its log files are closed. @param args: See L{LocalWorker} @param kwargs: See L{LocalWorker} @return: a L{LocalWorker} instance )r r$ r� r> �_testLog�close�_outLog�_errLog)r' �args�kwargsrH r r r �tidyLocalWorker4 s z LocalWorkerTests.tidyLocalWorkerc C sV | � t� dd�}t� |_|�dd� |�dd� | �d|jj� | �d|j�� � dS )z� L{LocalWorker.childDataReceived} forwards the received data to linked L{AMP} protocol if the right file descriptor, otherwise forwards to C{ProcessProtocol.childDataReceived}. �.�test.log� s foorp s barN) r� r� r r� �childDataReceivedr_ � _ampProtocolr� r� �r' � localWorkerr r r �test_childDataReceivedF s z'LocalWorkerTests.test_childDataReceivedc C s� t � }t| �� �}|�d�}t�� }| �tjtj|� t�tjd� t ||j d�}|� t � � | �|j j� | �|jj� z |�d� W |j�� n|j�� w | �dtj�d� |�� � dS )z� L{LocalWorker} write the log data with local newlines but in UTF-8 encoding regardless of the default encoding. r� )�C�asciiu Here comes the ☉!s Here comes the ☉!r� N)r� r �mktemp�child�locale� getlocaler> � setlocale�LC_ALLr r; r$ r� r� r� r� � testWriter� r_ r: �linesep�encode� getContent)r' �amp�tempDir�logFile� currentLocalerH r r r �_test_unicodeLogFileUTF8S s" �z)LocalWorkerTests._test_unicodeLogFileUTF8c C �< | � t� dd�}t� |_d}|�|� | �||j�� � dS )zb L{LocalWorker.outReceived} logs the output into its C{_outLog} log file. r� r� �+ The quick brown fox jumps over the lazy dogN)r� r� r r� � outReceivedr_ r� �r' r� r� r r r �test_outReceivedr � z!LocalWorkerTests.test_outReceivedc C r� )zb L{LocalWorker.errReceived} logs the errors into its C{_errLog} log file. r� r� r� N)r� r� r r� � errReceivedr_ r� r� r r r �test_errReceived} r� z!LocalWorkerTests.test_errReceivedc C s. t � }t|�}d}|�|� | �||j� dS )zi L{LocalWorkerTransport.write} forwards the written data to the given transport. r� N)r� r �writer_ r� �r' � transport�localTransportr� r r r � test_write� s zLocalWorkerTests.test_writec C s4 t � }t|�}d}|�|� | �d�|�|j� dS )zq L{LocalWorkerTransport.writeSequence} forwards the written data to the given transport. )s The quick s brown fox jumps s over the lazy dogr� N)r� r � writeSequencer_ �joinr� r� r r r �test_writeSequence� s z#LocalWorkerTests.test_writeSequencec C s( t � }t|�}|�� | �|jd� dS )zj L{LocalWorkerTransport.loseConnection} forwards the call to the given transport. rp N)r� r r� r_ r� )r' r� r� r r r �test_loseConnection� s z$LocalWorkerTests.test_loseConnectionc C sH | � t� dd�}|�d� | �|jj� | �|jj� | �|jj� dS )zG L{LocalWorker.connectionLost} closes the log streams. r� r� N)r� r� �connectionLostr- r� �closedr� r� r� r r r �test_connectionLost� s z$LocalWorkerTests.test_connectionLostc C sv t � }t� }t|dd�}|�|� |�tt�� | �|jj � | �|j j � | �|j j � | � d|j � | �|jt�S )zs L{LocalWorker.processEnded} calls C{connectionLost} on itself and on the L{AMP} protocol. r� r� N)r� r� r r$ � processEndedr r r- r� r� r� r� r� r� � assertFailure� endDeferredr )r' r� �protocolr� r r r �test_processEnded� s z"LocalWorkerTests.test_processEndedc C s4 t d�}| �tt|�� �� | �tt|�� �� dS )zy L{LocalWorkerTransport.getPeer} and L{LocalWorkerTransport.getHost} return L{IAddress} objects. N)r r- r r �getPeer�getHost�r' r� r r r �test_addresses� s z LocalWorkerTests.test_addressesc C s t d�}| �tt|�� dS )zk L{LocalWorkerTransport} implements L{ITransport} to be able to be used by L{AMP}. N)r r- r r r� r r r �test_transport� s z LocalWorkerTests.test_transportc C s8 dd� }t � }||_| �|dd� | �g | �t�� dS )z� L{LocalWorker} swallows the exceptions returned by the L{AMP} protocol start method, as it generates unnecessary errors. c S s t td��S )N�oops)r rs )r� � directoryr r r �failCallRemote� s z8LocalWorkerTests.test_startError.<locals>.failCallRemoter� r� N)r� r2 r� r_ �flushLoggedErrorsrs )r' r� r� r r r �test_startError� s z LocalWorkerTests.test_startErrorN)r r r r r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r� / s r� )0r r� r: �ior r �zope.interface.verifyr �twisted.internet.deferr r �twisted.internet.errorr �twisted.internet.interfacesr r �twisted.internet.mainr �twisted.protocols.ampr �twisted.python.failurer �twisted.python.filepathr �twisted.python.reflectr �twisted.scriptsr �twisted.test.proto_helpersr �twisted.trial._distr r �twisted.trial._dist.workerr r r r �twisted.trial.reporterr �twisted.trial.unittestr r r rC r� r� r� r r r r �<module> s4 + @ PK b�Z��'{ { : _dist/test/__pycache__/test_workerreporter.cpython-310.pycnu �[��� o �b% � @ sZ d Z ddlmZ ddlmZ ddlmZ ddlmZm Z G dd� d�Z G dd � d e�Z d S ) z2 Tests for L{twisted.trial._dist.workerreporter}. � )�Failure)�managercommands)�WorkerReporter)�TestCase�Todoc @ s e Zd ZdZdZdZdd� ZdS )�FakeAMProtocolzE A fake C{AMP} implementations to track C{callRemote} calls. r Nc K s || _ || _d S �N)�lastCall�lastArgs)�self�command�kwargs� r �N/usr/lib/python3/dist-packages/twisted/trial/_dist/test/test_workerreporter.py� callRemote s zFakeAMProtocol.callRemote)�__name__� __module__� __qualname__�__doc__�idr r r r r r r s r c @ sh e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dd� Z dd� Z dd� Z dd� Z dd� ZdS )�WorkerReporterTestsz& Tests for L{WorkerReporter}. c C s t � | _t| j�| _t� | _d S r )r �fakeAMProtocolr �workerReporterr �test�r r r r �setUp s zWorkerReporterTests.setUpc C �$ | j �| j� | �| jjtj� dS )ze L{WorkerReporter.addSuccess} sends a L{managercommands.AddSuccess} command. N)r � addSuccessr � assertEqualr r r � AddSuccessr r r r �test_addSuccess% s z#WorkerReporterTests.test_addSuccessc C �. | j �| jttd��� | �| jjtj � dS )zY L{WorkerReporter.addError} sends a L{managercommands.AddError} command. �errorN) r �addErrorr r � RuntimeErrorr r r r �AddErrorr r r r � test_addError- s z!WorkerReporterTests.test_addErrorc C �0 | j �| jttd�df� | �| jjtj� dS )z� Adding an error using L{WorkerReporter.addError} as a C{sys.exc_info}-style tuple sends an L{managercommands.AddError} command. r" N) r r# r r$ r r r r r% r r r r �test_addErrorTuple4 � �z&WorkerReporterTests.test_addErrorTuplec C r! )ze L{WorkerReporter.addFailure} sends a L{managercommands.AddFailure} command. �failN) r � addFailurer r r$ r r r r � AddFailurer r r r �test_addFailure? s z#WorkerReporterTests.test_addFailurec C r' )z� Adding a failure using L{WorkerReporter.addFailure} as a C{sys.exc_info}-style tuple sends an L{managercommands.AddFailure} message. r* N) r r+ r r$ r r r r r, r r r r �test_addFailureTupleG r) z(WorkerReporterTests.test_addFailureTuplec C s& | j �| jd� | �| jjtj� dS )zW L{WorkerReporter.addSkip} sends a L{managercommands.AddSkip} command. �reasonN)r �addSkipr r r r r �AddSkipr r r r � test_addSkipR s z WorkerReporterTests.test_addSkipc C s4 | j �| jttd��td�� | �| jjt j � dS )�� L{WorkerReporter.addExpectedFailure} sends a L{managercommands.AddExpectedFailure} command. protocol. r" �todoN) r �addExpectedFailurer r r$ r r r r r �AddExpectedFailurer r r r �test_addExpectedFailureY s � �z+WorkerReporterTests.test_addExpectedFailurec C r! )r3 r" N) r r5 r r r$ r r r r r6 r r r r � test_addExpectedFailureNoTodof s � �z1WorkerReporterTests.test_addExpectedFailureNoTodoc C s* | j �| jtd�� | �| jjtj� dS )�y L{WorkerReporter.addUnexpectedSuccess} sends a L{managercommands.AddUnexpectedSuccess} command. r4 N) r �addUnexpectedSuccessr r r r r r �AddUnexpectedSuccessr r r r �test_addUnexpectedSuccesss s �z-WorkerReporterTests.test_addUnexpectedSuccessc C r )r9 N)r r: r r r r r r; r r r r � test_addUnexpectedSuccessNoTodo} s �z3WorkerReporterTests.test_addUnexpectedSuccessNoTodoN)r r r r r r r& r( r- r. r2 r7 r8 r< r= r r r r r s r N) r �twisted.python.failurer �twisted.trial._distr �"twisted.trial._dist.workerreporterr �twisted.trial.unittestr r r r r r r r �<module> s PK b�Z;�Ȑ � 7 _dist/test/__pycache__/test_workertrial.cpython-310.pycnu �[��� o �bd � @ s� d Z ddlZddlZddlZddlmZ ddlmZ ddlm Z ddl m Z m Z m Z mZmZ ddlmZmZmZ ddlmZ G d d � d e�ZG d d � d e�ZG d d� de�ZG dd� de�ZdS )z/ Tests for L{twisted.trial._dist.workertrial}. � N)�BytesIO)�AMP)�StringTransport)�_WORKER_AMP_STDIN�_WORKER_AMP_STDOUT�managercommands�workercommands� workertrial)�WorkerLogObserver� _setupPath�main)�TestCasec @ s e Zd ZdZdS )�FakeAMPz A fake amp protocol. N)�__name__� __module__� __qualname__�__doc__� r r �K/usr/lib/python3/dist-packages/twisted/trial/_dist/test/test_workertrial.pyr s r c @ � e Zd ZdZdd� ZdS )�WorkerLogObserverTestsz) Tests for L{WorkerLogObserver}. c sL g � G � fdd�d�}t |� �}|�ddgi� | �� tjddifg� dS )zU L{WorkerLogObserver} forwards data to L{managercommands.TestWrite}. c s e Zd Z� fdd�ZdS )z4WorkerLogObserverTests.test_emit.<locals>.FakeClientc s � � ||f� d S �N)�append)�self�method�kwargs��callsr r � callRemote, s z?WorkerLogObserverTests.test_emit.<locals>.FakeClient.callRemoteN)r r r r r r r r � FakeClient+ s r �messagezSome log�outN)r �emit� assertEqualr � TestWrite)r r �observerr r r � test_emit% s z WorkerLogObserverTests.test_emitN)r r r r r& r r r r r s r c @ sJ e Zd ZdZdd� Zddd�Zdd� Zd d � Zd d � Zd d� Z dd� Z dS )� MainTestsz Tests for L{main}. c C s> t � | _t � | _| �td| j� | �ttdtj � dgt_ d S )N�startLoggingWithObserver�argv�trial) r � readStream� writeStream�patchr r( � addCleanup�setattr�sysr) �r r r r �setUp9 s � zMainTests.setUpNc C sB |t kr | �d|� | jS |tkr| �d|� | jS td|����)z� Fake C{os.fdopen} implementation which returns C{self.readStream} for the stdin fd and C{self.writeStream} for the stdout fd. �rb�wbzUnexpected fd )r �assertIdenticalr+ r r# r, �AssertionError)r �fd�moder r r �fdopenB s zMainTests.fdopenc C s | � |� dS )zP Override C{startLoggingWithObserver} for not starting logging. N)� assertFalse)r r" � setStdoutr r r r( P s z"MainTests.startLoggingWithObserverc C s t | j� | �d| j�� � dS )zU If no data is ever written, L{main} exits without writing data out. � N)r r9 r# r, �getvaluer1 r r r � test_emptyV s zMainTests.test_emptyc C s\ t � }t� }|�|� |jtjdd� |j| _| j�dd� t | j � | � d| j � � � dS )z� L{main} forwards data from its input stream to a L{WorkerProtocol} instance which writes data to the output stream. � doesntexist)�testCaser s No module named 'doesntexist'N)r r �makeConnectionr r �Run�ior+ �seekr r9 �assertInr, r= )r �client�clientTransportr r r �test_forwardCommand] s z MainTests.test_forwardCommandc sL g � G � fdd�d�}|� | _ t| j� | �d| j�� � | �dg� � dS )z� If reading the input stream fails with a C{IOError} with errno C{EINTR}, L{main} ignores it and continues reading. c s e Zd ZdZ� fdd�ZdS )z2MainTests.test_readInterrupted.<locals>.FakeStreamr c s4 | j d7 _ | j dkrttj��� �t�� � dS )N� r< )�count�OSError�errno�EINTRr r0 �exc_info��oself�size��excInfosr r �readu s z7MainTests.test_readInterrupted.<locals>.FakeStream.readN�r r r rJ rT r rR r r � FakeStreamr s rV r< )NNNN)r+ r r9 r# r, r= �r rV r rR r �test_readInterruptedk s z MainTests.test_readInterruptedc C s* G dd� d�}|� | _ | �tt| j� dS )zm L{main} only ignores C{IOError} with C{EINTR} errno: otherwise, the error pops out. c @ r )z1MainTests.test_otherReadError.<locals>.FakeStreamr c S s$ | j d7 _ | j dkrtd��dS )NrI zSomething else� )rJ rK rO r r r rT � s z6MainTests.test_otherReadError.<locals>.FakeStream.readNrU r r r r rV � s rV N)r+ � assertRaises�IOErrorr r9 rW r r r �test_otherReadError� s z MainTests.test_otherReadErrorr ) r r r r r2 r9 r( r> rH rX r\ r r r r r' 4 s r' c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �SetupPathTestsz; Tests for L{_setupPath} C{sys.path} manipulation. c C s | � ttdtjd d � � d S )N�path)r. r/ r0 r^ r1 r r r r2 � s zSetupPathTests.setUpc C s2 dt j�ddg�i}t|� | �ddgtj� dS )zu L{_setupPath} overrides C{sys.path} if B{TRIAL_PYTHONPATH} is specified in the environment. �TRIAL_PYTHONPATH�foo�barN)�os�pathsep�joinr r# r0 r^ )r �environr r r �test_overridePath� s z SetupPathTests.test_overridePathc C s( t jdd� }ti � | �|t j� dS )z| L{_setupPath} doesn't change C{sys.path} if B{TRIAL_PYTHONPATH} is not present in the environment. N)r0 r^ r r# )r � originalPathr r r �test_noVariable� s z SetupPathTests.test_noVariableN)r r r r r2 rf rh r r r r r] � s r] )r rL rb r0 rC r �twisted.protocols.ampr �twisted.test.proto_helpersr �twisted.trial._distr r r r r � twisted.trial._dist.workertrialr r r �twisted.trial.unittestr r r r' r] r r r r �<module> s aPK b�Z4�O�n= n= _dist/test/test_worker.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Test for distributed trial worker side. """ import locale import os from io import BytesIO, StringIO from zope.interface.verify import verifyObject from twisted.internet.defer import fail, succeed from twisted.internet.error import ConnectionDone from twisted.internet.interfaces import IAddress, ITransport from twisted.internet.main import CONNECTION_DONE from twisted.protocols.amp import AMP from twisted.python.failure import Failure from twisted.python.filepath import FilePath from twisted.python.reflect import fullyQualifiedName from twisted.scripts import trial from twisted.test.proto_helpers import StringTransport from twisted.trial._dist import managercommands, workercommands from twisted.trial._dist.worker import ( LocalWorker, LocalWorkerAMP, LocalWorkerTransport, WorkerProtocol, ) from twisted.trial.reporter import TestResult from twisted.trial.unittest import TestCase class FakeAMP(AMP): """ A fake amp protocol. """ class WorkerProtocolTests(TestCase): """ Tests for L{WorkerProtocol}. """ def setUp(self): """ Set up a transport, a result stream and a protocol instance. """ self.serverTransport = StringTransport() self.clientTransport = StringTransport() self.server = WorkerProtocol() self.server.makeConnection(self.serverTransport) self.client = FakeAMP() self.client.makeConnection(self.clientTransport) def test_run(self): """ Calling the L{workercommands.Run} command on the client returns a response with C{success} sets to C{True}. """ d = self.client.callRemote(workercommands.Run, testCase="doesntexist") def check(result): self.assertTrue(result["success"]) d.addCallback(check) self.server.dataReceived(self.clientTransport.value()) self.clientTransport.clear() self.client.dataReceived(self.serverTransport.value()) self.serverTransport.clear() return d def test_start(self): """ The C{start} command changes the current path. """ curdir = os.path.realpath(os.path.curdir) self.addCleanup(os.chdir, curdir) self.server.start("..") self.assertNotEqual(os.path.realpath(os.path.curdir), curdir) class LocalWorkerAMPTests(TestCase): """ Test case for distributed trial's manager-side local worker AMP protocol """ def setUp(self): self.managerTransport = StringTransport() self.managerAMP = LocalWorkerAMP() self.managerAMP.makeConnection(self.managerTransport) self.result = TestResult() self.workerTransport = StringTransport() self.worker = AMP() self.worker.makeConnection(self.workerTransport) config = trial.Options() self.testName = "twisted.doesnexist" config["tests"].append(self.testName) self.testCase = trial._getSuite(config)._tests.pop() self.managerAMP.run(self.testCase, self.result) self.managerTransport.clear() def pumpTransports(self): """ Sends data from C{self.workerTransport} to C{self.managerAMP}, and then data from C{self.managerTransport} back to C{self.worker}. """ self.managerAMP.dataReceived(self.workerTransport.value()) self.workerTransport.clear() self.worker.dataReceived(self.managerTransport.value()) def test_runSuccess(self): """ Run a test, and succeed. """ results = [] d = self.worker.callRemote(managercommands.AddSuccess, testName=self.testName) d.addCallback(lambda result: results.append(result["success"])) self.pumpTransports() self.assertTrue(results) def test_runExpectedFailure(self): """ Run a test, and fail expectedly. """ results = [] d = self.worker.callRemote( managercommands.AddExpectedFailure, testName=self.testName, error="error", todo="todoReason", ) d.addCallback(lambda result: results.append(result["success"])) self.pumpTransports() self.assertEqual(self.testCase, self.result.expectedFailures[0][0]) self.assertTrue(results) def test_runError(self): """ Run a test, and encounter an error. """ results = [] errorClass = fullyQualifiedName(ValueError) d = self.worker.callRemote( managercommands.AddError, testName=self.testName, error="error", errorClass=errorClass, frames=[], ) d.addCallback(lambda result: results.append(result["success"])) self.pumpTransports() self.assertEqual(self.testCase, self.result.errors[0][0]) self.assertTrue(results) def test_runErrorWithFrames(self): """ L{LocalWorkerAMP._buildFailure} recreates the C{Failure.frames} from the C{frames} argument passed to C{AddError}. """ results = [] errorClass = fullyQualifiedName(ValueError) d = self.worker.callRemote( managercommands.AddError, testName=self.testName, error="error", errorClass=errorClass, frames=["file.py", "invalid code", "3"], ) d.addCallback(lambda result: results.append(result["success"])) self.pumpTransports() self.assertEqual(self.testCase, self.result.errors[0][0]) self.assertEqual( [("file.py", "invalid code", 3, [], [])], self.result.errors[0][1].frames ) self.assertTrue(results) def test_runFailure(self): """ Run a test, and fail. """ results = [] failClass = fullyQualifiedName(RuntimeError) d = self.worker.callRemote( managercommands.AddFailure, testName=self.testName, fail="fail", failClass=failClass, frames=[], ) d.addCallback(lambda result: results.append(result["success"])) self.pumpTransports() self.assertEqual(self.testCase, self.result.failures[0][0]) self.assertTrue(results) def test_runSkip(self): """ Run a test, but skip it. """ results = [] d = self.worker.callRemote( managercommands.AddSkip, testName=self.testName, reason="reason" ) d.addCallback(lambda result: results.append(result["success"])) self.pumpTransports() self.assertEqual(self.testCase, self.result.skips[0][0]) self.assertTrue(results) def test_runUnexpectedSuccesses(self): """ Run a test, and succeed unexpectedly. """ results = [] d = self.worker.callRemote( managercommands.AddUnexpectedSuccess, testName=self.testName, todo="todo" ) d.addCallback(lambda result: results.append(result["success"])) self.pumpTransports() self.assertEqual(self.testCase, self.result.unexpectedSuccesses[0][0]) self.assertTrue(results) def test_testWrite(self): """ L{LocalWorkerAMP.testWrite} writes the data received to its test stream. """ results = [] stream = StringIO() self.managerAMP.setTestStream(stream) command = managercommands.TestWrite d = self.worker.callRemote(command, out="Some output") d.addCallback(lambda result: results.append(result["success"])) self.pumpTransports() self.assertEqual("Some output\n", stream.getvalue()) self.assertTrue(results) def test_stopAfterRun(self): """ L{LocalWorkerAMP.run} calls C{stopTest} on its test result once the C{Run} commands has succeeded. """ result = object() stopped = [] def fakeCallRemote(command, testCase): return succeed(result) self.managerAMP.callRemote = fakeCallRemote class StopTestResult(TestResult): def stopTest(self, test): stopped.append(test) d = self.managerAMP.run(self.testCase, StopTestResult()) self.assertEqual([self.testCase], stopped) return d.addCallback(self.assertIdentical, result) class SpyDataLocalWorkerAMP(LocalWorkerAMP): """ A fake implementation of L{LocalWorkerAMP} that records the received data and doesn't automatically dispatch any command.. """ id = 0 dataString = b"" def dataReceived(self, data): self.dataString += data class FakeTransport: """ A fake process transport implementation for testing. """ dataString = b"" calls = 0 def writeToChild(self, fd, data): self.dataString += data def loseConnection(self): self.calls += 1 class LocalWorkerTests(TestCase): """ Tests for L{LocalWorker} and L{LocalWorkerTransport}. """ def tidyLocalWorker(self, *args, **kwargs): """ Create a L{LocalWorker}, connect it to a transport, and ensure its log files are closed. @param args: See L{LocalWorker} @param kwargs: See L{LocalWorker} @return: a L{LocalWorker} instance """ worker = LocalWorker(*args, **kwargs) worker.makeConnection(FakeTransport()) self.addCleanup(worker._testLog.close) self.addCleanup(worker._outLog.close) self.addCleanup(worker._errLog.close) return worker def test_childDataReceived(self): """ L{LocalWorker.childDataReceived} forwards the received data to linked L{AMP} protocol if the right file descriptor, otherwise forwards to C{ProcessProtocol.childDataReceived}. """ localWorker = self.tidyLocalWorker(SpyDataLocalWorkerAMP(), ".", "test.log") localWorker._outLog = BytesIO() localWorker.childDataReceived(4, b"foo") localWorker.childDataReceived(1, b"bar") self.assertEqual(b"foo", localWorker._ampProtocol.dataString) self.assertEqual(b"bar", localWorker._outLog.getvalue()) def _test_unicodeLogFileUTF8(self): """ L{LocalWorker} write the log data with local newlines but in UTF-8 encoding regardless of the default encoding. """ amp = SpyDataLocalWorkerAMP() tempDir = FilePath(self.mktemp()) logFile = tempDir.child("test.log") # Modern OSes are running default locale in UTF-8 and this is what # is used by Python at startup. # For this test, we force an ASCII default encoding. currentLocale = locale.getlocale() self.addCleanup(locale.setlocale, locale.LC_ALL, currentLocale) locale.setlocale(locale.LC_ALL, ("C", "ascii")) worker = LocalWorker(amp, tempDir.path, "test.log") worker.makeConnection(FakeTransport()) self.addCleanup(worker._outLog.close) self.addCleanup(worker._errLog.close) try: amp.testWrite("Here comes the \N{sun}!") finally: worker._testLog.close() self.assertEqual( b"Here comes the \xe2\x98\x89!" + os.linesep.encode("ascii"), logFile.getContent(), ) def test_outReceived(self): """ L{LocalWorker.outReceived} logs the output into its C{_outLog} log file. """ localWorker = self.tidyLocalWorker(SpyDataLocalWorkerAMP(), ".", "test.log") localWorker._outLog = BytesIO() data = b"The quick brown fox jumps over the lazy dog" localWorker.outReceived(data) self.assertEqual(data, localWorker._outLog.getvalue()) def test_errReceived(self): """ L{LocalWorker.errReceived} logs the errors into its C{_errLog} log file. """ localWorker = self.tidyLocalWorker(SpyDataLocalWorkerAMP(), ".", "test.log") localWorker._errLog = BytesIO() data = b"The quick brown fox jumps over the lazy dog" localWorker.errReceived(data) self.assertEqual(data, localWorker._errLog.getvalue()) def test_write(self): """ L{LocalWorkerTransport.write} forwards the written data to the given transport. """ transport = FakeTransport() localTransport = LocalWorkerTransport(transport) data = b"The quick brown fox jumps over the lazy dog" localTransport.write(data) self.assertEqual(data, transport.dataString) def test_writeSequence(self): """ L{LocalWorkerTransport.writeSequence} forwards the written data to the given transport. """ transport = FakeTransport() localTransport = LocalWorkerTransport(transport) data = (b"The quick ", b"brown fox jumps ", b"over the lazy dog") localTransport.writeSequence(data) self.assertEqual(b"".join(data), transport.dataString) def test_loseConnection(self): """ L{LocalWorkerTransport.loseConnection} forwards the call to the given transport. """ transport = FakeTransport() localTransport = LocalWorkerTransport(transport) localTransport.loseConnection() self.assertEqual(transport.calls, 1) def test_connectionLost(self): """ L{LocalWorker.connectionLost} closes the log streams. """ localWorker = self.tidyLocalWorker(SpyDataLocalWorkerAMP(), ".", "test.log") localWorker.connectionLost(None) self.assertTrue(localWorker._outLog.closed) self.assertTrue(localWorker._errLog.closed) self.assertTrue(localWorker._testLog.closed) def test_processEnded(self): """ L{LocalWorker.processEnded} calls C{connectionLost} on itself and on the L{AMP} protocol. """ transport = FakeTransport() protocol = SpyDataLocalWorkerAMP() localWorker = LocalWorker(protocol, ".", "test.log") localWorker.makeConnection(transport) localWorker.processEnded(Failure(CONNECTION_DONE)) self.assertTrue(localWorker._outLog.closed) self.assertTrue(localWorker._errLog.closed) self.assertTrue(localWorker._testLog.closed) self.assertIdentical(None, protocol.transport) return self.assertFailure(localWorker.endDeferred, ConnectionDone) def test_addresses(self): """ L{LocalWorkerTransport.getPeer} and L{LocalWorkerTransport.getHost} return L{IAddress} objects. """ localTransport = LocalWorkerTransport(None) self.assertTrue(verifyObject(IAddress, localTransport.getPeer())) self.assertTrue(verifyObject(IAddress, localTransport.getHost())) def test_transport(self): """ L{LocalWorkerTransport} implements L{ITransport} to be able to be used by L{AMP}. """ localTransport = LocalWorkerTransport(None) self.assertTrue(verifyObject(ITransport, localTransport)) def test_startError(self): """ L{LocalWorker} swallows the exceptions returned by the L{AMP} protocol start method, as it generates unnecessary errors. """ def failCallRemote(command, directory): return fail(RuntimeError("oops")) protocol = SpyDataLocalWorkerAMP() protocol.callRemote = failCallRemote self.tidyLocalWorker(protocol, ".", "test.log") self.assertEqual([], self.flushLoggedErrors(RuntimeError)) PK b�Z~�(�� � _dist/test/test_distreporter.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.trial._dist.distreporter}. """ from io import StringIO from twisted.trial._dist.distreporter import DistReporter from twisted.trial.reporter import TreeReporter from twisted.trial.unittest import TestCase class DistReporterTests(TestCase): """ Tests for L{DistReporter}. """ def setUp(self): self.stream = StringIO() self.distReporter = DistReporter(TreeReporter(self.stream)) self.test = TestCase() def test_startSuccessStop(self): """ Success output only gets sent to the stream after the test has stopped. """ self.distReporter.startTest(self.test) self.assertEqual(self.stream.getvalue(), "") self.distReporter.addSuccess(self.test) self.assertEqual(self.stream.getvalue(), "") self.distReporter.stopTest(self.test) self.assertNotEqual(self.stream.getvalue(), "") def test_startErrorStop(self): """ Error output only gets sent to the stream after the test has stopped. """ self.distReporter.startTest(self.test) self.assertEqual(self.stream.getvalue(), "") self.distReporter.addError(self.test, "error") self.assertEqual(self.stream.getvalue(), "") self.distReporter.stopTest(self.test) self.assertNotEqual(self.stream.getvalue(), "") def test_forwardedMethods(self): """ Calling methods of L{DistReporter} add calls to the running queue of the test. """ self.distReporter.startTest(self.test) self.distReporter.addFailure(self.test, "foo") self.distReporter.addError(self.test, "bar") self.distReporter.addSkip(self.test, "egg") self.distReporter.addUnexpectedSuccess(self.test, "spam") self.distReporter.addExpectedFailure(self.test, "err", "foo") self.assertEqual(len(self.distReporter.running[self.test.id()]), 6) PK b�Z�ψ�3 3 _dist/test/test_options.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for distributed trial's options management. """ import gc import os import sys from twisted.trial._dist.options import WorkerOptions from twisted.trial.unittest import TestCase class WorkerOptionsTests(TestCase): """ Tests for L{WorkerOptions}. """ def setUp(self): """ Build an L{WorkerOptions} object to be used in the tests. """ self.options = WorkerOptions() def test_standardOptions(self): """ L{WorkerOptions} supports a subset of standard options supported by trial. """ self.addCleanup(sys.setrecursionlimit, sys.getrecursionlimit()) if gc.isenabled(): self.addCleanup(gc.enable) gc.enable() self.options.parseOptions(["--recursionlimit", "2000", "--disablegc"]) self.assertEqual(2000, sys.getrecursionlimit()) self.assertFalse(gc.isenabled()) def test_coverage(self): """ L{WorkerOptions.coverdir} returns the C{coverage} child directory of the current directory to be used for storing coverage data. """ self.assertEqual( os.path.realpath(os.path.join(os.getcwd(), "coverage")), self.options.coverdir().path, ) PK b�Z�t0O% % ! _dist/test/test_workerreporter.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.trial._dist.workerreporter}. """ from twisted.python.failure import Failure from twisted.trial._dist import managercommands from twisted.trial._dist.workerreporter import WorkerReporter from twisted.trial.unittest import TestCase, Todo class FakeAMProtocol: """ A fake C{AMP} implementations to track C{callRemote} calls. """ id = 0 lastCall = None def callRemote(self, command, **kwargs): self.lastCall = command self.lastArgs = kwargs class WorkerReporterTests(TestCase): """ Tests for L{WorkerReporter}. """ def setUp(self): self.fakeAMProtocol = FakeAMProtocol() self.workerReporter = WorkerReporter(self.fakeAMProtocol) self.test = TestCase() def test_addSuccess(self): """ L{WorkerReporter.addSuccess} sends a L{managercommands.AddSuccess} command. """ self.workerReporter.addSuccess(self.test) self.assertEqual(self.fakeAMProtocol.lastCall, managercommands.AddSuccess) def test_addError(self): """ L{WorkerReporter.addError} sends a L{managercommands.AddError} command. """ self.workerReporter.addError(self.test, Failure(RuntimeError("error"))) self.assertEqual(self.fakeAMProtocol.lastCall, managercommands.AddError) def test_addErrorTuple(self): """ Adding an error using L{WorkerReporter.addError} as a C{sys.exc_info}-style tuple sends an L{managercommands.AddError} command. """ self.workerReporter.addError( self.test, (RuntimeError, RuntimeError("error"), None) ) self.assertEqual(self.fakeAMProtocol.lastCall, managercommands.AddError) def test_addFailure(self): """ L{WorkerReporter.addFailure} sends a L{managercommands.AddFailure} command. """ self.workerReporter.addFailure(self.test, Failure(RuntimeError("fail"))) self.assertEqual(self.fakeAMProtocol.lastCall, managercommands.AddFailure) def test_addFailureTuple(self): """ Adding a failure using L{WorkerReporter.addFailure} as a C{sys.exc_info}-style tuple sends an L{managercommands.AddFailure} message. """ self.workerReporter.addFailure( self.test, (RuntimeError, RuntimeError("fail"), None) ) self.assertEqual(self.fakeAMProtocol.lastCall, managercommands.AddFailure) def test_addSkip(self): """ L{WorkerReporter.addSkip} sends a L{managercommands.AddSkip} command. """ self.workerReporter.addSkip(self.test, "reason") self.assertEqual(self.fakeAMProtocol.lastCall, managercommands.AddSkip) def test_addExpectedFailure(self): """ L{WorkerReporter.addExpectedFailure} sends a L{managercommands.AddExpectedFailure} command. protocol. """ self.workerReporter.addExpectedFailure( self.test, Failure(RuntimeError("error")), Todo("todo") ) self.assertEqual( self.fakeAMProtocol.lastCall, managercommands.AddExpectedFailure ) def test_addExpectedFailureNoTodo(self): """ L{WorkerReporter.addExpectedFailure} sends a L{managercommands.AddExpectedFailure} command. protocol. """ self.workerReporter.addExpectedFailure( self.test, Failure(RuntimeError("error")) ) self.assertEqual( self.fakeAMProtocol.lastCall, managercommands.AddExpectedFailure ) def test_addUnexpectedSuccess(self): """ L{WorkerReporter.addUnexpectedSuccess} sends a L{managercommands.AddUnexpectedSuccess} command. """ self.workerReporter.addUnexpectedSuccess(self.test, Todo("todo")) self.assertEqual( self.fakeAMProtocol.lastCall, managercommands.AddUnexpectedSuccess ) def test_addUnexpectedSuccessNoTodo(self): """ L{WorkerReporter.addUnexpectedSuccess} sends a L{managercommands.AddUnexpectedSuccess} command. """ self.workerReporter.addUnexpectedSuccess(self.test) self.assertEqual( self.fakeAMProtocol.lastCall, managercommands.AddUnexpectedSuccess ) PK b�Zv5R v v _dist/test/__init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Distributed trial test runner tests. """ PK b�Z?' �d d _dist/test/test_workertrial.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Tests for L{twisted.trial._dist.workertrial}. """ import errno import os import sys from io import BytesIO from twisted.protocols.amp import AMP from twisted.test.proto_helpers import StringTransport from twisted.trial._dist import ( _WORKER_AMP_STDIN, _WORKER_AMP_STDOUT, managercommands, workercommands, workertrial, ) from twisted.trial._dist.workertrial import WorkerLogObserver, _setupPath, main from twisted.trial.unittest import TestCase class FakeAMP(AMP): """ A fake amp protocol. """ class WorkerLogObserverTests(TestCase): """ Tests for L{WorkerLogObserver}. """ def test_emit(self): """ L{WorkerLogObserver} forwards data to L{managercommands.TestWrite}. """ calls = [] class FakeClient: def callRemote(self, method, **kwargs): calls.append((method, kwargs)) observer = WorkerLogObserver(FakeClient()) observer.emit({"message": ["Some log"]}) self.assertEqual(calls, [(managercommands.TestWrite, {"out": "Some log"})]) class MainTests(TestCase): """ Tests for L{main}. """ def setUp(self): self.readStream = BytesIO() self.writeStream = BytesIO() self.patch( workertrial, "startLoggingWithObserver", self.startLoggingWithObserver ) self.addCleanup(setattr, sys, "argv", sys.argv) sys.argv = ["trial"] def fdopen(self, fd, mode=None): """ Fake C{os.fdopen} implementation which returns C{self.readStream} for the stdin fd and C{self.writeStream} for the stdout fd. """ if fd == _WORKER_AMP_STDIN: self.assertIdentical("rb", mode) return self.readStream elif fd == _WORKER_AMP_STDOUT: self.assertEqual("wb", mode) return self.writeStream else: raise AssertionError(f"Unexpected fd {fd!r}") def startLoggingWithObserver(self, emit, setStdout): """ Override C{startLoggingWithObserver} for not starting logging. """ self.assertFalse(setStdout) def test_empty(self): """ If no data is ever written, L{main} exits without writing data out. """ main(self.fdopen) self.assertEqual(b"", self.writeStream.getvalue()) def test_forwardCommand(self): """ L{main} forwards data from its input stream to a L{WorkerProtocol} instance which writes data to the output stream. """ client = FakeAMP() clientTransport = StringTransport() client.makeConnection(clientTransport) client.callRemote(workercommands.Run, testCase="doesntexist") self.readStream = clientTransport.io self.readStream.seek(0, 0) main(self.fdopen) self.assertIn(b"No module named 'doesntexist'", self.writeStream.getvalue()) def test_readInterrupted(self): """ If reading the input stream fails with a C{IOError} with errno C{EINTR}, L{main} ignores it and continues reading. """ excInfos = [] class FakeStream: count = 0 def read(oself, size): oself.count += 1 if oself.count == 1: raise OSError(errno.EINTR) else: excInfos.append(sys.exc_info()) return b"" self.readStream = FakeStream() main(self.fdopen) self.assertEqual(b"", self.writeStream.getvalue()) self.assertEqual([(None, None, None)], excInfos) def test_otherReadError(self): """ L{main} only ignores C{IOError} with C{EINTR} errno: otherwise, the error pops out. """ class FakeStream: count = 0 def read(oself, size): oself.count += 1 if oself.count == 1: raise OSError("Something else") return "" self.readStream = FakeStream() self.assertRaises(IOError, main, self.fdopen) class SetupPathTests(TestCase): """ Tests for L{_setupPath} C{sys.path} manipulation. """ def setUp(self): self.addCleanup(setattr, sys, "path", sys.path[:]) def test_overridePath(self): """ L{_setupPath} overrides C{sys.path} if B{TRIAL_PYTHONPATH} is specified in the environment. """ environ = {"TRIAL_PYTHONPATH": os.pathsep.join(["foo", "bar"])} _setupPath(environ) self.assertEqual(["foo", "bar"], sys.path) def test_noVariable(self): """ L{_setupPath} doesn't change C{sys.path} if B{TRIAL_PYTHONPATH} is not present in the environment. """ originalPath = sys.path[:] _setupPath({}) self.assertEqual(originalPath, sys.path) PK b�ZB��� _dist/distreporter.pynu �[��� # -*- test-case-name: twisted.trial._dist.test.test_distreporter -*- # # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ The reporter is not made to support concurrent test running, so we will hold test results in here and only send them to the reporter once the test is over. @since: 12.3 """ from zope.interface import implementer from twisted.python.components import proxyForInterface from twisted.trial.itrial import IReporter @implementer(IReporter) class DistReporter(proxyForInterface(IReporter)): # type: ignore[misc] """ See module docstring. """ def __init__(self, original): super().__init__(original) self.running = {} def startTest(self, test): """ Queue test starting. """ self.running[test.id()] = [] self.running[test.id()].append((self.original.startTest, test)) def addFailure(self, test, fail): """ Queue adding a failure. """ self.running[test.id()].append((self.original.addFailure, test, fail)) def addError(self, test, error): """ Queue error adding. """ self.running[test.id()].append((self.original.addError, test, error)) def addSkip(self, test, reason): """ Queue adding a skip. """ self.running[test.id()].append((self.original.addSkip, test, reason)) def addUnexpectedSuccess(self, test, todo=None): """ Queue adding an unexpected success. """ self.running[test.id()].append((self.original.addUnexpectedSuccess, test, todo)) def addExpectedFailure(self, test, error, todo=None): """ Queue adding an unexpected failure. """ self.running[test.id()].append( (self.original.addExpectedFailure, test, error, todo) ) def addSuccess(self, test): """ Queue adding a success. """ self.running[test.id()].append((self.original.addSuccess, test)) def stopTest(self, test): """ Queue stopping the test, then unroll the queue. """ self.running[test.id()].append((self.original.stopTest, test)) for step in self.running[test.id()]: step[0](*step[1:]) del self.running[test.id()] PK b�ZI K� � _dist/options.pynu �[��� # -*- test-case-name: twisted.trial._dist.test.test_options -*- # # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Options handling specific to trial's workers. @since: 12.3 """ from twisted.application.app import ReactorSelectionMixin from twisted.python.filepath import FilePath from twisted.python.usage import Options from twisted.scripts.trial import _BasicOptions class WorkerOptions(_BasicOptions, Options, ReactorSelectionMixin): """ Options forwarded to the trial distributed worker. """ def coverdir(self): """ Return a L{FilePath} representing the directory into which coverage results should be written. """ return FilePath("coverage") PK b�Z�X�n! n! _dist/disttrial.pynu �[��� # -*- test-case-name: twisted.trial._dist.test.test_disttrial -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ This module contains the trial distributed runner, the management class responsible for coordinating all of trial's behavior at the highest level. @since: 12.3 """ import os import sys from twisted.internet.defer import DeferredList from twisted.internet.task import cooperate from twisted.python.filepath import FilePath from twisted.python.modules import theSystemPath from twisted.trial._asyncrunner import _iterateTests from twisted.trial._dist import _WORKER_AMP_STDIN, _WORKER_AMP_STDOUT from twisted.trial._dist.distreporter import DistReporter from twisted.trial._dist.worker import LocalWorker, LocalWorkerAMP from twisted.trial.reporter import UncleanWarningsReporterWrapper from twisted.trial.util import _unusedTestDirectory class DistTrialRunner: """ A specialized runner for distributed trial. The runner launches a number of local worker processes which will run tests. @ivar _workerNumber: the number of workers to be spawned. @type _workerNumber: C{int} @ivar _stream: stream which the reporter will use. @ivar _reporterFactory: the reporter class to be used. """ _distReporterFactory = DistReporter def _makeResult(self): """ Make reporter factory, and wrap it with a L{DistReporter}. """ reporter = self._reporterFactory( self._stream, self._tbformat, realtime=self._rterrors ) if self._uncleanWarnings: reporter = UncleanWarningsReporterWrapper(reporter) return self._distReporterFactory(reporter) def __init__( self, reporterFactory, workerNumber, workerArguments, stream=None, tracebackFormat="default", realTimeErrors=False, uncleanWarnings=False, logfile="test.log", workingDirectory="_trial_temp", ): self._workerNumber = workerNumber self._workerArguments = workerArguments self._reporterFactory = reporterFactory if stream is None: stream = sys.stdout self._stream = stream self._tbformat = tracebackFormat self._rterrors = realTimeErrors self._uncleanWarnings = uncleanWarnings self._result = None self._workingDirectory = workingDirectory self._logFile = logfile self._logFileObserver = None self._logFileObject = None self._logWarnings = False def writeResults(self, result): """ Write test run final outcome to result. @param result: A C{TestResult} which will print errors and the summary. """ result.done() def createLocalWorkers(self, protocols, workingDirectory): """ Create local worker protocol instances and return them. @param protocols: An iterable of L{LocalWorkerAMP} instances. @param workingDirectory: The base path in which we should run the workers. @type workingDirectory: C{str} @return: A list of C{quantity} C{LocalWorker} instances. """ return [ LocalWorker(protocol, os.path.join(workingDirectory, str(x)), self._logFile) for x, protocol in enumerate(protocols) ] def launchWorkerProcesses(self, spawner, protocols, arguments): """ Spawn processes from a list of process protocols. @param spawner: A C{IReactorProcess.spawnProcess} implementation. @param protocols: An iterable of C{ProcessProtocol} instances. @param arguments: Extra arguments passed to the processes. """ workertrialPath = theSystemPath["twisted.trial._dist.workertrial"].filePath.path childFDs = { 0: "w", 1: "r", 2: "r", _WORKER_AMP_STDIN: "w", _WORKER_AMP_STDOUT: "r", } environ = os.environ.copy() # Add an environment variable containing the raw sys.path, to be used by # subprocesses to make sure it's identical to the parent. See # workertrial._setupPath. environ["TRIAL_PYTHONPATH"] = os.pathsep.join(sys.path) for worker in protocols: args = [sys.executable, workertrialPath] args.extend(arguments) spawner(worker, sys.executable, args=args, childFDs=childFDs, env=environ) def _driveWorker(self, worker, result, testCases, cooperate): """ Drive a L{LocalWorkerAMP} instance, iterating the tests and calling C{run} for every one of them. @param worker: The L{LocalWorkerAMP} to drive. @param result: The global L{DistReporter} instance. @param testCases: The global list of tests to iterate. @param cooperate: The cooperate function to use, to be customized in tests. @type cooperate: C{function} @return: A C{Deferred} firing when all the tests are finished. """ def resultErrback(error, case): result.original.addFailure(case, error) return error def task(case): d = worker.run(case, result) d.addErrback(resultErrback, case) return d return cooperate(task(case) for case in testCases).whenDone() def run(self, suite, reactor=None, cooperate=cooperate, untilFailure=False): """ Spawn local worker processes and load tests. After that, run them. @param suite: A tests suite to be run. @param reactor: The reactor to use, to be customized in tests. @type reactor: A provider of L{twisted.internet.interfaces.IReactorProcess} @param cooperate: The cooperate function to use, to be customized in tests. @type cooperate: C{function} @param untilFailure: If C{True}, continue to run the tests until they fail. @type untilFailure: C{bool}. @return: The test result. @rtype: L{DistReporter} """ if reactor is None: from twisted.internet import reactor result = self._makeResult() count = suite.countTestCases() self._stream.write("Running %d tests.\n" % (count,)) if not count: # Take a shortcut if there is no test suite.run(result.original) self.writeResults(result) return result testDir, testDirLock = _unusedTestDirectory(FilePath(self._workingDirectory)) workerNumber = min(count, self._workerNumber) ampWorkers = [LocalWorkerAMP() for x in range(workerNumber)] workers = self.createLocalWorkers(ampWorkers, testDir.path) processEndDeferreds = [worker.endDeferred for worker in workers] self.launchWorkerProcesses(reactor.spawnProcess, workers, self._workerArguments) def runTests(): testCases = iter(list(_iterateTests(suite))) workerDeferreds = [] for worker in ampWorkers: workerDeferreds.append( self._driveWorker(worker, result, testCases, cooperate=cooperate) ) return DeferredList( workerDeferreds, consumeErrors=True, fireOnOneErrback=True ) stopping = [] def nextRun(ign): self.writeResults(result) if not untilFailure: return if not result.wasSuccessful(): return d = runTests() return d.addCallback(nextRun) def stop(ign): testDirLock.unlock() if not stopping: stopping.append(None) reactor.stop() def beforeShutDown(): if not stopping: stopping.append(None) d = DeferredList(processEndDeferreds, consumeErrors=True) return d.addCallback(continueShutdown) def continueShutdown(ign): self.writeResults(result) return ign d = runTests() d.addCallback(nextRun) d.addBoth(stop) reactor.addSystemEventTrigger("before", "shutdown", beforeShutDown) reactor.run() return result def runUntilFailure(self, suite): """ Run the tests with local worker processes until they fail. @param suite: A tests suite to be run. """ return self.run(suite, untilFailure=True) PK b�Z�?�� � _dist/workertrial.pynu �[��� # -*- test-case-name: twisted.trial._dist.test.test_workertrial -*- # # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Implementation of C{AMP} worker commands, and main executable entry point for the workers. @since: 12.3 """ import errno import os import sys def _setupPath(environ): """ Override C{sys.path} with what the parent passed in B{TRIAL_PYTHONPATH}. @see: twisted.trial._dist.disttrial.DistTrialRunner.launchWorkerProcesses """ if "TRIAL_PYTHONPATH" in environ: sys.path[:] = environ["TRIAL_PYTHONPATH"].split(os.pathsep) _setupPath(os.environ) from twisted.internet.protocol import FileWrapper from twisted.python.log import startLoggingWithObserver, textFromEventDict from twisted.trial._dist import _WORKER_AMP_STDIN, _WORKER_AMP_STDOUT from twisted.trial._dist.options import WorkerOptions class WorkerLogObserver: """ A log observer that forward its output to a C{AMP} protocol. """ def __init__(self, protocol): """ @param protocol: a connected C{AMP} protocol instance. @type protocol: C{AMP} """ self.protocol = protocol def emit(self, eventDict): """ Produce a log output. """ from twisted.trial._dist import managercommands text = textFromEventDict(eventDict) if text is None: return self.protocol.callRemote(managercommands.TestWrite, out=text) def main(_fdopen=os.fdopen): """ Main function to be run if __name__ == "__main__". @param _fdopen: If specified, the function to use in place of C{os.fdopen}. @type _fdopen: C{callable} """ config = WorkerOptions() config.parseOptions() from twisted.trial._dist.worker import WorkerProtocol workerProtocol = WorkerProtocol(config["force-gc"]) protocolIn = _fdopen(_WORKER_AMP_STDIN, "rb") protocolOut = _fdopen(_WORKER_AMP_STDOUT, "wb") workerProtocol.makeConnection(FileWrapper(protocolOut)) observer = WorkerLogObserver(workerProtocol) startLoggingWithObserver(observer.emit, False) while True: try: r = protocolIn.read(1) except OSError as e: if e.args[0] == errno.EINTR: continue else: raise if r == b"": break else: workerProtocol.dataReceived(r) protocolOut.flush() sys.stdout.flush() sys.stderr.flush() if config.tracer: sys.settrace(None) results = config.tracer.results() results.write_results( show_missing=True, summary=False, coverdir=config.coverdir().path ) if __name__ == "__main__": main() PK b�ZA*ʓ> > _dist/workercommands.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Commands for telling a worker to load tests or run tests. @since: 12.3 """ from twisted.protocols.amp import Boolean, Command, Unicode NativeString = Unicode class Run(Command): """ Run a test. """ arguments = [(b"testCase", NativeString())] response = [(b"success", Boolean())] class Start(Command): """ Set up the worker process, giving the running directory. """ arguments = [(b"directory", NativeString())] response = [(b"success", Boolean())] PK b�ZK�i� � _dist/managercommands.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Commands for reporting test success of failure to the manager. @since: 12.3 """ from twisted.protocols.amp import Boolean, Command, ListOf, Unicode NativeString = Unicode class AddSuccess(Command): """ Add a success. """ arguments = [(b"testName", NativeString())] response = [(b"success", Boolean())] class AddError(Command): """ Add an error. """ arguments = [ (b"testName", NativeString()), (b"error", NativeString()), (b"errorClass", NativeString()), (b"frames", ListOf(NativeString())), ] response = [(b"success", Boolean())] class AddFailure(Command): """ Add a failure. """ arguments = [ (b"testName", NativeString()), (b"fail", NativeString()), (b"failClass", NativeString()), (b"frames", ListOf(NativeString())), ] response = [(b"success", Boolean())] class AddSkip(Command): """ Add a skip. """ arguments = [(b"testName", NativeString()), (b"reason", NativeString())] response = [(b"success", Boolean())] class AddExpectedFailure(Command): """ Add an expected failure. """ arguments = [ (b"testName", NativeString()), (b"error", NativeString()), (b"todo", NativeString()), ] response = [(b"success", Boolean())] class AddUnexpectedSuccess(Command): """ Add an unexpected success. """ arguments = [(b"testName", NativeString()), (b"todo", NativeString())] response = [(b"success", Boolean())] class TestWrite(Command): """ Write test log. """ arguments = [(b"out", NativeString())] response = [(b"success", Boolean())] PK b�Zn[O3� � _dist/__init__.pynu �[��� # -*- test-case-name: twisted.trial._dist.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ This package implements the distributed Trial test runner: - The L{twisted.trial._dist.disttrial} module implements a test runner which runs in a manager process and can launch additional worker processes in which to run tests and gather up results from all of them. - The L{twisted.trial._dist.options} module defines command line options used to configure the distributed test runner. - The L{twisted.trial._dist.managercommands} module defines AMP commands which are sent from worker processes back to the manager process to report the results of tests. - The L{twisted.trial._dist.workercommands} module defines AMP commands which are sent from the manager process to the worker processes to control the execution of tests there. - The L{twisted.trial._dist.distreporter} module defines a proxy for L{twisted.trial.itrial.IReporter} which enforces the typical requirement that results be passed to a reporter for only one test at a time, allowing any reporter to be used with despite disttrial's simultaneously running tests. - The L{twisted.trial._dist.workerreporter} module implements a L{twisted.trial.itrial.IReporter} which is used by worker processes and reports results back to the manager process using AMP commands. - The L{twisted.trial._dist.workertrial} module is a runnable script which is the main point for worker processes. - The L{twisted.trial._dist.worker} process defines the manager's AMP protocol for accepting results from worker processes and a process protocol for use running workers as local child processes (as opposed to distributing them to another host). @since: 12.3 """ # File descriptors numbers used to set up pipes with the worker. _WORKER_AMP_STDIN = 3 _WORKER_AMP_STDOUT = 4 PK b�Z�7`, , _asyncrunner.pynu �[��� # -*- test-case-name: twisted.trial.test -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Infrastructure for test running and suites. """ import doctest import gc import unittest as pyunit from zope.interface import implementer from twisted.python import components from twisted.trial import itrial, reporter from twisted.trial._synctest import _logObserver class TestSuite(pyunit.TestSuite): """ Extend the standard library's C{TestSuite} with a consistently overrideable C{run} method. """ def run(self, result): """ Call C{run} on every member of the suite. """ for test in self._tests: if result.shouldStop: break test(result) return result @implementer(itrial.ITestCase) class TestDecorator( components.proxyForInterface( # type: ignore[misc] itrial.ITestCase, "_originalTest" ) ): """ Decorator for test cases. @param _originalTest: The wrapped instance of test. @type _originalTest: A provider of L{itrial.ITestCase} """ def __call__(self, result): """ Run the unit test. @param result: A TestResult object. """ return self.run(result) def run(self, result): """ Run the unit test. @param result: A TestResult object. """ return self._originalTest.run(reporter._AdaptedReporter(result, self.__class__)) def _clearSuite(suite): """ Clear all tests from C{suite}. This messes with the internals of C{suite}. In particular, it assumes that the suite keeps all of its tests in a list in an instance variable called C{_tests}. """ suite._tests = [] def decorate(test, decorator): """ Decorate all test cases in C{test} with C{decorator}. C{test} can be a test case or a test suite. If it is a test suite, then the structure of the suite is preserved. L{decorate} tries to preserve the class of the test suites it finds, but assumes the presence of the C{_tests} attribute on the suite. @param test: The C{TestCase} or C{TestSuite} to decorate. @param decorator: A unary callable used to decorate C{TestCase}s. @return: A decorated C{TestCase} or a C{TestSuite} containing decorated C{TestCase}s. """ try: tests = iter(test) except TypeError: return decorator(test) # At this point, we know that 'test' is a test suite. _clearSuite(test) for case in tests: test.addTest(decorate(case, decorator)) return test class _PyUnitTestCaseAdapter(TestDecorator): """ Adapt from pyunit.TestCase to ITestCase. """ class _BrokenIDTestCaseAdapter(_PyUnitTestCaseAdapter): """ Adapter for pyunit-style C{TestCase} subclasses that have undesirable id() methods. That is C{unittest.FunctionTestCase} and C{unittest.DocTestCase}. """ def id(self): """ Return the fully-qualified Python name of the doctest. """ testID = self._originalTest.shortDescription() if testID is not None: return testID return self._originalTest.id() class _ForceGarbageCollectionDecorator(TestDecorator): """ Forces garbage collection to be run before and after the test. Any errors logged during the post-test collection are added to the test result as errors. """ def run(self, result): gc.collect() TestDecorator.run(self, result) _logObserver._add() gc.collect() for error in _logObserver.getErrors(): result.addError(self, error) _logObserver.flushErrors() _logObserver._remove() components.registerAdapter(_PyUnitTestCaseAdapter, pyunit.TestCase, itrial.ITestCase) components.registerAdapter( _BrokenIDTestCaseAdapter, pyunit.FunctionTestCase, itrial.ITestCase ) _docTestCase = getattr(doctest, "DocTestCase", None) if _docTestCase: components.registerAdapter(_BrokenIDTestCaseAdapter, _docTestCase, itrial.ITestCase) def _iterateTests(testSuiteOrCase): """ Iterate through all of the test cases in C{testSuiteOrCase}. """ try: suite = iter(testSuiteOrCase) except TypeError: yield testSuiteOrCase else: for test in suite: yield from _iterateTests(test) PK b�Z��p�� �� reporter.pynu �[��� # -*- test-case-name: twisted.trial.test.test_reporter -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # # Maintainer: Jonathan Lange """ Defines classes that handle the results of tests. """ import os import sys import time import unittest as pyunit import warnings from collections import OrderedDict from zope.interface import implementer from twisted.python import log, reflect from twisted.python.components import proxyForInterface from twisted.python.failure import Failure from twisted.python.util import untilConcludes from twisted.trial import itrial, util try: from subunit import TestProtocolClient # type: ignore[import] except ImportError: TestProtocolClient = None def _makeTodo(value): """ Return a L{Todo} object built from C{value}. This is a synonym for L{twisted.trial.unittest.makeTodo}, but imported locally to avoid circular imports. @param value: A string or a tuple of C{(errors, reason)}, where C{errors} is either a single exception class or an iterable of exception classes. @return: A L{Todo} object. """ from twisted.trial.unittest import makeTodo return makeTodo(value) class BrokenTestCaseWarning(Warning): """ Emitted as a warning when an exception occurs in one of setUp or tearDown. """ class SafeStream: """ Wraps a stream object so that all C{write} calls are wrapped in L{untilConcludes<twisted.python.util.untilConcludes>}. """ def __init__(self, original): self.original = original def __getattr__(self, name): return getattr(self.original, name) def write(self, *a, **kw): return untilConcludes(self.original.write, *a, **kw) @implementer(itrial.IReporter) class TestResult(pyunit.TestResult): """ Accumulates the results of several L{twisted.trial.unittest.TestCase}s. @ivar successes: count the number of successes achieved by the test run. @type successes: C{int} """ # Used when no todo provided to addExpectedFailure or addUnexpectedSuccess. _DEFAULT_TODO = "Test expected to fail" def __init__(self): super().__init__() self.skips = [] self.expectedFailures = [] self.unexpectedSuccesses = [] self.successes = 0 self._timings = [] def __repr__(self) -> str: return "<%s run=%d errors=%d failures=%d todos=%d dones=%d skips=%d>" % ( reflect.qual(self.__class__), self.testsRun, len(self.errors), len(self.failures), len(self.expectedFailures), len(self.skips), len(self.unexpectedSuccesses), ) def _getTime(self): return time.time() def _getFailure(self, error): """ Convert a C{sys.exc_info()}-style tuple to a L{Failure}, if necessary. """ if isinstance(error, tuple): return Failure(error[1], error[0], error[2]) return error def startTest(self, test): """ This must be called before the given test is commenced. @type test: L{pyunit.TestCase} """ super().startTest(test) self._testStarted = self._getTime() def stopTest(self, test): """ This must be called after the given test is completed. @type test: L{pyunit.TestCase} """ super().stopTest(test) self._lastTime = self._getTime() - self._testStarted def addFailure(self, test, fail): """ Report a failed assertion for the given test. @type test: L{pyunit.TestCase} @type fail: L{Failure} or L{tuple} """ self.failures.append((test, self._getFailure(fail))) def addError(self, test, error): """ Report an error that occurred while running the given test. @type test: L{pyunit.TestCase} @type error: L{Failure} or L{tuple} """ self.errors.append((test, self._getFailure(error))) def addSkip(self, test, reason): """ Report that the given test was skipped. In Trial, tests can be 'skipped'. Tests are skipped mostly because there is some platform or configuration issue that prevents them from being run correctly. @type test: L{pyunit.TestCase} @type reason: L{str} """ self.skips.append((test, reason)) def addUnexpectedSuccess(self, test, todo=None): """ Report that the given test succeeded against expectations. In Trial, tests can be marked 'todo'. That is, they are expected to fail. When a test that is expected to fail instead succeeds, it should call this method to report the unexpected success. @type test: L{pyunit.TestCase} @type todo: L{unittest.Todo}, or L{None}, in which case a default todo message is provided. """ if todo is None: todo = _makeTodo(self._DEFAULT_TODO) self.unexpectedSuccesses.append((test, todo)) def addExpectedFailure(self, test, error, todo=None): """ Report that the given test failed, and was expected to do so. In Trial, tests can be marked 'todo'. That is, they are expected to fail. @type test: L{pyunit.TestCase} @type error: L{Failure} @type todo: L{unittest.Todo}, or L{None}, in which case a default todo message is provided. """ if todo is None: todo = _makeTodo(self._DEFAULT_TODO) self.expectedFailures.append((test, error, todo)) def addSuccess(self, test): """ Report that the given test succeeded. @type test: L{pyunit.TestCase} """ self.successes += 1 def wasSuccessful(self): """ Report whether or not this test suite was successful or not. The behaviour of this method changed in L{pyunit} in Python 3.4 to fail if there are any errors, failures, or unexpected successes. Previous to 3.4, it was only if there were errors or failures. This method implements the old behaviour for backwards compatibility reasons, checking just for errors and failures. @rtype: L{bool} """ return len(self.failures) == len(self.errors) == 0 def done(self): """ The test suite has finished running. """ @implementer(itrial.IReporter) class TestResultDecorator( proxyForInterface(itrial.IReporter, "_originalReporter") # type: ignore[misc] ): """ Base class for TestResult decorators. @ivar _originalReporter: The wrapped instance of reporter. @type _originalReporter: A provider of L{itrial.IReporter} """ @implementer(itrial.IReporter) class UncleanWarningsReporterWrapper(TestResultDecorator): """ A wrapper for a reporter that converts L{util.DirtyReactorAggregateError}s to warnings. """ def addError(self, test, error): """ If the error is a L{util.DirtyReactorAggregateError}, instead of reporting it as a normal error, throw a warning. """ if isinstance(error, Failure) and error.check(util.DirtyReactorAggregateError): warnings.warn(error.getErrorMessage()) else: self._originalReporter.addError(test, error) @implementer(itrial.IReporter) class _ExitWrapper(TestResultDecorator): """ A wrapper for a reporter that causes the reporter to stop after unsuccessful tests. """ def addError(self, *args, **kwargs): self.shouldStop = True return self._originalReporter.addError(*args, **kwargs) def addFailure(self, *args, **kwargs): self.shouldStop = True return self._originalReporter.addFailure(*args, **kwargs) class _AdaptedReporter(TestResultDecorator): """ TestResult decorator that makes sure that addError only gets tests that have been adapted with a particular test adapter. """ def __init__(self, original, testAdapter): """ Construct an L{_AdaptedReporter}. @param original: An {itrial.IReporter}. @param testAdapter: A callable that returns an L{itrial.ITestCase}. """ TestResultDecorator.__init__(self, original) self.testAdapter = testAdapter def addError(self, test, error): """ See L{itrial.IReporter}. """ test = self.testAdapter(test) return self._originalReporter.addError(test, error) def addExpectedFailure(self, test, failure, todo=None): """ See L{itrial.IReporter}. @type test: A L{pyunit.TestCase}. @type failure: A L{failure.Failure} or L{AssertionError} @type todo: A L{unittest.Todo} or None When C{todo} is L{None} a generic C{unittest.Todo} is built. L{pyunit.TestCase}'s C{run()} calls this with 3 positional arguments (without C{todo}). """ return self._originalReporter.addExpectedFailure( self.testAdapter(test), failure, todo ) def addFailure(self, test, failure): """ See L{itrial.IReporter}. """ test = self.testAdapter(test) return self._originalReporter.addFailure(test, failure) def addSkip(self, test, skip): """ See L{itrial.IReporter}. """ test = self.testAdapter(test) return self._originalReporter.addSkip(test, skip) def addUnexpectedSuccess(self, test, todo=None): """ See L{itrial.IReporter}. @type test: A L{pyunit.TestCase}. @type todo: A L{unittest.Todo} or None When C{todo} is L{None} a generic C{unittest.Todo} is built. L{pyunit.TestCase}'s C{run()} calls this with 2 positional arguments (without C{todo}). """ test = self.testAdapter(test) return self._originalReporter.addUnexpectedSuccess(test, todo) def startTest(self, test): """ See L{itrial.IReporter}. """ return self._originalReporter.startTest(self.testAdapter(test)) def stopTest(self, test): """ See L{itrial.IReporter}. """ return self._originalReporter.stopTest(self.testAdapter(test)) @implementer(itrial.IReporter) class Reporter(TestResult): """ A basic L{TestResult} with support for writing to a stream. @ivar _startTime: The time when the first test was started. It defaults to L{None}, which means that no test was actually launched. @type _startTime: C{float} or L{None} @ivar _warningCache: A C{set} of tuples of warning message (file, line, text, category) which have already been written to the output stream during the currently executing test. This is used to avoid writing duplicates of the same warning to the output stream. @type _warningCache: C{set} @ivar _publisher: The log publisher which will be observed for warning events. @type _publisher: L{twisted.python.log.LogPublisher} """ _separator = "-" * 79 _doubleSeparator = "=" * 79 def __init__( self, stream=sys.stdout, tbformat="default", realtime=False, publisher=None ): super().__init__() self._stream = SafeStream(stream) self.tbformat = tbformat self.realtime = realtime self._startTime = None self._warningCache = set() # Start observing log events so as to be able to report warnings. self._publisher = publisher if publisher is not None: publisher.addObserver(self._observeWarnings) def _observeWarnings(self, event): """ Observe warning events and write them to C{self._stream}. This method is a log observer which will be registered with C{self._publisher.addObserver}. @param event: A C{dict} from the logging system. If it has a C{'warning'} key, a logged warning will be extracted from it and possibly written to C{self.stream}. """ if "warning" in event: key = ( event["filename"], event["lineno"], event["category"].split(".")[-1], str(event["warning"]), ) if key not in self._warningCache: self._warningCache.add(key) self._stream.write("%s:%s: %s: %s\n" % key) def startTest(self, test): """ Called when a test begins to run. Records the time when it was first called and resets the warning cache. @param test: L{ITestCase} """ super().startTest(test) if self._startTime is None: self._startTime = self._getTime() self._warningCache = set() def addFailure(self, test, fail): """ Called when a test fails. If C{realtime} is set, then it prints the error to the stream. @param test: L{ITestCase} that failed. @param fail: L{failure.Failure} containing the error. """ super().addFailure(test, fail) if self.realtime: fail = self.failures[-1][1] # guarantee it's a Failure self._write(self._formatFailureTraceback(fail)) def addError(self, test, error): """ Called when a test raises an error. If C{realtime} is set, then it prints the error to the stream. @param test: L{ITestCase} that raised the error. @param error: L{failure.Failure} containing the error. """ error = self._getFailure(error) super().addError(test, error) if self.realtime: error = self.errors[-1][1] # guarantee it's a Failure self._write(self._formatFailureTraceback(error)) def _write(self, format, *args): """ Safely write to the reporter's stream. @param format: A format string to write. @param args: The arguments for the format string. """ s = str(format) assert isinstance(s, str) if args: self._stream.write(s % args) else: self._stream.write(s) untilConcludes(self._stream.flush) def _writeln(self, format, *args): """ Safely write a line to the reporter's stream. Newline is appended to the format string. @param format: A format string to write. @param args: The arguments for the format string. """ self._write(format, *args) self._write("\n") def upDownError(self, method, error, warn=True, printStatus=True): super().upDownError(method, error, warn, printStatus) if warn: tbStr = self._formatFailureTraceback(error) log.msg(tbStr) msg = "caught exception in {}, your TestCase is broken\n\n{}".format( method, tbStr, ) warnings.warn(msg, BrokenTestCaseWarning, stacklevel=2) def cleanupErrors(self, errs): super().cleanupErrors(errs) warnings.warn( "%s\n%s" % ( "REACTOR UNCLEAN! traceback(s) follow: ", self._formatFailureTraceback(errs), ), BrokenTestCaseWarning, ) def _trimFrames(self, frames): """ Trim frames to remove internal paths. When a C{SynchronousTestCase} method fails synchronously, the stack looks like this: - [0]: C{SynchronousTestCase._run} - [1]: C{util.runWithWarningsSuppressed} - [2:-2]: code in the test method which failed - [-1]: C{_synctest.fail} When a C{TestCase} method fails synchronously, the stack looks like this: - [0]: C{defer.maybeDeferred} - [1]: C{utils.runWithWarningsSuppressed} - [2]: C{utils.runWithWarningsSuppressed} - [3:-2]: code in the test method which failed - [-1]: C{_synctest.fail} When a method fails inside a C{Deferred} (i.e., when the test method returns a C{Deferred}, and that C{Deferred}'s errback fires), the stack captured inside the resulting C{Failure} looks like this: - [0]: C{defer.Deferred._runCallbacks} - [1:-2]: code in the testmethod which failed - [-1]: C{_synctest.fail} As a result, we want to trim either [maybeDeferred, runWWS, runWWS] or [Deferred._runCallbacks] or [SynchronousTestCase._run, runWWS] from the front, and trim the [unittest.fail] from the end. There is also another case, when the test method is badly defined and contains extra arguments. If it doesn't recognize one of these cases, it just returns the original frames. @param frames: The C{list} of frames from the test failure. @return: The C{list} of frames to display. """ newFrames = list(frames) if len(frames) < 2: return newFrames firstMethod = newFrames[0][0] firstFile = os.path.splitext(os.path.basename(newFrames[0][1]))[0] secondMethod = newFrames[1][0] secondFile = os.path.splitext(os.path.basename(newFrames[1][1]))[0] syncCase = (("_run", "_synctest"), ("runWithWarningsSuppressed", "util")) asyncCase = (("maybeDeferred", "defer"), ("runWithWarningsSuppressed", "utils")) twoFrames = ((firstMethod, firstFile), (secondMethod, secondFile)) # On PY3, we have an extra frame which is reraising the exception for frame in newFrames: frameFile = os.path.splitext(os.path.basename(frame[1]))[0] if frameFile == "compat" and frame[0] == "reraise": # If it's in the compat module and is reraise, BLAM IT newFrames.pop(newFrames.index(frame)) if twoFrames == syncCase: newFrames = newFrames[2:] elif twoFrames == asyncCase: newFrames = newFrames[3:] elif (firstMethod, firstFile) == ("_runCallbacks", "defer"): newFrames = newFrames[1:] if not newFrames: # The method fails before getting called, probably an argument # problem return newFrames last = newFrames[-1] if ( last[0].startswith("fail") and os.path.splitext(os.path.basename(last[1]))[0] == "_synctest" ): newFrames = newFrames[:-1] return newFrames def _formatFailureTraceback(self, fail): if isinstance(fail, str): return fail.rstrip() + "\n" fail.frames, frames = self._trimFrames(fail.frames), fail.frames result = fail.getTraceback(detail=self.tbformat, elideFrameworkCode=True) fail.frames = frames return result def _groupResults(self, results, formatter): """ Group tests together based on their results. @param results: An iterable of tuples of two or more elements. The first element of each tuple is a test case. The remaining elements describe the outcome of that test case. @param formatter: A callable which turns a test case result into a string. The elements after the first of the tuples in C{results} will be passed as positional arguments to C{formatter}. @return: A C{list} of two-tuples. The first element of each tuple is a unique string describing one result from at least one of the test cases in C{results}. The second element is a list of the test cases which had that result. """ groups = OrderedDict() for content in results: case = content[0] outcome = content[1:] key = formatter(*outcome) groups.setdefault(key, []).append(case) return list(groups.items()) def _printResults(self, flavor, errors, formatter): """ Print a group of errors to the stream. @param flavor: A string indicating the kind of error (e.g. 'TODO'). @param errors: A list of errors, often L{failure.Failure}s, but sometimes 'todo' errors. @param formatter: A callable that knows how to format the errors. """ for reason, cases in self._groupResults(errors, formatter): self._writeln(self._doubleSeparator) self._writeln(flavor) self._write(reason) self._writeln("") for case in cases: self._writeln(case.id()) def _printExpectedFailure(self, error, todo): return "Reason: {!r}\n{}".format( todo.reason, self._formatFailureTraceback(error) ) def _printUnexpectedSuccess(self, todo): ret = f"Reason: {todo.reason!r}\n" if todo.errors: ret += "Expected errors: {}\n".format(", ".join(todo.errors)) return ret def _printErrors(self): """ Print all of the non-success results to the stream in full. """ self._write("\n") self._printResults("[SKIPPED]", self.skips, lambda x: "%s\n" % x) self._printResults("[TODO]", self.expectedFailures, self._printExpectedFailure) self._printResults("[FAIL]", self.failures, self._formatFailureTraceback) self._printResults("[ERROR]", self.errors, self._formatFailureTraceback) self._printResults( "[SUCCESS!?!]", self.unexpectedSuccesses, self._printUnexpectedSuccess ) def _getSummary(self): """ Return a formatted count of tests status results. """ summaries = [] for stat in ( "skips", "expectedFailures", "failures", "errors", "unexpectedSuccesses", ): num = len(getattr(self, stat)) if num: summaries.append("%s=%d" % (stat, num)) if self.successes: summaries.append("successes=%d" % (self.successes,)) summary = (summaries and " (" + ", ".join(summaries) + ")") or "" return summary def _printSummary(self): """ Print a line summarising the test results to the stream. """ summary = self._getSummary() if self.wasSuccessful(): status = "PASSED" else: status = "FAILED" self._write("%s%s\n", status, summary) def done(self): """ Summarize the result of the test run. The summary includes a report of all of the errors, todos, skips and so forth that occurred during the run. It also includes the number of tests that were run and how long it took to run them (not including load time). Expects that C{_printErrors}, C{_writeln}, C{_write}, C{_printSummary} and C{_separator} are all implemented. """ if self._publisher is not None: self._publisher.removeObserver(self._observeWarnings) self._printErrors() self._writeln(self._separator) if self._startTime is not None: self._writeln( "Ran %d tests in %.3fs", self.testsRun, time.time() - self._startTime ) self._write("\n") self._printSummary() class MinimalReporter(Reporter): """ A minimalist reporter that prints only a summary of the test result, in the form of (timeTaken, #tests, #tests, #errors, #failures, #skips). """ def _printErrors(self): """ Don't print a detailed summary of errors. We only care about the counts. """ def _printSummary(self): """ Print out a one-line summary of the form: '%(runtime) %(number_of_tests) %(number_of_tests) %(num_errors) %(num_failures) %(num_skips)' """ numTests = self.testsRun if self._startTime is not None: timing = self._getTime() - self._startTime else: timing = 0 t = ( timing, numTests, numTests, len(self.errors), len(self.failures), len(self.skips), ) self._writeln(" ".join(map(str, t))) class TextReporter(Reporter): """ Simple reporter that prints a single character for each test as it runs, along with the standard Trial summary text. """ def addSuccess(self, test): super().addSuccess(test) self._write(".") def addError(self, *args): super().addError(*args) self._write("E") def addFailure(self, *args): super().addFailure(*args) self._write("F") def addSkip(self, *args): super().addSkip(*args) self._write("S") def addExpectedFailure(self, *args): super().addExpectedFailure(*args) self._write("T") def addUnexpectedSuccess(self, *args): super().addUnexpectedSuccess(*args) self._write("!") class VerboseTextReporter(Reporter): """ A verbose reporter that prints the name of each test as it is running. Each line is printed with the name of the test, followed by the result of that test. """ # This is actually the bwverbose option def startTest(self, tm): self._write("%s ... ", tm.id()) super().startTest(tm) def addSuccess(self, test): super().addSuccess(test) self._write("[OK]") def addError(self, *args): super().addError(*args) self._write("[ERROR]") def addFailure(self, *args): super().addFailure(*args) self._write("[FAILURE]") def addSkip(self, *args): super().addSkip(*args) self._write("[SKIPPED]") def addExpectedFailure(self, *args): super().addExpectedFailure(*args) self._write("[TODO]") def addUnexpectedSuccess(self, *args): super().addUnexpectedSuccess(*args) self._write("[SUCCESS!?!]") def stopTest(self, test): super().stopTest(test) self._write("\n") class TimingTextReporter(VerboseTextReporter): """ Prints out each test as it is running, followed by the time taken for each test to run. """ def stopTest(self, method): """ Mark the test as stopped, and write the time it took to run the test to the stream. """ super().stopTest(method) self._write("(%.03f secs)\n" % self._lastTime) class _AnsiColorizer: """ A colorizer is an object that loosely wraps around a stream, allowing callers to write text to the stream in a particular color. Colorizer classes must implement C{supported()} and C{write(text, color)}. """ _colors = dict( black=30, red=31, green=32, yellow=33, blue=34, magenta=35, cyan=36, white=37 ) def __init__(self, stream): self.stream = stream @classmethod def supported(cls, stream=sys.stdout): """ A class method that returns True if the current platform supports coloring terminal output using this method. Returns False otherwise. """ if not stream.isatty(): return False # auto color only on TTYs try: import curses except ImportError: return False else: try: try: return curses.tigetnum("colors") > 2 except curses.error: curses.setupterm() return curses.tigetnum("colors") > 2 except BaseException: # guess false in case of error return False def write(self, text, color): """ Write the given text to the stream in the given color. @param text: Text to be written to the stream. @param color: A string label for a color. e.g. 'red', 'white'. """ color = self._colors[color] self.stream.write(f"\x1b[{color};1m{text}\x1b[0m") class _Win32Colorizer: """ See _AnsiColorizer docstring. """ def __init__(self, stream): from win32console import ( # type: ignore[import] FOREGROUND_BLUE, FOREGROUND_GREEN, FOREGROUND_INTENSITY, FOREGROUND_RED, STD_OUTPUT_HANDLE, GetStdHandle, ) red, green, blue, bold = ( FOREGROUND_RED, FOREGROUND_GREEN, FOREGROUND_BLUE, FOREGROUND_INTENSITY, ) self.stream = stream self.screenBuffer = GetStdHandle(STD_OUTPUT_HANDLE) self._colors = { "normal": red | green | blue, "red": red | bold, "green": green | bold, "blue": blue | bold, "yellow": red | green | bold, "magenta": red | blue | bold, "cyan": green | blue | bold, "white": red | green | blue | bold, } @classmethod def supported(cls, stream=sys.stdout): try: import win32console screenBuffer = win32console.GetStdHandle(win32console.STD_OUTPUT_HANDLE) except ImportError: return False import pywintypes # type: ignore[import] try: screenBuffer.SetConsoleTextAttribute( win32console.FOREGROUND_RED | win32console.FOREGROUND_GREEN | win32console.FOREGROUND_BLUE ) except pywintypes.error: return False else: return True def write(self, text, color): color = self._colors[color] self.screenBuffer.SetConsoleTextAttribute(color) self.stream.write(text) self.screenBuffer.SetConsoleTextAttribute(self._colors["normal"]) class _NullColorizer: """ See _AnsiColorizer docstring. """ def __init__(self, stream): self.stream = stream @classmethod def supported(cls, stream=sys.stdout): return True def write(self, text, color): self.stream.write(text) @implementer(itrial.IReporter) class SubunitReporter: """ Reports test output via Subunit. @ivar _subunit: The subunit protocol client that we are wrapping. @ivar _successful: An internal variable, used to track whether we have received only successful results. @since: 10.0 """ testsRun = None def __init__( self, stream=sys.stdout, tbformat="default", realtime=False, publisher=None ): """ Construct a L{SubunitReporter}. @param stream: A file-like object representing the stream to print output to. Defaults to stdout. @param tbformat: The format for tracebacks. Ignored, since subunit always uses Python's standard format. @param realtime: Whether or not to print exceptions in the middle of the test results. Ignored, since subunit always does this. @param publisher: The log publisher which will be preserved for reporting events. Ignored, as it's not relevant to subunit. """ if TestProtocolClient is None: raise Exception("Subunit not available") self._subunit = TestProtocolClient(stream) self._successful = True def done(self): """ Record that the entire test suite run is finished. We do nothing, since a summary clause is irrelevant to the subunit protocol. """ pass @property def shouldStop(self): """ Whether or not the test runner should stop running tests. """ return self._subunit.shouldStop def stop(self): """ Signal that the test runner should stop running tests. """ return self._subunit.stop() def wasSuccessful(self): """ Has the test run been successful so far? @return: C{True} if we have received no reports of errors or failures, C{False} otherwise. """ # Subunit has a bug in its implementation of wasSuccessful, see # https://bugs.edge.launchpad.net/subunit/+bug/491090, so we can't # simply forward it on. return self._successful def startTest(self, test): """ Record that C{test} has started. """ return self._subunit.startTest(test) def stopTest(self, test): """ Record that C{test} has completed. """ return self._subunit.stopTest(test) def addSuccess(self, test): """ Record that C{test} was successful. """ return self._subunit.addSuccess(test) def addSkip(self, test, reason): """ Record that C{test} was skipped for C{reason}. Some versions of subunit don't have support for addSkip. In those cases, the skip is reported as a success. @param test: A unittest-compatible C{TestCase}. @param reason: The reason for it being skipped. The C{str()} of this object will be included in the subunit output stream. """ addSkip = getattr(self._subunit, "addSkip", None) if addSkip is None: self.addSuccess(test) else: self._subunit.addSkip(test, reason) def addError(self, test, err): """ Record that C{test} failed with an unexpected error C{err}. Also marks the run as being unsuccessful, causing L{SubunitReporter.wasSuccessful} to return C{False}. """ self._successful = False return self._subunit.addError(test, util.excInfoOrFailureToExcInfo(err)) def addFailure(self, test, err): """ Record that C{test} failed an assertion with the error C{err}. Also marks the run as being unsuccessful, causing L{SubunitReporter.wasSuccessful} to return C{False}. """ self._successful = False return self._subunit.addFailure(test, util.excInfoOrFailureToExcInfo(err)) def addExpectedFailure(self, test, failure, todo=None): """ Record an expected failure from a test. Some versions of subunit do not implement this. For those versions, we record a success. """ failure = util.excInfoOrFailureToExcInfo(failure) addExpectedFailure = getattr(self._subunit, "addExpectedFailure", None) if addExpectedFailure is None: self.addSuccess(test) else: addExpectedFailure(test, failure) def addUnexpectedSuccess(self, test, todo=None): """ Record an unexpected success. Since subunit has no way of expressing this concept, we record a success on the subunit stream. """ # Not represented in pyunit/subunit. self.addSuccess(test) class TreeReporter(Reporter): """ Print out the tests in the form a tree. Tests are indented according to which class and module they belong. Results are printed in ANSI color. """ currentLine = "" indent = " " columns = 79 FAILURE = "red" ERROR = "red" TODO = "blue" SKIP = "blue" TODONE = "red" SUCCESS = "green" def __init__(self, stream=sys.stdout, *args, **kwargs): super().__init__(stream, *args, **kwargs) self._lastTest = [] for colorizer in [_Win32Colorizer, _AnsiColorizer, _NullColorizer]: if colorizer.supported(stream): self._colorizer = colorizer(stream) break def getDescription(self, test): """ Return the name of the method which 'test' represents. This is what gets displayed in the leaves of the tree. e.g. getDescription(TestCase('test_foo')) ==> test_foo """ return test.id().split(".")[-1] def addSuccess(self, test): super().addSuccess(test) self.endLine("[OK]", self.SUCCESS) def addError(self, *args): super().addError(*args) self.endLine("[ERROR]", self.ERROR) def addFailure(self, *args): super().addFailure(*args) self.endLine("[FAIL]", self.FAILURE) def addSkip(self, *args): super().addSkip(*args) self.endLine("[SKIPPED]", self.SKIP) def addExpectedFailure(self, *args): super().addExpectedFailure(*args) self.endLine("[TODO]", self.TODO) def addUnexpectedSuccess(self, *args): super().addUnexpectedSuccess(*args) self.endLine("[SUCCESS!?!]", self.TODONE) def _write(self, format, *args): if args: format = format % args self.currentLine = format super()._write(self.currentLine) def _getPreludeSegments(self, testID): """ Return a list of all non-leaf segments to display in the tree. Normally this is the module and class name. """ segments = testID.split(".")[:-1] if len(segments) == 0: return segments segments = [ seg for seg in (".".join(segments[:-1]), segments[-1]) if len(seg) > 0 ] return segments def _testPrelude(self, testID): """ Write the name of the test to the stream, indenting it appropriately. If the test is the first test in a new 'branch' of the tree, also write all of the parents in that branch. """ segments = self._getPreludeSegments(testID) indentLevel = 0 for seg in segments: if indentLevel < len(self._lastTest): if seg != self._lastTest[indentLevel]: self._write(f"{self.indent * indentLevel}{seg}\n") else: self._write(f"{self.indent * indentLevel}{seg}\n") indentLevel += 1 self._lastTest = segments def cleanupErrors(self, errs): self._colorizer.write(" cleanup errors", self.ERROR) self.endLine("[ERROR]", self.ERROR) super().cleanupErrors(errs) def upDownError(self, method, error, warn, printStatus): self._colorizer.write(" %s" % method, self.ERROR) if printStatus: self.endLine("[ERROR]", self.ERROR) super().upDownError(method, error, warn, printStatus) def startTest(self, test): """ Called when C{test} starts. Writes the tests name to the stream using a tree format. """ self._testPrelude(test.id()) self._write( "%s%s ... " % (self.indent * (len(self._lastTest)), self.getDescription(test)) ) super().startTest(test) def endLine(self, message, color): """ Print 'message' in the given color. @param message: A string message, usually '[OK]' or something similar. @param color: A string color, 'red', 'green' and so forth. """ spaces = " " * (self.columns - len(self.currentLine) - len(message)) super()._write(spaces) self._colorizer.write(message, color) super()._write("\n") def _printSummary(self): """ Print a line summarising the test results to the stream, and color the status result. """ summary = self._getSummary() if self.wasSuccessful(): status = "PASSED" color = self.SUCCESS else: status = "FAILED" color = self.FAILURE self._colorizer.write(status, color) self._write("%s\n", summary) PK b�Z6 F7�| �| runner.pynu �[��� # -*- test-case-name: twisted.trial.test.test_runner -*- # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ A miscellany of code used to run Trial tests. Maintainer: Jonathan Lange """ __all__ = [ "TestSuite", "DestructiveTestSuite", "ErrorHolder", "LoggedSuite", "TestHolder", "TestLoader", "TrialRunner", "TrialSuite", "filenameToModule", "isPackage", "isPackageDirectory", "isTestCase", "name", "samefile", "NOT_IN_TEST", ] import doctest import importlib import inspect import os import sys import time import types import warnings from importlib.machinery import SourceFileLoader from zope.interface import implementer from twisted.internet import defer from twisted.python import failure, filepath, log, modules, reflect from twisted.trial import unittest, util from twisted.trial._asyncrunner import _ForceGarbageCollectionDecorator, _iterateTests from twisted.trial._synctest import _logObserver from twisted.trial.itrial import ITestCase from twisted.trial.reporter import UncleanWarningsReporterWrapper, _ExitWrapper # These are imported so that they remain in the public API for t.trial.runner from twisted.trial.unittest import TestSuite pyunit = __import__("unittest") def isPackage(module): """Given an object return True if the object looks like a package""" if not isinstance(module, types.ModuleType): return False basename = os.path.splitext(os.path.basename(module.__file__))[0] return basename == "__init__" def isPackageDirectory(dirname): """ Is the directory at path 'dirname' a Python package directory? Returns the name of the __init__ file (it may have a weird extension) if dirname is a package directory. Otherwise, returns False """ def _getSuffixes(): return importlib.machinery.all_suffixes() for ext in _getSuffixes(): initFile = "__init__" + ext if os.path.exists(os.path.join(dirname, initFile)): return initFile return False def samefile(filename1, filename2): """ A hacky implementation of C{os.path.samefile}. Used by L{filenameToModule} when the platform doesn't provide C{os.path.samefile}. Do not use this. """ return os.path.abspath(filename1) == os.path.abspath(filename2) def filenameToModule(fn): """ Given a filename, do whatever possible to return a module object matching that file. If the file in question is a module in Python path, properly import and return that module. Otherwise, load the source manually. @param fn: A filename. @return: A module object. @raise ValueError: If C{fn} does not exist. """ oldFn = fn if (3, 8) <= sys.version_info < (3, 10) and not os.path.isabs(fn): # module.__spec__.__file__ is supposed to be absolute in py3.8+ # importlib.util.spec_from_file_location does this automatically from # 3.10+ # This was backported to 3.8 and 3.9, but then reverted in 3.8.11 and # 3.9.6 # See https://twistedmatrix.com/trac/ticket/10230 # and https://bugs.python.org/issue44070 fn = os.path.join(os.getcwd(), fn) if not os.path.exists(fn): raise ValueError(f"{oldFn!r} doesn't exist") moduleName = reflect.filenameToModuleName(fn) try: ret = reflect.namedAny(moduleName) except (ValueError, AttributeError): # Couldn't find module. The file 'fn' is not in PYTHONPATH return _importFromFile(fn, moduleName=moduleName) # >=3.7 has __file__ attribute as None, previously __file__ was not present if getattr(ret, "__file__", None) is None: # This isn't a Python module in a package, so import it from a file return _importFromFile(fn, moduleName=moduleName) # ensure that the loaded module matches the file retFile = os.path.splitext(ret.__file__)[0] + ".py" # not all platforms (e.g. win32) have os.path.samefile same = getattr(os.path, "samefile", samefile) if os.path.isfile(fn) and not same(fn, retFile): del sys.modules[ret.__name__] ret = _importFromFile(fn, moduleName=moduleName) return ret def _importFromFile(fn, *, moduleName): fn = _resolveDirectory(fn) if not moduleName: moduleName = os.path.splitext(os.path.split(fn)[-1])[0] if moduleName in sys.modules: return sys.modules[moduleName] spec = importlib.util.spec_from_file_location(moduleName, fn) if not spec: raise SyntaxError(fn) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) sys.modules[moduleName] = module return module def _resolveDirectory(fn): if os.path.isdir(fn): initFile = isPackageDirectory(fn) if initFile: fn = os.path.join(fn, initFile) else: raise ValueError(f"{fn!r} is not a package directory") return fn def _getMethodNameInClass(method): """ Find the attribute name on the method's class which refers to the method. For some methods, notably decorators which have not had __name__ set correctly: getattr(method.im_class, method.__name__) != method """ if getattr(method.im_class, method.__name__, object()) != method: for alias in dir(method.im_class): if getattr(method.im_class, alias, object()) == method: return alias return method.__name__ class DestructiveTestSuite(TestSuite): """ A test suite which remove the tests once run, to minimize memory usage. """ def run(self, result): """ Almost the same as L{TestSuite.run}, but with C{self._tests} being empty at the end. """ while self._tests: if result.shouldStop: break test = self._tests.pop(0) test(result) return result # When an error occurs outside of any test, the user will see this string # in place of a test's name. NOT_IN_TEST = "<not in test>" class LoggedSuite(TestSuite): """ Any errors logged in this suite will be reported to the L{TestResult} object. """ def run(self, result): """ Run the suite, storing all errors in C{result}. If an error is logged while no tests are running, then it will be added as an error to C{result}. @param result: A L{TestResult} object. """ observer = _logObserver observer._add() super().run(result) observer._remove() for error in observer.getErrors(): result.addError(TestHolder(NOT_IN_TEST), error) observer.flushErrors() class TrialSuite(TestSuite): """ Suite to wrap around every single test in a C{trial} run. Used internally by Trial to set up things necessary for Trial tests to work, regardless of what context they are run in. """ def __init__(self, tests=(), forceGarbageCollection=False): if forceGarbageCollection: newTests = [] for test in tests: test = unittest.decorate(test, _ForceGarbageCollectionDecorator) newTests.append(test) tests = newTests suite = LoggedSuite(tests) super().__init__([suite]) def _bail(self): from twisted.internet import reactor d = defer.Deferred() reactor.addSystemEventTrigger("after", "shutdown", lambda: d.callback(None)) reactor.fireSystemEvent("shutdown") # radix's suggestion # As long as TestCase does crap stuff with the reactor we need to # manually shutdown the reactor here, and that requires util.wait # :( # so that the shutdown event completes unittest.TestCase("mktemp")._wait(d) def run(self, result): try: TestSuite.run(self, result) finally: self._bail() def name(thing): """ @param thing: an object from modules (instance of PythonModule, PythonAttribute), a TestCase subclass, or an instance of a TestCase. """ if isTestCase(thing): # TestCase subclass theName = reflect.qual(thing) else: # thing from trial, or thing from modules. # this monstrosity exists so that modules' objects do not have to # implement id(). -jml try: theName = thing.id() except AttributeError: theName = thing.name return theName def isTestCase(obj): """ @return: C{True} if C{obj} is a class that contains test cases, C{False} otherwise. Used to find all the tests in a module. """ try: return issubclass(obj, pyunit.TestCase) except TypeError: return False @implementer(ITestCase) class TestHolder: """ Placeholder for a L{TestCase} inside a reporter. As far as a L{TestResult} is concerned, this looks exactly like a unit test. """ failureException = None def __init__(self, description): """ @param description: A string to be displayed L{TestResult}. """ self.description = description def __call__(self, result): return self.run(result) def id(self): return self.description def countTestCases(self): return 0 def run(self, result): """ This test is just a placeholder. Run the test successfully. @param result: The C{TestResult} to store the results in. @type result: L{twisted.trial.itrial.IReporter}. """ result.startTest(self) result.addSuccess(self) result.stopTest(self) def shortDescription(self): return self.description class ErrorHolder(TestHolder): """ Used to insert arbitrary errors into a test suite run. Provides enough methods to look like a C{TestCase}, however, when it is run, it simply adds an error to the C{TestResult}. The most common use-case is for when a module fails to import. """ def __init__(self, description, error): """ @param description: A string used by C{TestResult}s to identify this error. Generally, this is the name of a module that failed to import. @param error: The error to be added to the result. Can be an `exc_info` tuple or a L{twisted.python.failure.Failure}. """ super().__init__(description) self.error = util.excInfoOrFailureToExcInfo(error) def __repr__(self) -> str: return "<ErrorHolder description={!r} error={!r}>".format( self.description, self.error[1], ) def run(self, result): """ Run the test, reporting the error. @param result: The C{TestResult} to store the results in. @type result: L{twisted.trial.itrial.IReporter}. """ result.startTest(self) result.addError(self, self.error) result.stopTest(self) class TestLoader: """ I find tests inside function, modules, files -- whatever -- then return them wrapped inside a Test (either a L{TestSuite} or a L{TestCase}). @ivar methodPrefix: A string prefix. C{TestLoader} will assume that all the methods in a class that begin with C{methodPrefix} are test cases. @ivar modulePrefix: A string prefix. Every module in a package that begins with C{modulePrefix} is considered a module full of tests. @ivar forceGarbageCollection: A flag applied to each C{TestCase} loaded. See L{unittest.TestCase} for more information. @ivar sorter: A key function used to sort C{TestCase}s, test classes, modules and packages. @ivar suiteFactory: A callable which is passed a list of tests (which themselves may be suites of tests). Must return a test suite. """ methodPrefix = "test" modulePrefix = "test_" def __init__(self): self.suiteFactory = TestSuite self.sorter = name self._importErrors = [] def sort(self, xs): """ Sort the given things using L{sorter}. @param xs: A list of test cases, class or modules. """ return sorted(xs, key=self.sorter) def findTestClasses(self, module): """Given a module, return all Trial test classes""" classes = [] for name, val in inspect.getmembers(module): if isTestCase(val): classes.append(val) return self.sort(classes) def findByName(self, _name, recurse=False): """ Find and load tests, given C{name}. @param _name: The qualified name of the thing to load. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. @return: If C{name} is a filename, return the module. If C{name} is a fully-qualified Python name, return the object it refers to. """ if os.sep in _name: # It's a file, try and get the module name for this file. name = reflect.filenameToModuleName(_name) try: # Try and import it, if it's on the path. # CAVEAT: If you have two twisteds, and you try and import the # one NOT on your path, it'll load the one on your path. But # that's silly, nobody should do that, and existing Trial does # that anyway. __import__(name) except ImportError: # If we can't import it, look for one NOT on the path. return self.loadFile(_name, recurse=recurse) else: name = _name obj = parent = remaining = None for searchName, remainingName in _qualNameWalker(name): # Walk down the qualified name, trying to import a module. For # example, `twisted.test.test_paths.FilePathTests` would try # the full qualified name, then just up to test_paths, and then # just up to test, and so forth. # This gets us the highest level thing which is a module. try: obj = reflect.namedModule(searchName) # If we reach here, we have successfully found a module. # obj will be the module, and remaining will be the remaining # part of the qualified name. remaining = remainingName break except ImportError: # Check to see where the ImportError happened. If it happened # in this file, ignore it. tb = sys.exc_info()[2] # Walk down to the deepest frame, where it actually happened. while tb.tb_next is not None: tb = tb.tb_next # Get the filename that the ImportError originated in. filenameWhereHappened = tb.tb_frame.f_code.co_filename # If it originated in the reflect file, then it's because it # doesn't exist. If it originates elsewhere, it's because an # ImportError happened in a module that does exist. if filenameWhereHappened != reflect.__file__: raise if remaining == "": raise reflect.ModuleNotFound(f"The module {name} does not exist.") if obj is None: # If it's none here, we didn't get to import anything. # Try something drastic. obj = reflect.namedAny(name) remaining = name.split(".")[len(".".split(obj.__name__)) + 1 :] try: for part in remaining: # Walk down the remaining modules. Hold on to the parent for # methods, as on Python 3, you can no longer get the parent # class from just holding onto the method. parent, obj = obj, getattr(obj, part) except AttributeError: raise AttributeError(f"{name} does not exist.") return self.loadAnything( obj, parent=parent, qualName=remaining, recurse=recurse ) def loadModule(self, module): """ Return a test suite with all the tests from a module. Included are TestCase subclasses and doctests listed in the module's __doctests__ module. If that's not good for you, put a function named either C{testSuite} or C{test_suite} in your module that returns a TestSuite, and I'll use the results of that instead. If C{testSuite} and C{test_suite} are both present, then I'll use C{testSuite}. """ ## XXX - should I add an optional parameter to disable the check for ## a custom suite. ## OR, should I add another method if not isinstance(module, types.ModuleType): raise TypeError(f"{module!r} is not a module") if hasattr(module, "testSuite"): return module.testSuite() elif hasattr(module, "test_suite"): return module.test_suite() suite = self.suiteFactory() for testClass in self.findTestClasses(module): suite.addTest(self.loadClass(testClass)) if not hasattr(module, "__doctests__"): return suite docSuite = self.suiteFactory() for docTest in module.__doctests__: docSuite.addTest(self.loadDoctests(docTest)) return self.suiteFactory([suite, docSuite]) loadTestsFromModule = loadModule def loadClass(self, klass): """ Given a class which contains test cases, return a list of L{TestCase}s. @param klass: The class to load tests from. """ if not isinstance(klass, type): raise TypeError(f"{klass!r} is not a class") if not isTestCase(klass): raise ValueError(f"{klass!r} is not a test case") names = self.getTestCaseNames(klass) tests = self.sort( [self._makeCase(klass, self.methodPrefix + name) for name in names] ) return self.suiteFactory(tests) loadTestsFromTestCase = loadClass def getTestCaseNames(self, klass): """ Given a class that contains C{TestCase}s, return a list of names of methods that probably contain tests. """ return reflect.prefixedMethodNames(klass, self.methodPrefix) def loadMethod(self, method): raise NotImplementedError("Can't happen on Py3") def _makeCase(self, klass, methodName): return klass(methodName) def loadPackage(self, package, recurse=False): """ Load tests from a module object representing a package, and return a TestSuite containing those tests. Tests are only loaded from modules whose name begins with 'test_' (or whatever C{modulePrefix} is set to). @param package: a types.ModuleType object (or reasonable facsimile obtained by importing) which may contain tests. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. @raise TypeError: If C{package} is not a package. @return: a TestSuite created with my suiteFactory, containing all the tests. """ if not isPackage(package): raise TypeError(f"{package!r} is not a package") pkgobj = modules.getModule(package.__name__) if recurse: discovery = pkgobj.walkModules() else: discovery = pkgobj.iterModules() discovered = [] for disco in discovery: if disco.name.split(".")[-1].startswith(self.modulePrefix): discovered.append(disco) suite = self.suiteFactory() for modinfo in self.sort(discovered): try: module = modinfo.load() except BaseException: thingToAdd = ErrorHolder(modinfo.name, failure.Failure()) else: thingToAdd = self.loadModule(module) suite.addTest(thingToAdd) return suite def loadDoctests(self, module): """ Return a suite of tests for all the doctests defined in C{module}. @param module: A module object or a module name. """ if isinstance(module, str): try: module = reflect.namedAny(module) except BaseException: return ErrorHolder(module, failure.Failure()) if not inspect.ismodule(module): warnings.warn("trial only supports doctesting modules") return extraArgs = {} # Work around Python issue2604: DocTestCase.tearDown clobbers globs def saveGlobals(test): """ Save C{test.globs} and replace it with a copy so that if necessary, the original will be available for the next test run. """ test._savedGlobals = getattr(test, "_savedGlobals", test.globs) test.globs = test._savedGlobals.copy() extraArgs["setUp"] = saveGlobals return doctest.DocTestSuite(module, **extraArgs) def loadAnything(self, obj, recurse=False, parent=None, qualName=None): """ Load absolutely anything (as long as that anything is a module, package, class, or method (with associated parent class and qualname). @param obj: The object to load. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. @param parent: If C{obj} is a method, this is the parent class of the method. C{qualName} is also required. @param qualName: If C{obj} is a method, this a list containing is the qualified name of the method. C{parent} is also required. @return: A C{TestCase} or C{TestSuite}. """ if isinstance(obj, types.ModuleType): # It looks like a module if isPackage(obj): # It's a package, so recurse down it. return self.loadPackage(obj, recurse=recurse) # Otherwise get all the tests in the module. return self.loadTestsFromModule(obj) elif isinstance(obj, type) and issubclass(obj, pyunit.TestCase): # We've found a raw test case, get the tests from it. return self.loadTestsFromTestCase(obj) elif ( isinstance(obj, types.FunctionType) and isinstance(parent, type) and issubclass(parent, pyunit.TestCase) ): # We've found a method, and its parent is a TestCase. Instantiate # it with the name of the method we want. name = qualName[-1] inst = parent(name) # Sanity check to make sure that the method we have got from the # test case is the same one as was passed in. This doesn't actually # use the function we passed in, because reasons. assert getattr(inst, inst._testMethodName).__func__ == obj return inst elif isinstance(obj, TestSuite): # We've found a test suite. return obj else: raise TypeError(f"don't know how to make test from: {obj}") def loadByName(self, name, recurse=False): """ Load some tests by name. @param name: The qualified name for the test to load. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. """ try: return self.suiteFactory([self.findByName(name, recurse=recurse)]) except BaseException: return self.suiteFactory([ErrorHolder(name, failure.Failure())]) loadTestsFromName = loadByName def loadByNames(self, names, recurse=False): """ Load some tests by a list of names. @param names: A L{list} of qualified names. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. """ things = [] errors = [] for name in names: try: things.append(self.loadByName(name, recurse=recurse)) except BaseException: errors.append(ErrorHolder(name, failure.Failure())) things.extend(errors) return self.suiteFactory(self._uniqueTests(things)) def _uniqueTests(self, things): """ Gather unique suite objects from loaded things. This will guarantee uniqueness of inherited methods on TestCases which would otherwise hash to same value and collapse to one test unexpectedly if using simpler means: e.g. set(). """ seen = set() for testthing in things: testthings = testthing._tests for thing in testthings: # This is horrible. if str(thing) not in seen: yield thing seen.add(str(thing)) def loadFile(self, fileName, recurse=False): """ Load a file, and then the tests in that file. @param fileName: The file name to load. @param recurse: A boolean. If True, inspect modules within packages within the given package (and so on), otherwise, only inspect modules in the package itself. """ name = reflect.filenameToModuleName(fileName) try: module = SourceFileLoader(name, fileName).load_module() return self.loadAnything(module, recurse=recurse) except OSError: raise ValueError(f"{fileName} is not a Python file.") def _qualNameWalker(qualName): """ Given a Python qualified name, this function yields a 2-tuple of the most specific qualified name first, followed by the next-most-specific qualified name, and so on, paired with the remainder of the qualified name. @param qualName: A Python qualified name. @type qualName: L{str} """ # Yield what we were just given yield (qualName, []) # If they want more, split the qualified name up qualParts = qualName.split(".") for index in range(1, len(qualParts)): # This code here will produce, from the example walker.texas.ranger: # (walker.texas, ["ranger"]) # (walker, ["texas", "ranger"]) yield (".".join(qualParts[:-index]), qualParts[-index:]) class TrialRunner: """ A specialised runner that the trial front end uses. """ DEBUG = "debug" DRY_RUN = "dry-run" def _setUpTestdir(self): self._tearDownLogFile() currentDir = os.getcwd() base = filepath.FilePath(self.workingDirectory) testdir, self._testDirLock = util._unusedTestDirectory(base) os.chdir(testdir.path) return currentDir def _tearDownTestdir(self, oldDir): os.chdir(oldDir) self._testDirLock.unlock() _log = log def _makeResult(self): reporter = self.reporterFactory( self.stream, self.tbformat, self.rterrors, self._log ) if self._exitFirst: reporter = _ExitWrapper(reporter) if self.uncleanWarnings: reporter = UncleanWarningsReporterWrapper(reporter) return reporter def __init__( self, reporterFactory, mode=None, logfile="test.log", stream=sys.stdout, profile=False, tracebackFormat="default", realTimeErrors=False, uncleanWarnings=False, workingDirectory=None, forceGarbageCollection=False, debugger=None, exitFirst=False, ): self.reporterFactory = reporterFactory self.logfile = logfile self.mode = mode self.stream = stream self.tbformat = tracebackFormat self.rterrors = realTimeErrors self.uncleanWarnings = uncleanWarnings self._result = None self.workingDirectory = workingDirectory or "_trial_temp" self._logFileObserver = None self._logFileObject = None self._forceGarbageCollection = forceGarbageCollection self.debugger = debugger self._exitFirst = exitFirst if profile: self.run = util.profiled(self.run, "profile.data") def _tearDownLogFile(self): if self._logFileObserver is not None: log.removeObserver(self._logFileObserver.emit) self._logFileObserver = None if self._logFileObject is not None: self._logFileObject.close() self._logFileObject = None def _setUpLogFile(self): self._tearDownLogFile() if self.logfile == "-": logFile = sys.stdout else: logFile = open(self.logfile, "a") self._logFileObject = logFile self._logFileObserver = log.FileLogObserver(logFile) log.startLoggingWithObserver(self._logFileObserver.emit, 0) def run(self, test): """ Run the test or suite and return a result object. """ test = unittest.decorate(test, ITestCase) return self._runWithoutDecoration(test, self._forceGarbageCollection) def _runWithoutDecoration(self, test, forceGarbageCollection=False): """ Private helper that runs the given test but doesn't decorate it. """ result = self._makeResult() # decorate the suite with reactor cleanup and log starting # This should move out of the runner and be presumed to be # present suite = TrialSuite([test], forceGarbageCollection) startTime = time.time() if self.mode == self.DRY_RUN: for single in _iterateTests(suite): result.startTest(single) result.addSuccess(single) result.stopTest(single) else: if self.mode == self.DEBUG: run = lambda: self.debugger.runcall(suite.run, result) else: run = lambda: suite.run(result) oldDir = self._setUpTestdir() try: self._setUpLogFile() run() finally: self._tearDownLogFile() self._tearDownTestdir(oldDir) endTime = time.time() done = getattr(result, "done", None) if done is None: warnings.warn( "%s should implement done() but doesn't. Falling back to " "printErrors() and friends." % reflect.qual(result.__class__), category=DeprecationWarning, stacklevel=3, ) result.printErrors() result.writeln(result.separator) result.writeln( "Ran %d tests in %.3fs", result.testsRun, endTime - startTime ) result.write("\n") result.printSummary() else: result.done() return result def runUntilFailure(self, test): """ Repeatedly run C{test} until it fails. """ count = 0 while True: count += 1 self.stream.write("Test Pass %d\n" % (count,)) if count == 1: result = self.run(test) else: result = self._runWithoutDecoration(test) if result.testsRun == 0: break if not result.wasSuccessful(): break return result PK b�Z�" � � __init__.pynu �[��� # Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. # # Maintainer: Jonathan Lange """ Twisted Trial: Asynchronous unit testing framework. Trial extends Python's builtin C{unittest} to provide support for asynchronous tests. Trial strives to be compatible with other Python xUnit testing frameworks. "Compatibility" is a difficult things to define. In practice, it means that: - L{twisted.trial.unittest.TestCase} objects should be able to be used by other test runners without those runners requiring special support for Trial tests. - Tests that subclass the standard library C{TestCase} and don't do anything "too weird" should be able to be discoverable and runnable by the Trial test runner without the authors of those tests having to jump through hoops. - Tests that implement the interface provided by the standard library C{TestCase} should be runnable by the Trial runner. - The Trial test runner and Trial L{unittest.TestCase} objects ought to be able to use standard library C{TestResult} objects, and third party C{TestResult} objects based on the standard library. This list is not necessarily exhaustive -- compatibility is hard to define. Contributors who discover more helpful ways of defining compatibility are encouraged to update this document. Examples: B{Timeouts} for tests should be implemented in the runner. If this is done, then timeouts could work for third-party TestCase objects as well as for L{twisted.trial.unittest.TestCase} objects. Further, Twisted C{TestCase} objects will run in other runners without timing out. See U{http://twistedmatrix.com/trac/ticket/2675}. Running tests in a temporary directory should be a feature of the test case, because often tests themselves rely on this behaviour. If the feature is implemented in the runner, then tests will change behaviour (possibly breaking) when run in a different test runner. Further, many tests don't even care about the filesystem. See U{http://twistedmatrix.com/trac/ticket/2916}. """ PK b�Z��̪�. �. & __pycache__/_asynctest.cpython-310.pycnu �[��� PK b�Z�h�� " &/ __pycache__/itrial.cpython-310.pycnu �[��� PK b�Z$��- �- �F __pycache__/util.cpython-310.pycnu �[��� PK b�Z=���- - $ �t __pycache__/__init__.cpython-310.pycnu �[��� PK b�Z4���� � $ } __pycache__/reporter.cpython-310.pycnu �[��� PK b�Z��,i ,i " __pycache__/runner.cpython-310.pycnu �[��� PK b�Z���� � $ �� __pycache__/unittest.cpython-310.pycnu �[��� PK b�Z^�1ͳ � ( ߊ __pycache__/_asyncrunner.cpython-310.pycnu �[��� PK b�Z����; ; $ � __pycache__/__main__.cpython-310.pycnu �[��� PK b�Z�Q� R� R� % y� __pycache__/_synctest.cpython-310.pycnu �[��� PK b�Z0X��6 6 ` itrial.pynu �[��� PK b�Z*4G/�� �� �q test/test_assertions.pynu �[��� PK b�Z���:� � c_ test/weird.pynu �[��� PK b�Zy�� Cb test/mockcustomsuite.pynu �[��� PK b�Zg�kZ# # �d test/detests.pynu �[��� PK b�Z��ȁ� � { test/scripttest.pynu ȯ�� PK b�Z���XW XW } test/test_loader.pynu �[��� PK b�ZP�QI� � �� test/mockcustomsuite3.pynu �[��� PK b�ZV�Ҹ � �� test/erroneous.pynu �[��� PK b�Z����7 7 * �� test/__pycache__/erroneous.cpython-310.pycnu �[��� PK b�Z"�!O� � 1 test/__pycache__/test_suppression.cpython-310.pycnu �[��� PK b�Z �ſ7 7 1 ! test/__pycache__/mockcustomsuite3.cpython-310.pycnu �[��� PK b�Zy{�� � - �% test/__pycache__/test_doctest.cpython-310.pycnu �[��� PK b�ZwLk{+ + ' �. test/__pycache__/novars.cpython-310.pycnu �[��� PK b�Z����� � ' <0 test/__pycache__/sample.cpython-310.pycnu �[��� PK b�Z�_:]! ]! . d? test/__pycache__/test_deferred.cpython-310.pycnu �[��� PK b�Zr;)�� � ) a test/__pycache__/__init__.cpython-310.pycnu �[��� PK b�Z^��� � . Pb test/__pycache__/test_keyboard.cpython-310.pycnu �[��� PK b�Z C��� � & rw test/__pycache__/weird.cpython-310.pycnu �[��� PK b�Z�[� (� (� . �{ test/__pycache__/test_reporter.cpython-310.pycnu �[��� PK b�Z��jS S , m test/__pycache__/mockdoctest.cpython-310.pycnu �[��� PK b�Z�2d�\� \� + �x test/__pycache__/test_tests.cpython-310.pycnu �[��� PK b�ZPn�,Y ,Y , �= test/__pycache__/test_loader.cpython-310.pycnu �[��� PK b�Z��J6�# �# ) � test/__pycache__/test_log.cpython-310.pycnu �[��� PK b�Z|��ع � , � test/__pycache__/suppression.cpython-310.pycnu �[��� PK b�Z�a1�Z �Z * � test/__pycache__/test_util.cpython-310.pycnu �[��� PK b�Z�w��� � 0 & test/__pycache__/mockcustomsuite.cpython-310.pycnu �[��� PK b�Z� �e e * �) test/__pycache__/test_skip.cpython-310.pycnu �[��� PK b�Zj���d! d! ( �9 test/__pycache__/detests.cpython-310.pycnu �[��� PK b�Z���� � , y[ test/__pycache__/test_output.cpython-310.pycnu �[��� PK b�Z�Ḧ́� � 1 �p test/__pycache__/mockcustomsuite2.cpython-310.pycnu �[��� PK b�Zz��X}E }E - �t test/__pycache__/test_warning.cpython-310.pycnu �[��� PK b�Z(��/ / + g� test/__pycache__/scripttest.cpython-310.pycnu �[��� PK b�Z�$�� � . � test/__pycache__/test_testcase.cpython-310.pycnu �[��� PK b�Z],�� � 5 � test/__pycache__/test_asyncassertions.cpython-310.pycnu �[��� PK b�Z�+{� � ) 7� test/__pycache__/packages.cpython-310.pycnu �[��� PK b�Z�Ӟ�r �r , ]� test/__pycache__/test_script.cpython-310.pycnu �[��� PK b�Z Z� �' �' 2 J` test/__pycache__/test_pyunitcompat.cpython-310.pycnu �[��� PK b�ZK�a� � � , P� test/__pycache__/test_runner.cpython-310.pycnu �[��� PK b�Zz�� / / + �) test/__pycache__/moduletest.cpython-310.pycnu �[��� PK b�Z�:Ѩ5 5 + B+ test/__pycache__/ordertests.cpython-310.pycnu �[��� PK b�Z��-}�% �% ) �1 test/__pycache__/skipping.cpython-310.pycnu �[��� PK b�Z�5�� � + �W test/__pycache__/moduleself.cpython-310.pycnu �[��� PK b�Z&!4"� "� 0 .Z test/__pycache__/test_assertions.cpython-310.pycnu �[��� PK b�Z���A� � - �V test/__pycache__/test_plugins.cpython-310.pycnu �[��� PK b�Z_�]� � �] test/novars.pynu �[��� PK b�Z���S� � �^ test/test_asyncassertions.pynu �[��� PK b�Z� �q -i test/mockcustomsuite2.pynu �[��� PK b�Z��2 M M �k test/skipping.pynu �[��� PK b�ZO�78� � � test/test_output.pynu �[��� PK b�Z't�` ` � test/ordertests.pynu �[��� PK b�Z��0 � � �� test/test_doctest.pynu �[��� PK b�ZP��r �r �� test/test_script.pynu �[��� PK b�Z {%[ [ � test/test_skip.pynu �[��� PK b�Z_-"� � ) test/test_pyunitcompat.pynu �[��� PK b�Zȓ� � 6< test/test_testcase.pynu �[��� PK b�Z�vUu u <D test/mockdoctest.pynu �[��� PK b�Z@���L �L �M test/test_util.pynu �[��� PK b�Z�i��� � � test/suppression.pynu �[��� PK b�Z�S��� �� � test/test_reporter.pynu �[��� PK b�Z�� �. . т test/moduletest.pynu �[��� PK b�Z�?\$ $ A� test/sample.pynu �[��� PK b�Z�vOv" v" �� test/test_deferred.pynu �[��� PK b�Z�=`\�D �D ^� test/test_warning.pynu �[��� PK b�Z � �� test/test_suppression.pynu �[��� PK b�Z �B�� � � test/test_runner.pynu �[��� PK b�Z�zh h � test/test_log.pynu �[��� PK b�Z�G�� � �� test/moduleself.pynu �[��� PK b�Z�"h+ + �� test/packages.pynu �[��� PK b�Z� �i\� \� � test/test_tests.pynu �[��� PK b�Z�=� � �� test/test_keyboard.pynu �[��� PK b�Z�}[�� � �� test/test_plugins.pynu �[��� PK b�Z�㽂 � �� test/__init__.pynu �[��� PK b�Z����� � n� _synctest.pynu �[��� PK b�Z�}�� � �l __main__.pynu �[��� PK b�Z��nX@7 @7 �m _asynctest.pynu �[��� PK b�Z�Ֆ� � d� unittest.pynu �[��� PK b�Z��O��0 �0 H� util.pynu �[��� PK b�Z�Ȧ/ / >� _dist/workerreporter.pynu �[��� PK b�ZԖa�: : - �� _dist/__pycache__/workertrial.cpython-310.pycnu �[��� PK b�ZP��� � * K� _dist/__pycache__/__init__.cpython-310.pycnu �[��� PK b�Z��_;� � 1 .� _dist/__pycache__/managercommands.cpython-310.pycnu �[��� PK b�Z�v~8 8 0 _dist/__pycache__/workercommands.cpython-310.pycnu �[��� PK b�Z���� � ) � _dist/__pycache__/options.cpython-310.pycnu �[��� PK b�Z�9�w w 0 � _dist/__pycache__/workerreporter.cpython-310.pycnu �[��� PK b�Z���e�' �' ( �! _dist/__pycache__/worker.cpython-310.pycnu �[��� PK b�Z�6ol�" �" + �I _dist/__pycache__/disttrial.cpython-310.pycnu �[��� PK b�Z4�W� . Tm _dist/__pycache__/distreporter.cpython-310.pycnu �[��� PK b�Z�g�$ �$ �x _dist/worker.pynu �[��� PK b�Zb�� lA lA �� _dist/test/test_disttrial.pynu �[��� PK b�Z�j0� � 3 [� _dist/test/__pycache__/test_options.cpython-310.pycnu �[��� PK b�Z�C�� � 8 �� _dist/test/__pycache__/test_distreporter.cpython-310.pycnu �[��� PK b�Z P � � / �� _dist/test/__pycache__/__init__.cpython-310.pycnu �[��� PK b�Z���ЪH �H 5 �� _dist/test/__pycache__/test_disttrial.cpython-310.pycnu �[��� PK b�Z#�� A A 2 : _dist/test/__pycache__/test_worker.cpython-310.pycnu �[��� PK b�Z��'{ { : �{ _dist/test/__pycache__/test_workerreporter.cpython-310.pycnu �[��� PK b�Z;�Ȑ � 7 f� _dist/test/__pycache__/test_workertrial.cpython-310.pycnu �[��� PK b�Z4�O�n= n= ]� _dist/test/test_worker.pynu �[��� PK b�Z~�(�� � � _dist/test/test_distreporter.pynu �[��� PK b�Z�ψ�3 3 >� _dist/test/test_options.pynu �[��� PK b�Z�t0O% % ! �� _dist/test/test_workerreporter.pynu �[��� PK b�Zv5R v v 1 _dist/test/__init__.pynu �[��� PK b�Z?' �d d � _dist/test/test_workertrial.pynu �[��� PK b�ZB��� � _dist/distreporter.pynu �[��� PK b�ZI K� � �" _dist/options.pynu �[��� PK b�Z�X�n! n! & _dist/disttrial.pynu �[��� PK b�Z�?�� � �G _dist/workertrial.pynu �[��� PK b�ZA*ʓ> > �R _dist/workercommands.pynu �[��� PK b�ZK�i� � LU _dist/managercommands.pynu �[��� PK b�Zn[O3� � }\ _dist/__init__.pynu �[��� PK b�Z�7`, , Sd _asyncrunner.pynu �[��� PK b�Z��p�� �� �u reporter.pynu �[��� PK b�Z6 F7�| �| � runner.pynu �[��� PK b�Z�" � � � __init__.pynu �[��� PK | | 4. �
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.05 |
proxy
|
phpinfo
|
Settings