File: //usr/lib/python3/dist-packages/twisted/application/test/__pycache__/test_internet.cpython-38.pyc
U
W[d� � @ s� d Z ddlmZmZ ddlZddlmZ ddlmZ ddl m
Z
m Z ddl m
Z
ddlmZmZ dd lmZ dd
lmZmZmZ dd lmZmZ dd lmZm Z m Z m Z m Z dd
l m!Z! ddl"m#Z# ddl$m%Z%m&Z& ddl'm(Z( dd� Z)ee�G dd� de*��Z+eee+� ee �G dd� de*��Z,eee+� G dd� de�Z-G dd� de�Z.G dd � d e*�Z/d%d d �Z0e%fd d!�Z1d"Z2G d#d$� d$e�Z3dS )&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.
� )�absolute_import�divisionN)� implementer)� verifyClass)�Factory�Protocol)�Clock)�TestCase�SynchronousTestCase)�internet)�StreamServerEndpointService� TimerService�
ClientService)�Deferred�CancelledError)�IStreamServerEndpoint�IStreamClientEndpoint�IListeningPort�IHalfCloseableProtocol�IFileDescriptorReceiver)�task)�Failure)�globalLogPublisher� formatEvent)�StringTransportc 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__G s zFakeServer.__init__c sF � j d7 _ |� _t� fdd�d�� _� jdk r@� 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>W � z#FakeServer.listen.<locals>.<lambda>)Z cancellerN)�listenAttempts�factoryr �result�failImmediatelyr& )r# r, r r" r �listenK 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] s 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! �deferredr0 r" r r r �stoppedListeningf s zFakeServer.stoppedListening)�__name__�
__module__� __qualname__�__doc__r- r, r. r r' r+ r$ r/ r1 r3 r r r r r , s r c @ s e Zd ZdZdZdd� 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.stopListening)r4 r5 r6 r7 r2 r8 r r r r r s 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; �_raiseSynchronouslyZ assertRaises� startService)r# Zthunkr 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)rC r; r= r" r r r � test_synchronousRaisePrivileged� s �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; rB r: r- r& r@ �flushLoggedErrors� assertEqual�len�r# Zloggedr 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; rA rB r: r- r& r@ rE rF rG rH 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)r@ r: r. r; rB rE rF rG rH 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; rB r> r, r: rF �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)r? r; rB rF r: r+ rL 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; r= r: r1 rB � stopService� addCallback�appendrF rG r3 Z assertFalserL �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; r= rO ZaddBothrQ rF rE r rR 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% ) r@ r: r' r; r= rO rP rQ rF rE rG )r# r- rS ZstoppingErrorsr r r � test_stopServiceCancelStartError s
z5EndpointServiceTests.test_stopServiceCancelStartError)N)r4 r5 r6 r7 r< r? rC rD rI rJ rK rM rN rT rU rV r r r r r9 � s
r9 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 rY F 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)
rZ rB �
assertTruerL �assertIsInstance�_loopr Z LoopingCallr> r[ r" r r r �test_startServiceP 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)rQ rZ rY rB rF )r# r- r r r �$test_startServiceRunsCallImmediately\ 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 � S r r )Z maybeReactor�Z
otherClockr r �
getOtherClockn s zKTimerServiceTests.test_startServiceUsesGlobalReactor.<locals>.getOtherClockZ_maybeGlobalReactorN) r r Zpatchr rZ rB r> r^ r[ )r# rb r ra r �"test_startServiceUsesGlobalReactorg 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) rZ rB rO �assertNoResultrF rL r2 r0 �objectr> �successResultOf�r# r( r r r �test_stopServiceWaitsu 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)rZ rB r2 r0 re rO r> rf rg 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) rZ rB r2 r& r r@ rE rF rG rO r> rf )r# �errorsr( r r r �test_failedCallLogsError� s
z*TimerServiceTests.test_failedCallLogsErrorc C sP t dt�}|�� t�|�}|�� t�|�}t� }t|d|�}| � ||� dS )zq
When pickling L{internet.TimerService}, it won't pickle
L{internet.TimerService._loop}.
r% r^ N�
r
r rB �pickle�dumpsrO �loadsre �getattrr> �r# rZ Z dumpedTimerZ loadedTimerZnothing�valuer r r �$test_pickleTimerServiceNotPickleLoop� s
z6TimerServiceTests.test_pickleTimerServiceNotPickleLoopc C sP t dt�}|�� t�|�}|�� t�|�}t� }t|d|�}| � ||� dS )zy
When pickling L{internet.TimerService}, it won't pickle
L{internet.TimerService._loopFinished}.
r% Z
_loopFinishedNrl rq r r r �,test_pickleTimerServiceNotPickleLoopFinished� s
z>TimerServiceTests.test_pickleTimerServiceNotPickleLoopFinishedN)r4 r5 r6 r7 r< rY r_ r` rc rh ri rk rs rt r r r r rW / s
rW 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 ru � s ru Fc s. t t�G � �fdd�dt��}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 )�
buildProtocolrw rQ r ZmakeConnection)�ignored�protocol� transport)r, �infor r �createProtocol� s
zNendpointForTesting.<locals>.ClientTestEndpoint.connect.<locals>.createProtocol)r rx rQ rP rv r0 )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 re ru )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 )ZremoveObserverrQ r �� logPublisher�logsr r r) � r* zcatchLogs.<locals>.<lambda>c s dd� � D �S )Nc S s g | ] }t |��qS r )r )�.0Zeventr r r �
<listcomp> s z/catchLogs.<locals>.<lambda>.<locals>.<listcomp>r r )r� r r r) r* )Z addObserverrQ �
addCleanup)ZtestCaser� 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�dtt�� � � |_}t||f|�����fdd�} ��| � |r��� � |�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.
�r[ r[ �r� c s$ e Zd Z�Z�� �fdd�Z� ZS )z>ClientServiceTests.makeReconnector.<locals>.RememberingFactoryc s t � | ��|�}��|� |S r )�superry rQ )r# Zaddrr- )�RememberingFactory� __class__�applicationProtocolsr r ry 6 s
zLClientServiceTests.makeReconnector.<locals>.RememberingFactory.buildProtocol)r4 r5 r6 r{ ry �
__classcell__r )r� r� � protocolType)r� r r� 4 s r� c s( d �_ �jr��� ��� �� g � d S r )Z _protocolrL rO rF �getDelayedCallsr )r[ r# �servicer r �stop> s z0ClientServiceTests.makeReconnector.<locals>.stop)
�updater r� r� r re �applicationFactoryr r� rB )
r# r� rB r� �kwZnkw�cqZendpointr, r� r )r� r� r[ 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� rF rG rv )r# r� r� r r r r_ K 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� rF ZnumPortsrx ZdoStart)r# r� r� ZfirstAppFactoryZfirstPassedFactoryr r r �test_startStopFactoryS 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� rO rd rw rF r| �
disconnecting�connectionLostr � Exceptionrf �r# r� r� r( r{ r r r � test_stopServiceWhileConnectedb 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% rX N) r� rO rd rw rF r| r� rB rG r� r r� r� r r r �#test_startServiceWaitsForDisconnectq 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% rX )r� rv r0 rw rO rd �
whenConnectedrB rF r| r� r� r r� rf rG r> r� )r# r� r� �first�stoppedZ nextProtocolZ
secondStoppedr r r � test_startServiceWhileStopping� 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� rO rf �failureResultOfr� r rB rv r0 r> r� )r# r� r� r� r r r � test_startServiceWhileStopped� s
�z0ClientServiceTests.test_startServiceWhileStoppedc C sZ t tt�G dd� dtt��}| 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 re r� rw r\ Z
providedBy)r# r� r� r� Z
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� r[ r rX r% N) r r� rv r& r� �advance�AT_LEAST_ONE_ATTEMPTrF rG rO rf �r# r[ 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� rF rG rv rd rO rf 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� rF r� r> rf r� )r# r[ r� r� ZawaitingProtocolr 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 )Ztrapr )rz r r r r) � r* z@ClientServiceTests.test_clientConnectionFailed.<locals>.<lambda>rX N)
r r� rF rG rv r& r r� r� rd Z
addErrbackr� r� )r# r[ 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)r[ r� r% r NrX )r r� rF rG rv r0 r> rf r� r� rw r� r r� r� r� )r# r[ 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� rO rw r� r �IndentationErrorr� r� r r\ Zcalledr� 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� rB r r% z$Duplicate ClientService.startServiceN)r� rF rG rv rB r� ZassertIn)r# r� r� Zmessagesr 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% �ZfailAfterFailuresr N) r r� r� rd rv r0 rf r> r� )
r# r[ r� r� �a�b�cZresultAZresultBZresultCr r r �test_whenConnectedLater0 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� rX � r N)r r� r� rd r r� rv r& r> r� r� r� rF rG r0 rf r� )r# r[ r� r� Za0Za1Za2Za3�f1�f2ZAT_LEAST_TWO_ATTEMPTSZresultA0ZresultA3Za4ZresultA4r r r �test_whenConnectedFailsF 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� rd rO r� r� r� r )r# r[ r� r� r� r� r� r r r � test_whenConnectedStopService� 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� rv r& r� rO rF r� rf 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� rB r[ N�r r� rO Z assertIsNonerf )r# r[ �_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� rv r& r� rO r] r� rr r )r# r[ r� r� ZbeforeErrbackAndStopZafterErrbackAndStopr 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� rv r0 rO rw r� r r� rf �r# r[ 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� rv r0 rO rB rw r� r r� rf 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# r[ 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 s � d d7 < d S �Nr r% r �Z_proto�Zpreparesr r �prepareConnection s z[ClientServiceTests.test_prepareConnectionCalledWhenServiceStarts.<locals>.prepareConnectionT)r� rB r% N)r� rF �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 �rQ ��proto�� newProtocolsr r r� " s zVClientServiceTests.test_prepareConnectionCalledWithProtocol.<locals>.prepareConnection�r� r N)r� r> rw 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 s � d d7 < d S r� r r� r� r r r� 2 s z]ClientServiceTests.test_prepareConnectionCalledAfterConnectionMade.<locals>.prepareConnectionF)r� r� r[ zconnection attempt failedr% N) r r� rv r& r� rF r� r� r0 �r# r� r[ 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 s � d d7 < d S r� r r� r� r r r� J s zUClientServiceTests.test_prepareConnectionCalledOnReconnect.<locals>.prepareConnection�r� r[ r% rX N) r r� rF rw r� r r� r� r� r� r r� r �'test_prepareConnectionCalledOnReconnectC 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 s � S r r r� ��sentinelr r r� e s zVClientServiceTests.test_prepareConnectionReturnValueIgnored.<locals>.prepareConnectionr� N)re r� rf r� ZassertNotIdentical)r# r� r� r� r- r r� r �(test_prepareConnectionReturnValueIgnoredZ 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� �ZnewProtocolDeferredr� r r r� v s
zVClientServiceTests.test_prepareConnectionReturningADeferred.<locals>.prepareConnectionr� Nr )r r� r� rd r0 r> r� rf )r# r� r� r� �whenConnectedDeferredr r� r �(test_prepareConnectionReturningADeferredn 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 � �d S r )r� r� r r r r� � s zJClientServiceTests.test_prepareConnectionThrows.<locals>.prepareConnectionr� rX r� N)
r r� r� rd r� r� r> r� r� �type)r# r[ r� r� r� r� r r r � test_prepareConnectionThrows� s �
�z/ClientServiceTests.test_prepareConnectionThrowsN)$r4 r5 r6 r7 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� sD �
@
;r� )F)4r7 Z
__future__r r rm Zzope.interfacer Zzope.interface.verifyr Ztwisted.internet.protocolr r Ztwisted.internet.taskr Ztwisted.trial.unittestr r
Ztwisted.applicationr Z twisted.application.internetr r
r Ztwisted.internet.deferr r Ztwisted.internet.interfacesr r r r r Ztwisted.internetr Ztwisted.python.failurer Ztwisted.loggerr r Ztwisted.test.proto_helpersr r re r r r9 rW ru r� r� r� r� r r r r �<module> s> B
'