o ¯bO£ã@stdZddlZddlmZddlmZddlmZddlm Z m Z m Z ddl m Z ddlmZmZdd lmZmZmZmZmZdd lmZmZdd lmZdd lmZmZdd lm Z ddl!m"Z"ddl#m$Z$m%Z%dd„Z&eeƒGdd„dƒƒZ'eee'ƒeeƒGdd„dƒƒZ(eee'ƒGdd„de%ƒZ)Gdd„de%ƒZ*Gdd„dƒZ+d$dd„Z,efdd „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)Ú ClientServiceÚStreamServerEndpointServiceÚ TimerService)Útask)ÚCancelledErrorÚDeferred)ÚIFileDescriptorReceiverÚIHalfCloseableProtocolÚIListeningPortÚIStreamClientEndpointÚIStreamServerEndpoint)ÚFactoryÚProtocol)ÚClock)Ú formatEventÚglobalLogPublisher)ÚFailure)ÚStringTransport)ÚSynchronousTestCaseÚTestCasecCsdS)zM A fake target function for testing TimerService which does nothing. N©rrrúH/usr/lib/python3/dist-packages/twisted/application/test/test_internet.pyÚfakeTargetFunction)src@sFeZdZdZdZdZdZeƒ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. NrcCs tƒ|_dS©N)ÚFakePortÚport©ÚselfrrrÚ__init__Ls zFakeServer.__init__csFˆjd7_|ˆ_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} écs | ˆj¡Sr)ÚerrbackÚcancelException)Údr rrÚZó z#FakeServer.listen..)Ú cancellerN)ÚlistenAttemptsÚfactoryr ÚresultÚfailImmediatelyr$)r!r+rr rÚlistenOs   zFakeServer.listencCs|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,Úcallbackrr rrrÚstartedListening_ózFakeServer.startedListeningcCs|jj 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 rrrÚstoppedListeninggszFakeServer.stoppedListening)Ú__name__Ú __module__Ú __qualname__Ú__doc__r,r+r-r r%r*r"r.r0r3rrrrr0s rc@s,eZdZdZdZdd„Zdd„Zdd„ZdS) 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 r2r rrrÚ stopListening~szFakePort.stopListeningcCódSrrr rrrÚgetHost‡ózFakePort.getHostcCr9rrr rrrÚstartListening‹r;zFakePort.startListening)r4r5r6r7r2r8r:r<rrrrrts  rc@sreZdZdZdd„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}. cCs$tƒ|_tƒ|_t|j|jƒ|_dS)zp Construct a stub server, a stub factory, and a L{StreamServerEndpointService} to test. N)rÚ fakeServerrr+rÚsvcr rrrÚsetUp˜szEndpointServiceTests.setUpcCs |j ¡| |j|jj¡dS)z‡ L{StreamServerEndpointService.privilegedStartService} calls its endpoint's C{listen} method with its factory. N)r?ÚprivilegedStartServiceÚassertIdenticalr+r>r rrrÚtest_privilegedStartService¡s z0EndpointServiceTests.test_privilegedStartServiceNcCs*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!ÚthunkrrrÚ(test_synchronousRaiseRaisesSynchronously©s z=EndpointServiceTests.test_synchronousRaiseRaisesSynchronouslycCs| |jj¡dS)zÓ L{StreamServerEndpointService.privilegedStartService} should behave the same as C{startService} with respect to L{EndpointServiceTests.test_synchronousRaiseRaisesSynchronously}. N)rIr?rAr rrrÚtest_synchronousRaisePrivileged½r1z4EndpointServiceTests.test_synchronousRaisePrivilegedcCs8|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?rGr>r,r$rDÚflushLoggedErrorsÚ assertEqualÚlen©r!ÚloggedrrrÚtest_failReportsErrorÅs  z*EndpointServiceTests.test_failReportsErrorcCs@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?rErGr>r,r$rDrKrLrMrNrrrÚ!test_asynchronousFailReportsErrorÑs   z6EndpointServiceTests.test_asynchronousFailReportsErrorcCs2tƒ|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)rDr>r-r?rGrKrLrMrNrrrÚ test_synchronousFailReportsErrorßs   z5EndpointServiceTests.test_synchronousFailReportsErrorcCs0|j ¡| |j|jj¡| |jjd¡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?rGrBr+r>rLÚrunningr rrrÚtest_startServiceUnstartedés z/EndpointServiceTests.test_startServiceUnstartedcCs6| ¡|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)rCr?rGrLr>r*rSr rrrÚtest_startServiceStartedós 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?rAr>r0rGÚ stopServiceÚ addCallbackÚappendrLrMr3Ú assertFalserS©r!r,ÚlrrrÚtest_stopServiceýs      z%EndpointServiceTests.test_stopServicecCsH|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?rArVÚaddBothrXrLrKr rZrrrÚ#test_stopServiceBeforeStartFinisheds   z8EndpointServiceTests.test_stopServiceBeforeStartFinishedcCsZtƒ|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#) rDr>r%r?rArVrWrXrLrKrM)r!r,r[ÚstoppingErrorsrrrÚ test_stopServiceCancelStartErrors     z5EndpointServiceTests.test_stopServiceCancelStartErrorr)r4r5r6r7r@rCrIrJrPrQrRrTrUr\r^r`rrrrr=“s      r=c@s`eZdZdZdd„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}. cCs,td|jƒ|_t ¡|_|j_tƒ|_dS)z1 Set up a timer service to test. éN)rÚcallÚtimerrrÚclockr r2r rrrr@:s zTimerServiceTests.setUpcCs|jS)z‚ Function called by L{TimerService} being tested. @returns: C{self.deferred} @rtype: L{Deferred} )r2r rrrrcBszTimerServiceTests.callcCsV|j ¡| |jjd¡| |jjtj¡| |j |jjj ¡| |jjjd¡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) rdrGÚ assertTruerSÚassertIsInstanceÚ_looprÚ LoopingCallrBrer rrrÚtest_startServiceKs z#TimerServiceTests.test_startServicecCs0g}|jdif|j_|j ¡| dg|¡dS)zi When L{TimerService.startService} is called, it calls the function immediately. rN)rXrdrcrGrL)r!r,rrrÚ$test_startServiceRunsCallImmediatelyVs z6TimerServiceTests.test_startServiceRunsCallImmediatelycsBt ¡‰‡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óˆSrr)Ú maybeReactor©Ú otherClockrrÚ getOtherClockhózKTimerServiceTests.test_startServiceUsesGlobalReactor..getOtherClockÚ_maybeGlobalReactorN) rrÚpatchrrdrGrBrhre)r!rprrnrÚ"test_startServiceUsesGlobalReactor`s   z4TimerServiceTests.test_startServiceUsesGlobalReactorcCsR|j ¡|j ¡}| |¡| d|jj¡|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) rdrGrVÚassertNoResultrLrSr2r/ÚobjectrBÚsuccessResultOf©r!r&rrrÚtest_stopServiceWaitsos   z'TimerServiceTests.test_stopServiceWaitscCs8|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)rdrGr2r/rvrVrBrwrxrrrÚtest_stopServiceImmediately{s  z-TimerServiceTests.test_stopServiceImmediatelycCsV|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) rdrGr2r$rrDrKrLrMrVrBrw)r!Úerrorsr&rrrÚtest_failedCallLogsError…s   z*TimerServiceTests.test_failedCallLogsErrorcCóPtdtƒ}| ¡t |¡}| ¡t |¡}tƒ}t|d|ƒ}|  ||¡dS)zq When pickling L{internet.TimerService}, it won't pickle L{internet.TimerService._loop}. r#rhN© rrrGÚpickleÚdumpsrVÚloadsrvÚgetattrrB©r!rdÚ dumpedTimerÚ loadedTimerÚnothingÚvaluerrrÚ$test_pickleTimerServiceNotPickleLoop‘ó    z6TimerServiceTests.test_pickleTimerServiceNotPickleLoopcCr})zy When pickling L{internet.TimerService}, it won't pickle L{internet.TimerService._loopFinished}. r#Ú _loopFinishedNr~rƒrrrÚ,test_pickleTimerServiceNotPickleLoopFinished¡r‰z>TimerServiceTests.test_pickleTimerServiceNotPickleLoopFinishedN)r4r5r6r7r@rcrjrkrtryrzr|rˆr‹rrrrra,s       rac@seZdZdZdd„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. cCsg|_g|_g|_dSr)Ú connectQueueÚconstructedProtocolsÚpassedFactoriesr rrrr"Às zConnectInformation.__init__N)r4r5r6r7r"rrrrrŒ²s rŒFcs,ttƒ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}. cseZdZ‡‡fdd„ZdS)z.endpointForTesting..ClientTestEndpointcsDtƒ}ˆj ˆ¡|j‡‡fdd„ƒ}ˆj |¡ˆr | d¡|S)Ncs*ˆ d¡}ˆj |¡tƒ}| |¡|Sr)Ú buildProtocolrŽrXrÚmakeConnection)ÚignoredÚprotocolÚ transport)r+ÚinforrÚcreateProtocolØs   zNendpointForTesting..ClientTestEndpoint.connect..createProtocol)r rrXrWrr/)r!r+r,r–©ÚfireImmediatelyr•)r+rÚconnectÔs   z6endpointForTesting..ClientTestEndpoint.connectN)r4r5r6r™rr—rrÚClientTestEndpointÒsrš)rrrŒ)r˜ršrr—rÚendpointForTestingÆs  r›cs0g‰ˆ ˆ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} cs ˆ ˆj¡Sr)ÚremoveObserverrXr©Ú logPublisherÚlogsrrr'÷r(zcatchLogs..csdd„ˆDƒS)NcSsg|]}t|ƒ‘qSr)r)Ú.0ÚeventrrrÚ øsz/catchLogs....rr)rŸrrr'øs)Ú addObserverrXÚ addCleanup)ÚtestCaseržrrrÚ catchLogsés  r¦gY@c@seZdZdZddefdd„Zdd„Zdd„Zd d „Zd d „Z d d„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd„Zdd „Zd!d"„Zd#d$„Zd%d&„Zd'd(„Zd)d*„Zd+d,„Zd-d.„Zd/d0„Zd1d2„Zd3d4„Zd5d6„Zd7d8„Zd9d:„Z d;d<„Z!d=d>„Z"d?d@„Z#dAS)BÚClientServiceTestsz% Tests for L{ClientService}. Tc  sži}|jtƒ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. ©rere©r˜cs"eZdZ”Z‡‡fdd„Z‡ZS)z>ClientServiceTests.makeReconnector..RememberingFactorycstƒ |¡}ˆ |¡|Sr)ÚsuperrrX)r!Úaddrr,)Ú __class__ÚapplicationProtocolsrrr0s  zLClientServiceTests.makeReconnector..RememberingFactory.buildProtocol)r4r5r6r“rÚ __classcell__r)r­Ú protocolType)r¬rÚRememberingFactory-sr°cs(dˆ_ˆjr ˆ ¡ˆ ˆ ¡g¡dSr)Ú _protocolrSrVrLÚgetDelayedCallsr)rer!ÚservicerrÚstop9sz0ClientServiceTests.makeReconnector..stop) Úupdaterr›r­rÚapplicationFactoryrr¤rG) r!r˜rGr¯ÚkwÚnkwÚcqÚendpointr°r+r´r)r­rer¯r!r³rÚmakeReconnectors    z"ClientServiceTests.makeReconnectorcCs&|jdd\}}| t|jƒd¡dS)zL When the service is started, a connection attempt is made. Fr©r#N)r»rLrMr)r!r¹r³rrrrjFsz$ClientServiceTests.test_startServicecCsD| ¡\}}|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. rr#N)r»r¶rLÚnumPortsrÚdoStart)r!r¹r³ÚfirstAppFactoryÚfirstPassedFactoryrrrÚtest_startStopFactoryMs  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) r»rVrurŽrLr”Ú disconnectingÚconnectionLostrÚ Exceptionrw©r!r¹r³r&r“rrrÚtest_stopServiceWhileConnected[s   z1ClientServiceTests.test_stopServiceWhileConnectedcCs‚| ¡\}}| ¡}| |¡|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. rTr#rbN) r»rVrurŽrLr”rÁrGrMrÂrrÃrÄrrrÚ#test_startServiceWaitsForDisconnectis    z6ClientServiceTests.test_startServiceWaitsForDisconnectcCsä|jdd\}}|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©rNTr#rb)r»rr/rŽrVruÚ whenConnectedrGrLr”rÁrÂrrÃrwrMrBr­)r!r¹r³ÚfirstÚstoppedÚ nextProtocolÚ secondStoppedrrrÚtest_startServiceWhileStoppingys(      ÿz1ClientServiceTests.test_startServiceWhileStoppingcCsj|jdd\}}| ¡}| |¡| | ¡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»rVrwÚfailureResultOfrÇr rGrr/rBr­)r!r¹r³rÉrrrÚtest_startServiceWhileStopped•s ÿz0ClientServiceTests.test_startServiceWhileStoppedcCsXtttƒGdd„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@seZdZdZdS)zEClientServiceTests.test_interfacesForTransport..FancyProtocolz9 Provider of various interfaces. N)r4r5r6r7rrrrÚ FancyProtocol¯srÐ)r¯rN)rr r rr»rŽrfÚ providedBy)r!rÐr¹r³Ú reactorFacingrrrÚtest_interfacesForTransport¦s   z.ClientServiceTests.test_interfacesForTransportcCsntƒ}|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˜rerrbr#N) rr»rr$rÃÚadvanceÚAT_LEAST_ONE_ATTEMPTrLrMrVrw©r!rer¹r³r&rrrÚtest_stopServiceWhileRetryingºs z0ClientServiceTests.test_stopServiceWhileRetryingcCsPtƒ}|jd|d\}}| t|jƒd¡| |jd¡| ¡}| |¡dS)zv When the service is stopped while initially connecting, the connection attempt is cancelled. FrÔr#rN)rr»rLrMrrurVrwr×rrrÚtest_stopServiceWhileConnectingÇs z2ClientServiceTests.test_stopServiceWhileConnectingcCsJtƒ}|j|d\}}| ¡}| | ¡g¡| | |¡|jd¡dS)zy When a client connects, the service keeps a reference to the new protocol and resets the delay. r¨rN)rr»rÇrLr²rBrwr­)r!rer¹r³ÚawaitingProtocolrrrÚtest_clientConnectedÓsÿz'ClientServiceTests.test_clientConnectedcCs€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#rcSs | t¡Sr)Útrapr )r’rrrr'ís z@ClientServiceTests.test_clientConnectionFailed..rbN) rr»rLrMrr$rrÃrÇruÚ addErrbackrÕrÖ)r!rer¹r³rÇrrrÚtest_clientConnectionFailedàs  z.ClientServiceTests.test_clientConnectionFailedcCsÊ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)rer˜r#rNrb)rr»rLrMrr/rBrwrÇr­rŽrÂrrÃrÕrÖ)r!rer¹r³rrrÚtest_clientConnectionLostñsÿ ÿz,ClientServiceTests.test_clientConnectionLostcCsTtƒ}|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¨rN) rr»rVrŽrÂrÚIndentationErrorrÎrÇr rfÚcalledr×rrrÚ&test_clientConnectionLostWhileStoppings z9ClientServiceTests.test_clientConnectionLostWhileStoppingcCsv|jddd\}}| 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˜rGrr#z$Duplicate ClientService.startServiceN)r»rLrMrrGr¦ÚassertIn)r!r¹r³ÚmessagesrrrÚtest_startTwicesz"ClientServiceTests.test_startTwicec Cs®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#©ÚfailAfterFailuresrN) rr»rÇrurr/rwrBr­) r!rer¹r³ÚaÚbÚcÚresultAÚresultBÚresultCrrrÚtest_whenConnectedLater"s         z*ClientServiceTests.test_whenConnectedLatercCsÐ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érN)rr»rÇrurrÃrr$rBrÎrÕrÖrLrMr/rwr­)r!rer¹r³Úa0Úa1Úa2Úa3Úf1Úf2ÚAT_LEAST_TWO_ATTEMPTSÚresultA0ÚresultA3Úa4ÚresultA4rrrÚtest_whenConnectedFails7sN                          z*ClientServiceTests.test_whenConnectedFailscCsŒ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) rr»rÇrurVrÕrÖrÎr )r!rer¹r³rèrérêrrrÚtest_whenConnectedStopServiceqs       z0ClientServiceTests.test_whenConnectedStopServicecCsRtƒ}|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) rr»rr$rÃrVrLr²rwr×rrrÚtest_retryCancelled„s 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)r˜rGreN©rr»rVÚ assertIsNonerw)r!reÚ_r³r&rrrÚ"test_stopServiceBeforeStartService‘s  ÿz5ClientServiceTests.test_stopServiceBeforeStartServicecCsptƒ}|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ÔrrýN) rr»rÇrr$rÃrVrgrÎr‡r )r!rer¹r³ÚbeforeErrbackAndStopÚafterErrbackAndStoprrrÚ'test_whenConnectedErrbacksOnStopServicežs ÿ ÿz:ClientServiceTests.test_whenConnectedErrbacksOnStopServicecCsftƒ}|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ÔrN) rr»rr/rVrŽrÂrràrw©r!rer¹r³ÚfirstStopDeferredÚsecondStopDeferredrrrÚ"test_stopServiceWhileDisconnecting·s z5ClientServiceTests.test_stopServiceWhileDisconnectingcCsntƒ}|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ÔrN) rr»rr/rVrGrŽrÂrràrwrrrrÚtest_stopServiceWhileRestartingÎs 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}. FrÔNrÿ)r!rerr³rrrrrÚ test_stopServiceOnStoppedServiceæs z3ClientServiceTests.test_stopServiceOnStoppedServicecs8dg‰‡fdd„}|j|dd\}}| dˆd¡dS)z† The C{prepareConnection} callable is called after L{ClientService.startService} once the connection is made. rcóˆdd7<dS©Nrr#r©Ú_proto©ÚpreparesrrÚprepareConnectionúóz[ClientServiceTests.test_prepareConnectionCalledWhenServiceStarts..prepareConnectionT)rrGr#N)r»rL©r!rr¹r³rrrÚ-test_prepareConnectionCalledWhenServiceStartsós   ÿz@ClientServiceTests.test_prepareConnectionCalledWhenServiceStartscs:g‰‡fdd„}|j|d\}}| |jdˆd¡dS)zf The C{prepareConnection} callable is passed the connected protocol instance. csˆ |¡dSr©rX©Úproto©Ú newProtocolsrrr szVClientServiceTests.test_prepareConnectionCalledWithProtocol..prepareConnection©rrN)r»rBrŽrrrrÚ(test_prepareConnectionCalledWithProtocols   ÿz;ClientServiceTests.test_prepareConnectionCalledWithProtocolcs~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. rcr r rrrrrrrz]ClientServiceTests.test_prepareConnectionCalledAfterConnectionMade..prepareConnectionF)rr˜rezconnection attempt failedr#N) rr»rr$rÃrLrÕrÖr/©r!rrer¹r³rrrÚ/test_prepareConnectionCalledAfterConnectionMades  ÿ zBClientServiceTests.test_prepareConnectionCalledAfterConnectionMadecsndg‰‡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. rcr r rrrrrr/rzUClientServiceTests.test_prepareConnectionCalledOnReconnect..prepareConnection©rrer#rbN) rr»rLrŽrÂrràrÕrÖrrrrÚ'test_prepareConnectionCalledOnReconnect(s  ÿ z:ClientServiceTests.test_prepareConnectionCalledOnReconnectcs@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. crlrrr©ÚsentinelrrrJrqzVClientServiceTests.test_prepareConnectionReturnValueIgnored..prepareConnectionrN)rvr»rwrÇÚassertNotIdentical)r!rr¹r³r,rr!rÚ(test_prepareConnectionReturnValueIgnored?s  z;ClientServiceTests.test_prepareConnectionReturnValueIgnoredcs`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. csˆ |¡ˆSrrr©ÚnewProtocolDeferredrrrrZs zVClientServiceTests.test_prepareConnectionReturningADeferred..prepareConnectionrNr)r r»rÇrur/rBr­rw)r!rr¹r³ÚwhenConnectedDeferredrr%rÚ(test_prepareConnectionReturningADeferredRs  ÿ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. cSstƒ‚r)ràrrrrrpszJClientServiceTests.test_prepareConnectionThrows..prepareConnectionrrbræN) rr»rÇrurÕrÖrBràrÎÚtype)r!rerr¹r³r'rrrÚtest_prepareConnectionThrowsis ÿ      ÿz/ClientServiceTests.test_prepareConnectionThrowsN)$r4r5r6r7rr»rjrÀrÅrÆrÌrÏrÓrØrÙrÛrÞrßrârårîrûrürþrrr r r rrrr r$r(r*rrrrr§þsD ÿC    :    r§)F)0r7rÚzope.interfacerÚzope.interface.verifyrÚtwisted.applicationrÚtwisted.application.internetrrrÚtwisted.internetrÚtwisted.internet.deferr r Útwisted.internet.interfacesr r r rrÚtwisted.internet.protocolrrÚtwisted.internet.taskrÚtwisted.loggerrrÚtwisted.python.failurerÚtwisted.test.proto_helpersrÚtwisted.trial.unittestrrrrrr=rarŒr›r¦rÖr§rrrrÚs>        @   #