o Òó·i¬ã@stdZddlZddlmZddlmZddlmZddlm Z m Z m Z ddl m Z ddlmZmZdd lmZmZmZmZmZdd lmZmZdd lmZdd lmZdd lmZm 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,e fdd „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)ÚStringTransport)Ú formatEventÚglobalLogPublisher)ÚFailure)ÚSynchronousTestCaseÚTestCasecCsdS)zM A fake target function for testing TimerService which does nothing. N©rrrúlC:\Users\psant\Downloads\PAF backend\school\venv\Lib\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__Ls zFakeServer.__init__csFˆjd7_|ˆ_t‡fdd„dˆ_ˆjdur ˆj ˆj¡ˆjS)zê Return a Deferred and store it for future use. (Implementation of L{IStreamServerEndpoint}). @param factory: the factory to listen with @return: a L{Deferred} stored in L{FakeServer.result} écs | ˆj¡Sr)ÚerrbackÚcancelException)Údr rrÚZó z#FakeServer.listen..)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_ózFakeServer.startedListeningcCs|jj d¡dS)a Test code should invoke this method after causing C{stopListening} to be invoked on the port fired from the L{Deferred} returned from C{listen} in order to cause the L{Deferred} returned from C{stopListening} to fire. N)rÚdeferredr.r rrrÚstoppedListeninggszFakeServer.stoppedListening)Ú__name__Ú __module__Ú __qualname__Ú__doc__r+r*r,r r%r)r"r-r/r2rrrrr0s rc@s,eZdZdZdZdd„Zdd„Zdd„ZdS) rzs Fake L{IListeningPort} implementation. @ivar deferred: The L{Deferred} returned by C{stopListening}. NcCstƒ|_|jS)z` Stop listening. @return: a L{Deferred} stored in L{FakePort.deferred} N)r r1r rrrÚ stopListening~szFakePort.stopListeningcCódSrrr rrrÚgetHost‡ózFakePort.getHostcCr8rrr rrrÚstartListening‹r:zFakePort.startListening)r3r4r5r6r1r7r9r;rrrrrts  rc@sreZdZdZdd„Zdd„Zddd„Zd d „Zd d „Zd d„Z dd„Z dd„Z dd„Z dd„Z dd„Zdd„ZdS)ÚEndpointServiceTestsz4 Tests for L{twisted.application.internet}. cCs$tƒ|_tƒ|_t|j|jƒ|_dS)zp Construct a stub server, a stub factory, and a L{StreamServerEndpointService} to test. N)rÚ fakeServerrr*rÚsvcr rrrÚsetUp˜szEndpointServiceTests.setUpcCs |j ¡| |j|jj¡dS)z‡ L{StreamServerEndpointService.privilegedStartService} calls its endpoint's C{listen} method with its factory. N)r>ÚprivilegedStartServiceÚassertIdenticalr*r=r rrrÚtest_privilegedStartService¡s z0EndpointServiceTests.test_privilegedStartServiceNcCs*tƒ|j_d|j_| t|p|jj¡dS)a@ L{StreamServerEndpointService.startService} should raise synchronously if the L{Deferred} returned by its wrapped L{IStreamServerEndpoint.listen} has already fired with an errback and the L{StreamServerEndpointService}'s C{_raiseSynchronously} flag has been set. This feature is necessary to preserve compatibility with old behavior of L{twisted.internet.strports.service}, which is to return a service which synchronously raises an exception from C{startService} (so that, among other things, twistd will not start running). However, since L{IStreamServerEndpoint.listen} may fail asynchronously, it is a bad idea to rely on this behavior. @param thunk: If specified, a callable to execute in place of C{startService}. TN)ÚZeroDivisionErrorr=r,r>Ú_raiseSynchronouslyÚ assertRaisesÚ startService)r!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)rGr>r@r rrrÚtest_synchronousRaisePrivileged½r0z4EndpointServiceTests.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>rFr=r+r$rCÚ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>rDrFr=r+r$rCrIrJrKrLrrrÚ!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)rCr=r,r>rFrIrJrKrLrrrÚ 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>rFrAr*r=rJÚ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)rBr>rFrJr=r)rPr 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/rFÚ stopServiceÚ addCallbackÚappendrJrKr2Z assertFalserP©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@rSZaddBothrUrJrIr rVrrrÚ#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#) rCr=r%r>r@rSrTrUrJrIrK)r!r+rWZstoppingErrorsrrrÚ test_stopServiceCancelStartErrors     z5EndpointServiceTests.test_stopServiceCancelStartErrorr)r3r4r5r6r?rBrGrHrMrNrOrQrRrXrYrZrrrrr<“s      r<c@s`eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dS)ÚTimerServiceTestsa) Tests for L{twisted.application.internet.TimerService}. @type timer: L{TimerService} @ivar timer: service to test @type clock: L{task.Clock} @ivar clock: source of time @type deferred: L{Deferred} @ivar deferred: deferred returned by L{TimerServiceTests.call}. cCs,td|jƒ|_t ¡|_|j_tƒ|_dS)z1 Set up a timer service to test. éN)rÚcallÚtimerrrÚclockr r1r rrrr?:s zTimerServiceTests.setUpcCs|jS)z‚ Function called by L{TimerService} being tested. @returns: C{self.deferred} @rtype: L{Deferred} N)r1r rrrr]BszTimerServiceTests.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) r^rFÚ assertTruerPÚassertIsInstanceÚ_looprZ LoopingCallrAr_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)rUr^r]rFrJ)r!r+rrrÚ$test_startServiceRunsCallImmediatelyVs z6TimerServiceTests.test_startServiceRunsCallImmediatelycsBt ¡‰‡fdd„}| td|¡|j ¡| ˆ|jjj¡dS)z± L{TimerService.startService} uses L{internet._maybeGlobalReactor} to choose the reactor to pass to L{task.LoopingCall} uses the global reactor. cóˆSrr)Z maybeReactor©Z otherClockrrÚ getOtherClockhózKTimerServiceTests.test_startServiceUsesGlobalReactor..getOtherClockZ_maybeGlobalReactorN) rrÚpatchrr^rFrArbr_)r!rgrrfrÚ"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) r^rFrSÚassertNoResultrJrPr1r.ÚobjectrAÚ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)r^rFr1r.rlrSrArmrnrrrÚ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) r^rFr1r$rrCrIrJrKrSrArm)r!Úerrorsr&rrrÚtest_failedCallLogsError…s   z*TimerServiceTests.test_failedCallLogsErrorcCóPtdtƒ}| ¡t |¡}| ¡t |¡}tƒ}t|d|ƒ}|  ||¡dS)zq When pickling L{internet.TimerService}, it won't pickle L{internet.TimerService._loop}. r#rbN© rrrFÚpickleÚdumpsrSÚloadsrlÚgetattrrA©r!r^Z dumpedTimerZ loadedTimerZnothingÚvaluerrrÚ$test_pickleTimerServiceNotPickleLoop‘ó    z6TimerServiceTests.test_pickleTimerServiceNotPickleLoopcCrs)zy When pickling L{internet.TimerService}, it won't pickle L{internet.TimerService._loopFinished}. r#Z _loopFinishedNrtryrrrÚ,test_pickleTimerServiceNotPickleLoopFinished¡r|z>TimerServiceTests.test_pickleTimerServiceNotPickleLoopFinishedN)r3r4r5r6r?r]rcrdrjrorprrr{r}rrrrr[,s       r[c@seZdZdZdd„ZdS)ÚConnectInformationaË Information about C{endpointForTesting} @ivar connectQueue: a L{list} of L{Deferred} returned from C{connect}. If these are not already fired, you can fire them with no value and they will trigger building a factory. @ivar constructedProtocols: a L{list} of protocols constructed. @ivar passedFactories: a L{list} of L{IProtocolFactory}; the ones actually passed to the underlying endpoint / i.e. the reactor. cCsg|_g|_g|_dSr)Ú connectQueueÚconstructedProtocolsÚpassedFactoriesr rrrr"Às zConnectInformation.__init__N)r3r4r5r6r"rrrrr~²s r~Fcs,ttƒG‡‡fdd„dƒƒ}tƒ‰ˆ|ƒfS)aD Make a sample endpoint for testing. @param fireImmediately: If true, fire all L{Deferred}s returned from C{connect} immedaitely. @return: a 2-tuple of C{(information, endpoint)}, where C{information} is a L{ConnectInformation} describing the operations in progress on C{endpoint}. cseZdZ‡‡fdd„ZdS)z.endpointForTesting..ClientTestEndpointcsDtƒ}ˆj ˆ¡|j‡‡fdd„ƒ}ˆj |¡ˆr | d¡|S)Ncs*ˆ d¡}ˆj |¡tƒ}| |¡|Sr)Ú buildProtocolr€rUrZmakeConnection)ÚignoredÚprotocolÚ transport)r*ÚinforrÚcreateProtocolØs   zNendpointForTesting..ClientTestEndpoint.connect..createProtocol)r rrUrTrr.)r!r*r+r‡©ÚfireImmediatelyr†)r*rÚconnectÔs   z6endpointForTesting..ClientTestEndpoint.connectN)r3r4r5rŠrrˆrrÚClientTestEndpointÒsr‹N)rrr~)r‰r‹rrˆrÚendpointForTestingÆs  rŒcs0g‰ˆ ˆj¡| ‡‡fdd„¡‡fdd„S)a6 Catch the global log stream. @param testCase: The test case to add a cleanup to. @param logPublisher: the log publisher to add and remove observers for. @return: a 0-argument callable that returns a list of textual log messages for comparison. @rtype: L{list} of L{unicode} cs ˆ ˆj¡Sr)ZremoveObserverrUr©Ú logPublisherÚlogsrrr'÷r(zcatchLogs..csdd„ˆDƒS)NcSsg|]}t|ƒ‘qSr)r)Ú.0ÚeventrrrÚ øsz/catchLogs....rr)rrrr'øsN)Z addObserverrUÚ addCleanup)ZtestCaserŽrrrÚ catchLogsés  r”gY@c@seZdZdZddedfdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„ZdFd d!„Zd"d#„Zd$d%„Zd&d'„Zd(d)„Zd*d+„Zd,d-„Zd.d/„Zd0d1„Zd2d3„Zd4d5„Zd6d7„Zd8d9„Zd:d;„Zdd?„Z!d@dA„Z"dBdC„Z#dDdE„Z$dS)GÚClientServiceTestsz% Tests for L{ClientService}. TFc  s i}|jtƒd| |¡|d‰t|d\}}g‰|_G‡‡‡fdd„dtƒ} | ƒ|_} t|| fi|¤Ž‰‡‡‡fdd„} ˆ | ¡|rLˆ ¡|ˆ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..RememberingFactorycs"ˆrdStƒ |¡}ˆ |¡|Sr)Úsuperr‚rU)r!Úaddrr+)Ú __class__ÚapplicationProtocolsÚrefuseConnectionsrrr‚5s   zLClientServiceTests.makeReconnector..RememberingFactory.buildProtocol)r3r4r5r„r‚Ú __classcell__r)r›Ú protocolTyperœ)ršrÚRememberingFactory2srŸcs(dˆ_ˆjr ˆ ¡ˆ ˆ ¡g¡dSr)Ú _protocolrPrSrJÚgetDelayedCallsr)r_r!ÚservicerrÚstop@sz0ClientServiceTests.makeReconnector..stopN) ÚupdaterrŒr›rÚapplicationFactoryrr“rF) r!r‰rFržrœÚkwZnkwÚcqZendpointrŸr*r£r)r›r_ržrœr!r¢rÚmakeReconnectors!    z"ClientServiceTests.makeReconnectorcCs&|jdd\}}| t|jƒd¡dS)zL When the service is started, a connection attempt is made. Fr—r#N)r¨rJrKr)r!r§r¢rrrrcMsz$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¥rJZnumPortsrZdoStart)r!r§r¢ZfirstAppFactoryZfirstPassedFactoryrrrÚtest_startStopFactoryTs  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¨rSrkr€rJr…Ú disconnectingÚconnectionLostrÚ Exceptionrm©r!r§r¢r&r„rrrÚtest_stopServiceWhileConnectedbs   z1ClientServiceTests.test_stopServiceWhileConnectedcCs„| ¡\}}| ¡}| |¡|jd}| |jjd¡| ¡| |¡| t|jƒd¡|  t t dƒƒ¡| t|jƒd¡dS)z— When L{ClientService} is restarted after having been connected, it waits to start connecting until after having disconnected. rTr#zsynthetic connectionLostr\N) r¨rSrkr€rJr…rªrFrKr«rr¬r­rrrÚ#test_startServiceWaitsForDisconnectps    z6ClientServiceTests.test_startServiceWaitsForDisconnectcCsæ|jdd\}}|jd d¡|jd}| ¡}| |¡| ¡}| |¡| ¡| |¡| |¡| |j j d¡|  t t dƒƒ¡| |¡|jd d¡| t|jƒd¡| | |¡|jd¡| ¡}| |¡dS) a% When L{ClientService} is stopping - that is, L{ClientService.stopService} has been called, but the L{Deferred} it returns has not fired yet - calling L{startService} will cause a new connection to be made, and new calls to L{whenConnected} to succeed. Fr—rNTzsynthetic connection lostr#r\)r¨rr.r€rSrkÚ whenConnectedrFrJr…rªr«rr¬rmrKrAr›)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¨rSrmÚfailureResultOfr°r rFrr.rAr›)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)r3r4r5r6rrrrÚ FancyProtocol¶sr·)ržrN)rr r rr¨r€r`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_rr\r#N) rr¨rr$r¬ÚadvanceÚAT_LEAST_ONE_ATTEMPTrJrKrSrm©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¨rJrKrrkrSrmr¼rrrÚtest_stopServiceWhileConnectingÎs z2ClientServiceTests.test_stopServiceWhileConnectingcCsštƒ}|j|d\}}| ¡}| | ¡g¡| | |¡|jd¡| |jdj |jd¡|  t |jdƒt |jdƒ¡|  dt |j dƒ¡dS)zy When a client connects, the service keeps a reference to the new protocol and resets the delay. r–rrŸN) rr¨r°rJr¡rArmr›r€r ÚassertInÚstrr)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 )rƒrrrr'ÿs z@ClientServiceTests.test_clientConnectionFailed..r\N) rr¨rJrKrr$rr¬r°rkZ 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#rNr\)rr¨rJrKrr.rArmr°r›r€r«rr¬rºr»©r!r_r§r¢rrrÚtest_clientConnectionLostsÿ ÿz,ClientServiceTests.test_clientConnectionLostÚreturnNcs²tƒ}ˆ ‡‡fdd„¡ˆj|ddd\}}ˆ t|jƒd¡|j d¡ d¡ˆ t|jƒd¡| ¡‰ˆ  ˆ¡|  t ¡ˆ t|jƒd¡|j d¡ d¡ˆ  ˆ¡dS) z™ When the client factory refuses connections by returning None from buildProtocol, the factory keeps attempting new connections. cs ˆ ˆt¡Sr)rµr r©r!r°rrr'"r(zAClientServiceTests.test_clientConnectionRefused..FT)r_r‰rœr#rN) rr“r¨rJrKrÚpopr.r°rkrºr»rÃrrÆrÚtest_clientConnectionRefuseds  ü  z/ClientServiceTests.test_clientConnectionRefusedcCsTtƒ}|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¨rSr€r«rÚIndentationErrorrµr°r r`Úcalledr¼rrrÚ&test_clientConnectionLostWhileStopping>s 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‰rFrr#z$Duplicate ClientService.startServiceN)r¨rJrKrrFr”r¿)r!r§r¢ÚmessagesrrrÚtest_startTwiceKsz"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°rkrr.rmrAr›) r!r_r§r¢ÚaÚbÚcZresultAZresultBZresultCrrrÚtest_whenConnectedLaterZs         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Îr\érN)rr¨r°rkrr¬rr$rArµrºr»rJrKr.rmr›)r!r_r§r¢Za0Za1Za2Úa3Úf1Úf2ZAT_LEAST_TWO_ATTEMPTSZresultA0ZresultA3Za4ZresultA4rrrÚtest_whenConnectedFailsosN                          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°rkrSrºr»rµr )r!r_r§r¢rÏrÐrÑrrrÚtest_whenConnectedStopService©s       z0ClientServiceTests.test_whenConnectedStopServicecCsTtƒ}|jd|d\}}|j d¡ tdƒ¡| ¡}| | ¡g¡|  |¡dS)zÎ When L{ClientService.stopService} is called while waiting between connection attempts, the pending reconnection attempt is cancelled and the service is stopped immediately. Fr¹rú no connectionN) rr¨rrÇr$r¬rSrJr¡rmr¼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‰rFr_N©rr¨rSZ assertIsNonerm)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°rr$r¬rSrarµrzr )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¨rr.rSr€r«rrÉrm©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¨rr.rSrFr€r«rrÉrmrßrrrÚtest_stopServiceWhileRestartings 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_stopServiceOnStoppedServices z3ClientServiceTests.test_stopServiceOnStoppedServicecs8dg‰‡fdd„}|j|dd\}}| dˆd¡dS)z† The C{prepareConnection} callable is called after L{ClientService.startService} once the connection is made. rcóˆdd7<dS©Nrr#r©Ú_proto©ZpreparesrrÚprepareConnection2óz[ClientServiceTests.test_prepareConnectionCalledWhenServiceStarts..prepareConnectionT)rêrFr#N)r¨rJ©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©rU©Úproto©Ú newProtocolsrrrêAszVClientServiceTests.test_prepareConnectionCalledWithProtocol..prepareConnection©rêrN)r¨rAr€rìrrñrÚ(test_prepareConnectionCalledWithProtocol:s   ÿz;ClientServiceTests.test_prepareConnectionCalledWithProtocolcs~dg‰‡fdd„}tƒ}|j|d|d\}}|jd tdƒ¡| dˆd¡| t¡|jd d¡| dˆd¡dS) zf The C{prepareConnection} callback is invoked only once a connection is made. rcrårærrçrérrrêPrëz]ClientServiceTests.test_prepareConnectionCalledAfterConnectionMade..prepareConnectionF)rêr‰r_zconnection attempt failedr#N) rr¨rr$r¬rJrºr»r.©r!rêr_r§r¢rrérÚ/test_prepareConnectionCalledAfterConnectionMadeIs  ÿ zBClientServiceTests.test_prepareConnectionCalledAfterConnectionMadecsndg‰‡fdd„}tƒ}|j||d\}}| dˆd¡|jd ttƒƒ¡| t¡| dˆd¡dS)z The C{prepareConnection} callback is invoked each time a connection is made, including on reconnection. rcrårærrçrérrrêgrëzUClientServiceTests.test_prepareConnectionCalledOnReconnect..prepareConnection©rêr_r#r\N) rr¨rJr€r«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. crerrrï©Úsentinelrrrê‚rhzVClientServiceTests.test_prepareConnectionReturnValueIgnored..prepareConnectionróN)rlr¨rmr°ZassertNotIdentical)r!rêr§r¢r+rrùrÚ(test_prepareConnectionReturnValueIgnoredws  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ê’s zVClientServiceTests.test_prepareConnectionReturningADeferred..prepareConnectionróNr)r r¨r°rkr.rAr›rm)r!rêr§r¢ÚwhenConnectedDeferredrrürÚ(test_prepareConnectionReturningADeferredŠs  ÿz;ClientServiceTests.test_prepareConnectionReturningADeferredcCsltƒ}dd„}|j||d\}}|jdd}| |¡| t¡| |¡| t¡| t| |¡j ¡dS)zs The connection attempt counts as a failure when the C{prepareConnection} callable throws. cSstƒ‚r)rÉrçrrrrê¨szJClientServiceTests.test_prepareConnectionThrows..prepareConnectionr÷r\rÎN) rr¨r°rkrºr»rArÉrµÚtype)r!r_rêr§r¢rýrrrÚtest_prepareConnectionThrows¡s ÿ      ÿz/ClientServiceTests.test_prepareConnectionThrows)rÅN)%r3r4r5r6rr¨rcr©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þrrrrrr•þsL ûJ   & :    r•)F)0r6ruZzope.interfacerZzope.interface.verifyrZtwisted.applicationrZtwisted.application.internetrrrZtwisted.internetrZtwisted.internet.deferr r Ztwisted.internet.interfacesr r r rrZtwisted.internet.protocolrrZtwisted.internet.taskrZtwisted.internet.testingrZtwisted.loggerrrZtwisted.python.failurerZtwisted.trial.unittestrrrrrr<r[r~rŒr”r»r•rrrrÚs>        @   #