← Back
Editing: 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 '
Save File
Cancel