| Server IP : 209.38.156.173 / Your IP : 216.73.216.122 [ Web Server : Apache/2.4.52 (Ubuntu) System : Linux lakekumayuhotel 5.15.0-136-generic #147-Ubuntu SMP Sat Mar 15 15:53:30 UTC 2025 x86_64 User : root ( 0) PHP Version : 8.1.2-1ubuntu2.22 Disable Function : NONE Domains : 2 Domains MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON Directory : /usr/lib/python3/dist-packages/twisted/application/test/__pycache__/ |
Upload File : |
o
�bO� � @ st d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z m
Z
m Z ddl m
Z
ddlmZmZ dd lmZmZmZmZmZ dd
lmZmZ dd lmZ dd l m Z m Z dd
l m Z ddl!m"Z" ddl#m$Z$m%Z% dd� Z&ee�G dd� d��Z'eee'� ee�G dd� d��Z(eee'� G dd� de%�Z)G dd� de%�Z*G dd� d�Z+d$d d �Z,e fd d �Z-d!Z.G d"d#� d#e$�Z/dS )%z�
Tests for (new code in) L{twisted.application.internet}.
@var AT_LEAST_ONE_ATTEMPT: At least enough seconds for L{ClientService} to make
one attempt.
� N)� implementer)� verifyClass)�internet)�
ClientService�StreamServerEndpointService� TimerService)�task)�CancelledError�Deferred)�IFileDescriptorReceiver�IHalfCloseableProtocol�IListeningPort�IStreamClientEndpoint�IStreamServerEndpoint)�Factory�Protocol)�Clock)� formatEvent�globalLogPublisher)�Failure)�StringTransport)�SynchronousTestCase�TestCasec C s dS )zM
A fake target function for testing TimerService which does nothing.
N� r r r �H/usr/lib/python3/dist-packages/twisted/application/test/test_internet.py�fakeTargetFunction) s r c @ sF e Zd ZdZdZdZdZe� ZdZ dd� Z
dd� Z dd � Z d
d � Z
dS ) �
FakeServeraq
In-memory implementation of L{IStreamServerEndpoint}.
@ivar result: The L{Deferred} resulting from the call to C{listen}, after
C{listen} has been called.
@ivar factory: The factory passed to C{listen}.
@ivar cancelException: The exception to errback C{self.result} when it is
cancelled.
@ivar port: The L{IListeningPort} which C{listen}'s L{Deferred} will fire
with.
@ivar listenAttempts: The number of times C{listen} has been invoked.
@ivar failImmediately: If set, the exception to fail the L{Deferred}
returned from C{listen} before it is returned.
Nr c C s t � | _d S �N)�FakePort�port��selfr r r �__init__L s zFakeServer.__init__c sF � j d7 _ |� _t� fdd�d�� _� jdur � j�� j� � jS )z�
Return a Deferred and store it for future use. (Implementation of
L{IStreamServerEndpoint}).
@param factory: the factory to listen with
@return: a L{Deferred} stored in L{FakeServer.result}
� c s | � � j�S r )�errback�cancelException)�dr r r �<lambda>Z � z#FakeServer.listen.<locals>.<lambda>)� cancellerN)�listenAttempts�factoryr
�result�failImmediatelyr$ )r! r+ r r r �listenO s
zFakeServer.listenc C s | j �| j� dS )z�
Test code should invoke this method after causing C{listen} to be
invoked in order to fire the L{Deferred} previously returned from
C{listen}.
N)r, �callbackr r r r r �startedListening_ � zFakeServer.startedListeningc C s | j j�d� dS )a
Test code should invoke this method after causing C{stopListening} to
be invoked on the port fired from the L{Deferred} returned from
C{listen} in order to cause the L{Deferred} returned from
C{stopListening} to fire.
N)r �deferredr/ r r r r �stoppedListeningg s zFakeServer.stoppedListening)�__name__�
__module__� __qualname__�__doc__r, r+ r- r r% r* r" r. r0 r3 r r r r r 0 s r c @ s, e Zd ZdZdZdd� Zdd� Zdd� ZdS ) r zs
Fake L{IListeningPort} implementation.
@ivar deferred: The L{Deferred} returned by C{stopListening}.
Nc C s t � | _| jS )z`
Stop listening.
@return: a L{Deferred} stored in L{FakePort.deferred}
)r
r2 r r r r �
stopListening~ s zFakePort.stopListeningc C � d S r r r r r r �getHost� � zFakePort.getHostc C r9 r r r r r r �startListening� r; zFakePort.startListening)r4 r5 r6 r7 r2 r8 r: r< r r r r r t s r c @ sr e Zd ZdZdd� Zdd� Zddd�Zd d
� Zd d � Zd
d� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� ZdS ) �EndpointServiceTestsz4
Tests for L{twisted.application.internet}.
c C s$ t � | _t� | _t| j| j�| _dS )zp
Construct a stub server, a stub factory, and a
L{StreamServerEndpointService} to test.
N)r �
fakeServerr r+ r �svcr r r r �setUp� s zEndpointServiceTests.setUpc C s | j �� | �| j| jj� dS )z�
L{StreamServerEndpointService.privilegedStartService} calls its
endpoint's C{listen} method with its factory.
N)r? �privilegedStartService�assertIdenticalr+ r> r r r r �test_privilegedStartService� s
z0EndpointServiceTests.test_privilegedStartServiceNc C s* t � | j_d| j_| �t |p| jj� dS )a@
L{StreamServerEndpointService.startService} should raise synchronously
if the L{Deferred} returned by its wrapped
L{IStreamServerEndpoint.listen} has already fired with an errback and
the L{StreamServerEndpointService}'s C{_raiseSynchronously} flag has
been set. This feature is necessary to preserve compatibility with old
behavior of L{twisted.internet.strports.service}, which is to return a
service which synchronously raises an exception from C{startService}
(so that, among other things, twistd will not start running). However,
since L{IStreamServerEndpoint.listen} may fail asynchronously, it is a
bad idea to rely on this behavior.
@param thunk: If specified, a callable to execute in place of
C{startService}.
TN)�ZeroDivisionErrorr> r- r? �_raiseSynchronously� assertRaises� startService)r! �thunkr r r �(test_synchronousRaiseRaisesSynchronously� s
z=EndpointServiceTests.test_synchronousRaiseRaisesSynchronouslyc C s | � | jj� dS )z�
L{StreamServerEndpointService.privilegedStartService} should behave the
same as C{startService} with respect to
L{EndpointServiceTests.test_synchronousRaiseRaisesSynchronously}.
N)rI r? rA r r r r � test_synchronousRaisePrivileged� r1 z4EndpointServiceTests.test_synchronousRaisePrivilegedc C s8 | j �� | jj�t� � | �t�}| �t|�d� dS )a
L{StreamServerEndpointService.startService} and
L{StreamServerEndpointService.privilegedStartService} should both log
an exception when the L{Deferred} returned from their wrapped
L{IStreamServerEndpoint.listen} fails.
r# N) r? rG r> r, r$ rD �flushLoggedErrors� assertEqual�len�r! �loggedr r r �test_failReportsError� s
z*EndpointServiceTests.test_failReportsErrorc C s@ d| j _| j �� | jj�t� � | �t�}| �t |�d� dS )aB
L{StreamServerEndpointService.startService} and
L{StreamServerEndpointService.privilegedStartService} should both log
an exception when the L{Deferred} returned from their wrapped
L{IStreamServerEndpoint.listen} fails asynchronously, even if
C{_raiseSynchronously} is set.
Tr# N)
r? rE rG r> r, r$ rD rK rL rM rN r r r �!test_asynchronousFailReportsError� s
z6EndpointServiceTests.test_asynchronousFailReportsErrorc C s2 t � | j_| j�� | �t �}| �t|�d� dS )z�
Without the C{_raiseSynchronously} compatibility flag, failing
immediately has the same behavior as failing later; it logs the error.
r# N)rD r> r- r? rG rK rL rM rN r r r � test_synchronousFailReportsError� s
z5EndpointServiceTests.test_synchronousFailReportsErrorc C s0 | j �� | �| j| jj� | �| j jd� dS )z�
L{StreamServerEndpointService.startService} sets the C{running} flag,
and calls its endpoint's C{listen} method with its factory, if it
has not yet been started.
TN)r? rG rB r+ r> rL �runningr r r r �test_startServiceUnstarted� s
z/EndpointServiceTests.test_startServiceUnstartedc C s6 | � � | j�� | �| jjd� | �| jjd� dS )z�
L{StreamServerEndpointService.startService} sets the C{running} flag,
but nothing else, if the service has already been started.
r# TN)rC r? rG rL r> r* rS r r r r �test_startServiceStarted� s
z-EndpointServiceTests.test_startServiceStartedc C st | j �� | j�� | j �� | j �� }g }|�|j� | �t |�d� | j�
� | �t |�d� | � | j j � dS )z�
L{StreamServerEndpointService.stopService} calls C{stopListening} on
the L{IListeningPort} returned from its endpoint, returns the
C{Deferred} from stopService, and sets C{running} to C{False}.
r r# N)
r? rA r> r0 rG � stopService� addCallback�appendrL rM r3 � assertFalserS �r! r, �lr r r �test_stopService� s
z%EndpointServiceTests.test_stopServicec C sH | j �� | j �� }g }|�|j� | �|dg� | �| �t�g � dS )z�
L{StreamServerEndpointService.stopService} cancels the L{Deferred}
returned by C{listen} if it has not yet fired. No error will be logged
about the cancellation of the listen attempt.
N)r? rA rV �addBothrX rL rK r rZ r r r �#test_stopServiceBeforeStartFinished s
z8EndpointServiceTests.test_stopServiceBeforeStartFinishedc C sZ t � | j_| j�� | j�� }g }|�|j� | �|dg� | � t �}| �t
|�d� dS )z�
L{StreamServerEndpointService.stopService} cancels the L{Deferred}
returned by C{listen} if it has not fired yet. An error will be logged
if the resulting exception is not L{CancelledError}.
Nr# ) rD r> r% r? rA rV rW rX rL rK rM )r! r, r[ �stoppingErrorsr r r � test_stopServiceCancelStartError s
z5EndpointServiceTests.test_stopServiceCancelStartErrorr )r4 r5 r6 r7 r@ rC rI rJ rP rQ rR rT rU 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
dS )�TimerServiceTestsa)
Tests for L{twisted.application.internet.TimerService}.
@type timer: L{TimerService}
@ivar timer: service to test
@type clock: L{task.Clock}
@ivar clock: source of time
@type deferred: L{Deferred}
@ivar deferred: deferred returned by L{TimerServiceTests.call}.
c C s, t d| j�| _t�� | _| j_t� | _dS )z1
Set up a timer service to test.
� N)r �call�timerr r �clockr
r2 r r r r r@ : s zTimerServiceTests.setUpc C s | j S )z�
Function called by L{TimerService} being tested.
@returns: C{self.deferred}
@rtype: L{Deferred}
)r2 r r r r rc B s zTimerServiceTests.callc C sV | j �� | �| j jd� | �| j jtj� | �| j | j jj � | �| j jjd� dS )z�
When L{TimerService.startService} is called, it marks itself
as running, creates a L{task.LoopingCall} and starts it.
zService is startedzLoopingCall is startedN)
rd rG �
assertTruerS �assertIsInstance�_loopr � LoopingCallrB re r r r r �test_startServiceK s
z#TimerServiceTests.test_startServicec C s0 g }|j di f| j_| j�� | �dg|� dS )zi
When L{TimerService.startService} is called, it calls the function
immediately.
r N)rX rd rc rG rL )r! r, r r r �$test_startServiceRunsCallImmediatelyV s
z6TimerServiceTests.test_startServiceRunsCallImmediatelyc sB t �� � � fdd�}| �td|� | j�� | �� | jjj� dS )z�
L{TimerService.startService} uses L{internet._maybeGlobalReactor} to
choose the reactor to pass to L{task.LoopingCall}
uses the global reactor.
c � � S r r )� maybeReactor��
otherClockr r �
getOtherClockh � zKTimerServiceTests.test_startServiceUsesGlobalReactor.<locals>.getOtherClock�_maybeGlobalReactorN) r r �patchr rd rG rB rh re )r! rp r rn r �"test_startServiceUsesGlobalReactor` s
z4TimerServiceTests.test_startServiceUsesGlobalReactorc C sR | j �� | j �� }| �|� | �d| j j� | j�t� � | � | �
|�d� dS )z�
When L{TimerService.stopService} is called while a call is in progress.
the L{Deferred} returned doesn't fire until after the call finishes.
TN) rd rG rV �assertNoResultrL rS r2 r/ �objectrB �successResultOf�r! r& r r r �test_stopServiceWaitso s
z'TimerServiceTests.test_stopServiceWaitsc C s8 | j �� | j�t� � | j �� }| �| �|�d� dS )z�
When L{TimerService.stopService} is called while a call isn't in progress.
the L{Deferred} returned has already been fired.
N)rd rG r2 r/ rv rV rB rw rx r r r �test_stopServiceImmediately{ s
z-TimerServiceTests.test_stopServiceImmediatelyc C sV | j �� | j�tt� �� | �t�}| �dt|�� | j � � }| �
| � |�d� dS )z�
When function passed to L{TimerService} returns a deferred that errbacks,
the exception is logged, and L{TimerService.stopService} doesn't raise an error.
r# N) rd rG r2 r$ r rD rK rL rM rV rB rw )r! �errorsr& r r r �test_failedCallLogsError� s
z*TimerServiceTests.test_failedCallLogsErrorc C �P t dt�}|�� t�|�}|�� t�|�}t� }t|d|�}| � ||� dS )zq
When pickling L{internet.TimerService}, it won't pickle
L{internet.TimerService._loop}.
r# rh N�
r r rG �pickle�dumpsrV �loadsrv �getattrrB �r! rd � dumpedTimer� loadedTimer�nothing�valuer r r �$test_pickleTimerServiceNotPickleLoop� �
z6TimerServiceTests.test_pickleTimerServiceNotPickleLoopc C r} )zy
When pickling L{internet.TimerService}, it won't pickle
L{internet.TimerService._loopFinished}.
r# �
_loopFinishedNr~ r� r r r �,test_pickleTimerServiceNotPickleLoopFinished� r� z>TimerServiceTests.test_pickleTimerServiceNotPickleLoopFinishedN)r4 r5 r6 r7 r@ rc rj rk rt ry rz r| r� r� r r r r ra , s
ra c @ s e Zd ZdZdd� ZdS )�ConnectInformationa�
Information about C{endpointForTesting}
@ivar connectQueue: a L{list} of L{Deferred} returned from C{connect}. If
these are not already fired, you can fire them with no value and they
will trigger building a factory.
@ivar constructedProtocols: a L{list} of protocols constructed.
@ivar passedFactories: a L{list} of L{IProtocolFactory}; the ones actually
passed to the underlying endpoint / i.e. the reactor.
c C s g | _ g | _g | _d S r )� connectQueue�constructedProtocols�passedFactoriesr r r r r" � s
zConnectInformation.__init__N)r4 r5 r6 r7 r" r r r r r� � s
r� Fc s, t t�G � �fdd�d��}t� ��|� fS )aD
Make a sample endpoint for testing.
@param fireImmediately: If true, fire all L{Deferred}s returned from
C{connect} immedaitely.
@return: a 2-tuple of C{(information, endpoint)}, where C{information} is a
L{ConnectInformation} describing the operations in progress on
C{endpoint}.
c s e Zd Z� �fdd�ZdS )z.endpointForTesting.<locals>.ClientTestEndpointc sD t � }�j�� � |j� �fdd��}�j�|� �r |�d � |S )Nc s* � � d �}�j�|� t� }|�|� |S r )�
buildProtocolr� rX r �makeConnection)�ignored�protocol� transport)r+ �infor r �createProtocol� s
zNendpointForTesting.<locals>.ClientTestEndpoint.connect.<locals>.createProtocol)r
r� rX rW r� r/ )r! r+ r, r� ��fireImmediatelyr� )r+ r �connect� s
z6endpointForTesting.<locals>.ClientTestEndpoint.connectN)r4 r5 r6 r� r r� r r �ClientTestEndpoint� s r� )r r r� )r� r� r r� r �endpointForTesting� s
r� c s0 g �� � �j� | �� �fdd�� �fdd�S )a6
Catch the global log stream.
@param testCase: The test case to add a cleanup to.
@param logPublisher: the log publisher to add and remove observers for.
@return: a 0-argument callable that returns a list of textual log messages
for comparison.
@rtype: L{list} of L{unicode}
c s � � �j�S r )�removeObserverrX r �� logPublisher�logsr r r' � r( zcatchLogs.<locals>.<lambda>c s dd� � D �S )Nc S s g | ]}t |��qS r )r )�.0�eventr r r �
<listcomp>� s z/catchLogs.<locals>.<lambda>.<locals>.<listcomp>r r )r� r r r' � s )� addObserverrX �
addCleanup)�testCaser� r r� r � catchLogs� s r� g Y@c @ s e Zd ZdZddefdd�Zdd� Zdd� Zd d
� Zd 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(� Zd)d*� Zd+d,� Zd-d.� Zd/d0� Zd1d2� Z d3d4� Z d5d6� Z d7d8� Z d9d:� Z d;d<� Z!d=d>� Z"d?d@� Z#dAS )B�ClientServiceTestsz%
Tests for L{ClientService}.
Tc s� i }|j t� d� |� |� |d �t|d�\}}g � |_G � �fdd�dt�}|� |_} t|| fi |������fdd�}
��|
� |rK��� |�fS )aL
Create a L{ClientService} along with a L{ConnectInformation} indicating
the connections in progress on its endpoint.
@param fireImmediately: Should all of the endpoint connection attempts
fire synchronously?
@type fireImmediately: L{bool}
@param startService: Should the L{ClientService} be started before
being returned?
@type startService: L{bool}
@param protocolType: a 0-argument callable returning a new L{IProtocol}
provider to be used for application-level protocol connections.
@param kw: Arbitrary keyword arguments to be passed on to
L{ClientService}
@return: a 2-tuple of L{ConnectInformation} (for information about test
state) and L{ClientService} (the system under test). The
L{ConnectInformation} has 2 additional attributes;
C{applicationFactory} and C{applicationProtocols}, which refer to
the unwrapped protocol factory and protocol instances passed in to
L{ClientService} respectively.
�re re �r� c s" e Zd Z�Z� �fdd�Z� ZS )z>ClientServiceTests.makeReconnector.<locals>.RememberingFactoryc s t � �|�}��|� |S r )�superr� rX )r! �addrr, )� __class__�applicationProtocolsr r r� 0 s
zLClientServiceTests.makeReconnector.<locals>.RememberingFactory.buildProtocol)r4 r5 r6 r� r� �
__classcell__r )r� � protocolType)r� r �RememberingFactory- s r� c s( d �_ �jr
��� ��� �� g � d S r )� _protocolrS rV rL �getDelayedCallsr )re r! �servicer r �stop9 s z0ClientServiceTests.makeReconnector.<locals>.stop) �updater r� r� r �applicationFactoryr r� rG ) r! r� rG r� �kw�nkw�cq�endpointr� r+ r� r )r� re r� r! r� r �makeReconnector s
z"ClientServiceTests.makeReconnectorc C s& | j dd�\}}| �t|j�d� dS )zL
When the service is started, a connection attempt is made.
Fr� r# N)r� rL rM r� )r! r� r� r r r rj F s z$ClientServiceTests.test_startServicec C sD | � � \}}|j}| �|jd� |jd }|�� | �|jd� dS )a!
Although somewhat obscure, L{IProtocolFactory} includes both C{doStart}
and C{doStop} methods; ensure that when these methods are called on the
factory that was passed to the reactor, the factory that was passed
from the application receives them.
r r# N)r� r� rL �numPortsr� �doStart)r! r� r� �firstAppFactory�firstPassedFactoryr r r �test_startStopFactoryM s
z(ClientServiceTests.test_startStopFactoryc C sV | � � \}}|�� }| �|� |jd }| �|jjd� |�tt � �� | �
|� dS )z�
When the service is stopped, no further connect attempts are made. The
returned L{Deferred} fires when all outstanding connections have been
stopped.
r TN) r� rV ru r� rL r� �
disconnecting�connectionLostr � Exceptionrw �r! r� r� r& r� r r r � test_stopServiceWhileConnected[ s
z1ClientServiceTests.test_stopServiceWhileConnectedc C s� | � � \}}|�� }| �|� |jd }| �|jjd� |�� | �|� | �t|j�d� |� t
t � �� | �t|j�d� dS )z�
When L{ClientService} is restarted after having been connected, it
waits to start connecting until after having disconnected.
r Tr# rb N) r� rV ru r� rL r� r� rG rM r� r r� r� r r r �#test_startServiceWaitsForDisconnecti s
z6ClientServiceTests.test_startServiceWaitsForDisconnectc C s� | j dd�\}}|jd �d� |jd }|�� }| �|� |�� }| �|� |�� | �|� | �|� | �|j j
d� |� t t
� �� | �|� |jd �d� | �t|j�d� | �| �|�|jd � |�� }| �|� dS )a%
When L{ClientService} is stopping - that is,
L{ClientService.stopService} has been called, but the L{Deferred} it
returns has not fired yet - calling L{startService} will cause a new
connection to be made, and new calls to L{whenConnected} to succeed.
Fr� r NTr# rb )r� r� r/ r� rV ru �
whenConnectedrG rL r� r� r� r r� rw rM rB r� )r! r� r� �first�stopped� nextProtocol�
secondStoppedr r r � test_startServiceWhileStoppingy s(
�z1ClientServiceTests.test_startServiceWhileStoppingc C sj | j dd�\}}|�� }| �|� | �|�� t� |�� |jd �d� | � |j
d | �|�� �� dS )a
When L{ClientService} is stopped - that is,
L{ClientService.stopService} has been called and the L{Deferred} it
returns has fired - calling L{startService} will cause a new connection
to be made, and new calls to L{whenConnected} to succeed.
Fr� ���N) r� rV rw �failureResultOfr� r rG r� r/ rB r� )r! r� r� r� r r r � test_startServiceWhileStopped� s
�z0ClientServiceTests.test_startServiceWhileStoppedc C sX t tt�G dd� dt��}| j|d�\}}|jd }| �t�|�� | �t�|�� dS )aC
If the protocol objects returned by the factory given to
L{ClientService} provide special "marker" interfaces for their
transport - L{IHalfCloseableProtocol} or L{IFileDescriptorReceiver} -
those interfaces will be provided by the protocol objects passed on to
the reactor.
c @ s e Zd ZdZdS )zEClientServiceTests.test_interfacesForTransport.<locals>.FancyProtocolz9
Provider of various interfaces.
N)r4 r5 r6 r7 r r r r �
FancyProtocol� s r� )r� r N)r r r r r� r� rf �
providedBy)r! r� r� r� �
reactorFacingr r r �test_interfacesForTransport� s
z.ClientServiceTests.test_interfacesForTransportc C sn t � }| jd|d�\}}|jd �t� � |�t� | �t|j�d� |� � }|jd �t� � | �
|� dS )zU
When the service is stopped while retrying, the retry is cancelled.
F�r� re r rb r# N) r r� r� r$ r� �advance�AT_LEAST_ONE_ATTEMPTrL rM rV rw �r! re r� r� r& r r r � test_stopServiceWhileRetrying� s
z0ClientServiceTests.test_stopServiceWhileRetryingc C sP t � }| jd|d�\}}| �t|j�d� | �|jd � |�� }| �|� dS )zv
When the service is stopped while initially connecting, the connection
attempt is cancelled.
Fr� r# r N)r r� rL rM r� ru rV rw r� r r r � test_stopServiceWhileConnecting� s z2ClientServiceTests.test_stopServiceWhileConnectingc C sJ t � }| j|d�\}}|�� }| �|�� g � | �| �|�|jd � dS )zy
When a client connects, the service keeps a reference to the new
protocol and resets the delay.
r� r N)r r� r� rL r� rB rw r� )r! re r� r� �awaitingProtocolr r r �test_clientConnected� s �z'ClientServiceTests.test_clientConnectedc C s� t � }| jd|d�\}}| �t|j�d� |jd �tt� �� |�� }| � |� |�
dd� � |� t � | �t|j�d� dS ) z�
When a client connection fails, the service removes its reference
to the protocol and tries again after a timeout.
Fr� r# r c S s
| � t�S r )�trapr )r� r r r r' � s
z@ClientServiceTests.test_clientConnectionFailed.<locals>.<lambda>rb N)
r r� rL rM r� r$ r r� r� ru �
addErrbackr� r� )r! re r� r� r� r r r �test_clientConnectionFailed� s
z.ClientServiceTests.test_clientConnectionFailedc C s� t � }| j|dd�\}}| �t|j�d� |jd �d� | �t|j�d� | �| �|�� �|j d � |j
d � t t
� �� |�t� | �t|j�d� |jd �d� | �| �|�� �|j d � dS )z~
When a client connection is lost, the service removes its reference
to the protocol and calls retry.
F)re r� r# r Nrb )r r� rL rM r� r/ rB rw r� r� r� r� r r� r� r� )r! re r� r� r r r �test_clientConnectionLost� s �
�z,ClientServiceTests.test_clientConnectionLostc C sT t � }| j|d�\}}|�� }|jd �tt� �� | �|�� t � | �
|j � dS )z�
When a client connection is lost while the service is stopping, the
protocol stopping deferred is called and the reference to the protocol
is removed.
r� r N) r r� rV r� r� r �IndentationErrorr� r� r rf �calledr� r r r �&test_clientConnectionLostWhileStopping s z9ClientServiceTests.test_clientConnectionLostWhileStoppingc C sv | j ddd�\}}| �t|j�d� |�� | �t|j�d� t| �}|�� | �t|j�d� | �d|� d � dS )z�
If L{ClientService} is started when it's already started, it will log a
complaint and do nothing else (in particular it will not make
additional connections).
F)r� rG r r# z$Duplicate ClientService.startServiceN)r� rL rM r� rG r� �assertIn)r! r� r� �messagesr r r �test_startTwice s z"ClientServiceTests.test_startTwicec
C s� t � }| jd|d�\}}|�� }|�� }|jdd�}| �|� | �|� | �|� |jd �d� | �|�}| �|�}| �|�} | �||� | �|| � | �||jd � dS )z{
L{ClientService.whenConnected} returns a L{Deferred} that fires when a
connection is established.
Fr� r# ��failAfterFailuresr N) r r� r� ru r� r/ rw rB r� )
r! re r� r� �a�b�c�resultA�resultB�resultCr r r �test_whenConnectedLater" s
z*ClientServiceTests.test_whenConnectedLaterc C s� t � }| jd|d�\}}|�� }|jdd�}|jdd�}|jdd�}| �|� | �|� | �|� | �|� tt� �}|jd �|� | �|� | �| � |t�|� | �|� | �|� |�
t � | � t
|j�d� | �|� | �|� | �|� tt� �} |jd �| � | �|� | �| � |t�| � | �|� t }
|�
|
� | � t
|j�d� | �|� | �|� |jd �d� | �|�} | �|�} | �| | � | �| |jd � |jdd�}
| �|
�}| �| |� dS ) z�
L{ClientService.whenConnected} returns a L{Deferred} that fails, if
asked, when some number of connections have failed.
Fr� r# r� rb � r N)r r� r� ru r r� r� r$ rB r� r� r� rL rM r/ rw r� )r! re r� r� �a0�a1�a2�a3�f1�f2�AT_LEAST_TWO_ATTEMPTS�resultA0�resultA3�a4�resultA4r r r �test_whenConnectedFails7 sN
z*ClientServiceTests.test_whenConnectedFailsc C s� t � }| jd|d�\}}|�� }|�� }|jdd�}| �|� | �|� | �|� |�� |�t� | �|t� | �|t� | �|t� dS )z�
L{ClientService.whenConnected} returns a L{Deferred} that fails when
L{ClientService.stopService} is called.
Fr� r# r� N) r r� r� ru rV r� r� r� r )r! re r� r� r� r� r� r r r � test_whenConnectedStopServiceq s
z0ClientServiceTests.test_whenConnectedStopServicec C sR t � }| jd|d�\}}|jd �td�� |�� }| �|�� g � | �|� dS )z�
When L{ClientService.stopService} is called while waiting between
connection attempts, the pending reconnection attempt is cancelled and
the service is stopped immediately.
Fr� r �
no connectionN) r r� r� r$ r� rV rL r� rw r� r r r �test_retryCancelled� s z&ClientServiceTests.test_retryCancelledc C s6 t � }| jdd|d�\}}|�� }| �| �|�� dS )z�
Calling L{ClientService.stopService} before
L{ClientService.startService} returns a L{Deferred} that has
already fired with L{None}.
F)r� rG re N�r r� rV � assertIsNonerw )r! re �_r� r& r r r �"test_stopServiceBeforeStartService� s
�z5ClientServiceTests.test_stopServiceBeforeStartServicec C sp t � }| jd|d�\}}|�� }|jd �td�� |�� |�� }| �| �|�j t
� | �| �|�j t
� dS )z�
L{ClientService.whenConnected} returns a L{Deferred} that
errbacks with L{CancelledError} if
L{ClientService.stopService} is called between connection
attempts.
Fr� r r� N) r r� r� r� r$ r� rV rg r� r� r )r! re r� r� �beforeErrbackAndStop�afterErrbackAndStopr r r �'test_whenConnectedErrbacksOnStopService� s � �z:ClientServiceTests.test_whenConnectedErrbacksOnStopServicec C sf t � }| jd|d�\}}|jd �d� |�� }|�� }|jd �tt� �� | � |� | � |� dS )z�
Calling L{ClientService.stopService} twice after it has
connected (that is, stopping it while it is disconnecting)
returns a L{Deferred} each time that fires when the
disconnection has completed.
Fr� r N)
r r� r� r/ rV r� r� r r� rw �r! re r� r� �firstStopDeferred�secondStopDeferredr r r �"test_stopServiceWhileDisconnecting� s
z5ClientServiceTests.test_stopServiceWhileDisconnectingc C sn t � }| jd|d�\}}|jd �d� |�� }|�� |�� }|jd �tt � �� | �
|� | �
|� dS )z�
Calling L{ClientService.stopService} after calling a
reconnection attempt returns a L{Deferred} that fires when the
disconnection has completed.
Fr� r N) r r� r� r/ rV rG r� r� r r� rw r r r r � test_stopServiceWhileRestarting� s
z2ClientServiceTests.test_stopServiceWhileRestartingc C sL t � }| jd|d�\}}|�� }|�� }| �| �|�� | �| �|�� dS )z�
Calling L{ClientService.stopService} on a stopped service
returns a L{Deferred} that has already fired with L{None}.
Fr� Nr� )r! re r r� r r r r r � test_stopServiceOnStoppedService� s z3ClientServiceTests.test_stopServiceOnStoppedServicec s8 dg� � fdd�}| j |dd�\}}| �d� d � dS )z�
The C{prepareConnection} callable is called after
L{ClientService.startService} once the connection is made.
r c � � d d7 < d S �Nr r# r ��_proto��preparesr r �prepareConnection� � z[ClientServiceTests.test_prepareConnectionCalledWhenServiceStarts.<locals>.prepareConnectionT)r rG r# N)r� rL �r! r r� r� r r r �-test_prepareConnectionCalledWhenServiceStarts� s
�z@ClientServiceTests.test_prepareConnectionCalledWhenServiceStartsc s: g � � fdd�}| j |d�\}}| �|jd � d � dS )zf
The C{prepareConnection} callable is passed the connected protocol
instance.
c s � � | � d S r �rX ��proto�� newProtocolsr r r s zVClientServiceTests.test_prepareConnectionCalledWithProtocol.<locals>.prepareConnection�r r N)r� rB r� r r r r �(test_prepareConnectionCalledWithProtocol s
�z;ClientServiceTests.test_prepareConnectionCalledWithProtocolc s~ dg� � fdd�}t � }| j|d|d�\}}|jd �td�� | �d� d � |�t� |jd �d� | �d� d � dS ) zf
The C{prepareConnection} callback is invoked only once a connection is
made.
r c r r
r r r r r r r z]ClientServiceTests.test_prepareConnectionCalledAfterConnectionMade.<locals>.prepareConnectionF)r r� re zconnection attempt failedr# N) r r� r� r$ r� rL r� r� r/ �r! r re r� r� r r r �/test_prepareConnectionCalledAfterConnectionMade s
�
zBClientServiceTests.test_prepareConnectionCalledAfterConnectionMadec sn dg� � fdd�}t � }| j||d�\}}| �d� d � |jd �tt� �� |�t� | �d� d � dS )z�
The C{prepareConnection} callback is invoked each time a connection is
made, including on reconnection.
r c r r
r r r r r r / r zUClientServiceTests.test_prepareConnectionCalledOnReconnect.<locals>.prepareConnection�r re r# rb N) r r� rL r� r� r r� r� r� r r r r �'test_prepareConnectionCalledOnReconnect( s
�
z:ClientServiceTests.test_prepareConnectionCalledOnReconnectc s@ t � � � fdd�}| j|d�\}}| �|�� �}| �� |� dS )a?
The C{prepareConnection} return value is ignored when it does not
indicate a failure. Even though the callback participates in the
internal new-connection L{Deferred} chain for error propagation
purposes, any successful result does not affect the ultimate return
value.
c rl r r r ��sentinelr r r J rq zVClientServiceTests.test_prepareConnectionReturnValueIgnored.<locals>.prepareConnectionr N)rv r� rw r� �assertNotIdentical)r! r r� r� r, r r! r �(test_prepareConnectionReturnValueIgnored? s
z;ClientServiceTests.test_prepareConnectionReturnValueIgnoredc s` g �t � � � �fdd�}| j|d�\}}|�� }| �|� � �d� | �|jd | �|�� dS )z�
The C{prepareConnection} callable returns a deferred and calls to
L{ClientService.whenConnected} wait until it fires.
c s �� | � � S r r r ��newProtocolDeferredr r r r Z s
zVClientServiceTests.test_prepareConnectionReturningADeferred.<locals>.prepareConnectionr Nr )r
r� r� ru r/ rB r� rw )r! r r� r� �whenConnectedDeferredr r% r �(test_prepareConnectionReturningADeferredR s
�z;ClientServiceTests.test_prepareConnectionReturningADeferredc C sl t � }dd� }| j||d�\}}|jdd�}| �|� |�t� | �|� |�t� | �t| �|�j � dS )zs
The connection attempt counts as a failure when the
C{prepareConnection} callable throws.
c S s t � �r )r� r r r r r p s zJClientServiceTests.test_prepareConnectionThrows.<locals>.prepareConnectionr rb r� N)
r r� r� ru r� r� rB r� r� �type)r! re r r� r� r' r r r � test_prepareConnectionThrowsi s
�
�z/ClientServiceTests.test_prepareConnectionThrowsN)$r4 r5 r6 r7 r r� rj 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� � sD
�C
:
r� )F)0r7 r �zope.interfacer �zope.interface.verifyr �twisted.applicationr � twisted.application.internetr r r �twisted.internetr �twisted.internet.deferr r
�twisted.internet.interfacesr r r
r r �twisted.internet.protocolr r �twisted.internet.taskr �twisted.loggerr r �twisted.python.failurer �twisted.test.proto_helpersr �twisted.trial.unittestr r r r r r= ra r� r� r� r� r� r r r r �<module> s>
@
#