֛hSrSSKrSSKJr SSKJr SSKJr SSKJ r J r J r SSK J r SSKJrJr SS KJrJrJrJrJr SS KJrJr SS KJr SS KJr SS KJrJ r SSK!J"r" SSK#J$r$J%r% Sr&\"\5"SS55r'\"\\'5 \"\5"SS55r(\"\\'5 "SS\%5r)"SS\%5r*"SS5r+S Sjr,\ 4Sjr-Sr."SS\$5r/g)!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)SynchronousTestCaseTestCasecg)zE A fake target function for testing TimerService which does nothing. NrjC:\Users\psant\Downloads\Noiseback\school\venv\Lib\site-packages\twisted/application/test/test_internet.pyfakeTargetFunctionr)s rcN\rSrSrSrSrSrSr\"5r Sr Sr Sr Sr SrS rg) FakeServer0aA 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"[5UlgN)FakePortportselfs r__init__FakeServer.__init__Ls J rc^T=RS- slUTl[U4SjS9TlTRb%TRR TR5 TR$)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:>URTR5$r#)errbackcancelException)dr's r#FakeServer.listen..Zs199T=Q=Q3Rr) canceller)listenAttemptsfactoryr resultfailImmediatelyr-)r'r4s` rlistenFakeServer.listenOsX q  )RS    + KK   4 4 5{{rcNURRUR5 g)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)r5callbackr%r&s rstartedListeningFakeServer.startedListening_s TYY'rcNURRRS5 g)z 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&s rstoppedListeningFakeServer.stoppedListeninggs ##D)r)r4r%r5)__name__ __module__ __qualname____firstlineno____doc__r5r4r6r r.r3r(r7r;r?__static_attributes__rrrr r 0s9(FGO$&ON (*rr c.\rSrSrSrSrSrSrSrSr g)r$tzg Fake L{IListeningPort} implementation. @ivar deferred: The L{Deferred} returned by C{stopListening}. Nc8[5UlUR$)zH Stop listening. @return: a L{Deferred} stored in L{FakePort.deferred} )r r>r&s r stopListeningFakePort.stopListening~s !  }}rcgr#rr&s rgetHostFakePort.getHost rcgr#rr&s rstartListeningFakePort.startListeningrOrr>) rArBrCrDrEr>rJrMrQrFrrrr$r$ts H  rr$cd\rSrSrSrSrSrSSjrSrSr S r S r S r S r S rSrSrSrg)EndpointServiceTestsz, Tests for L{twisted.application.internet}. c[5Ul[5Ul[ URUR5Ulg)zX Construct a stub server, a stub factory, and a L{StreamServerEndpointService} to test. N)r fakeServerrr4rsvcr&s rsetUpEndpointServiceTests.setUps, %,y .t MrcURR5 URURURR5 g)zo L{StreamServerEndpointService.privilegedStartService} calls its endpoint's C{listen} method with its factory. N)rYprivilegedStartServiceassertIdenticalr4rXr&s rtest_privilegedStartService0EndpointServiceTests.test_privilegedStartServices2 '') T\\4??+B+BCrNc[5URlSURlUR [U=(d URR 5 g)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)ZeroDivisionErrorrXr6rY_raiseSynchronously assertRaises startService)r'thunks r(test_synchronousRaiseRaisesSynchronously=EndpointServiceTests.test_synchronousRaiseRaisesSynchronouslys? +<*=''+$ +U-Kdhh6K6KLrcNURURR5 g)z L{StreamServerEndpointService.privilegedStartService} should behave the same as C{startService} with respect to L{EndpointServiceTests.test_synchronousRaiseRaisesSynchronously}. N)rgrYr]r&s rtest_synchronousRaisePrivileged4EndpointServiceTests.test_synchronousRaisePrivilegeds 55dhh6U6UVrcURR5 URRR [ 55 UR [ 5nUR[U5S5 g)z 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) rYrerXr5r-rbflushLoggedErrors assertEquallenr'loggeds rtest_failReportsError*EndpointServiceTests.test_failReportsErrorsU  &&'8':;''(9: Va(rcSURlURR5 URRR [ 55 UR[ 5nUR[U5S5 g)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 asynchronously, even if C{_raiseSynchronously} is set. Tr+N) rYrcrerXr5r-rbrmrnrorps r!test_asynchronousFailReportsError6EndpointServiceTests.test_asynchronousFailReportsErrorsa(,$  &&'8':;''(9: Va(rc[5URlURR 5 UR [5nUR [U5S5 g)z Without the C{_raiseSynchronously} compatibility flag, failing immediately has the same behavior as failing later; it logs the error. r+N)rbrXr6rYrermrnrorps r test_synchronousFailReportsError5EndpointServiceTests.test_synchronousFailReportsErrorsH +<*=' ''(9: Va(rcURR5 URURURR5 UR URR S5 g)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)rYrer^r4rXrnrunningr&s rtest_startServiceUnstarted/EndpointServiceTests.test_startServiceUnstartedsL  T\\4??+B+BC ))40rcUR5 URR5 URURR S5 URURR S5 g)z L{StreamServerEndpointService.startService} sets the C{running} flag, but nothing else, if the service has already been started. r+TN)r_rYrernrXr3r{r&s rtest_startServiceStarted-EndpointServiceTests.test_startServiceStartedsT ((*  77; ))40rcURR5 URR5 URR 5 URR 5n/nUR UR5 UR[U5S5 URR5 UR[U5S5 URURR5 g)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) rYr]rXr;re stopService addCallbackappendrnror? assertFalser{r'r5ls rtest_stopService%EndpointServiceTests.test_stopServices '') ((* %%' 188$ Q# ((* Q# ))*rcURR5 URR5n/nURUR5 UR US/5 UR UR [5/5 g)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)rYr]raddBothrrnrmr rs r#test_stopServiceBeforeStartFinished8EndpointServiceTests.test_stopServiceBeforeStartFinishedsh '')%%' qxx  TF# //?Drc^[5URlURR 5 URR 5n/nUR UR5 URUS/5 UR[5nUR[U5S5 g)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+) rbrXr.rYr]rrrrnrmro)r'r5rstoppingErrorss r test_stopServiceCancelStartError5EndpointServiceTests.test_stopServiceCancelStartErrors +<*=' '')%%' 188$ TF#//0AB ^,a0r)r4rXrYr#)rArBrCrDrErZr_rgrjrrrurxr|rrrrrFrrrrUrUsHNDM(W ) ))11+$ E 1rrUcT\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rg)TimerServiceTestsi,a  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[SUR5Ul[R"5=UlURl[ 5Ulg)z! Set up a timer service to test. N)rcalltimerr rclockr r>r&s rrZTimerServiceTests.setUp:s8"!TYY/ (, 4 TZZ%  rcUR$)zb Function called by L{TimerService} being tested. @returns: C{self.deferred} @rtype: L{Deferred} rSr&s rrTimerServiceTests.callBs}}rcURR5 URURRS5 UR URR [ R5 URURURR R5 URURR RS5 g)zw When L{TimerService.startService} is called, it marks itself as running, creates a L{task.LoopingCall} and starts it. zService is startedzLoopingCall is startedN) rre assertTruer{assertIsInstance_loopr LoopingCallr^rr&s rtest_startService#TimerServiceTests.test_startServiceKs !  **,@A djj..0@0@A TZZ)9)9)?)?@  ((002JKrc/nURS04URlURR5 UR S/U5 g)zQ When L{TimerService.startService} is called, it calls the function immediately. r#N)rrrrern)r'r5s r$test_startServiceRunsCallImmediately6TimerServiceTests.test_startServiceRunsCallImmediatelyVsA !=='26  ! $(rc^[R"5mU4SjnUR[SU5 URR 5 UR TURRR5 g)z L{TimerService.startService} uses L{internet._maybeGlobalReactor} to choose the reactor to pass to L{task.LoopingCall} uses the global reactor. c>T$r#r) maybeReactor otherClocks r getOtherClockKTimerServiceTests.test_startServiceUsesGlobalReactor..getOtherClockhs  r_maybeGlobalReactorN) r rpatchrrrer^rr)r'rrs @r"test_startServiceUsesGlobalReactor4TimerServiceTests.test_startServiceUsesGlobalReactor`sX ZZ\   82MB ! Z)9)9)?)?@rcbURR5 URR5nURU5 UR SURR 5 UR R[55 URURU5S5 g)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) rrerassertNoResultrnr{r>r:objectr^successResultOfr'r/s rtest_stopServiceWaits'TimerServiceTests.test_stopServiceWaitsos} ! JJ " " $ A tzz112 vx( T11!4d;rcURR5 URR[ 55 URR 5nUR URU5S5 g)z} When L{TimerService.stopService} is called while a call isn't in progress. the L{Deferred} returned has already been fired. N)rrer>r:rrr^rrs rtest_stopServiceImmediately-TimerServiceTests.test_stopServiceImmediately{sU ! vx( JJ " " $ T11!4d;rcfURR5 URR[ [ 555 UR [ 5nURS[U55 URR5nURURU5S5 g)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) rrer>r-rrbrmrnrorr^r)r'errorsr/s rtest_failedCallLogsError*TimerServiceTests.test_failedCallLogsErrors ! g&7&9:;''(9: CK( JJ " " $ T11!4d;rc [S[5nUR5 [R"U5nUR 5 [R "U5n[5n[USU5nURXE5 g)zY When pickling L{internet.TimerService}, it won't pickle L{internet.TimerService._loop}. r+rN rrrepickledumpsrloadsrgetattrr^r'r dumpedTimer loadedTimernothingvalues r$test_pickleTimerServiceNotPickleLoop6TimerServiceTests.test_pickleTimerServiceNotPickleLoopshQ 23 ll5)  ll;/ ( Wg6 W,rc [S[5nUR5 [R"U5nUR 5 [R "U5n[5n[USU5nURXE5 g)za When pickling L{internet.TimerService}, it won't pickle L{internet.TimerService._loopFinished}. r+ _loopFinishedNrrs r,test_pickleTimerServiceNotPickleLoopFinished>TimerServiceTests.test_pickleTimerServiceNotPickleLoopFinishedshQ 23 ll5)  ll;/ ( _g> W,r)rr>rN)rArBrCrDrErZrrrrrrrrrrFrrrrr,s; # L) A << <- -rrc\rSrSrSrSrSrg)ConnectInformationia 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./Ul/Ul/Ulgr# connectQueueconstructedProtocolspassedFactoriesr&s rr(ConnectInformation.__init__s$&!!rrN)rArBrCrDrEr(rFrrrrrs  "rrcl^^[[5"UU4SjS55n[5mTU"54$)a( 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$>\rSrSrUU4SjrSrg).endpointForTesting..ClientTestEndpointic>^[5nTRRT5 URUU4Sj5nTRRU5 T(aUR S5 U$)Nc>TRS5nTRRU5 [5nUR U5 U$r#) buildProtocolrrrmakeConnection)ignoredprotocol transportr4infos rcreateProtocolNendpointForTesting..ClientTestEndpoint.connect..createProtocolsB"006))00:+- '' 2r)r rrrrr:)r'r4r5rfireImmediatelyrs ` rconnect6endpointForTesting..ClientTestEndpoint.connects`ZF  ' ' 0          $ $V ,%MrrN)rArBrCrDrrF)rrsrClientTestEndpointrs   rr)rrr)rrrs` @rendpointForTestingrs;&'($  D #% %%rcx^^/mTRTR5 URUU4Sj5 U4Sj$)a 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:>TRTR5$r#)removeObserverr) logPublisherlogssrr0catchLogs..s ; ;DKK HrcF>TVs/sHn[U5PM sn$s snfr#)r)eventrs rr0rsD9D5K&D99s) addObserverr addCleanup)testCaserrs `@r catchLogsrs1 DT[[) HI 99rgY@c\rSrSrSrSS\S4SjrSrSrSr S r S r S r S r S rSrSrSrSrS'SjrSrSrSrSrSrSrSrSrSrSrSrSrS r S!r!S"r"S#r#S$r$S%r%S&r&g)(ClientServiceTestsiz Tests for L{ClientService}. TFc X^^^^ ^ ^0nUR[5S9 URU5 USm [US9upx/=m Ul"U UU4SjS[5n U "5=Uln [ X40UD6mU UU4Sjn TRU 5 U(aTR5 UT4$)a 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. rrrc4>^\rSrSrYrUUU4SjrSrU=r$)>ClientServiceTests.makeReconnector..RememberingFactoryi2cX>T(ag[TU]U5nTRU5 U$r#)superrr)r'addrr5 __class__applicationProtocolsrefuseConnectionss rrLClientServiceTests.makeReconnector..RememberingFactory.buildProtocol5s+$.t4$++F3 rr)rArBrCrDrrrF __classcell__)rr protocolTypers@rRememberingFactoryr2s#H  rrc>STlTR(aTR5 TRTR 5/5 gr#) _protocolr{rrngetDelayedCalls)rr'servicesrstop0ClientServiceTests.makeReconnector..stop@s9 $G ##%   U224b 9r) updaterrrrapplicationFactoryrrre)r'rrerrkwnkwcqendpointrr4r rrr s` `` @@@rmakeReconnector"ClientServiceTests.makeReconnectorsB  ! 2G )/J :<;r6   +=*>>9S9 :    "7{rcpURSS9upUR[UR5S5 g)z< When the service is started, a connection attempt is made. Frr+N)rrnror)r'rr s rr$ClientServiceTests.test_startServiceMs2**5*A  R__-q1rcUR5upURnURURS5 URSnUR 5 URURS5 g)z 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)rr rnnumPortsrdoStart)r'rr firstAppFactoryfirstPassedFactorys rtest_startStopFactory(ClientServiceTests.test_startStopFactoryTsh**, // 1115//2""$ 1115rc:UR5upUR5nURU5 URSnUR UR R S5 UR[[555 URU5 g)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) rrrrrnr disconnectingconnectionLostr Exceptionrr'rr r/rs rtest_stopServiceWhileConnected1ClientServiceTests.test_stopServiceWhileConnectedbs **,     ! A**1- ++994@ 45 QrcUR5upUR5nURU5 URSnUR UR R S5 UR5 URU5 UR [UR5S5 UR[[S555 UR [UR5S5 g)z When L{ClientService} is restarted after having been connected, it waits to start connecting until after having disconnected. rTr+zsynthetic connectionLostrN) rrrrrnrrrerorrr r!s r#test_startServiceWaitsForDisconnect6ClientServiceTests.test_startServiceWaitsForDisconnectps **,     ! A**1- ++994@ A R445q9 2L(M NO R445q9rc@URSS9upURSRS5 URSnUR 5nUR U5 UR 5nUR U5 UR5 UR U5 UR U5 URURRS5 UR[[S555 URU5 URSRS5 UR[UR5S5 UR!URU5UR"S5 UR 5nUR U5 g) z 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+r)rrr:rrr whenConnectedrernrrrrr rror^r)r'rr firststopped nextProtocol secondStoppeds rtest_startServiceWhileStopping1ClientServiceTests.test_startServiceWhileStoppingsZ**5*A  ##D)''*%%' G$,,.  L) L) G$ 66= WY/J%KLM W% ##D) R445q9    .0G0G0J  ++-  M*rcURSS9upUR5nURU5 URUR 5[ 5 UR 5 URSRS5 URURSURUR 555 g)z 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) rrrfailureResultOfr(r rerr:r^r)r'rr r*s rtest_startServiceWhileStopped0ClientServiceTests.test_startServiceWhileStoppeds**5*A %%' W% W224nE $$T*   # #B ')=)=g>S>S>U)V rc$[[[5"SS[55nUR US9up#UR SnUR [R"U55 UR [R"U55 g)a 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\rSrSrSrSrg)EClientServiceTests.test_interfacesForTransport..FancyProtocoliz! Provider of various interfaces. rN)rArBrCrDrErFrrr FancyProtocolr6s rr7)rrN)rr r rrrr providedBy)r'r7rr  reactorFacings rtest_interfacesForTransport.ClientServiceTests.test_interfacesForTransports~ +-D E H  F  ** *F //2  /::=IJ .99-HIrc[5nURSUS9up#URSR[ 55 UR [ 5 UR[UR5S5 UR5nURSR[ 55 URU5 g)zE When the service is stopped while retrying, the retry is cancelled. Frrrrr+N) rrrr-r advanceAT_LEAST_ONE_ATTEMPTrnrorrr'rrr r/s rtest_stopServiceWhileRetrying0ClientServiceTests.test_stopServiceWhileRetryings**5*N  ""9;/ *+ R__-q1    ! ""9;/ Qrc[5nURSUS9up#UR[UR5S5 UR URS5 UR 5nURU5 g)z^ When the service is stopped while initially connecting, the connection attempt is cancelled. Fr=r+rN)rrrnrorrrrr@s rtest_stopServiceWhileConnecting2ClientServiceTests.test_stopServiceWhileConnectingsn **5*N  R__-q1 BOOA./    ! Qrc.[5nURUS9up#UR5nURUR 5/5 UR UR U5URS5 UR URSRURS5 UR[URS5[URS55 URS[URS55 g)za When a client connects, the service keeps a reference to the new protocol and resets the delay. rrrN) rrr(rnrr^rrrrassertInstrr)r'rrr awaitingProtocols rtest_clientConnected'ClientServiceTests.test_clientConnecteds ***7 "002 ..0"5   !1 2B4K4KA4N    # #A & 0 0"2I2I!2L  ''* + ''* +  ""1% & rc[5nURSUS9up#UR[UR5S5 URSR [ [555 UR5nURU5 URS5 UR[5 UR[UR5S5 g)zt When a client connection fails, the service removes its reference to the protocol and tries again after a timeout. Fr=r+rc,UR[5$r#)trapr )rs rr0@ClientServiceTests.test_clientConnectionFailed..s n1MrrN) rrrnrorr-rr r(r addErrbackr>r?r'rrr r(s rtest_clientConnectionFailed.ClientServiceTests.test_clientConnectionFaileds **5*N  R__-q1 ""79;#78--/  M*   !MN *+ R__-q1rc [5nURUSS9up#UR[UR5S5 URSR S5 UR[UR5S5 UR URUR55URS5 URSR[[555 UR[5 UR[UR5S5 URSR S5 UR URUR55URS5 g)zf When a client connection is lost, the service removes its reference to the protocol and calls retry. F)rrr+rNr)rrrnrorr:r^rr(rrrrr r>r?)r'rrr s rtest_clientConnectionLost,ClientServiceTests.test_clientConnectionLosts0 ***N  R__-q1 ##D) R__-q1   !6!6!8 92;R;RST;U  "11')+2FG *+ R__-q1 ##D)   !6!6!8 92;R;RST;U rNc^^[5nTRUU4Sj5 TRUSSS9up#TR[ UR 5S5 UR R S5RS5 TR[ UR 5S5 UR5mTRT5 UR[5 TR[ UR 5S5 UR R S5RS5 TRT5 g)z When the client factory refuses connections by returning None from buildProtocol, the factory keeps attempting new connections. c0>TRT[5$r#)r1r )r'r(srr0AClientServiceTests.test_clientConnectionRefused.."s 4 4]N SrFT)rrrr+rN) rrrrnrorpopr:r(rr>r?rQs` @rtest_clientConnectionRefused/ClientServiceTests.test_clientConnectionRefuseds  ST**!" +  R__-q1 A''- R__-q1--/  M*  *+ R__-q1 A''- M*rc6[5nURUS9up#UR5nURSR [ [ 555 URUR5[5 URUR5 g)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) rrrrrrIndentationErrorr1r(r rcalledr@s r&test_clientConnectionLostWhileStopping9ClientServiceTests.test_clientConnectionLostWhileStopping>sy ***7     ! "11':J:L2MN W224nE !rcURSSS9upUR[UR5S5 UR 5 UR[UR5S5 [ U5nUR 5 UR[UR5S5 UR SU"5S5 g)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)rrerr+z$Duplicate ClientService.startServiceN)rrnrorrerrG)r'rr messagess rtest_startTwice"ClientServiceTests.test_startTwiceKs **5u*U  R__-q1 R__-q1T? R__-q1 r?rnror:rr)r'rrr a0a1a2a3f1f2AT_LEAST_TWO_ATTEMPTSresultA0resultA3a4resultA4s rtest_whenConnectedFails*ClientServiceTests.test_whenConnectedFailsos **5*N   " " $  " "Q " 7  " "Q " 7  " "Q " 7 B B B B Y[ ! ""2& B T11"i@"E B B *+ R__-q1 B B B Y[ ! ""2& B T11"i@"E B 4 +, R__-q1 B B ##D)''+''+ X0 X'>'>q'AB " "Q " 7''+ X0rc[5nURSUS9up#UR5nUR5nURSS9nURU5 URU5 URU5 UR 5 UR [ 5 URU[5 URU[5 URU[5 g)zn L{ClientService.whenConnected} returns a L{Deferred} that fails when L{ClientService.stopService} is called. Fr=r+rgN) rrr(rrr>r?r1r )r'rrr rirjrks rtest_whenConnectedStopService0ClientServiceTests.test_whenConnectedStopServices **5*N   ! ! #  ! ! #  ! !A ! 6 A A A *+ Q/ Q/ Q/rc$[5nURSUS9up#URRS5R [ S55 UR 5nURUR5/5 URU5 g)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) rrrrZr-r rrnrrr@s rtest_retryCancelled&ClientServiceTests.test_retryCancelledsy **5*N  A&&y'AB    ! ..0"5 Qrc[5nURSSUS9up#UR5nURUR U55 g)z Calling L{ClientService.stopService} before L{ClientService.startService} returns a L{Deferred} that has already fired with L{None}. F)rrerNrrr assertIsNoner)r'r_r r/s r"test_stopServiceBeforeStartService5ClientServiceTests.test_stopServiceBeforeStartServicesR ))!U*     ! $..q12rc[5nURSUS9up#UR5nURSR [ S55 UR 5 UR5nURURU5R[5 URURU5R[5 g)z L{ClientService.whenConnected} returns a L{Deferred} that errbacks with L{CancelledError} if L{ClientService.stopService} is called between connection attempts. Fr=rrN) rrr(rr-r rrr1rr )r'rrr beforeErrbackAndStopafterErrbackAndStops r'test_whenConnectedErrbacksOnStopService:ClientServiceTests.test_whenConnectedErrbacksOnStopServices**5*N &446 ""9_#=>%335   !5 6 < TS==S- ss'gNrr+r_protopreparess rprepareConnection[ClientServiceTests.test_prepareConnectionCalledWhenServiceStarts..prepareConnection2 QK1 KrT)rrer+N)rrn)r'rrr rs @r-test_prepareConnectionCalledWhenServiceStarts@ClientServiceTests.test_prepareConnectionCalledWhenServiceStarts+sE 3 **/d+  HQK(rc|^/mU4SjnURUS9up#URURSTS5 g)zN The C{prepareConnection} callable is passed the connected protocol instance. c(>TRU5 gr#r)proto newProtocolss rrVClientServiceTests.test_prepareConnectionCalledWithProtocol..prepareConnectionAs    &rrrN)rr^r)r'rrr rs @r(test_prepareConnectionCalledWithProtocol;ClientServiceTests.test_prepareConnectionCalledWithProtocol:sL   '**/+  R44Q7aIrcZ^S/mU4Sjn[5nURUSUS9up4URSR[ S55 UR STS5 UR [5 URSRS5 UR STS5 g)zN The C{prepareConnection} callback is invoked only once a connection is made. rc >TS==S- ss'grrrs rr]ClientServiceTests.test_prepareConnectionCalledAfterConnectionMade..prepareConnectionPrrF)rrrzconnection attempt failedr+N) rrrr-r rnr>r?r:r'rrrr rs @r/test_prepareConnectionCalledAfterConnectionMadeBClientServiceTests.test_prepareConnectionCalledAfterConnectionMadeIs 3 **/e+  ""9-H#IJ HQK( *+ ##D) HQK(rc*^S/mU4Sjn[5nURXS9up4URSTS5 URSR [ [ 555 UR[5 URSTS5 g)zi The C{prepareConnection} callback is invoked each time a connection is made, including on reconnection. rc >TS==S- ss'grrrs rrUClientServiceTests.test_prepareConnectionCalledOnReconnect..prepareConnectiongrrrrr+rN) rrrnrrrr^r>r?rs @r'test_prepareConnectionCalledOnReconnect:ClientServiceTests.test_prepareConnectionCalledOnReconnect`s 3 **/+  HQK( "11':J:L2MN *+ HQK(rc^[5mU4SjnURUS9up#URUR55nUR TU5 g)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>T$r#r)rsentinels rrVClientServiceTests.test_prepareConnectionReturnValueIgnored..prepareConnectionsOrrN)rrrr(assertNotIdentical)r'rrr r5rs @r(test_prepareConnectionReturnValueIgnored;ClientServiceTests.test_prepareConnectionReturnValueIgnoredwsR8 **=N*O %%g&;&;&=> &1rc^^/m[5mUU4SjnURUS9up#UR5nURU5 TR S5 UR UR SURU55 g)zw The C{prepareConnection} callable returns a deferred and calls to L{ClientService.whenConnected} wait until it fires. c*>TRU5 T$r#r)rnewProtocolDeferredrs rrVClientServiceTests.test_prepareConnectionReturningADeferred..prepareConnections    && &rrNr)r rr(rr:r^rr)r'rrr whenConnectedDeferredrrs @@r(test_prepareConnectionReturningADeferred;ClientServiceTests.test_prepareConnectionReturningADeferreds  &j '**=N*O  ' 5 5 7 12$$T*   # #A &(<(<=R(S rcT[5nSnURX!S9up4URSS9nURU5 UR [ 5 URU5 UR [ 5 UR [URU5R5 g)z[ The connection attempt counts as a failure when the C{prepareConnection} callable throws. c[5er#)r^)rs rrJClientServiceTests.test_prepareConnectionThrows..prepareConnections "$ $rrrrgN) rrr(rr>r?r^r^r1type)r'rrrr rs rtest_prepareConnectionThrows/ClientServiceTests.test_prepareConnectionThrowss  %**/+ !( 5 5 5 J 12 *+ 12 *+  d223HINN rr)returnN)'rArBrCrDrErrrrr"r%r-r2r:rArDrJrRrUr[r`rdror~rrrrrrrrrrrrrrrFrrrrrs  HT2 6  : +8 "J(     02" *$+L " MB*81t0&   3 21.10 D ) J).).2& . rr)F)0rErzope.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$rUrrrrr?rrrrrs &-( ";8'4:*@  "#=*=*$=*@ !:. ^   6 !:.V18V1rC-C-L""( &F&8:$z  ,z  r