YfMdZddlZddlmZddlmZddlmZddlm Z m Z m Z ddl m Z ddlmZmZdd lmZmZmZmZmZdd lmZmZdd lmZdd lmZdd lmZm Z ddl!m"Z"ddl#m$Z$m%Z%dZ&eeGddZ'eee'eeGddZ(eee'Gdde%Z)Gdde%Z*GddZ+d!dZ,e fdZ-dZ.Gdd 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)SynchronousTestCaseTestCasecdS)zM A fake target function for testing TimerService which does nothing. NrX/var/www/html/env/lib/python3.11/site-packages/twisted/application/test/test_internet.pyfakeTargetFunctionr)s  DrcNeZdZdZdZdZdZeZdZ dZ dZ dZ dZ 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. Nrc,t|_dSN)FakePortportselfs r__init__zFakeServer.__init__LsJJ rcxjdz c_|_tfd_jjjjS)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} c8|jSr")errbackcancelException)dr&s rz#FakeServer.listen..Zs199T=Q3R3Rr) canceller)listenAttemptsfactoryr resultfailImmediatelyr+)r&r1s` rlistenzFakeServer.listenOsf q  )R)R)R)RSSS   + K   4 5 5 5{rcD|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)r2callbackr$r%s rstartedListeningzFakeServer.startedListening_s" TY'''''rcD|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)r$deferredr6r%s rstoppedListeningzFakeServer.stoppedListeninggs# ##D)))))r)__name__ __module__ __qualname____doc__r2r1r3r r,r0r'r4r7r:rrrr r 0s}(FGO$n&&ON (((*****rr c(eZdZdZdZdZdZdZdS)r#zs Fake L{IListeningPort} implementation. @ivar deferred: The L{Deferred} returned by C{stopListening}. Nc6t|_|jS)z` Stop listening. @return: a L{Deferred} stored in L{FakePort.deferred} )r r9r%s r stopListeningzFakePort.stopListening~s !  }rcdSr"rr%s rgetHostzFakePort.getHost rcdSr"rr%s rstartListeningzFakePort.startListeningrDr)r;r<r=r>r9rArCrFrrrr#r#tsR H        rr#c\eZdZdZdZdZddZdZdZdZ d Z d Z d Z d Z d ZdZdS)EndpointServiceTestsz4 Tests for L{twisted.application.internet}. ct|_t|_t |j|j|_dS)zp Construct a stub server, a stub factory, and a L{StreamServerEndpointService} to test. N)r fakeServerrr1rsvcr%s rsetUpzEndpointServiceTests.setUps3 %,,yy .t MMrc|j||j|jjdS)z L{StreamServerEndpointService.privilegedStartService} calls its endpoint's C{listen} method with its factory. N)rKprivilegedStartServiceassertIdenticalr1rJr%s rtest_privilegedStartServicez0EndpointServiceTests.test_privilegedStartServices; ''))) T\4?+BCCCCCrNct|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)ZeroDivisionErrorrJr3rK_raiseSynchronously assertRaises startService)r&thunks r(test_synchronousRaiseRaisesSynchronouslyz=EndpointServiceTests.test_synchronousRaiseRaisesSynchronouslysE +<*=*=''+$ +U-Kdh6KLLLLLrcD||jjdS)z L{StreamServerEndpointService.privilegedStartService} should behave the same as C{startService} with respect to L{EndpointServiceTests.test_synchronousRaiseRaisesSynchronously}. N)rWrKrNr%s rtest_synchronousRaisePrivilegedz4EndpointServiceTests.test_synchronousRaisePrivilegeds# 55dh6UVVVVVrc|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) rKrUrJr2r+rRflushLoggedErrors assertEquallenr&loggeds rtest_failReportsErrorz*EndpointServiceTests.test_failReportsErrorsn  &&'8':':;;;''(9:: Va(((((rc 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) rKrSrUrJr2r+rRr[r\r]r^s r!test_asynchronousFailReportsErrorz6EndpointServiceTests.test_asynchronousFailReportsErrorsx(,$  &&'8':':;;;''(9:: Va(((((rct|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)rRrJr3rKrUr[r\r]r^s r test_synchronousFailReportsErrorz5EndpointServiceTests.test_synchronousFailReportsErrors^ +<*=*=' ''(9:: Va(((((rc|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)rKrUrOr1rJr\runningr%s rtest_startServiceUnstartedz/EndpointServiceTests.test_startServiceUnstartedsV  T\4?+BCCC )400000rc||j||jjd||jjddS)z L{StreamServerEndpointService.startService} sets the C{running} flag, but nothing else, if the service has already been started. r)TN)rPrKrUr\rJr0rfr%s rtest_startServiceStartedz-EndpointServiceTests.test_startServiceStartedsf ((***  7;;; )400000rc|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) rKrNrJr7rU stopService addCallbackappendr\r]r: assertFalserfr&r2ls rtest_stopServicez%EndpointServiceTests.test_stopServices ''))) ((*** %%'' 18$$$ Q### ((*** Q### )*****rc,|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)rKrNrkaddBothrmr\r[r ros r#test_stopServiceBeforeStartFinishedz8EndpointServiceTests.test_stopServiceBeforeStartFinisheds '')))%%'' qx    TF### //??DDDDDrczt|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)) rRrJr,rKrNrkrlrmr\r[r])r&r2rpstoppingErrorss r test_stopServiceCancelStartErrorz5EndpointServiceTests.test_stopServiceCancelStartErrors +<*=*=' '')))%%'' 18$$$ TF###//0ABB ^,,a00000rr")r;r<r=r>rLrPrWrYr`rbrdrgrirqrtrwrrrrHrHsNNNDDDMMMM(WWW ) ) ) ) ) ))))111111+++$ E E E 1 1 1 1 1rrHcNeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d S) 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}. ctd|j|_tjx|_|j_t |_dS)z1 Set up a timer service to test. N)rcalltimerr rclockr r9r%s rrLzTimerServiceTests.setUp:s="!TY// (, 4 TZ%  rc|jS)z Function called by L{TimerService} being tested. @returns: C{self.deferred} @rtype: L{Deferred} )r9r%s rr|zTimerServiceTests.callBs }rcj|j||jjd||jjt j||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}rU assertTruerfassertIsInstance_loopr LoopingCallrOr~r%s rtest_startServicez#TimerServiceTests.test_startServiceKs !!!  *,@AAA dj.0@AAA TZ)9)?@@@  (02JKKKKKrcg}|jdif|j_|j|dg|dS)zi When L{TimerService.startService} is called, it calls the function immediately. r"N)rmr}r|rUr\)r&r2s r$test_startServiceRunsCallImmediatelyz6TimerServiceTests.test_startServiceRunsCallImmediatelyVsM !='26  !!! $(((((rctjfd}|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. cSr"r) maybeReactor otherClocks r getOtherClockzKTimerServiceTests.test_startServiceUsesGlobalReactor..getOtherClockhs  r_maybeGlobalReactorN) r rpatchrr}rUrOrr~)r&rrs @r"test_startServiceUsesGlobalReactorz4TimerServiceTests.test_startServiceUsesGlobalReactor`sz Z\\       82MBBB !!! Z)9)?@@@@@rcr|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}rUrkassertNoResultr\rfr9r6objectrOsuccessResultOfr&r-s rtest_stopServiceWaitsz'TimerServiceTests.test_stopServiceWaitsos !!! J " " $ $ A tz1222 vxx((( T11!44d;;;;;rc|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}rUr9r6rrkrOrrs rtest_stopServiceImmediatelyz-TimerServiceTests.test_stopServiceImmediately{so !!! vxx((( J " " $ $ T11!44d;;;;;rc|j|jt t |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}rUr9r+rrRr[r\r]rkrOr)r&errorsr-s rtest_failedCallLogsErrorz*TimerServiceTests.test_failedCallLogsErrors !!! g&7&9&9::;;;''(9:: CKK((( J " " $ $ T11!44d;;;;;rc:tdt}|tj|}|tj|}t}t|d|}| ||dS)zq When pickling L{internet.TimerService}, it won't pickle L{internet.TimerService._loop}. r)rN rrrUpickledumpsrkloadsrgetattrrOr&r} dumpedTimer loadedTimernothingvalues r$test_pickleTimerServiceNotPickleLoopz6TimerServiceTests.test_pickleTimerServiceNotPickleLoopsQ 233 l5))  l;// (( Wg66 We,,,,,rc:tdt}|tj|}|tj|}t}t|d|}| ||dS)zy When pickling L{internet.TimerService}, it won't pickle L{internet.TimerService._loopFinished}. r) _loopFinishedNrrs r,test_pickleTimerServiceNotPickleLoopFinishedz>TimerServiceTests.test_pickleTimerServiceNotPickleLoopFinishedsQ 233 l5))  l;// (( _g>> We,,,,,rN)r;r<r=r>rLr|rrrrrrrrrrrryry,s  ### L L L))) A A A < < <<<< < < <--- -----rryceZdZdZdZdS)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. c0g|_g|_g|_dSr") connectQueueconstructedProtocolspassedFactoriesr%s rr'zConnectInformation.__init__s $&!!rN)r;r<r=r>r'rrrrrs-  """""rrFcttGfdd}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}. ceZdZfdZdS).endpointForTesting..ClientTestEndpointct}j|jfd}j|r|d|S)Ncd}j|t}|||Sr") buildProtocolrrmrmakeConnection)ignoredprotocol transportr1infos rcreateProtocolzNendpointForTesting..ClientTestEndpoint.connect..createProtocolsQ"0066)00:::+-- '' 222r)r rrmrlrr6)r&r1r2rfireImmediatelyrs ` rconnectz6endpointForTesting..ClientTestEndpoint.connectsZZF  ' ' 0 0 0            $ $V , , , &%%%MrN)r;r<r=r)rrsrClientTestEndpointrs3        rr)rrr)rrrs` @rendpointForTestingrss&''('$   D ##%% %%rczgj|fdfdS)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} c8jSr")removeObserverrm) logPublisherlogssrr.zcatchLogs..s ; ;DK H HrcdDS)Nc,g|]}t|Sr)r).0events r z/catchLogs....s 9995K&&999rr)rsrr.zcatchLogs..s99D999r) addObserverrm addCleanup)testCaserrs `@r catchLogsrsQ DT[))) HHHHHIII 9 9 9 99rgY@ceZdZdZddefdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!d Z"d!Z#d"S)#ClientServiceTestsz% Tests for L{ClientService}. Tc  i}|t|||d t|\}}gx |_G fddt}|x|_} t || fi| fd} | |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~rc&eZdZZfdZxZS)>ClientServiceTests.makeReconnector..RememberingFactoryctt|}||Sr")superrrm)r&addrr2 __class__applicationProtocolss rrzLClientServiceTests.makeReconnector..RememberingFactory.buildProtocol0s3..t44$++F333 r)r;r<r=rr __classcell__)rr protocolTypes@rRememberingFactoryr-sC#H          rrcd_jrgdSr") _protocolrfrkr\getDelayedCalls)r~r&servicesrstopz0ClientServiceTests.makeReconnector..stop9sQ $G  &##%%%   U2244b 9 9 9 9 9r) updaterrrrapplicationFactoryrrrU)r&rrUrkwnkwcqendpointrr1rrr~rs` ` @@@rmakeReconnectorz"ClientServiceTests.makeReconnectors%8  !!! 2G )/JJJ H:<;r6           +=*<*>*>>'99S99 : : : : : : :   #  " " "7{rc|d\}}|t|jddS)zL When the service is started, a connection attempt is made. Frr)N)rr\r]r)r&rrs rrz$ClientServiceTests.test_startServiceFsD**5*AA G R_--q11111rc|\}}|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)rrr\numPortsrdoStart)r&rrfirstAppFactoryfirstPassedFactorys rtest_startStopFactoryz(ClientServiceTests.test_startStopFactoryMsy**,, G/ 11555/2""$$$ 1155555rcf|\}}|}|||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) rrkrrr\r disconnectingconnectionLostr Exceptionrr&rrr-rs rtest_stopServiceWhileConnectedz1ClientServiceTests.test_stopServiceWhileConnected[s **,, G    ! ! A*1- +94@@@ 4 4555 Qrc.|\}}|}|||jd}||jjd||||t|jd| tt|t|jddS)z When L{ClientService} is restarted after having been connected, it waits to start connecting until after having disconnected. rTr)r{N) rrkrrr\rrrUr]rrrrs r#test_startServiceWaitsForDisconnectz6ClientServiceTests.test_startServiceWaitsForDisconnectis **,, G    ! ! A*1- +94@@@ A R455q999 4 4555 R455q99999rc|d\}}|jdd|jd}|}|||}|||||||||j j d| tt|||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. FrrNTr)r{)rrr6rrkr whenConnectedrUr\rrrrrrr]rOr)r&rrfirststopped nextProtocol secondStoppeds rtest_startServiceWhileStoppingz1ClientServiceTests.test_startServiceWhileStoppingys**5*AA G ##D)))'*%%'' G$$$,,..  L))) L))) G$$$ 6=== WY[[11222 W%%% ##D))) R455q999    . .0G0J    ++--  M*****rc|d\}}|}||||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) rrkrfailureResultOfrr rUrr6rOr)r&rrrs rtest_startServiceWhileStoppedz0ClientServiceTests.test_startServiceWhileStoppeds**5*AA G%%'' W%%% W2244nEEE $$T***   #B ')=)=g>S>S>U>U)V)V     rcTtttGddt}||\}}|jd}|tj||tj|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. ceZdZdZdS)EClientServiceTests.test_interfacesForTransport..FancyProtocolz9 Provider of various interfaces. N)r;r<r=r>rrr FancyProtocolrs    rr)rrN)rr r rrrr providedBy)r&rrr reactorFacings rtest_interfacesForTransportz.ClientServiceTests.test_interfacesForTransports +-D E E     H   F E  ** *FF G/2  /:=IIJJJ .9-HHIIIIIrct}|d|\}}|jdt |t |t|jd| }|jdt | |dS)zU When the service is stopped while retrying, the retry is cancelled. Frr~rr{r)N) rrrr+radvanceAT_LEAST_ONE_ATTEMPTr\r]rkrr&r~rrr-s rtest_stopServiceWhileRetryingz0ClientServiceTests.test_stopServiceWhileRetryings**5*NN G ""9;;/// *+++ R_--q111    ! ! ""9;;/// Qrc8t}|d|\}}|t|jd||jd|}||dS)zv When the service is stopped while initially connecting, the connection attempt is cancelled. Fr r)rN)rrr\r]rrrkrrs rtest_stopServiceWhileConnectingz2ClientServiceTests.test_stopServiceWhileConnectings **5*NN G R_--q111 BOA.///    ! ! Qrc4t}||\}}|}||g||||jddS)zy When a client connects, the service keeps a reference to the new protocol and resets the delay. rrN)rrrr\rrOrr)r&r~rrawaitingProtocols rtest_clientConnectedz'ClientServiceTests.test_clientConnecteds ***77 G"0022 ..00"555   !1 2 2B4KA4N     rct}|d|\}}|t|jd|jdt t|}| || d| t|t|jddS)z When a client connection fails, the service removes its reference to the protocol and tries again after a timeout. Fr r)rc6|tSr")trapr )rs rr.z@ClientServiceTests.test_clientConnectionFailed..sn1M1Mrr{N) rrr\r]rr+rrrr addErrbackr r )r&r~rrrs rtest_clientConnectionFailedz.ClientServiceTests.test_clientConnectionFaileds **5*NN G R_--q111 ""79;;#7#7888--//  M***   !M!MNNN *+++ R_--q11111rct}||d\}}|t|jd|jdd|t|jd||||j d|j d tt|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)rNr{)rrr\r]rr6rOrrrrrrrr r )r&r~rrs rtest_clientConnectionLostz,ClientServiceTests.test_clientConnectionLosts ***NN G R_--q111 ##D))) R_--q111   !6!6!8!8 9 92;RST;U    "11')++2F2FGGG *+++ R_--q111 ##D)))   !6!6!8!8 9 92;RST;U     rc|t}||\}}|}|jdt t ||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) rrrkrrrIndentationErrorrrr rcalledrs r&test_clientConnectionLostWhileStoppingz9ClientServiceTests.test_clientConnectionLostWhileStoppings ***77 G    ! ! "11':J:L:L2M2MNNN W2244nEEE !!!!!rc|dd\}}|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)rrUrr)z$Duplicate ClientService.startServiceN)rr\r]rrUrassertIn)r&rrmessagess rtest_startTwicez"ClientServiceTests.test_startTwices **5u*UU G R_--q111 R_--q111T?? R_--q111 q'ABBB " "Q " 7 7''++ Xx00000rcNt}|d|\}}|}|}|d}||||||||t ||t||t||tdS)z L{ClientService.whenConnected} returns a L{Deferred} that fails when L{ClientService.stopService} is called. Fr r)r%N) rrrrrkr r rr )r&r~rrr'r(r)s rtest_whenConnectedStopServicez0ClientServiceTests.test_whenConnectedStopServiceqs  **5*NN G  ! ! # #  ! ! # #  ! !A ! 6 6 A A A *+++ Q/// Q/// Q/////rcRt}|d|\}}|jdt d|}||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) rrrr+rrkr\rrrs rtest_retryCancelledz&ClientServiceTests.test_retryCancelleds **5*NN G ""9_#=#=>>>    ! ! ..00"555 Qrct}|dd|\}}|}|||dS)z Calling L{ClientService.stopService} before L{ClientService.startService} returns a L{Deferred} that has already fired with L{None}. F)rrUr~Nrrrk assertIsNoner)r&r~_rr-s r"test_stopServiceBeforeStartServicez5ClientServiceTests.test_stopServiceBeforeStartServicesm ))!U*  7    ! ! $..q1122222rct}|d|\}}|}|jdt d||}|||j t|||j tdS)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) rrrrr+rrkrrrr )r&r~rrbeforeErrbackAndStopafterErrbackAndStops r'test_whenConnectedErrbacksOnStopServicez:ClientServiceTests.test_whenConnectedErrbacksOnStopServices**5*NN G&4466 ""9_#=#=>>>%3355   !5 6 6 .prepareConnection QKKK1 KKKKKrT)rYrUr)N)rr\)r&rYrrrXs @r-test_prepareConnectionCalledWhenServiceStartsz@ClientServiceTests.test_prepareConnectionCalledWhenServiceStartssl 3     **/d+  G HQK(((((rcgfd}||\}}||jdddS)zf The C{prepareConnection} callable is passed the connected protocol instance. c2|dSr"rm)proto newProtocolss rrYzVClientServiceTests.test_prepareConnectionCalledWithProtocol..prepareConnection s    & & & & &rrYrN)rrOr)r&rYrrr`s @r(test_prepareConnectionCalledWithProtocolz;ClientServiceTests.test_prepareConnectionCalledWithProtocolsp   ' ' ' ' '**/+  G R4Q7aIIIIIrcdgfd}t}||d|\}}|jdt d|dd|t|jdd|dddS)zf The C{prepareConnection} callback is invoked only once a connection is made. rc(dxxdz cc<dSrUrrVs rrYz]ClientServiceTests.test_prepareConnectionCalledAfterConnectionMade..prepareConnectionrZrF)rYrr~zconnection attempt failedr)N) rrrr+rr\r r r6r&rYr~rrrXs @r/test_prepareConnectionCalledAfterConnectionMadezBClientServiceTests.test_prepareConnectionCalledAfterConnectionMades 3     **/e+  G ""9-H#I#IJJJ HQK((( *+++ ##D))) HQK(((((rc~dgfd}t}|||\}}|dd|jdt t |t|dddS)z The C{prepareConnection} callback is invoked each time a connection is made, including on reconnection. rc(dxxdz cc<dSrUrrVs rrYzUClientServiceTests.test_prepareConnectionCalledOnReconnect..prepareConnection/rZrrYr~r)r{N) rrr\rrrrr r res @r'test_prepareConnectionCalledOnReconnectz:ClientServiceTests.test_prepareConnectionCalledOnReconnect(s 3     **/u+  G HQK((( "11':J:L:L2M2MNNN *+++ HQK(((((rctfd}||\}}||}||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. cSr"r)r_sentinels rrYzVClientServiceTests.test_prepareConnectionReturnValueIgnored..prepareConnectionJsOrraN)rrrrassertNotIdentical)r&rYrrr2rms @r(test_prepareConnectionReturnValueIgnoredz;ClientServiceTests.test_prepareConnectionReturnValueIgnored?s88     **=N*OO G%%g&;&;&=&=>> &11111rcLgtfd}||\}}|}||d||jd||dS)z The C{prepareConnection} callable returns a deferred and calls to L{ClientService.whenConnected} wait until it fires. c2|Sr"r^)r_newProtocolDeferredr`s rrYzVClientServiceTests.test_prepareConnectionReturningADeferred..prepareConnectionZs    & & && &rraNr)r rrrr6rOrr)r&rYrrwhenConnectedDeferredrrr`s @@r(test_prepareConnectionReturningADeferredz;ClientServiceTests.test_prepareConnectionReturningADeferredRs  &jj ' ' ' ' ' '**=N*OO G ' 5 5 7 7 1222$$T***   #A &(<(<=R(S(S     rct}d}|||\}}|d}|||t |||t |t||j dS)zs The connection attempt counts as a failure when the C{prepareConnection} callable throws. ctr")r)rWs rrYzJClientServiceTests.test_prepareConnectionThrows..prepareConnectionps"$$ $rrir{r%N) rrrrr r rOrrtype)r&r~rYrrrss rtest_prepareConnectionThrowsz/ClientServiceTests.test_prepareConnectionThrowsis  % % %**/u+  G!( 5 5 5 J J 1222 *+++ 1222 *+++  d223HIIN     rN)$r;r<r=r>rrrrrrrrr rrrrrrr#r-r;r=r@rErIrNrPrRr[rbrfrjrortrxrrrrrs #HAAAAF222 6 6 6    ::: +++8   "JJJ(            222"   * " " " M M MBBB*818181t000&     3 3 3   2111.1110 D D D ) ) ) J J J))).))).222&   .     rr)F)0r>rzope.interfacerzope.interface.verifyrtwisted.applicationrtwisted.application.internetrrrtwisted.internetr twisted.internet.deferr r twisted.internet.interfacesr r rrrtwisted.internet.protocolrrtwisted.internet.taskrtwisted.internet.testingrtwisted.loggerrrtwisted.python.failurertwisted.trial.unittestrrrr r#rHryrrrr rrrrrs0  &&&&&&------(((((( "!!!!!;;;;;;;;87777777''''''444444::::::::******@@@@@@@@     "##=*=*=*=*=*=*=*$#=*@ !:... ^        6 !:...V1V1V1V1V18V1V1V1rC-C-C-C-C-C-C-C-L""""""""( & & & &F&8::::$B  B  B  B  B  ,B  B  B  B  B  r