U “j@stdZddlZddlmZddlmZddlmZddlm Z m Z m Z ddl m Z ddlmZmZdd lmZmZmZmZmZdd lmZmZdd lmZdd lmZdd lmZm Z ddl!m"Z"ddl#m$Z$m%Z%ddZ&eeGdddZ'eee'eeGdddZ(eee'Gddde%Z)Gddde%Z*GdddZ+d$ddZ,e fdd Z-d!Z.Gd"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) ClientServiceStreamServerEndpointService TimerService)task)CancelledErrorDeferred)IFileDescriptorReceiverIHalfCloseableProtocolIListeningPortIStreamClientEndpointIStreamServerEndpoint)FactoryProtocol)Clock)StringTransport) formatEventglobalLogPublisher)Failure)SynchronousTestCaseTestCasecCsdS)zM A fake target function for testing TimerService which does nothing. NrrrJ/tmp/pip-unpacked-wheel-59kc99xd/twisted/application/test/test_internet.pyfakeTargetFunction)src@sFeZdZdZdZdZdZeZdZ ddZ ddZ 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. NrcCs t|_dSN)FakePortportselfrrr__init__LszFakeServer.__init__csFjd7_|_tfddd_jdk r@jjjS)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} cs |jSr)errbackcancelException)dr rrZz#FakeServer.listen..)Z cancellerN)listenAttemptsfactoryr resultfailImmediatelyr$)r!r*rr rlistenOs  zFakeServer.listencCs|j|jdS)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+callbackrr rrrstartedListening_szFakeServer.startedListeningcCs|jjddS)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)rdeferredr.r rrrstoppedListeninggszFakeServer.stoppedListening)__name__ __module__ __qualname____doc__r+r*r,r r%r)r"r-r/r1rrrrr0src@s,eZdZdZdZddZddZddZdS) rzs Fake L{IListeningPort} implementation. @ivar deferred: The L{Deferred} returned by C{stopListening}. NcCst|_|jS)z` Stop listening. @return: a L{Deferred} stored in L{FakePort.deferred} )r r0r rrr stopListening~szFakePort.stopListeningcCsdSrrr rrrgetHostszFakePort.getHostcCsdSrrr rrrstartListeningszFakePort.startListening)r2r3r4r5r0r6r7r8rrrrrts  rc@sreZdZdZddZddZdddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZddZdS)EndpointServiceTestsz4 Tests for L{twisted.application.internet}. cCs$t|_t|_t|j|j|_dS)zp Construct a stub server, a stub factory, and a L{StreamServerEndpointService} to test. N)r fakeServerrr*rsvcr rrrsetUpszEndpointServiceTests.setUpcCs |j||j|jjdS)z L{StreamServerEndpointService.privilegedStartService} calls its endpoint's C{listen} method with its factory. N)r;privilegedStartServiceassertIdenticalr*r:r rrrtest_privilegedStartServices z0EndpointServiceTests.test_privilegedStartServiceNcCs*t|j_d|j_|t|p"|jjdS)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!Zthunkrrr(test_synchronousRaiseRaisesSynchronouslys z=EndpointServiceTests.test_synchronousRaiseRaisesSynchronouslycCs||jjdS)z L{StreamServerEndpointService.privilegedStartService} should behave the same as C{startService} with respect to L{EndpointServiceTests.test_synchronousRaiseRaisesSynchronously}. N)rDr;r=r rrrtest_synchronousRaisePrivilegedsz4EndpointServiceTests.test_synchronousRaisePrivilegedcCs8|j|jjt|t}|t|ddS)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;rCr:r+r$r@flushLoggedErrors assertEquallenr!Zloggedrrrtest_failReportsErrors  z*EndpointServiceTests.test_failReportsErrorcCs@d|j_|j|jjt|t}|t |ddS)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;rArCr:r+r$r@rFrGrHrIrrr!test_asynchronousFailReportsErrors   z6EndpointServiceTests.test_asynchronousFailReportsErrorcCs2t|j_|j|t}|t|ddS)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;rCrFrGrHrIrrr test_synchronousFailReportsErrors   z5EndpointServiceTests.test_synchronousFailReportsErrorcCs0|j||j|jj||jjddS)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;rCr>r*r:rGrunningr rrrtest_startServiceUnstarteds z/EndpointServiceTests.test_startServiceUnstartedcCs6||j||jjd||jjddS)z L{StreamServerEndpointService.startService} sets the C{running} flag, but nothing else, if the service has already been started. r#TN)r?r;rCrGr:r)rMr rrrtest_startServiceStarteds z-EndpointServiceTests.test_startServiceStartedcCst|j|j|j|j}g}||j|t |d|j |t |d| |jj 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}. rr#N) r;r=r:r/rC stopService addCallbackappendrGrHr1Z assertFalserMr!r+lrrrtest_stopServices      z%EndpointServiceTests.test_stopServicecCsH|j|j}g}||j||dg||tgdS)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=rPZaddBothrRrGrFr rSrrr#test_stopServiceBeforeStartFinisheds    z8EndpointServiceTests.test_stopServiceBeforeStartFinishedcCsZt|j_|j|j}g}||j||dg| t}|t |ddS)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=rPrQrRrGrFrH)r!r+rTZstoppingErrorsrrr test_stopServiceCancelStartErrors     z5EndpointServiceTests.test_stopServiceCancelStartError)N)r2r3r4r5r<r?rDrErJrKrLrNrOrUrVrWrrrrr9s       r9c@s`eZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ 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}. cCs,td|j|_t|_|j_t|_dS)z1 Set up a timer service to test. N)rcalltimerrrclockr r0r rrrr<:szTimerServiceTests.setUpcCs|jS)z Function called by L{TimerService} being tested. @returns: C{self.deferred} @rtype: L{Deferred} )r0r rrrrZBszTimerServiceTests.callcCsV|j||jjd||jjtj||j |jjj ||jjjddS)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) r[rC assertTruerMassertIsInstance_looprZ LoopingCallr>r\r rrrtest_startServiceKs  z#TimerServiceTests.test_startServicecCs0g}|jdif|j_|j|dg|dS)zi When L{TimerService.startService} is called, it calls the function immediately. rN)rRr[rZrCrG)r!r+rrr$test_startServiceRunsCallImmediatelyVs z6TimerServiceTests.test_startServiceRunsCallImmediatelycsBtfdd}|td||j||jjjdS)z L{TimerService.startService} uses L{internet._maybeGlobalReactor} to choose the reactor to pass to L{task.LoopingCall} uses the global reactor. csSrr)Z maybeReactorZ otherClockrr getOtherClockhszKTimerServiceTests.test_startServiceUsesGlobalReactor..getOtherClockZ_maybeGlobalReactorN) rrpatchrr[rCr>r_r\)r!rcrrbr"test_startServiceUsesGlobalReactor`s   z4TimerServiceTests.test_startServiceUsesGlobalReactorcCsR|j|j}|||d|jj|jt| | |ddS)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) r[rCrPassertNoResultrGrMr0r.objectr>successResultOfr!r&rrrtest_stopServiceWaitsos    z'TimerServiceTests.test_stopServiceWaitscCs8|j|jt|j}|||ddS)z When L{TimerService.stopService} is called while a call isn't in progress. the L{Deferred} returned has already been fired. N)r[rCr0r.rgrPr>rhrirrrtest_stopServiceImmediately{s  z-TimerServiceTests.test_stopServiceImmediatelycCsV|j|jtt|t}|dt||j }| | |ddS)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) r[rCr0r$rr@rFrGrHrPr>rh)r!errorsr&rrrtest_failedCallLogsErrors    z*TimerServiceTests.test_failedCallLogsErrorcCsPtdt}|t|}|t|}t}t|d|}| ||dS)zq When pickling L{internet.TimerService}, it won't pickle L{internet.TimerService._loop}. r#r_N rrrCpickledumpsrPloadsrggetattrr>r!r[Z dumpedTimerZ loadedTimerZnothingvaluerrr$test_pickleTimerServiceNotPickleLoops    z6TimerServiceTests.test_pickleTimerServiceNotPickleLoopcCsPtdt}|t|}|t|}t}t|d|}| ||dS)zy When pickling L{internet.TimerService}, it won't pickle L{internet.TimerService._loopFinished}. r#Z _loopFinishedNrnrsrrr,test_pickleTimerServiceNotPickleLoopFinisheds    z>TimerServiceTests.test_pickleTimerServiceNotPickleLoopFinishedN)r2r3r4r5r<rZr`rarerjrkrmrurvrrrrrX,s       rXc@seZdZdZddZdS)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. cCsg|_g|_g|_dSr) connectQueueconstructedProtocolspassedFactoriesr rrrr"szConnectInformation.__init__N)r2r3r4r5r"rrrrrws rwFcs,ttGfddd}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}. cseZdZfddZdS)z.endpointForTesting..ClientTestEndpointcsDt}j|jfdd}j|r@|d|S)Ncs*d}j|t}|||Sr) buildProtocolryrRrZmakeConnection)ignoredprotocol transport)r*inforrcreateProtocols    zNendpointForTesting..ClientTestEndpoint.connect..createProtocol)r rzrRrQrxr.)r!r*r+rfireImmediatelyr)r*rconnects   z6endpointForTesting..ClientTestEndpoint.connectN)r2r3r4rrrrrClientTestEndpointsr)rrrw)rrrrrendpointForTestings rcs0gj|fddfddS)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} cs jSr)ZremoveObserverrRr logPublisherlogsrrr'r(zcatchLogs..csddDS)NcSsg|] }t|qSr)r).0eventrrr sz/catchLogs....rr)rrrr'r()Z addObserverrR addCleanup)ZtestCaserrrr catchLogss  rgY@c@s eZdZdZddedfddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8d9Zd:d;Zdd?Z!d@dAZ"dBdCZ#dDdEZ$dS)FClientServiceTestsz% Tests for L{ClientService}. TFc  si}|jtd|||dt|d\}}g|_Gfdddt} | |_} 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\rcs$eZdZZfddZZS)z>ClientServiceTests.makeReconnector..RememberingFactorycs"rdSt|}||Sr)superr{rR)r!addrr+) __class__applicationProtocolsrefuseConnectionsrrr{5s   zLClientServiceTests.makeReconnector..RememberingFactory.buildProtocol)r2r3r4r}r{ __classcell__r)r protocolTyper)rrRememberingFactory2srcs(d_jrgdSr) _protocolrMrPrGgetDelayedCallsr)r\r!servicerrstop@sz0ClientServiceTests.makeReconnector..stop) updaterrrrapplicationFactoryrrrC) r!rrCrrkwZnkwcqZendpointrr*rr)rr\rrr!rrmakeReconnectors!    z"ClientServiceTests.makeReconnectorcCs&|jdd\}}|t|jddS)zL When the service is started, a connection attempt is made. Frr#N)rrGrHrx)r!rrrrrr`Msz$ClientServiceTests.test_startServicecCsD|\}}|j}||jd|jd}|||jddS)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. rr#N)rrrGZnumPortsrzZdoStart)r!rrZfirstAppFactoryZfirstPassedFactoryrrrtest_startStopFactoryTs   z(ClientServiceTests.test_startStopFactorycCsV|\}}|}|||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. rTN) rrPrfryrGr~ disconnectingconnectionLostr Exceptionrhr!rrr&r}rrrtest_stopServiceWhileConnectedbs   z1ClientServiceTests.test_stopServiceWhileConnectedcCs|\}}|}|||jd}||jjd||||t|jd| t t d|t|jddS)z When L{ClientService} is restarted after having been connected, it waits to start connecting until after having disconnected. rTr#zsynthetic connectionLostrYN) rrPrfryrGr~rrCrHrrrrrrr#test_startServiceWaitsForDisconnectps    z6ClientServiceTests.test_startServiceWaitsForDisconnectcCs|jdd\}}|jdd|jd}|}|||}|||||||||j j d| t t d|||jdd|t|jd||||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. FrrNTzsynthetic connection lostr#rY)rrxr.ryrPrf whenConnectedrCrGr~rrrrrhrHr>r)r!rrfirststoppedZ nextProtocolZ secondStoppedrrrtest_startServiceWhileStoppings*      z1ClientServiceTests.test_startServiceWhileStoppingcCsj|jdd\}}|}||||t||jdd| |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. FrN) rrPrhfailureResultOfrr rCrxr.r>r)r!rrrrrrtest_startServiceWhileStoppeds  z0ClientServiceTests.test_startServiceWhileStoppedcCsXtttGdddt}|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@seZdZdZdS)zEClientServiceTests.test_interfacesForTransport..FancyProtocolz9 Provider of various interfaces. N)r2r3r4r5rrrr FancyProtocolsr)rrN)rr r rrryr]Z providedBy)r!rrrZ reactorFacingrrrtest_interfacesForTransports  z.ClientServiceTests.test_interfacesForTransportcCsnt}|jd|d\}}|jdt|t|t|jd| }|jdt| |dS)zU When the service is stopped while retrying, the retry is cancelled. Frr\rrYr#N) rrrxr$radvanceAT_LEAST_ONE_ATTEMPTrGrHrPrhr!r\rrr&rrrtest_stopServiceWhileRetryings z0ClientServiceTests.test_stopServiceWhileRetryingcCsPt}|jd|d\}}|t|jd||jd|}||dS)zv When the service is stopped while initially connecting, the connection attempt is cancelled. Frr#rN)rrrGrHrxrfrPrhrrrrtest_stopServiceWhileConnectings z2ClientServiceTests.test_stopServiceWhileConnectingcCst}|j|d\}}|}||g||||jd||jdj |jd| t |jdt |jd| dt |j ddS)zy When a client connects, the service keeps a reference to the new protocol and resets the delay. rrrN) rrrrGrr>rhrryrassertInstrrz)r!r\rrZawaitingProtocolrrrtest_clientConnecteds(    z'ClientServiceTests.test_clientConnectedcCst}|jd|d\}}|t|jd|jdtt|}| || dd| t |t|jddS) z When a client connection fails, the service removes its reference to the protocol and tries again after a timeout. Frr#rcSs |tSr)Ztrapr )r|rrrr'r(z@ClientServiceTests.test_clientConnectionFailed..rYN) rrrGrHrxr$rrrrfZ addErrbackrr)r!r\rrrrrrtest_clientConnectionFaileds  z.ClientServiceTests.test_clientConnectionFailedcCst}|j|dd\}}|t|jd|jdd|t|jd||||j d|j d t t |t|t|jd|jdd||||j ddS)z~ When a client connection is lost, the service removes its reference to the protocol and calls retry. F)r\rr#rNrY)rrrGrHrxr.r>rhrrryrrrrrr!r\rrrrrtest_clientConnectionLosts"   z,ClientServiceTests.test_clientConnectionLostN)returncst}fddj|ddd\}}t|jd|jddt|jd| | t t|jd|jdd dS) z When the client factory refuses connections by returning None from buildProtocol, the factory keeps attempting new connections. cs tSr)rr rr!rrrr'"r(zAClientServiceTests.test_clientConnectionRefused..FT)r\rrr#rN) rrrrGrHrxpopr.rrfrrrrrrtest_clientConnectionRefuseds    z/ClientServiceTests.test_clientConnectionRefusedcCsTt}|j|d\}}|}|jdtt||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. rrN) rrrPryrrIndentationErrorrrr r]calledrrrr&test_clientConnectionLostWhileStopping>s z9ClientServiceTests.test_clientConnectionLostWhileStoppingcCsv|jddd\}}|t|jd||t|jdt|}||t|jd|d|ddS)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)rrCrr#z$Duplicate ClientService.startServiceN)rrGrHrxrCrr)r!rrmessagesrrrtest_startTwiceKsz"ClientServiceTests.test_startTwicec Cst}|jd|d\}}|}|}|jdd}|||||||jdd||}||}||} |||||| |||jddS)z{ L{ClientService.whenConnected} returns a L{Deferred} that fires when a connection is established. Frr#ZfailAfterFailuresrN) rrrrfrxr.rhr>r) r!r\rrabcZresultAZresultBZresultCrrrtest_whenConnectedLaterZs         z*ClientServiceTests.test_whenConnectedLatercCst}|jd|d\}}|}|jdd}|jdd}|jdd}||||||||tt}|jd||||| |t|||||| t | t |jd||||||tt} |jd| |||| |t| ||t } | | | t |jd|||||jdd||} ||} || | || |jd|jdd} || }|| |dS) z L{ClientService.whenConnected} returns a L{Deferred} that fails, if asked, when some number of connections have failed. Frr#rrYrN)rrrrfrrrxr$r>rrrrGrHr.rhr)r!r\rrZa0Za1Za2a3f1f2ZAT_LEAST_TWO_ATTEMPTSZresultA0ZresultA3Za4ZresultA4rrrtest_whenConnectedFailsosN                          z*ClientServiceTests.test_whenConnectedFailscCst}|jd|d\}}|}|}|jdd}||||||||t||t||t||tdS)z L{ClientService.whenConnected} returns a L{Deferred} that fails when L{ClientService.stopService} is called. Frr#rN) rrrrfrPrrrr )r!r\rrrrrrrrtest_whenConnectedStopServices       z0ClientServiceTests.test_whenConnectedStopServicecCsTt}|jd|d\}}|jdtd|}||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. Frr no connectionN) rrrxrr$rrPrGrrhrrrrtest_retryCancelleds z&ClientServiceTests.test_retryCancelledcCs6t}|jdd|d\}}|}|||dS)z Calling L{ClientService.stopService} before L{ClientService.startService} returns a L{Deferred} that has already fired with L{None}. F)rrCr\NrrrPZ assertIsNonerh)r!r\_rr&rrr"test_stopServiceBeforeStartServices z5ClientServiceTests.test_stopServiceBeforeStartServicecCspt}|jd|d\}}|}|jdtd||}|||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. FrrrN) rrrrxr$rrPr^rrtr )r!r\rrZbeforeErrbackAndStopZafterErrbackAndStoprrr'test_whenConnectedErrbacksOnStopServices  z:ClientServiceTests.test_whenConnectedErrbacksOnStopServicecCsft}|jd|d\}}|jdd|}|}|jdtt| || |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. FrrN) rrrxr.rPryrrrrhr!r\rrfirstStopDeferredsecondStopDeferredrrr"test_stopServiceWhileDisconnectings z5ClientServiceTests.test_stopServiceWhileDisconnectingcCsnt}|jd|d\}}|jdd|}||}|jdtt | || |dS)z Calling L{ClientService.stopService} after calling a reconnection attempt returns a L{Deferred} that fires when the disconnection has completed. FrrN) rrrxr.rPrCryrrrrhrrrrtest_stopServiceWhileRestartings z2ClientServiceTests.test_stopServiceWhileRestartingcCsLt}|jd|d\}}|}|}||||||dS)z Calling L{ClientService.stopService} on a stopped service returns a L{Deferred} that has already fired with L{None}. FrNr)r!r\rrrrrrr test_stopServiceOnStoppedServices z3ClientServiceTests.test_stopServiceOnStoppedServicecs8dgfdd}|j|dd\}}|dddS)z The C{prepareConnection} callable is called after L{ClientService.startService} once the connection is made. rcsdd7<dSNrr#rZ_protoZpreparesrrprepareConnection2sz[ClientServiceTests.test_prepareConnectionCalledWhenServiceStarts..prepareConnectionT)rrCr#N)rrGr!rrrrrr-test_prepareConnectionCalledWhenServiceStarts+s  z@ClientServiceTests.test_prepareConnectionCalledWhenServiceStartscs:gfdd}|j|d\}}||jdddS)zf The C{prepareConnection} callable is passed the connected protocol instance. cs|dSrrRproto newProtocolsrrrAszVClientServiceTests.test_prepareConnectionCalledWithProtocol..prepareConnectionrrN)rr>ryrrrr(test_prepareConnectionCalledWithProtocol:s   z;ClientServiceTests.test_prepareConnectionCalledWithProtocolcs~dgfdd}t}|j|d|d\}}|jdtd|dd|t|jdd|dddS) zf The C{prepareConnection} callback is invoked only once a connection is made. rcsdd7<dSrrrrrrrPsz]ClientServiceTests.test_prepareConnectionCalledAfterConnectionMade..prepareConnectionF)rrr\zconnection attempt failedr#N) rrrxr$rrGrrr.r!rr\rrrrr/test_prepareConnectionCalledAfterConnectionMadeIs   zBClientServiceTests.test_prepareConnectionCalledAfterConnectionMadecsndgfdd}t}|j||d\}}|dd|jdtt|t|dddS)z The C{prepareConnection} callback is invoked each time a connection is made, including on reconnection. rcsdd7<dSrrrrrrrgszUClientServiceTests.test_prepareConnectionCalledOnReconnect..prepareConnectionrr\r#rYN) rrrGryrrrrrrrrr'test_prepareConnectionCalledOnReconnect`s   z:ClientServiceTests.test_prepareConnectionCalledOnReconnectcs@tfdd}|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. csSrrrsentinelrrrszVClientServiceTests.test_prepareConnectionReturnValueIgnored..prepareConnectionrN)rgrrhrZassertNotIdentical)r!rrrr+rrr(test_prepareConnectionReturnValueIgnoredws  z;ClientServiceTests.test_prepareConnectionReturnValueIgnoredcs`gtfdd}|j|d\}}|}||d||jd||dS)z The C{prepareConnection} callable returns a deferred and calls to L{ClientService.whenConnected} wait until it fires. cs|SrrrZnewProtocolDeferredrrrrs zVClientServiceTests.test_prepareConnectionReturningADeferred..prepareConnectionrNr)r rrrfr.r>rrh)r!rrrwhenConnectedDeferredrrr(test_prepareConnectionReturningADeferreds  z;ClientServiceTests.test_prepareConnectionReturningADeferredcCslt}dd}|j||d\}}|jdd}|||t|||t|t||j dS)zs The connection attempt counts as a failure when the C{prepareConnection} callable throws. cSs tdSr)rrrrrrszJClientServiceTests.test_prepareConnectionThrows..prepareConnectionrrYrN) rrrrfrrr>rrtype)r!r\rrrrrrrtest_prepareConnectionThrowss       z/ClientServiceTests.test_prepareConnectionThrows)%r2r3r4r5rrr`rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsJ J  & :   r)F)0r5roZzope.interfacerZzope.interface.verifyrZtwisted.applicationrZtwisted.application.internetrrrZtwisted.internetrZtwisted.internet.deferr r Ztwisted.internet.interfacesr r r rrZtwisted.internet.protocolrrZtwisted.internet.taskrZtwisted.internet.testingrZtwisted.loggerrrZtwisted.python.failurerZtwisted.trial.unittestrrrrrr9rXrwrrrrrrrrs<       @   #