a )¶(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úElib/python3.9/site-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__LszFakeServer.__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..)Z 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_szFakeServer.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-r/r1rrrrr0src@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 r0r rrrÚ stopListening~szFakePort.stopListeningcCsdSrrr rrrÚgetHost‡szFakePort.getHostcCsdSrrr rrrÚstartListening‹szFakePort.startListening)r2r3r4r5r0r6r7r8rrrrrts  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;Ú_raiseSynchronouslyZ assertRaisesÚ startService)r!ZthunkrrrÚ(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)rCr;r=r rrrÚtest_synchronousRaisePrivileged½sz4EndpointServiceTests.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;rBr:r+r$r@ÚflushLoggedErrorsÚ assertEqualÚlen©r!ZloggedrrrÚ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;rArBr:r+r$r@rErFrGrHrrrÚ!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)r@r:r,r;rBrErFrGrHrrrÚ 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;rBr>r*r:rFÚ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)r?r;rBrFr:r)rLr 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;r=r:r/rBÚ stopServiceÚ addCallbackÚappendrFrGr1Z assertFalserL©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;r=rOZaddBothrQrFrEr rRrrrÚ#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#) r@r:r%r;r=rOrPrQrFrErG)r!r+rSZstoppingErrorsrrrÚ test_stopServiceCancelStartErrors     z5EndpointServiceTests.test_stopServiceCancelStartError)N)r2r3r4r5r<r?rCrDrIrJrKrMrNrTrUrVrrrrr9“s       r9c@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 r0r rrrr<:szTimerServiceTests.setUpcCs|jS)z‚ Function called by L{TimerService} being tested. @returns: C{self.deferred} @rtype: L{Deferred} )r0r rrrrYBszTimerServiceTests.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) rZrBÚ assertTruerLÚassertIsInstanceÚ_looprZ LoopingCallr>r[r 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)rQrZrYrBrF)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. csˆSrr)Z maybeReactor©Z otherClockrrÚ getOtherClockhszKTimerServiceTests.test_startServiceUsesGlobalReactor..getOtherClockZ_maybeGlobalReactorN) rrZpatchrrZrBr>r^r[)r!rbrrarÚ"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) rZrBrOÚassertNoResultrFrLr0r.Úobjectr>Ú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)rZrBr0r.rerOr>rfrgrrrÚ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) rZrBr0r$rr@rErFrGrOr>rf)r!Úerrorsr&rrrÚtest_failedCallLogsError…s    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© rrrBÚpickleÚdumpsrOÚloadsreÚgetattrr>©r!rZZ dumpedTimerZ loadedTimerZnothingÚvaluerrrÚ$test_pickleTimerServiceNotPickleLoop‘s    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 _loopFinishedNrlrqrrrÚ,test_pickleTimerServiceNotPickleLoopFinished¡s    z>TimerServiceTests.test_pickleTimerServiceNotPickleLoopFinishedN)r2r3r4r5r<rYr_r`rcrhrirkrsrtrrrrrW,s       rWc@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"ÀszConnectInformation.__init__N)r2r3r4r5r"rrrrru²s ruFcs,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)Ú buildProtocolrwrQrZmakeConnection)ÚignoredÚprotocolÚ transport)r*ÚinforrÚcreateProtocolØs    zNendpointForTesting..ClientTestEndpoint.connect..createProtocol)r rxrQrPrvr.)r!r*r+r~©ÚfireImmediatelyr})r*rÚconnectÔs   z6endpointForTesting..ClientTestEndpoint.connectN)r2r3r4rrrrrÚClientTestEndpointÒsr‚)rrru)r€r‚rrrÚ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)ZremoveObserverrQr©Ú logPublisherÚlogsrrr'÷r(zcatchLogs..csdd„ˆDƒS)NcSsg|] }t|ƒ‘qSr)r)Ú.0ZeventrrrÚ ør(z/catchLogs....rr)r†rrr'ør()Z addObserverrQÚ addCleanup)ZtestCaser…rr„rÚ 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„} ˆ | ¡|r–ˆ ¡|ˆfS)aL Create a L{ClientService} along with a L{ConnectInformation} indicating the connections in progress on its endpoint. @param fireImmediately: Should all of the endpoint connection attempts fire synchronously? @type fireImmediately: L{bool} @param startService: Should the L{ClientService} be started before being returned? @type startService: L{bool} @param protocolType: a 0-argument callable returning a new L{IProtocol} provider to be used for application-level protocol connections. @param kw: Arbitrary keyword arguments to be passed on to L{ClientService} @return: a 2-tuple of L{ConnectInformation} (for information about test state) and L{ClientService} (the system under test). The L{ConnectInformation} has 2 additional attributes; C{applicationFactory} and C{applicationProtocols}, which refer to the unwrapped protocol factory and protocol instances passed in to L{ClientService} respectively. ©r[r[©r€cs"eZdZ”Z‡‡fdd„Z‡ZS)z>ClientServiceTests.makeReconnector..RememberingFactorycstƒ |¡}ˆ |¡|Sr)ÚsuperryrQ)r!Zaddrr+)Ú __class__ÚapplicationProtocolsrrry0s  zLClientServiceTests.makeReconnector..RememberingFactory.buildProtocol)r2r3r4r{ryÚ __classcell__r)rÚ protocolType)rrÚRememberingFactory-sr“cs(dˆ_ˆjrˆ ¡ˆ ˆ ¡g¡dSr)Z _protocolrLrOrFÚgetDelayedCallsr)r[r!ÚservicerrÚstop9sz0ClientServiceTests.makeReconnector..stop) ÚupdaterrƒrrÚapplicationFactoryrr‰rB) r!r€rBr’ÚkwZnkwÚcqZendpointr“r*r–r)rr[r’r!r•rÚmakeReconnectors    z"ClientServiceTests.makeReconnectorcCs&|jdd\}}| t|jƒd¡dS)zL When the service is started, a connection attempt is made. Frr#N)r›rFrGrv)r!ršr•rrrr_Fsz$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˜rFZnumPortsrxZdoStart)r!ršr•ZfirstAppFactoryZfirstPassedFactoryrrrÚ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›rOrdrwrFr|Ú disconnectingÚconnectionLostrÚ Exceptionrf©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#rXN) r›rOrdrwrFr|rrBrGrž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. FrrNTr#rX)r›rvr.rwrOrdÚ whenConnectedrBrFr|rržrrŸrfrGr>r)r!ršr•ÚfirstÚstoppedZ nextProtocolZ 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›rOrfÚfailureResultOfr£r rBrvr.r>r)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)r2r3r4r5rrrrÚ FancyProtocol¯srª)r’rN)rr r rr›rwr\Z providedBy)r!rªršr•Z 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€r[rrXr#N) rr›rvr$rŸÚadvanceÚAT_LEAST_ONE_ATTEMPTrFrGrOrf©r!r[rš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›rFrGrvrdrOrfr¯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£rFr”r>rfr)r!r[ršr•ZawaitingProtocolrrrÚ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)Ztrapr )rzrrrr'ír(z@ClientServiceTests.test_clientConnectionFailed..rXN) rr›rFrGrvr$rrŸr£rdZ addErrbackr­r®)r!r[rš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)r[r€r#rNrX)rr›rFrGrvr.r>rfr£rrwržrrŸr­r®)r!r[rš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›rOrwržrÚIndentationErrorr¨r£r r\Zcalledr¯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€rBrr#z$Duplicate ClientService.startServiceN)r›rFrGrvrBrŠZassertIn)r!ršr•ZmessagesrrrÚ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#©ZfailAfterFailuresrN) rr›r£rdrvr.rfr>r) r!r[ršr•ÚaÚbÚcZresultAZresultBZresultCrrrÚ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¸rXérN)rr›r£rdrrŸrvr$r>r¨r­r®rFrGr.rfr)r!r[ršr•Za0Za1Za2Za3Úf1Úf2ZAT_LEAST_TWO_ATTEMPTSZresultA0ZresultA3Za4ZresultA4rrrÚ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£rdrOr­r®r¨r )r!r[rš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›rvr$rŸrOrFr”rfr¯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€rBr[N©rr›rOZ assertIsNonerf)r!r[Ú_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£rvr$rŸrOr]r¨rrr )r!r[ršr•ZbeforeErrbackAndStopZafterErrbackAndStoprrrÚ'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›rvr.rOrwržrrµrf©r!r[rš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›rvr.rOrBrwržrrµrfrÈrrrÚ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!r[rÅr•rÉrÊrrrÚ 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. rcsˆdd7<dS©Nrr#r©Z_proto©ZpreparesrrÚprepareConnectionúsz[ClientServiceTests.test_prepareConnectionCalledWhenServiceStarts..prepareConnectionT)rÑrBr#N)r›rF©r!rÑršr•rrÐrÚ-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©rQ©Úproto©Ú newProtocolsrrrÑ szVClientServiceTests.test_prepareConnectionCalledWithProtocol..prepareConnection©rÑrN)r›r>rwrÒrr×rÚ(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. rcsˆdd7<dSrÎrrÏrÐrrrÑsz]ClientServiceTests.test_prepareConnectionCalledAfterConnectionMade..prepareConnectionF)rÑr€r[zconnection attempt failedr#N) rr›rvr$rŸrFr­r®r.©r!rÑr[ršr•rrÐrÚ/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. rcsˆdd7<dSrÎrrÏrÐrrrÑ/szUClientServiceTests.test_prepareConnectionCalledOnReconnect..prepareConnection©rÑr[r#rXN) rr›rFrwržrrµr­r®rÛrrÐrÚ'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. csˆSrrrÕ©ÚsentinelrrrÑJszVClientServiceTests.test_prepareConnectionReturnValueIgnored..prepareConnectionrÙN)rer›rfr£ZassertNotIdentical)r!rÑrš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ˆ |¡ˆSrrÔrÕ©ZnewProtocolDeferredrØrrrÑZs zVClientServiceTests.test_prepareConnectionReturningADeferred..prepareConnectionrÙNr)r r›r£rdr.r>rrf)r!rÑrš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. cSs tƒ‚dSr)rµrÏrrrrÑpszJClientServiceTests.test_prepareConnectionThrows..prepareConnectionrÝrXr¸N) rr›r£rdr­r®r>rµr¨Útype)r!r[rÑršr•rãrrrÚtest_prepareConnectionThrowsisÿ       ÿz/ClientServiceTests.test_prepareConnectionThrowsN)$r2r3r4r5rr›r_rœr¡r¢r¦r©r«r°r±r²r³r´r¶r·r¼rÀrÁrÃrÆrÇrËrÌrÍrÓrÚrÜrÞrárärærrrrr‹þsBÿ C    :   r‹)F)0r5rmZzope.interfacerZzope.interface.verifyrZtwisted.applicationrZtwisted.application.internetrrrZtwisted.internetrZtwisted.internet.deferr r Ztwisted.internet.interfacesr r r rrZtwisted.internet.protocolrrZtwisted.internet.taskrZtwisted.loggerrrZtwisted.python.failurerZtwisted.test.proto_helpersrZtwisted.trial.unittestrrrrrr9rWrurƒrŠr®r‹rrrrÚs<       @   #