U  W[d¥ã@sŠdZddlmZmZddlZddlmZddlmZddl m Z m Z ddl m Z ddlmZmZdd lmZdd lmZmZmZdd lmZmZdd lmZmZmZmZmZdd l m!Z!ddl"m#Z#ddl$m%Z%m&Z&ddl'm(Z(dd„Z)eeƒGdd„de*ƒƒZ+eee+ƒeeƒGdd„de*ƒƒZ,eee+ƒGdd„deƒZ-Gdd„deƒZ.Gdd„de*ƒZ/d%dd„Z0e%fd d!„Z1d"Z2Gd#d$„d$eƒZ3dS)&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. é)Úabsolute_importÚdivisionN)Ú implementer)Ú verifyClass)ÚFactoryÚProtocol)ÚClock)ÚTestCaseÚSynchronousTestCase)Úinternet)ÚStreamServerEndpointServiceÚ TimerServiceÚ ClientService)ÚDeferredÚCancelledError)ÚIStreamServerEndpointÚIStreamClientEndpointÚIListeningPortÚIHalfCloseableProtocolÚIFileDescriptorReceiver)Útask)ÚFailure)ÚglobalLogPublisherÚ formatEvent)ÚStringTransportcCsdS)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__GszFakeServer.__init__csFˆjd7_|ˆ_t‡fdd„dˆ_ˆjdk r@ˆ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ÚWóz#FakeServer.listen..)Z cancellerN)ÚlistenAttemptsÚfactoryrÚresultÚfailImmediatelyr&)r#r,rr"rÚlistenKs  ÿ 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-Úcallbackr!r"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!Údeferredr0r"rrrÚstoppedListeningfszFakeServer.stoppedListening)Ú__name__Ú __module__Ú __qualname__Ú__doc__r-r,r.rr'r+r$r/r1r3rrrrr,s rc@seZdZdZdZdd„ZdS)r zs 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} )rr2r"rrrÚ stopListening|szFakePort.stopListening)r4r5r6r7r2r8rrrrr ssr c@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¶sÿz4EndpointServiceTests.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:r1rBÚ stopServiceÚ addCallbackÚappendrFrGr3Z 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=rOZaddBothrQrFrErrRrrrÚ#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)r4r5r6r7r<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Úclockrr2r"rrrr<=szTimerServiceTests.setUpcCs|jS)z‚ Function called by L{TimerService} being tested. @returns: C{self.deferred} @rtype: L{Deferred} )r2r"rrrrYFszTimerServiceTests.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_startServicePs  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_startServiceRunsCallImmediately\s 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Ú getOtherClocknszKTimerServiceTests.test_startServiceUsesGlobalReactor..getOtherClockZ_maybeGlobalReactorN) rrZpatchr rZrBr>r^r[)r#rbrrarÚ"test_startServiceUsesGlobalReactorgs   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ÚassertNoResultrFrLr2r0Úobjectr>ÚsuccessResultOf©r#r(rrrÚtest_stopServiceWaitsus    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)rZrBr2r0rerOr>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) rZrBr2r&rr@rErFrGrOr>rf)r#Úerrorsr(rrrÚtest_failedCallLogsErrors    z*TimerServiceTests.test_failedCallLogsErrorcCsPtdtƒ}| ¡t |¡}| ¡t |¡}tƒ}t|d|ƒ}|  ||¡dS)zq When pickling L{internet.TimerService}, it won't pickle L{internet.TimerService._loop}. r%r^N© r rrBÚ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)r4r5r6r7r<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)r4r5r6r7r$rrrrru½s ruFcs.ttƒG‡‡fdd„dtƒƒ}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)rrxrQrPrvr0)r#r,r-r~©ÚfireImmediatelyr})r,rÚconnectÞs   z6endpointForTesting..ClientTestEndpoint.connectN)r4r5r6rrrrrÚClientTestEndpointÜsr‚)rrreru)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Ú sz/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„dttƒ‰ˆƒ|_}t||f|Ž‰‡‡‡fdd„} ˆ | ¡|r–ˆ  ¡|ˆfS)aL Create a L{ClientService} along with a L{ConnectInformation} indicating the connections in progress on its endpoint. @param fireImmediately: Should all of the endpoint connection attempts fire synchronously? @type fireImmediately: L{bool} @param startService: Should the L{ClientService} be started before being returned? @type startService: L{bool} @param protocolType: a 0-argument callable returning a new L{IProtocol} provider to be used for application-level protocol connections. @param kw: Arbitrary keyword arguments to be passed on to L{ClientService} @return: a 2-tuple of L{ConnectInformation} (for information about test state) and L{ClientService} (the system under test). The L{ConnectInformation} has 2 additional attributes; C{applicationFactory} and C{applicationProtocols}, which refer to the unwrapped protocol factory and protocol instances passed in to L{ClientService} respectively. ©r[r[©r€cs$eZdZ”Z‡‡‡fdd„Z‡ZS)z>ClientServiceTests.makeReconnector..RememberingFactorycstˆ|ƒ |¡}ˆ |¡|Sr)ÚsuperryrQ)r#Zaddrr-)ÚRememberingFactoryÚ __class__ÚapplicationProtocolsrrry6s zLClientServiceTests.makeReconnector..RememberingFactory.buildProtocol)r4r5r6r{ryÚ __classcell__r)rr‘Ú protocolType)rrr4srcs(dˆ_ˆjrˆ ¡ˆ ˆ ¡g¡dSr)Z _protocolrLrOrFÚgetDelayedCallsr)r[r#ÚservicerrÚstop>sz0ClientServiceTests.makeReconnector..stop) Úupdaterrƒr‘rreÚapplicationFactoryrr‰rB) r#r€rBr“ÚkwZnkwÚcqZendpointr,r–r)rr‘r[r“r#r•rÚmakeReconnector s    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_Ksz$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_startStopFactorySs   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_stopServiceWhileConnectedbs   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_startServiceWaitsForDisconnectqs    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›rvr0rwrOrdÚ whenConnectedrBrFr|rržrrŸrfrGr>r‘)r#ršr•ÚfirstÚstoppedZ nextProtocolZ secondStoppedrrrÚtest_startServiceWhileStopping‚s(       ÿ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£rrBrvr0r>r‘)r#ršr•r¥rrrÚtest_startServiceWhileStoppedžs   ÿz0ClientServiceTests.test_startServiceWhileStoppedcCsZtttƒGdd„dttƒƒ}|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) rrrrrer›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›rFrGrvr0r>rfr£r‘rwrž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£rr\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_startTwicesÿ z"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£rdrvr0rfr>r‘) r#r[ršr•ÚaÚbÚcZresultAZresultBZresultCrrrÚtest_whenConnectedLater0s         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®rFrGr0rfr‘)r#r[ršr•Za0Za1Za2Za3Úf1Úf2ZAT_LEAST_TWO_ATTEMPTSZresultA0ZresultA3Za4ZresultA4rrrÚtest_whenConnectedFailsFsN                          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_whenConnectedStopServices       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›rvr0rOrwrž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›rvr0rOrBrwrž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ÚprepareConnectionsz[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Ñ2sz]ClientServiceTests.test_prepareConnectionCalledAfterConnectionMade..prepareConnectionF)rÑr€r[zconnection attempt failedr%N) rr›rvr&rŸrFr­r®r0©r#rÑr[ršr•rrÐrÚ/test_prepareConnectionCalledAfterConnectionMade+s þ  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ÑJszUClientServiceTests.test_prepareConnectionCalledOnReconnect..prepareConnection©rÑr[r%rXN) rr›rFrwržrrµr­r®rÛrrÐrÚ'test_prepareConnectionCalledOnReconnectCs ÿ  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ÑeszVClientServiceTests.test_prepareConnectionReturnValueIgnored..prepareConnectionrÙN)rer›rfr£ZassertNotIdentical)r#rÑršr•r-rrßrÚ(test_prepareConnectionReturnValueIgnoredZs  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Ñvs zVClientServiceTests.test_prepareConnectionReturningADeferred..prepareConnectionrÙNr)rr›r£rdr0r>r‘rf)r#rÑršr•ÚwhenConnectedDeferredrrârÚ(test_prepareConnectionReturningADeferredns   ÿ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ÑŒszJClientServiceTests.test_prepareConnectionThrows..prepareConnectionrÝrXr¸N) rr›r£rdr­r®r>rµr¨Útype)r#r[rÑršr•rãrrrÚtest_prepareConnectionThrows…sÿ       ÿz/ClientServiceTests.test_prepareConnectionThrowsN)$r4r5r6r7rr›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‹sDÿ @  ;r‹)F)4r7Z __future__rrrmZzope.interfacerZzope.interface.verifyrZtwisted.internet.protocolrrZtwisted.internet.taskrZtwisted.trial.unittestr r Ztwisted.applicationr Ztwisted.application.internetr r rZtwisted.internet.deferrrZtwisted.internet.interfacesrrrrrZtwisted.internetrZtwisted.python.failurerZtwisted.loggerrrZtwisted.test.proto_helpersrrrerr r9rWrurƒrŠr®r‹rrrrÚs>       B  '