o bD @sRdZddlmZddlmZmZmZmZmZddl m Z ddl m Z ddl mZddlmZmZmZddlmZdd lmZmZdd lmZdd lmZmZmZmZmZm Z m!Z!m"Z"dd l#m$Z$dd l%m&Z&m'Z'm(Z(m)Z)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0m1Z1m2Z2m3Z3m4Z4ddl5m6Z6m7Z7m8Z8ddl9m:Z:ddl;mZ?m@Z@mAZAmBZBddlCmDZDmEZEddlFmGZGddlHmIZImJZJddlKmLZLddlMmNZNddlOmPZPddlQmRZRddlSmTZTddlUmVZVddlWmXZXddlYmZZZm[Z[dd l\m Z eVd!j]^d"Z_eVd!j]^d#Z`eVd!j]^d$ZaeVebj]^d%Zcecdd&Zeefe_jgZhefe`jgZiefeajgZjefecjgZkefeejgZlz:dd'lmmnZompZpmqZqmrZrdd(lsmtZtmuZumvZvmwZwmxZxdd)lymzZzdd*l{m|Z|et}e_~Zex}e_~Zd+Zd,ZWneyZz d-ZeeZWYd.Z[nd.Z[wwGd/d0d0e8ZeejGd1d2d2eZeejGd3d4d4eZeejGd5d6d6eZGd7d8d8e6ZGd9d:d:e6ZGd;d<dd>ZGd?d@d@ZGdAdBdBeeZGdCdDdDe7ZGdEdFdFZGdGdHdHe jZGdIdJdJej8ZeejGdKdLdLeBZeej0eeej2eeejeeejGdMdNdNZGdOdPdPe jZGdQdRdRe jZGdSdTdTe jZGdUdVdVee jZGdWdXdXee jZGdYdZdZee jZGd[d\d\e@e<Zdd^d_ZGd`dadae jZGdbdcdce jZGdddedeeZGdfdgdgee jZGdhdidiee jZGdjdkdkee jZGdldmdmee jZGdndodoe jZGdpdqdqe jZGdrdsdse jZGdtdudue jZeeeGdvdwdwee jZGdxdydyee jZGdzd{d{e jZGd|d}d}e jZdddZGddde jZeeeGddde jZGdddee jZGddde jZGddde jZGddde jZGddde jZGdddeJjZGdddeJjZGdddeIjZGdddeƒZGddde jZddZeeeGddde jZddZGddde jZd.S)z Test the C{I...Endpoint} implementations that wrap the L{IReactorTCP}, L{IReactorSSL}, and L{IReactorUNIX} interfaces found in L{twisted.internet.endpoints}. )EPERM)AF_INETAF_INET6 IPPROTO_TCP SOCK_STREAMgaierror) FunctionType) normalize)skipIf) implementer providedByprovider)InterfaceClass) verifyClass verifyObject)plugins)defer endpointserror interfacesprotocolreactorstdiothreads) isIPv6Address)HostnameAddress IPv4Address IPv6Address UNIXAddress_ProcessAddress)StandardErrorBehavior)ConnectingCancelledError) IConsumerIHostnameResolver IPushProducerIReactorPluggableNameResolver ITransport) ClientFactoryFactoryProtocol) PipeAddress)Clock)MemoryReactorClockRaisingMemoryReactorStringTransport StringTransportWithDisconnection) ILogObserverglobalLogPublisher) getPlugins)basicpolicies)log) nativeString)proxyForInterface)Failure)FilePath) getModule) ListenFDs)connectableEndpointconnectedServerAndClient)unittestz twisted.testz server.pemzkey.pem.no_trailing_newlinezcert.pem.no_trailing_newlinefake_CAsz chain.pem)Context OP_NO_SSLv3 SSLv23_METHOD TLSv1_METHOD) CertificateCertificateOptionsDiffieHellmanParametersKeyPairPrivateCertificateTLSMemoryBIOFactory)makeCertificateFTNc@8eZdZdZddZddZddZdd Zd d Zd S) TestProtocolzx Protocol whose only function is to callback deferreds on the factory when it is connected or disconnected. cCsg|_g|_d|_dSNr)dataconnectionsLostconnectionMadeCallsselfrUF/usr/lib/python3/dist-packages/twisted/internet/test/test_endpoints.py__init__|s zTestProtocol.__init__cCsdS)NA Test ProtocolrUrSrUrUrV logPrefixzTestProtocol.logPrefixcCs|jd7_dSN)rRrSrUrUrVconnectionMadezTestProtocol.connectionMadecC|j|dSN)rPappendrTrPrUrUrV dataReceivedzTestProtocol.dataReceivedcCr_r`)rQrarTreasonrUrUrVconnectionLostrdzTestProtocol.connectionLostN) __name__ __module__ __qualname____doc__rWrYr]rcrgrUrUrUrVrNvs rNc@(eZdZdZddZddZddZdS) TestHalfCloseableProtocolab A Protocol that implements L{IHalfCloseableProtocol} and records whether its C{readConnectionLost} and {writeConnectionLost} methods are called. @ivar readLost: A C{bool} indicating whether C{readConnectionLost} has been called. @ivar writeLost: A C{bool} indicating whether C{writeConnectionLost} has been called. cCst|d|_d|_dS)NF)rNrWreadLost writeLostrSrUrUrVrWs  z"TestHalfCloseableProtocol.__init__cC d|_dSNT)rnrSrUrUrVreadConnectionLost z,TestHalfCloseableProtocol.readConnectionLostcCrprq)rorSrUrUrVwriteConnectionLostrsz-TestHalfCloseableProtocol.writeConnectionLostN)rhrirjrkrWrrrtrUrUrUrVrms   rmc@ eZdZdZddZddZdS)"TestFileDescriptorReceiverProtocola A Protocol that implements L{IFileDescriptorReceiver} and records how its C{fileDescriptorReceived} method is called. @ivar receivedDescriptors: A C{list} containing all of the file descriptors passed to C{fileDescriptorReceived} calls made on this instance. cCst|g|_dSr`)rNr]receivedDescriptorsrSrUrUrVr]  z1TestFileDescriptorReceiverProtocol.connectionMadecCr_r`)rwra)rT descriptorrUrUrVfileDescriptorReceivedrdz9TestFileDescriptorReceiverProtocol.fileDescriptorReceivedN)rhrirjrkr]rzrUrUrUrVrvs rvc@ru)TestHandshakeListenera A Protocol that implements L{IHandshakeListener} and records the number of times its C{handshakeCompleted} method has been called. @ivar handshakeCompletedCalls: The number of times C{handshakeCompleted} @type handshakeCompletedCalls: L{int} cCst|d|_dSrO)rNrWhandshakeCompletedCallsrSrUrUrVrWrxzTestHandshakeListener.__init__cCs|jd7_dS)zk Called when a TLS handshake has completed. Implemented per L{IHandshakeListener} r\N)r|rSrUrUrVhandshakeCompletedz(TestHandshakeListener.handshakeCompletedN)rhrirjrkrWr}rUrUrUrVr{s r{c@eZdZdZeZdS) TestFactoryz Simple factory to be used both when connecting and listening. It contains two deferreds which are called back when my protocol connects and disconnects. N)rhrirjrkrNrrUrUrUrVrsrc@eZdZdZddZdS) NoneFactoryzC A one off factory whose C{buildProtocol} returns L{None}. cCdSr`rUrTaddrrUrUrV buildProtocolrZzNoneFactory.buildProtocolNrhrirjrkrrUrUrUrVr rc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,S)-WrappingFactoryTestszS Test the behaviour of our ugly implementation detail C{_WrappingFactory}. cCs*t}t|}||d|jdS)z L{_WrappingFactory.doStart} passes through to the wrapped factory's C{doStart} method, allowing application-specific setup and logging. r\N)r'r_WrappingFactorydoStart assertEqualnumPortsrTfactorywfrUrUrV test_doStarts z!WrappingFactoryTests.test_doStartcCs0t}d|_t|}||d|jdS)z L{_WrappingFactory.doStop} passes through to the wrapped factory's C{doStop} method, allowing application-specific cleanup and logging. N)r'rrrdoStoprrrUrUrV test_doStops  z WrappingFactoryTests.test_doStopcsJGdddt}t|}|d|jt}|fdd|S)z An exception raised in C{buildProtocol} of our wrappedFactory results in our C{onConnection} errback being fired. c@r)zCWrappingFactoryTests.test_failedBuildProtocol..BogusFactoryzZ A one off factory whose C{buildProtocol} raises an C{Exception}. cSstd)NMy protocol is poorly defined.) ValueErrorrrUrUrVrszQWrappingFactoryTests.test_failedBuildProtocol..BogusFactory.buildProtocolNrrUrUrUrV BogusFactoryrrNcs|jdS)N)r)rargs)erSrUrVsz?WrappingFactoryTests.test_failedBuildProtocol..)r'rrr assertFailure _onConnectionr addCallback)rTrrdrUrSrVtest_failedBuildProtocols   z-WrappingFactoryTests.test_failedBuildProtocolcCs*tt}|d||jtjdS)z If the wrapped factory's C{buildProtocol} returns L{None} the C{onConnection} errback fires with L{error.NoProtocol}. N)rrrrfailureResultOfrr NoProtocolrTwrappingFactoryrUrUrVtest_buildNoneProtocols  z+WrappingFactoryTests.test_buildNoneProtocolcCs0tt}|jdd||ddS)z If the wrapped factory's C{buildProtocol} returns L{None} then L{endpoints._WrappingFactory.buildProtocol} returns L{None}. cSrr`rUrfrUrUrVr&zDWrappingFactoryTests.test_buildProtocolReturnsNone..N)rrrr addErrback assertIsNonerrrUrUrVtest_buildProtocolReturnsNones z2WrappingFactoryTests.test_buildProtocolReturnsNonecCs*tt}|d}||ddS)z If the wrapped protocol provides L{ILoggingContext}, whatever is returned from the wrapped C{logPrefix} method is returned from L{_WrappingProtocol.logPrefix}. NrX)rrrrrrY)rTrwprUrUrVtest_logPrefixPassthrough*s  z.WrappingFactoryTests.test_logPrefixPassthroughcCsBGddd}t}||_t|}|d}||ddS)z If the wrapped protocol does not provide L{ILoggingContext}, the wrapped protocol's class name is returned from L{_WrappingProtocol.logPrefix}. c@ eZdZdS)z>WrappingFactoryTests.test_logPrefixDefault..NoProtocolNrhrirjrUrUrUrVr;srN)rrrrrrrY)rTrrrrrUrUrVtest_logPrefixDefault4s   z*WrappingFactoryTests.test_logPrefixDefaultcCs^tt}|d}|d|d||jjdg|d||jjddgdS)z The wrapped C{Protocol}'s C{dataReceived} will get called when our C{_WrappingProtocol}'s C{dataReceived} gets called. Nsfoosbar) rrrrmakeConnectionrcr_wrappedProtocolrP)rTrprUrUrV test_wrappedProtocolDataReceivedDs     z5WrappingFactoryTests.test_wrappedProtocolDataReceivedcCsHtt}|d}t}||||j|||jj|dS)zo Our transport is properly hooked up to the wrappedProtocol when a connection is made. N) rrrrobjectrr transportr)rTrrdummyTransportrUrUrVtest_wrappedProtocolTransportSs   z2WrappingFactoryTests.test_wrappedProtocolTransportcCs:t}t|}|d}|d||jjdgdS)z Our wrappedProtocol's connectionLost method is called when L{_WrappingProtocol.connectionLost} is called. Nfail)rrrrrgrrrQ)rTtfrrrUrUrV"test_wrappedProtocolConnectionLostcs    z7WrappingFactoryTests.test_wrappedProtocolConnectionLostcsVtt}ttjdd}|d|gfdd}|j|| |gdS)z Calls to L{_WrappingFactory.clientConnectionLost} should errback the L{_WrappingFactory._onConnection} L{Deferred} rstringNc|dSr`raferrorsrUrVgotError|zBWrappingFactoryTests.test_clientConnectionFailed..gotError) rrrr8r ConnectErrorclientConnectionFailedrrr)rTrexpectedFailurerrUrrVtest_clientConnectionFailedps    z0WrappingFactoryTests.test_clientConnectionFailedcCs>d}t}t||}|tj||ttj|dS)zv Our L{_WrappingProtocol} should be an L{IFileDescriptorReceiver} if the wrapped protocol is. N)rvr_WrappingProtocol assertTruerIFileDescriptorReceiverr r)rTconnectedDeferredapplicationProtocolwrapperrUrUrV+test_wrappingProtocolFileDescriptorReceivers  z@WrappingFactoryTests.test_wrappingProtocolFileDescriptorReceivercC(t}td|}|tj|dS)z~ Our L{_WrappingProtocol} does not provide L{IHalfCloseableProtocol} if the wrapped protocol doesn't. N)rNrr assertFalserrr rTtprrUrUrV.test_wrappingProtocolNotFileDescriptorReceiver zCWrappingFactoryTests.test_wrappingProtocolNotFileDescriptorReceivercCs@t}tt|}|t|d||j dgdS)z L{_WrappingProtocol.fileDescriptorReceived} calls the wrapped protocol's C{fileDescriptorReceived} method. *N) rvrrrDeferredrr.rzrrw)rTwrappedProtocolrrUrUrV*test_wrappedProtocolFileDescriptorReceiveds   z?WrappingFactoryTests.test_wrappedProtocolFileDescriptorReceivedcCs0t}t}t||}|tj|ddS)zw Our L{_WrappingProtocol} should be an L{IHalfCloseableProtocol} if the C{wrappedProtocol} is. TN)rrmrrrrIHalfCloseableProtocolr )rTcdhcprrUrUrV"test_wrappingProtocolHalfCloseables z7WrappingFactoryTests.test_wrappingProtocolHalfCloseablecCs*t}td|}|tj|ddS)z Our L{_WrappingProtocol} should not provide L{IHalfCloseableProtocol} if the C{WrappedProtocol} doesn't. NF)rNrrrrrr rrUrUrV%test_wrappingProtocolNotHalfCloseables z:WrappingFactoryTests.test_wrappingProtocolNotHalfCloseablecCr)zs Our L{_WrappingProtocol} should be an L{IHandshakeListener} if the C{wrappedProtocol} is. N)r{rrrrIHandshakeListenerr )rThandshakeListenerwrappedrUrUrV&test_wrappingProtocolHandshakeListenerrz;WrappingFactoryTests.test_wrappingProtocolHandshakeListenercCr)z~ Our L{_WrappingProtocol} should not provide L{IHandshakeListener} if the C{wrappedProtocol} doesn't. N)rNrrrrrr rrUrUrV)test_wrappingProtocolNotHandshakeListenerrz>WrappingFactoryTests.test_wrappingProtocolNotHandshakeListenercC*t}td|}|||jdS)z~ L{_WrappingProtocol.readConnectionLost} should proxy to the wrapped protocol's C{readConnectionLost} N)rmrrrrrrnrTrrrUrUrV&test_wrappedProtocolReadConnectionLost z;WrappingFactoryTests.test_wrappedProtocolReadConnectionLostcCr)z L{_WrappingProtocol.writeConnectionLost} should proxy to the wrapped protocol's C{writeConnectionLost} N)rmrrrtrrorrUrUrV'test_wrappedProtocolWriteConnectionLostrz.checkProtor\rN) rrrconnectrrrcallbackrrlenassertConnectArgs rTprotomreactorrr expectedArgs ignoredDestrrrrrUrrVtest_endpointConnectSuccesss       z7ClientEndpointTestCaseMixin.test_endpointConnectSuccessc sdtjdd}t|d}t}|||\}}}||}gfdd}||||gdS)t If an endpoint tries to connect to a non-listening port it gets a C{ConnectError} failure. Connection FailedrconnectExceptionc|jdSr`ravaluerreceivedExceptionsrUrV checkFailure2rdzMClientEndpointTestCaseMixin.test_endpointConnectFailure..checkFailureN)rrr-rrrrr) rT expectedErrorrrrrr rrrUrrVtest_endpointConnectFailures     z7ClientEndpointTestCaseMixin.test_endpointConnectFailurec st}t}|||\}}}||}gfdd}|||||}|dtt | t dd} | | jt j| | jj|dS) Calling L{Deferred.cancel} on the L{Deferred} returned from L{IStreamClientEndpoint.connect} is errbacked with an expected L{ConnectingCancelledError} exception. crr`rrreceivedFailuresrUrVrIrzRClientEndpointTestCaseMixin.test_endpointConnectingCancelled..checkFailureNr\r)rrrrrcancelrrr8r UserErrorrrassertIsInstancerr!r) rTrrrrrrrattemptFactoryfailurerUrrV test_endpointConnectingCancelled9s    zClientEndpointTestCaseMixin.test_endpointConnectNonDefaultArgsN) rhrirjrkrrr rrr"rUrUrUrVrs    #rc@0eZdZdZddZddZddZdd Zd S) ServerEndpointTestCaseMixinrcCr)zL The endpoint provides L{interfaces.IStreamServerEndpoint}. N)rcreateServerEndpointrrrrIStreamServerEndpoint)rTrrrr rUrUrVrvrz*ServerEndpointTestCaseMixin.test_interfacecsht}t}|||\}}}||}gfdd}||||g||||gdS)zs An endpoint can listen and returns a deferred that gets called back with a port instance. cs|dSr`)ragetHost)port receivedHostsrUrVcheckPortAndServerr^zRServerEndpointTestCaseMixin.test_endpointListenSuccess..checkPortAndServerN)rrr%listenrrexpectedServers)rTrrrr expectedHostrr+rUr)rVtest_endpointListenSuccesss   z6ServerEndpointTestCaseMixin.test_endpointListenSuccessc sht}tdd|}t|d}|||\}}}|t}gfdd}||||gdS)z When an endpoint tries to listen on an already listening port, a C{CannotListenError} failure is errbacked. rLP)listenExceptioncrr`rrrrUrVrrdzLServerEndpointTestCaseMixin.test_endpointListenFailure..checkFailureN)rrCannotListenErrorr-r%r,rr) rTr exceptionrrrr rrrUrrVtest_endpointListenFailures    z6ServerEndpointTestCaseMixin.test_endpointListenFailurecCsPt}t}|j||fi|\}}}||||}|||gdS)zm The endpoint should pass it's listenArgs parameter to the reactor's listen methods. N)rrr% listenArgsr,r-r)rTrrrrr!r-rUrUrV!test_endpointListenNonDefaultArgss  z=ServerEndpointTestCaseMixin.test_endpointListenNonDefaultArgsN)rhrirjrkrr/r4r6rUrUrUrVr$qs   r$c@eZdZdZdS)EndpointTestCaseMixinzJ Generic test methods to be mixed into all endpoint test classes. NrhrirjrkrUrUrUrVr8r8c@ru)SpecificFactoryz An L{IProtocolFactory} whose C{buildProtocol} always returns its C{specificProtocol} and sets C{passedAddress}. Raising an exception if C{specificProtocol} has already been used. cCs ||_dSr`)specificProtocol)rTr<rUrUrVrWrszSpecificFactory.__init__cCs"t|jdr td||j_|jS)N passedAddresszspecificProtocol already used.)hasattrr<rr=rrUrUrVrs zSpecificFactory.buildProtocolN)rhrirjrkrWrrUrUrUrVr;s r;c@eZdZdZdddZdS) FakeStdioz_ A L{stdio.StandardIO} like object that simply captures its constructor arguments. NcCs||_||_dS)z @param protocolInstance: like the first argument of L{stdio.StandardIO} @param reactor: like the reactor keyword argument of L{stdio.StandardIO} N)protocolInstancer)rTrArrUrUrVrWs zFakeStdio.__init__r`rhrirjrkrWrUrUrUrVr@sr@c@rl) StandardIOEndpointsTestsz* Tests for Standard I/O Endpoints cCsNt|_t|j}||jtjt|_t |_ | | t |j |_dS)z Construct a L{StandardIOEndpoint} with a dummy reactor and a fake L{stdio.StandardIO} like object. Listening on it with a L{SpecificFactory}. N)rrrStandardIOEndpointassertIs_stdior StandardIOr@r)r<successResultOfr,r; fakeStdiorTendpointrUrUrVsetUps  zStandardIOEndpointsTests.setUpcCs(||jj|j||jjjtdS)z L{StandardIOEndpoint} returns a L{Deferred} that fires with an instance of a L{stdio.StandardIO} like object that was passed the result of L{SpecificFactory.buildProtocol} which was passed a L{PipeAddress}. N)rErIrAr<rr=r*rSrUrUrVtest_protocolCreations z.StandardIOEndpointsTests.test_protocolCreationcCs||jj|jdS)z L{StandardIOEndpoint} passes its C{reactor} argument to the constructor of its L{stdio.StandardIO} like object. N)rErIrrSrUrUrVtest_passedReactor z+StandardIOEndpointsTests.test_passedReactorN)rhrirjrkrLrMrNrUrUrUrVrCs  rCc@ru)StubApplicationProtocolz# An L{IProtocol} provider. cC ||_dS)zY @param data: The data received by the protocol. @type data: str N)rPrbrUrUrVrc z$StubApplicationProtocol.dataReceivedcCrQ)zA @type reason: L{twisted.python.failure.Failure} NrrerUrUrVrg z&StubApplicationProtocol.connectionLostN)rhrirjrkrcrgrUrUrUrVrPs rPcsZeZdZdZdfdd ZddZddZd d Zd d Zd dZ ddZ ddZ Z S)MemoryProcessTransportzC A fake L{IProcessTransport} provider to be used in tests. Ncs.tjttdg|_t|_t|_dS)N) hostAddress peerAddress)superrWrsignalssetclosedChildFDsr)rrTr __class__rUrVrW,s zMemoryProcessTransport.__init__cCs|dkr ||dSdSrOwrite)rTchildFDrPrUrUrV writeToChild2sz#MemoryProcessTransport.writeToChildcC|ddSrO closeChildFDrSrUrUrV closeStdin6rz!MemoryProcessTransport.closeStdincCrbr[rcrSrUrUrV closeStdout9rz"MemoryProcessTransport.closeStdoutcCrb)NrrcrSrUrUrV closeStderr<rz"MemoryProcessTransport.closeStderrcCr_r`)rZadd)rTfdrUrUrVrd?rdz#MemoryProcessTransport.closeChildFDcCr_r`)rXra)rTsignalrUrUrV signalProcessBrdz$MemoryProcessTransport.signalProcesscCrr`rUrSrUrUrVpidEszMemoryProcessTransport.pidr`) rhrirjrkrWrarerfrgrdrkrl __classcell__rUrUr\rVrT&srTc@s(eZdZdZdidddddfddZdS)MemoryProcessReactorzA A fake L{IReactorProcess} provider to be used in tests. rUNrc CsR||_||_||_||_||_||_||_||_| |_t |_ |j |j |j S)z @ivar processProtocol: Stores the protocol passed to the reactor. @return: An L{IProcessTransport} provider. ) processProtocol executablerenvpathuidgidusePTYchildFDsrTprocessTransportr) rTrorprrqrrrsrtrurvrUrUrV spawnProcessUsz!MemoryProcessReactor.spawnProcess)rhrirjrkrxrUrUrUrVrnOsrnc@PeZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ dS)ProcessEndpointsTestsz, Tests for child process endpoints. cCs.t|_t|jd|_t|_t|j_dSN/bin/executable) rnrrProcessEndpointrrr(rrPrSrUrUrVrLys  zProcessEndpointsTests.setUpcCs||jjt||jjd||jjd||jji||jj ||jj ||jj ||jj d||jj ||jjtjdS)zU Default values are set for the optional parameters in the endpoint. r|rUrN)rr_reactorrnr _executable_args_envr_path_uid_gid_usePTY _childFDs_errFlagr LOGrSrUrUrVtest_constructorDefaultssz.ProcessEndpointsTests.test_constructorDefaultscCsddi}ttddgd|didddddd d d tj }||jt||jd||j dg||j d|di||j d||j d||j d||j||jdd d d ||jtjdS) zI The parameters passed to the endpoint are stored in it. HOMENr|/runProcessHere/r\rTwrr)rr}rnr DROPrr~rrrrrrrrrrr)rTenvironrrUrUrVtest_constructorNonDefaultss.    z1ProcessEndpointsTests.test_constructorNonDefaultscCs2|j|j}|||jj}||tjdS)z The wrapper function _WrapIProtocol gives an IProcessProtocol implementation that wraps over an IProtocol. N) rrrrHrrorr_WrapIProtocolrTrwpprUrUrVtest_wrappedProtocols z*ProcessEndpointsTests.test_wrappedProtocolcCsddi}t}t|ddgd|didddddd d d  }||j}||||jtj| |j |j | |j |j | |j|j| |j|j| |j|j| |j|j| |j|j| |j|jdS) z The parameters for spawnProcess stored in the endpoint are passed when the endpoint's connect method is invoked. rNr|rr\rTrrr)rnrr}rrrHrrorrrprrrrqrrrrrsrrtrrurrvr)rTr memoryReactorrrrUrUrVtest_spawnProcesss0   z'ProcessEndpointsTests.test_spawnProcesscCs@Gdddtj}|}|j|}||||jtdS)zz The address passed to the factory's buildProtocol in the endpoint is a _ProcessAddress instance. c@seZdZeZdZddZdS)zBProcessEndpointsTests.test_processAddress..TestAddrFactoryNcSs||_|}||_|Sr`)rrr)rTrrrUrUrVrszPProcessEndpointsTests.test_processAddress..TestAddrFactory.buildProtocol)rhrirjrPrrrrUrUrUrVTestAddrFactorys rN)rr(rrrHrrr)rTr myFactoryrrUrUrVtest_processAddresss   z)ProcessEndpointsTests.test_processAddresscCs$||j|j}||tdS)zd L{ProcessEndpoint.connect} returns a Deferred with the connected protocol. N)rHrrrrrP)rTrrUrUrV test_connectsz"ProcessEndpointsTests.test_connectcCs6dd}||j_|j|j}||}|tdS)zg In case of failure, L{ProcessEndpoint.connect} returns a Deferred that fails. c Sstr`) Exception) pprprrqrrrsrtrurvrUrUrVtestSpawnProcessszCProcessEndpointsTests.test_connectFailure..testSpawnProcessN)r _spawnProcessrrrtrapr)rTrrrrUrUrVtest_connectFailures  z)ProcessEndpointsTests.test_connectFailureN) rhrirjrkrLrrrrrrrrUrUrUrVrzts   rzc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"S)#ProcessEndpointTransportTestsze Test the behaviour of the implementation detail L{endpoints._ProcessEndpointTransport}. cCsFt|_t|jd|_||jtt }|jj |_ |j |_ dSr{)rnrrr}rKrHrr( forProtocolr)rwprocessrendpointTransportr[rUrUrVrL s  z#ProcessEndpointTransportTests.setUpcCtt|jdS)zE L{_ProcessEndpointTransport}s provide L{IConsumer}. N)rr"rrSrUrUrVtest_verifyConsumerz1ProcessEndpointTransportTests.test_verifyConsumercCr)zI L{_ProcessEndpointTransport}s provide L{IPushProducer}. N)rr$rrSrUrUrVtest_verifyProducerrz1ProcessEndpointTransportTests.test_verifyProducercCr)zF L{_ProcessEndpointTransport}s provide L{ITransport}. N)rr&rrSrUrUrVtest_verifyTransportrz2ProcessEndpointTransportTests.test_verifyTransportcCs||jj|jdS)zd The L{_ProcessEndpointTransport} instance stores the process passed to it. N)rEr_processrrSrUrUrVtest_constructor$rOz.ProcessEndpointTransportTests.test_constructorcCs>ttGddd}|}|j|d||jj|dS)z Registering a producer with the endpoint transport registers it with the underlying process transport. c@r)zFProcessEndpointTransportTests.test_registerProducer..AProducerNrrUrUrUrV AProducer1srFN)r r$rregisterProducerrErproducer)rTr aProducerrUrUrVtest_registerProducer+s z3ProcessEndpointTransportTests.test_registerProducercC|j||jjddS)zY Pausing the endpoint transport pauses the underlying process transport. pausedN)rpauseProducingrr producerStaterSrUrUrVtest_pauseProducing9s z1ProcessEndpointTransportTests.test_pauseProducingcCs&||j||jjddS)zc Resuming the endpoint transport resumes the underlying process transport. producingN)rrresumeProducingrrrrSrUrUrVtest_resumeProducing@s z2ProcessEndpointTransportTests.test_resumeProducingcCr)zo Stopping the endpoint transport as a producer stops the underlying process transport. stoppedN)r stopProducingrrrrSrUrUrVtest_stopProducingIs z0ProcessEndpointTransportTests.test_stopProducingcCs$||j||jjdS)z Unregistring the endpoint transport's producer unregisters the underlying process transport's producer. N)rrunregisterProducerrrrrSrUrUrVtest_unregisterProducerQs z5ProcessEndpointTransportTests.test_unregisterProducercCsg|j_|tt|jddS)z L{endpoints._ProcessEndpointTransport} filters out extraneous attributes of its underlying transport, to present a more consistent cross-platform view of subprocesses and prevent accidental dependencies. pipesN)rr assertRaisesAttributeErrorgetattrrrSrUrUrVtest_extraneousAttributesZsz7ProcessEndpointTransportTests.test_extraneousAttributescCs(|jgd||jjddS)z The writeSequence method of L{_ProcessEndpointTransport} writes a list of string passed to it to the transport's stdin. )stest1stest2stest3stest1test2test3N)r writeSequencerriogetvaluerSrUrUrVtest_writeSequencedsz0ProcessEndpointTransportTests.test_writeSequencecCs$|jd||jjddS)z The write method of L{_ProcessEndpointTransport} writes a string of data passed to it to the child process's stdin. stestN)rr_rrrrrSrUrUrV test_writels z(ProcessEndpointTransportTests.test_writecCs|j||jjdS)z A call to the loseConnection method of a L{_ProcessEndpointTransport} instance returns a call to the process transport's loseConnection. N)rloseConnectionrr connectedrSrUrUrVtest_loseConnectionts z1ProcessEndpointTransportTests.test_loseConnectioncC,|j}||t|||jdS)z L{_ProcessEndpointTransport.getHost} returns a L{_ProcessAddress} instance matching the process C{getHost}. N)rr'rrrEr)rThostrUrUrV test_getHost|  z*ProcessEndpointTransportTests.test_getHostcCr)z L{_ProcessEndpointTransport.getPeer} returns a L{_ProcessAddress} instance matching the process C{getPeer}. N)rgetPeerrrrEr)rTpeerrUrUrV test_getPeerrz*ProcessEndpointTransportTests.test_getPeerN)rhrirjrkrLrrrrrrrrrrrrrrrrUrUrUrVrs$     rc@sXeZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ dS)WrappedIProtocolTestszL Test the behaviour of the implementation detail C{_WrapIProtocol}. cCs4t|_t|jd|_d|_t|_t |j_dSr{) rnrrr}reventLogrr(rrPrSrUrUrVrLs   zWrappedIProtocolTests.setUpcCsD|j|j}|||jj}||jt| |j |jj dS)zQ Stores an L{IProtocol} provider and the flag to log/drop stderr N) rrrrHrrorrrPrerrFlagrrrUrUrVrs  z&WrappedIProtocolTests.test_constructorcCs6|j|j}|||jj}||jj|jdS)zx Our process transport is properly hooked up to the wrappedIProtocol when a connection is made. N) rrrrHrrorrrrrUrUrVtest_makeConnections z)WrappedIProtocolTests.test_makeConnectioncCrQ)z! A log observer. N)r)rT eventDictrUrUrV_stdLogrSzWrappedIProtocolTests._stdLogcCs|j|j}|||jj}t|j| tj |j| dd| |j d|j| |j dd| |j d|j|dt|j dS)z When the _errFlag is set to L{StandardErrorBehavior.LOG}, L{endpoints._WrapIProtocol} logs stderr (in childDataReceived). rsstderr1rprPrzwrote stderr unhandled byN)rrrrHrror5 addObserverr addCleanupremoveObserverchildDataReceivedrrrprassertIntextFromEventDictrrUrUrVtest_logStderrs   z$WrappedIProtocolTests.test_logStderrcCsbtj|j_|j|j}|||jj}t |j | t j |j |dd||jdS)z When the _errFlag is set to L{StandardErrorBehavior.DROP}, L{endpoints._WrapIProtocol} ignores stderr. rsstderr2N)r rrrrrrHrror5rrrrrrrrrUrUrVtest_stderrSkips    z%WrappedIProtocolTests.test_stderrSkipcCs@|j|j}|||jj}|dd||jj ddS)z In childDataReceived of L{_WrappedIProtocol} instance, the protocol's dataReceived is called when stdout is generated. r\sstdoutN) rrrrHrrorrrrPrrUrUrV test_stdouts   z!WrappedIProtocolTests.test_stdoutcCsR|j|j}|||jj}|tt d| |j j tjtjdS)z L{error.ProcessDone} with status=0 is turned into a clean disconnect type, i.e. L{error.ConnectionDone}. rN)rrrrHrro processEndedr8r ProcessDonerrrfcheckConnectionDonerrUrUrVtest_processDones z&WrappedIProtocolTests.test_processDonecCsP|j|j}|||jj}|tt | |j j tjtjdS)z{ Exceptions other than L{error.ProcessDone} with status=0 are turned into L{error.ConnectionLost}. N)rrrrHrrorr8rProcessTerminatedrrrfrConnectionLostrrUrUrVtest_processEndeds z'WrappedIProtocolTests.test_processEndedN) rhrirjrkrLrrrrrrrrrUrUrUrVrs   rc@HeZdZdZddZddZddZdd Zd d Zd d Z ddZ dS)TCP4EndpointsTestsz' Tests for TCP IPv4 Endpoints. cC|jSzD @return: List of calls to L{IReactorTCP.listenTCP}  tcpServersrrUrUrVr-z"TCP4EndpointsTests.expectedServerscCrzE @return: List of calls to L{IReactorTCP.connectTCP}  tcpClientsrrUrUrVr rz"TCP4EndpointsTests.expectedClientsc CP|\}}}}}|\}} } } } |||||| ||| ||| dSa] Compare host, port, timeout, and bindAddress in C{receivedArgs} to C{expectedArgs}. We ignore the factory because we don't only care what protocol comes out of the C{IStreamClientEndpoint.connect} call. @param receivedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{timeout}, C{bindAddress}) that was passed to L{IReactorTCP.connectTCP}. @param expectedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{timeout}, C{bindAddress}) that we expect to have been passed to L{IReactorTCP.connectTCP}. Nr rT receivedArgsrrr(ignoredFactorytimeout bindAddressr. expectedPort_ignoredFactoryexpectedTimeoutexpectedBindAddressrUrUrVr   z$TCP4EndpointsTests.assertConnectArgscC dddSK @return: C{dict} of keyword arguments to pass to connect.  localhostirrrUrSrUrUrVr +rSzTCP4EndpointsTests.connectArgscCrI @return: C{dict} of keyword arguments to pass to listen d 127.0.0.1backlog interfacerUrSrUrUrVr51rSzTCP4EndpointsTests.listenArgscKsBtddd}tj||jfi||j||dd|ddf|fS)a Create an L{TCP4ServerEndpoint} and return the values needed to verify its behaviour. @param reactor: A fake L{IReactorTCP} that L{TCP4ServerEndpoint} can call L{IReactorTCP.listenTCP} on. @param factory: The thing that we expect to be passed to our L{IStreamServerEndpoint.listen} implementation. @param listenArgs: Optional dictionary of arguments to L{IReactorTCP.listenTCP}. TCP0.0.0.0rr2rrL)rrTCP4ServerEndpointr(getrTrrr5rrUrUrVr%7   z'TCP4EndpointsTests.createServerEndpointc KJtddd}tj||j|jfi||j|j||dd|ddf|fS)a Create an L{TCP4ClientEndpoint} and return the values needed to verify its behavior. @param reactor: A fake L{IReactorTCP} that L{TCP4ClientEndpoint} can call L{IReactorTCP.connectTCP} on. @param clientFactory: The thing that we expect to be passed to our L{IStreamClientEndpoint.connect} implementation. @param connectArgs: Optional dictionary of arguments to L{IReactorTCP.connectTCP} rrr0rrN)rrTCP4ClientEndpointrr(rrTrrr rrUrUrVrP    z'TCP4EndpointsTests.createClientEndpointN rhrirjrkr-rrr r5r%rrUrUrUrVrs rc@r)TCP6EndpointsTestsz' Tests for TCP IPv6 Endpoints. cCrrrrrUrUrVr-rrz"TCP6EndpointsTests.expectedServerscCrrrrrUrUrVrxrz"TCP6EndpointsTests.expectedClientsc CrrrrrUrUrVr~rz$TCP6EndpointsTests.assertConnectArgscCrrrUrSrUrUrVr rSzTCP6EndpointsTests.connectArgscCr)r r ::1rrUrSrUrUrVr5rSzTCP6EndpointsTests.listenArgscKsF|dd}td|d}tj||jfi||j||dd|f|fS)a Create a L{TCP6ServerEndpoint} and return the values needed to verify its behaviour. @param reactor: A fake L{IReactorTCP} that L{TCP6ServerEndpoint} can call L{IReactorTCP.listenTCP} on. @param factory: The thing that we expect to be passed to our L{IStreamServerEndpoint.listen} implementation. @param listenArgs: Optional dictionary of arguments to L{IReactorTCP.listenTCP}. rz::rrrr)rrrTCP6ServerEndpointr()rTrrr5rrrUrUrVr%s z'TCP6EndpointsTests.createServerEndpointc Kr) Create a L{TCP6ClientEndpoint} and return the values needed to verify its behavior. @param reactor: A fake L{IReactorTCP} that L{TCP6ClientEndpoint} can call L{IReactorTCP.connectTCP} on. @param clientFactory: The thing that we expect to be passed to our L{IStreamClientEndpoint.connect} implementation. @param connectArgs: Optional dictionary of arguments to L{IReactorTCP.connectTCP} rrr0rrrN)rrTCP6ClientEndpointrr(rrrUrUrVrrz'TCP6EndpointsTests.createClientEndpointNrrUrUrUrVrms rc@r)TCP6EndpointNameResolutionTestszl Tests for a TCP IPv6 Client Endpoint pointed at a hostname instead of an IPv6 address literal. c sdtddd}tj|d|jfi|_fdd}|j_j|j|j||dd|d d f|fS) r!r::2r0ipv6.example.comcs>d|tttddftttddftttddfg}t|S)Nr%rL)r$rrr)z::3rrr)z::4rrr)rrrrrsucceed)rrPrSrUrVtestNameResolutions     zPTCP6EndpointNameResolutionTests.createClientEndpoint..testNameResolutionrrrN)rrr"r(r_nameResolutionrr)rTrrr rr'rUrSrVrs"     z4TCP6EndpointNameResolutionTests.createClientEndpointcCrrrUrSrUrUrVr rSz+TCP6EndpointNameResolutionTests.connectArgscCrrrrrUrUrVr rz/TCP6EndpointNameResolutionTests.expectedClientsc CrrrrrUrUrVrrz1TCP6EndpointNameResolutionTests.assertConnectArgscCs"tddd}||jtjdS)zg By default, L{TCP6ClientEndpoint._deferToThread} is L{threads.deferToThread}. Nzwww.example.com)rr"r_deferToThreadr deferToThreadrTrrUrUrVtest_freeFunctionDeferToThread.sz>TCP6EndpointNameResolutionTests.test_freeFunctionDeferToThreadcsZgfdd}ttdd}t}||_||_|t||ddt fifgdS)zl While resolving hostnames, _nameResolution calls _deferToThread with _getaddrinfo. cs|||ftSr`)rarr)rrkwargscallsrUrVfakeDeferToThread=szNTCP6EndpointNameResolutionTests.test_nameResolution..fakeDeferToThreadr%r)rN) rr"rr _getaddrinfor*rrrr)rTr1rKfakegetaddrinforUr/rVtest_nameResolution6s  z3TCP6EndpointNameResolutionTests.test_nameResolutionN) rhrirjrkrr rrr-r4rUrUrUrVr#s( r#c@r?)RaisingMemoryReactorWithClockzE An extension of L{RaisingMemoryReactor} with L{task.Clock}. NcCst|t|||dSr`)r+rWr-)rTr1rrUrUrVrWPs z&RaisingMemoryReactorWithClock.__init__)NNrBrUrUrUrVr5Ksr5rUc sfdurittGfdddttGfdddttdtt|}||S)ap Create a reactor that will deterministically resolve all hostnames it is passed to the list of addresses given. @param reactor: An object that we wish to add an L{IReactorPluggableNameResolver} to. @type reactor: Any object with some formally-declared interfaces (i.e. one where C{list(providedBy(reactor))} is not empty); usually C{IReactor*} interfaces. @param expectedAddresses: (optional); the addresses expected to be returned for every address. If these are strings, they should be IPv4 or IPv6 literals, and they will be wrapped in L{IPv4Address} and L{IPv6Address} objects in the resolution result. @type expectedAddresses: iterable of C{object} or C{str} @param hostMap: (optional); the names (unicode) mapped to lists of addresses (str or L{IAddress}); in the same format as expectedAddress, which map the results for I{specific} hostnames to addresses. @return: A new reactor which provides all the interfaces previously provided by C{reactor} as well as L{IReactorPluggableNameResolver}. All name resolutions performed with its C{nameResolver} attribute will resolve reentrantly and synchronously with the given C{expectedAddresses}. However, it is not a complete implementation as it does not have an C{installNameResolver} method. Ncs&eZdZe   dfdd ZdS)z9deterministicResolvingReactor..SimpleNameResolverrNrcsT|d|D]}t|trttgt|d||}||q |dS)Nr) resolutionBeganr isinstancestrrrraddressResolvedresolutionComplete)resolutionReceiverhostName portNumber addressTypestransportSemanticsexpectedAddressexpectedAddresseshostMaprUrVresolveHostNamews    zIdeterministicResolvingReactor..SimpleNameResolver.resolveHostName)rNr)rhrirj staticmethodrDrUrArUrVSimpleNameResolverus rFcseZdZZdS)z3deterministicResolvingReactor..WithResolverN)rhrirj nameResolverrU)rFrUrV WithResolvers rH*)copyr r#r%r7rtupler )rrBrCrHrU)rFrBrCrVdeterministicResolvingReactorUsrLc@rM) SimpleHostnameResolverTestsa Tests for L{endpoints._SimpleHostnameResolver}. @ivar fakeResolverCalls: Arguments with which L{fakeResolver} was called. @type fakeResolverCalls: L{list} of C{(hostName, port)} L{tuple}s. @ivar fakeResolverReturns: The return value of L{fakeResolver}. @type fakeResolverReturns: L{Deferred} @ivar resolver: The instance to test. @type resolver: L{endpoints._SimpleHostnameResolver} @ivar resolutionBeganCalls: Arguments with which receiver's C{resolutionBegan} method was called. @type resolutionBeganCalls: L{list} @ivar addressResolved: Arguments with which C{addressResolved} was called. @type addressResolved: L{list} @ivar resolutionCompleteCallCount: The number of calls to the receiver's C{resolutionComplete} method. @type resolutionCompleteCallCount: L{int} @ivar receiver: A L{interfaces.IResolutionReceiver} provider. csVg_t_tj_g_g_ d_ t t j Gfddd}|_dS)Nrcs<eZdZefddZefddZefddZdS)z4SimpleHostnameResolverTests.setUp.._Receivercj|dSr`)resolutionBeganCallsra)resolutionInProgressrSrUrVr6zDSimpleHostnameResolverTests.setUp.._Receiver.resolutionBegancrNr`)addressResolvedCallsra)rrSrUrVr9rQzDSimpleHostnameResolverTests.setUp.._Receiver.addressResolvedcsjd7_dSr[)resolutionCompleteCallCountrUrSrUrVr:szGSimpleHostnameResolverTests.setUp.._Receiver.resolutionCompleteN)rhrirjrEr6r9r:rUrSrUrV _ReceiversrT)fakeResolverCallsrrfakeResolverReturnsr_SimpleHostnameResolver fakeResolverresolverrOrRrSr rIResolutionReceiverreceiver)rTrTrUrSrVrLs  z!SimpleHostnameResolverTests.setUpcCs|j||f|jS)z A fake resolver callable. @param hostName: The hostname to resolve. @param portNumber: The port number the returned address should include. @return: L{fakeResolverCalls} @rtype: L{Deferred} )rUrarV)rTr<r=rUrUrVrXs z(SimpleHostnameResolverTests.fakeResolvercCs|ttj|jdS)zs A L{endpoints._SimpleHostnameResolver} instance provides L{interfaces.IHostnameResolver}. N)rrrr#rYrSrUrUrVrz*SimpleHostnameResolverTests.test_interfacecs gttfddt|fdd|j|jd}|||j|j t | dt | dt |t \}||d||dd||d t|j| dt |j| |jd jd||j| d|jd S) z A resolution failure is logged with the name that failed to resolve and the callable that tried to resolve it. The resolution receiver begins, receives no addresses, and completes. crr`r)event)logsrUrV captureLogsszHSimpleHostnameResolverTests.test_resolveNameFailure..captureLogscs tSr`)r1rrU)r_rUrVrs zESimpleHostnameResolverTests.test_resolveNameFailure.. example.comr\isErrornamecallablerN)r r0r1rrrYrDr[rErVerrbackrrrflushLoggedErrorsrrreprrXrOrbrrRrS)rTr[r]rU)r_r^rVtest_resolveNameFailures$  z3SimpleHostnameResolverTests.test_resolveNameFailurec Csd}d}d}|j|jd}|||j|jtttd||fft ttd||ffg| dt |j | |j dj d| |jtd||td||g| |jdd S) zs The resolution receiver begins, and resolved hostnames are delivered before it completes. r01.2.3.4z 1::2::3::4r`rLr\rrN)rYrDr[rErVrrrrrrrrOrbrRrrrS)rTr(ipv4Hostipv6Hostr[rUrUrVtest_resolveNameDeliverss"z4SimpleHostnameResolverTests.test_resolveNameDeliversN) rhrirjrkrLrXrrgrkrUrUrUrVrMs #rMc@r)+HostnameEndpointFallbackNameResolutionTestszd L{HostnameEndpoint._fallbackNameResolution} defers a name resolution call to a thread. csJddlm}tj|ddd}d\|}fdd}||S)z L{_fallbackNameResolution} returns a L{Deferred} that fires with the resoution of the the host and request port. r)rignored)rr()rhr\csLt|d|\\}}}}}|t|t|fdSr[)rrrr)resultfamilysocktype_sockaddrrr(rTrUrVassertHostPortFamilySockType0s   zmHostnameEndpointFallbackNameResolutionTests.test_fallbackNameResolution..assertHostPortFamilySockType)twisted.internetrrHostnameEndpoint_fallbackNameResolutionr)rTrrresolutionDeferredrtrUrsrVtest_fallbackNameResolution#s   zGHostnameEndpointFallbackNameResolutionTests.test_fallbackNameResolutionN)rhrirjrkryrUrUrUrVrl rlc@r)#_HostnameEndpointMemoryReactorMixinz Common methods for testing L{HostnameEndpoint} against L{MemoryReactor} instances that do not provide L{IReactorPluggableNameResolver}. cOs8z ||i|}Wn tytYSwt|S)a A synchronous version of L{deferToThread}. @param f: The callable to invoke. @type f: L{callable} @param args: Positional arguments to the callable. @param kwargs: Keyword arguments to the callable. @return: A L{Deferred} that fires with the result of applying C{f} to C{args} and C{kwargs} or the exception raised. ) BaseExceptionrrr&)rTrrr.rnrUrUrVsynchronousDeferredToThreadAs    z?_HostnameEndpointMemoryReactorMixin.synchronousDeferredToThreadcCr)z Extract expected clients from the reactor. @param reactor: The L{MemoryReactor} under test. @return: List of calls to L{IReactorTCP.connectTCP} rrrUrUrVrVsz3_HostnameEndpointMemoryReactorMixin.expectedClientscCr)zL @return: C{dict} of keyword arguments to pass to connect. g$@rr rUrSrUrUrVr `rRz/_HostnameEndpointMemoryReactorMixin.connectArgsc CrrrrrUrUrVrgrz5_HostnameEndpointMemoryReactorMixin.assertConnectArgscCntjdd}t|d}t}|||\}}}||}|tjj | | |j || g| dS)z When L{HostnameEndpoint.connect} cannot connect to its destination, the returned L{Deferred} will fail with C{ConnectError}. r rr Nrrr5rrradvancerrv_DEFAULT_ATTEMPT_DELAYrrrgetDelayedCallsrTrrrrrr rrUrUrVr   z?_HostnameEndpointMemoryReactorMixin.test_endpointConnectFailurecCs`t}t}||||}|dt||t|dd||dd ddS)z Instantiating L{HostnameEndpoint} with a reactor that does not provide L{IReactorPluggableResolver} emits a deprecation warning. r\rcategorymessagezPassing HostnameEndpoint a reactor that does not provide IReactorPluggableNameResolver (twisted.internet.testing.MemoryReactorClock) was deprecated in Twisted 17.5.0; please use a reactor that provides IReactorPluggableNameResolver insteadN) rrr flushWarningsrrrEDeprecationWarningr startswith)rTrrwarningsrUrUrVtest_deprecations  z4_HostnameEndpointMemoryReactorMixin.test_deprecationcCsft}t}|||\}}}dd}||_||}|||jtj | dt | t dS)z8 Hostname resolution errors are logged. c_s tdd)Nz#No address associated with hostname)r)rr.rUrUrVgetaddrinfoThatFailsrszS_HostnameEndpointMemoryReactorMixin.test_errorsLogged..getaddrinfoThatFailsr\N)rrrr2rrrrrDNSLookupErrorrrrer)rTrrrrr rrrUrUrVtest_errorsLoggeds  z5_HostnameEndpointMemoryReactorMixin.test_errorsLoggedN) rhrirjrkr}rr rrrrrUrUrUrVr{:s  r{c@r)&HostnameEndpointMemoryIPv4ReactorTestsz IPv4 resolution tests for L{HostnameEndpoint} with L{MemoryReactor} subclasses that do not provide L{IReactorPluggableNameResolver}. c fdtdd}tj|d|jfi|}fdd}||_|j|_||j||dd|dd f|fS) a Creates a L{HostnameEndpoint} instance where the hostname is resolved into a single IPv4 address. @param reactor: The L{MemoryReactor} @param clientFactory: The client L{IProtocolFactory} @param connectArgs: Additional arguments to L{HostnameEndpoint.connect} @return: A L{tuple} of the form C{(endpoint, (expectedAddress, expectedPort, clientFactory, timeout, localBindAddress, hostnameAddress))} rh example.comr0ctttddffgSNrLr0)rrrrr(rorpr@rUrVr3zTHostnameEndpointMemoryIPv4ReactorTests.createClientEndpoint..fakegetaddrinforrrNrrrvr(r2r}r*rrTrrr rrKr3rUrrVr&    z;HostnameEndpointMemoryIPv4ReactorTests.createClientEndpointNrhrirjrkrrUrUrUrVr rc@r)&HostnameEndpointMemoryIPv6ReactorTestsz IPv6 resolution tests for L{HostnameEndpoint} with L{MemoryReactor} subclasses that do not provide L{IReactorPluggableNameResolver}. c r) a Creates a L{HostnameEndpoint} instance where the hostname is resolved into a single IPv6 address. @param reactor: The L{MemoryReactor} @param clientFactory: The client L{IProtocolFactory} @param connectArgs: Additional arguments to L{HostnameEndpoint.connect} @return: A L{tuple} of the form C{(endpoint, (expectedAddress, expectedPort, clientFactory, timeout, localBindAddress, hostnameAddress))} 1:2::3:4ipv6.example.comr0crr)rrrrrrUrVr3rzTHostnameEndpointMemoryIPv6ReactorTests.createClientEndpoint..fakegetaddrinforrrNrrrUrrVrrz;HostnameEndpointMemoryIPv6ReactorTests.createClientEndpointNrrUrUrUrVrrrc@sZeZdZdZddZddZddZdd Zdd d Zd dZ ddZ ddZ ddZ d S)HostnameEndpointsOneIPv4Testsz^ Tests for the hostname based endpoints when GAI returns only one (IPv4) address. c KsTd}tdd}tjt||gd|jfi|}|||j||dd|ddf|fS)z{ Creates a L{HostnameEndpoint} instance where the hostname is resolved into a single IPv4 address. rhrr0rrrNrrrvrLr(r)rTrrr r@rrKrUrUrVr7s$    z2HostnameEndpointsOneIPv4Tests.createClientEndpointcCrrrrrUrUrVrQrz-HostnameEndpointsOneIPv4Tests.expectedClientsc CrrrrrUrUrVrWrz/HostnameEndpointsOneIPv4Tests.assertConnectArgscCrrrUrSrUrUrVr srSz)HostnameEndpointsOneIPv4Tests.connectArgsNc Cst}t}tj|_|||\}}}||}|dur"|||||}| dt t | |} || jt j|| jj|||jddjj|g|dS)z Calling L{Deferred.cancel} on the L{Deferred} returned from L{IStreamClientEndpoint.connect} will cause it to be errbacked with a L{ConnectingCancelledError} exception. Nrr)rrr(r)rrrrrrr8rrrrrr!rrrr _connectorstoppedConnectingr) rTrrrrrrrrrrUrUrVrys    z>HostnameEndpointsOneIPv4Tests.test_endpointConnectingCancelledcCs$tjj}||d}|j|ddS)a  Calling L{Deferred.cancel} on the L{Deferred} returned from L{IStreamClientEndpoint.connect} after enough time has passed that all connection attempts have been initiated will cause it to be errbacked with a L{ConnectingCancelledError} exception. g@)rN)rrvrr)rT oneBetweenrrUrUrV7test_endpointConnectingCancelledAfterAllAttemptsStarteds zUHostnameEndpointsOneIPv4Tests.test_endpointConnectingCancelledAfterAllAttemptsStartedcCr~)z If L{HostnameEndpoint.connect} is invoked and there is no server listening for connections, the returned L{Deferred} will fail with C{ConnectError}. r rr NrrrUrUrVrrz9HostnameEndpointsOneIPv4Tests.test_endpointConnectFailurec Cstjdd}t}t}|||\}}}||}|d|jd\}} } } } | |j d|| | |j || g| dS)a If a connection attempt initiated by L{HostnameEndpoint.connect} fails only after L{HostnameEndpoint} has exhausted the list of possible server addresses, the returned L{Deferred} will fail with C{ConnectError}. r r333333?rN)rrrrrrrrr connectorsrrrr) rTrrrrrr rrr(rrrrUrUrV)test_endpointConnectFailureAfterIterations   zGHostnameEndpointsOneIPv4Tests.test_endpointConnectFailureAfterIterationc st}t}t}|||\}}}||}gfdd}||||} |d| j|| |g| |} | t | d| | d|| g| dS)a\ If a connection attempt initiated by L{HostnameEndpoint.connect} succeeds only after L{HostnameEndpoint} has exhausted the list of possible server addresses, the returned L{Deferred} will fire with the connected protocol instance and the endpoint will leave no delayed calls in the reactor. crr`rrrrUrVrrz[HostnameEndpointsOneIPv4Tests.test_endpointConnectSuccessAfterIteration..checkProtorr\rN)rrrrrrrrrrrrrrrrUrrV)test_endpointConnectSuccessAfterIterations$        zGHostnameEndpointsOneIPv4Tests.test_endpointConnectSuccessAfterIterationr`) rhrirjrkrrrr rrrrrrUrUrUrVr1s   rc@r)HostnameEndpointsOneIPv6Testsz^ Tests for the hostname based endpoints when GAI returns only one (IPv6) address. c KsPtdd}tjt|dgd|jfi|}|d|j||dd|ddf|fS)z{ Creates a L{HostnameEndpoint} instance where the hostname is resolved into a single IPv6 address. rr0rrrrNr)rTrrr rrKrUrUrVrs"    z2HostnameEndpointsOneIPv6Tests.createClientEndpointcCrrrrrUrUrVr rz-HostnameEndpointsOneIPv6Tests.expectedClientsc CrrrrrUrUrVr rz/HostnameEndpointsOneIPv6Tests.assertConnectArgscCrrrUrSrUrUrVr 9 rSz)HostnameEndpointsOneIPv6Tests.connectArgsc Cst}t}tj|_|t|dg|\}}}||}|||}| dt t | |}||jt j||jj|||jddjj|g|dS)rr Nrr)rrr(r)rrLrrrrr8rrrrrr!rrrrrrr) rTrrrrrrrrrUrUrVr? s    z>HostnameEndpointsOneIPv6Tests.test_endpointConnectingCancelledcCsjtjdd}t|d}t}|||\}}}||}|d|||j ||g| dS)r r rr rN) rrr5rrrrrrrrrrUrUrVr\ s    z9HostnameEndpointsOneIPv6Tests.test_endpointConnectFailureN) rhrirjrkrrrr rrrUrUrUrVrs rc@s8eZdZdZdZdZddZddZdd Zd d Z d S) HostnameEndpointIDNATestszJ Tests for L{HostnameEndpoint}'s constructor's encoding behavior. bücher.chsxn--bcher-kva.chcC>tttdg|jd}||j|j||j|jdS)z A L{HostnameEndpoint} constructed with text will contain an IDNA-encoded bytes representation of that text. r r0N rrvrLrsampleIDNATextr _hostBytessampleIDNABytes _hostTextrJrUrUrVtest_idnaHostnameTextw  z/HostnameEndpointIDNATests.test_idnaHostnameTextcCr)z A L{HostnameEndpoint} constructed with bytes will contain an IDNA-decoded textual representation of those bytes. r r0NrrJrUrUrVtest_idnaHostnameBytes rz0HostnameEndpointIDNATests.test_idnaHostnameBytescCsDtttdgtd|jd}||j|j||j |jdS)z A L{HostnameEndpoint} constructed with NFD-normalized text will store the NFC-normalized version of that text. r NFDr0N) rrvrLrr rrrrrrJrUrUrVtest_nonNormalizedText s  z0HostnameEndpointIDNATests.test_nonNormalizedTextcCstttdgdd}|tt}||t }| dt |tttdgdd}|t}||t }| dt |dS)a& Since any client of L{IStreamClientEndpoint} needs to handle Deferred failures from C{connect}, L{HostnameEndpoint}'s constructor will not raise exceptions when given bad host names, instead deferring to returning a failing L{Deferred} from C{connect}. r  -garbage-r0z\xff-garbage-\xffu⿰-garbage-⿰z\u2ff0-garbage-\u2ff0N) rrvrLrrr(rr)rrrr8)rTrKdeferrederrrUrUrVtest_deferBadEncodingToConnect s      z8HostnameEndpointIDNATests.test_deferBadEncodingToConnectN) rhrirjrkrrrrrrrUrUrUrVro s  rc@r#) HostnameEndpointReprTestsz@ Tests for L{HostnameEndpoint}'s string representation. cC>tttgdd}t|}|d||tt|dS)z The string representation of L{HostnameEndpoint} includes the host and port passed to the constructor. r`r0z!N rrvrLr+rfrrEr8typerTrKreprUrUrV test_allASCII   z'HostnameEndpointReprTests.test_allASCIIcCr)z When IDN is passed to the L{HostnameEndpoint} constructor the string representation includes the punycode version of the host. rz'NrrrUrUrVtest_idnaHostname rz+HostnameEndpointReprTests.test_idnaHostnamecCr)z When the host passed to L{HostnameEndpoint} is an IPv6 address it is wrapped in brackets in the string representation, like in a URI. This prevents the colon separating the host from the port from being ambiguous. s::1zNrrrUrUrVtest_hostIPv6Address s  z.HostnameEndpointReprTests.test_hostIPv6AddresscCs*tttgdd}|dt|dS)z When a bad hostname is passed to L{HostnameEndpoint}, the string representation displays invalid characters in backslash-escaped form. rr0z'N)rrvrLr+rrfrJrUrUrVtest_badEncoding sz*HostnameEndpointReprTests.test_badEncodingN)rhrirjrkrrrrrUrUrUrVr s  rc@r) HostnameEndpointsGAIFailureTestszM Tests for the hostname based endpoints when GAI returns no address. cCsHtttgdd}t}||}||tj}| dt |dS)z If no address is returned by GAI for a hostname, the connection attempt fails with L{error.DNSLookupError}. rr0r`N) rrvrLr+rrrrrrr8)rTrKrdConnectexcrUrUrV test_failure s z-HostnameEndpointsGAIFailureTests.test_failureN)rhrirjrkrrUrUrUrVr rrc@rM) &HostnameEndpointsFasterConnectionTestsz Tests for the hostname based endpoints when gai returns an IPv4 and an IPv6 address, and one connection takes less time than the other. cCs(t|_tt|jddgdd|_dS)Nrhrwww.example.comr0)rrrrvrLrKrSrUrUrVrL s  z,HostnameEndpointsFasterConnectionTests.setUpcCst|_tt|jdtdgdd|_d}|j||jd|jj d\}}}}}| t |jj d| |d| |ddS) z If an address type other than L{IPv4Address} and L{IPv6Address} is returned by on address resolution, the endpoint ignores that address. rhrrr0Nrr\r) rrrrvrLrrKrrrrr)rTrrr(rrrrUrUrVtest_ignoreUnknownAddressTypes s   zEHostnameEndpointsFasterConnectionTests.test_ignoreUnknownAddressTypesc Cst}tj|_|j|}g}||j|jjd\}}}}}| |d| |d| ||f} t } | |g| | | t |d| |dj|| g|jdS)a= The endpoint returns a connection to the IPv4 address. IPv4 ought to be the first attempt, since nameResolution (standing in for GAI here) returns it first. The IPv4 attempt succeeds, the connection is established, and a Deferred fires with the protocol constructed. rrhr0r\N)rr(r)rKrrrarrrrrrrrr rTrrresultsrr(rrrr fakeTransportrUrUrVtest_IPv4IsFaster5 s       z8HostnameEndpointsFasterConnectionTests.test_IPv4IsFasterc Cst}tj|_|j|}g}||j|jd|jj d\}}}}}| |d| |d| ||f} t } | |g| | | t|d| |dj|| g|jdS)a= The endpoint returns a connection to the IPv6 address. IPv6 ought to be the second attempt, since nameResolution (standing in for GAI here) returns it second. The IPv6 attempt succeeds, a connection is established, and a Deferred fires with the protocol constructed. rr\rr0rN)rr(r)rKrrrarrrrrrrrrrrrUrUrVtest_IPv6IsFasterT s         z8HostnameEndpointsFasterConnectionTests.test_IPv6IsFasterc Cst}tj|_|j|}g}||j|jd|jj d\}}}}}| ||f} t } | | | d|jj ddjj| g|jdS)a Once the endpoint returns a successful connection, all the other pending connections are cancelled. Here, the second connection attempt, i.e. IPv6, succeeds, and the pending first attempt, i.e. IPv4, is cancelled. rr\TrrN)rr(r)rKrrrarrrrrrrrrrrrUrUrVtest_otherConnectionsCancelledu s    zEHostnameEndpointsFasterConnectionTests.test_otherConnectionsCancelledN) rhrirjrkrLrrrrrUrUrUrVr s !rc@ry)SSL4EndpointsTestsz" Tests for SSL Endpoints. cCr)zD @return: List of calls to L{IReactorSSL.listenSSL} ) sslServersrrUrUrVr- rz"SSL4EndpointsTests.expectedServerscCr)zE @return: List of calls to L{IReactorSSL.connectSSL} ) sslClientsrrUrUrVr rz"SSL4EndpointsTests.expectedClientscCs`|\}}}}}}|\} } } } } }||| ||| ||| ||| |||dS)a Compare host, port, contextFactory, timeout, and bindAddress in C{receivedArgs} to C{expectedArgs}. We ignore the factory because we don't only care what protocol comes out of the C{IStreamClientEndpoint.connect} call. @param receivedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{contextFactory}, C{timeout}, C{bindAddress}) that was passed to L{IReactorSSL.connectSSL}. @param expectedArgs: C{tuple} of (C{host}, C{port}, C{factory}, C{contextFactory}, C{timeout}, C{bindAddress}) that we expect to have been passed to L{IReactorSSL.connectSSL}. Nr)rTrrrr(rcontextFactoryrrr.rrexpectedContextFactoryrrrUrUrVr s*     z$SSL4EndpointsTests.assertConnectArgscCrrrUrSrUrUrVr  rSzSSL4EndpointsTests.connectArgscCrr rUrSrUrUrVr5 rSzSSL4EndpointsTests.listenArgscCsLtddd\|_|_tddd\|_|_t|j|jdd|_tdd|_d S) zF Set up client and server SSL contexts for use later. zServer Test Certificateserver)OCNzClient Test CertificateclientF) privateKey certificaterequireCertificate)rN)rKsKeysCertcKeycCertrEserverSSLContextclientSSLContextrSrUrUrVrL s zSSL4EndpointsTests.setUpc KsJtddd}tj||j|jfi||j||j|dd|ddf|fS)a Create an L{SSL4ServerEndpoint} and return the tools to verify its behaviour. @param factory: The thing that we expect to be passed to our L{IStreamServerEndpoint.listen} implementation. @param reactor: A fake L{IReactorSSL} that L{SSL4ServerEndpoint} can call L{IReactorSSL.listenSSL} on. @param listenArgs: Optional dictionary of arguments to L{IReactorSSL.listenSSL}. rrrrrrrL)rrSSL4ServerEndpointr(rrrrUrUrVr% s    z'SSL4EndpointsTests.createServerEndpointc KsRtddd}tj||j|j|jfi||j|j||j|dd|ddf|fS)a Create an L{SSL4ClientEndpoint} and return the values needed to verify its behaviour. @param reactor: A fake L{IReactorSSL} that L{SSL4ClientEndpoint} can call L{IReactorSSL.connectSSL} on. @param clientFactory: The thing that we expect to be passed to our L{IStreamClientEndpoint.connect} implementation. @param connectArgs: Optional dictionary of arguments to L{IReactorSSL.connectSSL} rrr0rrrN)rrSSL4ClientEndpointrr(rrrrUrUrVr s$   z'SSL4EndpointsTests.createClientEndpointN) rhrirjrkr-rrr r5rLr%rrUrUrUrVr s& rc@ry)UNIXEndpointsTestsz) Tests for UnixSocket Endpoints. cCr)z Override L{EndpointTestCaseMixin.retrieveConnectedFactory} to account for different index of 'factory' in C{connectUNIX} args. rr\rrrUrUrVr( r~z+UNIXEndpointsTests.retrieveConnectedFactorycCr)zF @return: List of calls to L{IReactorUNIX.listenUNIX} ) unixServersrrUrUrVr-/ rz"UNIXEndpointsTests.expectedServerscCr)zG @return: List of calls to L{IReactorUNIX.connectUNIX} ) unixClientsrrUrUrVr5 rz"UNIXEndpointsTests.expectedClientsc Cs@|\}}}}|\}}} } |||||| ||| dS)a Compare path, timeout, checkPID in C{receivedArgs} to C{expectedArgs}. We ignore the factory because we don't only care what protocol comes out of the C{IStreamClientEndpoint.connect} call. @param receivedArgs: C{tuple} of (C{path}, C{timeout}, C{checkPID}) that was passed to L{IReactorUNIX.connectUNIX}. @param expectedArgs: C{tuple} of (C{path}, C{timeout}, C{checkPID}) that we expect to have been passed to L{IReactorUNIX.connectUNIX}. Nr) rTrrrrrrcheckPID expectedPathrrexpectedCheckPIDrUrUrVr; s   z$UNIXEndpointsTests.assertConnectArgscCr)rrr\)rrrUrSrUrUrVr T rSzUNIXEndpointsTests.connectArgscCs ddddS)r r ir\)rmodewantPIDrUrSrUrUrVr5Z s zUNIXEndpointsTests.listenArgsc KsLt|}tj||jfi||j||dd|dd|ddf|fS)a Create an L{UNIXServerEndpoint} and return the tools to verify its behaviour. @param reactor: A fake L{IReactorUNIX} that L{UNIXServerEndpoint} can call L{IReactorUNIX.listenUNIX} on. @param factory: The thing that we expect to be passed to our L{IStreamServerEndpoint.listen} implementation. @param listenArgs: Optional dictionary of arguments to L{IReactorUNIX.listenUNIX}. rrrrr)rmktemprUNIXServerEndpointrbrrrUrUrVr%` s    z'UNIXEndpointsTests.createServerEndpointcKsBt|}tj||jfi||j||dd|ddf|fS)a Create an L{UNIXClientEndpoint} and return the values needed to verify its behaviour. @param reactor: A fake L{IReactorUNIX} that L{UNIXClientEndpoint} can call L{IReactorUNIX.connectUNIX} on. @param clientFactory: The thing that we expect to be passed to our L{IStreamClientEndpoint.connect} implementation. @param connectArgs: Optional dictionary of arguments to L{IReactorUNIX.connectUNIX} rrrr)rrrUNIXClientEndpointrbrrrUrUrVrz rz'UNIXEndpointsTests.createClientEndpointN) rhrirjrkrr-rrr r5r%rrUrUrUrVr# s rc@sleZdZdZdZddZddZddZd d Zd d Z d dZ ddZ ddZ ddZ ddZddZdS) ParserTestszK Tests for L{endpoints._parseServer}, the low-level parsing logic. r(cOstj|i|S)zT Provide a hook for test_strports to substitute the deprecated API. )r _parseServer)rTakwrUrUrVparse rzParserTests.parsecC,||d|jdd|jfdddfdS)zN Simple strings with a 'tcp:' prefix should be parsed as TCP. ztcp:80rr0rLrrrNrrrrSrUrUrVtest_simpleTCP  zParserTests.test_simpleTCPcCr)zU TCP port descriptions parse their 'interface' argument as a string. ztcp:80:interface=127.0.0.1rr0r rrNrrSrUrUrVtest_interfaceTCP rzParserTests.test_interfaceTCPcCr)zU TCP port descriptions parse their 'backlog' argument as an integer. ztcp:80:backlog=6rr0rLrNrrSrUrUrVtest_backlogTCP rzParserTests.test_backlogTCPc C.||d|jdd|jfddddfdS) z L{endpoints._parseServer} returns a C{'UNIX'} port description with defaults for C{'mode'}, C{'backlog'}, and C{'wantPID'} when passed a string with the C{'unix:'} prefix and no other parameter values. zunix:/var/run/fingerUNIX/var/run/fingerrrTrrrNrrSrUrUrVtest_simpleUNIX s  zParserTests.test_simpleUNIXc Cr) zK C{mode} can be set by including C{"mode="}. zunix:/var/run/finger:mode=0660rrirTrNrrSrUrUrV test_modeUNIX   zParserTests.test_modeUNIXc Cr) zM C{wantPID} can be set to false by included C{"lockfile=0"}. zunix:/var/run/finger:lockfile=0rrrrFrNrrSrUrUrVtest_wantPIDUNIX r zParserTests.test_wantPIDUNIXc Cr) zf Backslash can be used to escape colons and backslashes in port descriptions. zunix:foo\:bar\=baz\:qux\\rzfoo:bar=baz:qux\rrTrNrrSrUrUrV test_escape   zParserTests.test_escapecCs|tdddS)z L{endpoints.quoteStringArgument} should quote backslashes and colons for interpolation into L{endpoints.serverFromString} and L{endpoints.clientFactory} arguments. zsome : stuff \zsome \: stuff \\N)rrquoteStringArgumentrSrUrUrVtest_quoteStringArgument sz$ParserTests.test_quoteStringArgumentc Cr) z In strports descriptions, '=' in a parameter value does not need to be quoted; it will simply be parsed as part of the value. zunix:address=foo=barrzfoo=barrrTrNrrSrUrUrVtest_impliedEscape r zParserTests.test_impliedEscapecCs|t|jd|jdS)ze L{strports.parse} raises C{ValueError} when given an unknown endpoint type. zbogus-type:nothingN)rrrrrSrUrUrVtest_unknownType r\zParserTests.test_unknownTypeN)rhrirjrkrrrrrrrr r rrrrUrUrUrVr s      rc@seZdZdZddZeeeddZeeeddZ dZ eeed d Z eeed d Z eeed dZ eeeddZddZddZddZdS)ServerStringTestszC Tests for L{twisted.internet.endpoints.serverFromString}. cCs\t}t|d}||tj||j|||jd||j d||j ddS)z When passed a TCP strports description, L{endpoints.serverFromString} returns a L{TCP4ServerEndpoint} instance initialized with the values from the string. z&tcp:1234:backlog=12:interface=10.0.0.1r) 10.0.0.1N) rrserverFromStringrrrEr~r_port_backlog _interface)rTrrrUrUrVtest_tcp szServerStringTests.test_tcpcCst}t|dttf}||tj||j|||j d||j d||j d||j j t|j }||tdS)z When passed an SSL strports description, L{endpoints.serverFromString} returns a L{SSL4ServerEndpoint} instance initialized with the values from the string. Vssl:1234:backlog=12:privateKey=%s:certKey=%s:sslmethod=TLSv1_METHOD:interface=10.0.0.1r)rrN)rrrescapedPEMPathNamerrrEr~rrrr_sslContextFactorymethodrC getContext ContextTyperTrrctxrUrUrVtest_ssl) s zServerStringTests.test_sslcCst}t|dt}||tj||j|||j d||j d||j d||j j t||j jt@|j }||tdS)z An SSL string endpoint description with minimal arguments returns a properly initialized L{SSL4ServerEndpoint} instance. zssl:4321:privateKey=rrLN)rrrrrrrEr~rrrrrrrBr_optionsrArrrrUrUrVtest_sslWithDefaults@ s   z&ServerStringTests.test_sslWithDefaultsz(ssl:1234:privateKey=%s:extraCertChain=%scCsttt|jttf}dddD}|j}||jd d|d d||jd d|d ddS)zf Specifying a chain file loads the contained certificates in the right order. cSs&g|]}ttd|fqS)z thing%d.pem)rDloadPEMcasPathchild getContent).0nrUrUrV k sz8ServerStringTests.test_sslChainLoads..)r\rrsha1r\N) rrrSSL_CHAIN_TEMPLATErescapedChainPathNamerrextraCertChaindigest)rTrexpectedChainCertscfrUrUrVtest_sslChainLoadsZ s$ z$ServerStringTests.test_sslChainLoadsc Cst|}||t}tt|j t t |j fWdn1s,wY| t|jd|j fdS)zy If C{extraCertChain} is passed, it has to contain at least one valid certificate in PEM format. NzOSpecified chain file '%s' doesn't contain any valid certificates in PEM format.)r9rcreatecloserrrrrr-rr rrrr8r3)rTfpcaughtrUrUrV test_sslChainFileMustContainCertw s$     z2ServerStringTests.test_sslChainFileMustContainCertcCsLd}t}t|dtt|}|j}||jt| t ||jj dS)z If C{dhParameters} are specified, they are passed as L{DiffieHellmanParameters} into L{CertificateOptions}. someFilez1ssl:4321:privateKey={}:certKey={}:dhParameters={}N) rrrformatrrr dhParametersrFrr9_dhFile)rTfileNamerrr2rUrUrVtest_sslDHparameters sz&ServerStringTests.test_sslDHparameterscCst}t|dttf}||tj||j|| |j d| |j d| |j d| |j jt|j }||tdS)zq Lack of a trailing newline in key and cert .pem files should not generate an exception. rr)rrN)rrr&escapedNoTrailingNewlineKeyPEMPathName'escapedNoTrailingNewlineCertPEMPathNamerrrEr~rrrrrrrCrrrrUrUrVtest_sslNoTrailingNewlinePem s"  z.ServerStringTests.test_sslNoTrailingNewlinePemcCsht}t|d}||tj||j|||jd||j d||j d| |j dS)z When passed a UNIX strports description, L{endpoint.serverFromString} returns a L{UNIXServerEndpoint} instance initialized with the values from the string. z0unix:/var/foo/bar:backlog=7:mode=0123:lockfile=1 /var/foo/barSN) rrrrrrEr~r_addressr_moder_wantPID)rTrrKrUrUrV test_unix szServerStringTests.test_unixcC&|ttjdd}|t|ddS)zq L{endpoints.serverFromString} raises C{ValueError} when given an unknown endpoint type. Nftl:andromeda/carcosa/hali/2387Unknown endpoint type: 'ftl')rrrrrr8rTrrUrUrVr z"ServerStringTests.test_unknownTypecCbt|t}t|d}ddlm}||j|||j |ddf||j t dddd S) z L{endpoints.serverFromString} looks up plugins of type L{IStreamServerEndpoint} and constructs endpoints from them. zfake:hello:world:yes=no:up=downr)fakehelloworldnodown)yesupN) addFakePluginrrrtwisted.plugins.fakeendpointrOrEparserrrr.dict)rT notAReactor fakeEndpointrOrUrUrVtest_typeFromPlugin s z%ServerStringTests.test_typeFromPluginN)rhrirjrkrr skipSSL skipSSLReasonr!r$r-r3r8r>rArHrr\rUrUrUrVr s&       rfakeendpoint.pycsxddljttjfdd}||t|}| t t j |||tj|jdS)z For the duration of C{testCase}, add a fake plugin to twisted.plugins which contains some sample endpoint parsers. rNcs(jjtjdd<dSr`)modulesclearupdater__path__rU savedModulessavedPluginPathsysrUrVcleanup s  zaddFakePlugin..cleanup)rgr`rJlistrrcrr9rcreateDirectoryr:rhfilePathsiblingcopyTor'rarr)testCase dropinSourcerhr6rUrdrVrV s    rVc@sheZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZdS)ClientStringTestszC Tests for L{twisted.internet.endpoints.clientFromString}. cCjt}t|d}||tj||j|||jd||j d||j d||j ddS)z When passed a TCP strports description, L{endpoints.clientFromString} returns a L{TCP4ClientEndpoint} instance initialized with the values from the string. z=tcp:host=example.com:port=1234:timeout=7:bindAddress=10.0.0.2r`r)rCz10.0.0.2rN rrclientFromStringrrrEr~r_hostr_timeout _bindAddressrTrrrUrUrVr zClientStringTests.test_tcpcCrq)z When passed a TCP strports description using positional arguments, L{endpoints.clientFromString} returns a L{TCP4ClientEndpoint} instance initialized with the values from the string. z3tcp:example.com:1234:timeout=7:bindAddress=10.0.0.2r`r)rCrrNrsrxrUrUrVtest_tcpPositionalArgs! ryz(ClientStringTests.test_tcpPositionalArgscC2t}t|d}||jd||jddS)z When passed a TCP strports description specifying host as a positional argument, L{endpoints.clientFromString} returns a L{TCP4ClientEndpoint} instance initialized with the values from the string. z8tcp:example.com:port=1234:timeout=7:bindAddress=10.0.0.2r`r)NrrrtrrurrxrUrUrVtest_tcpHostPositionalArg2 s z+ClientStringTests.test_tcpHostPositionalArgcCr{)z When passed a TCP strports description specifying port as a positional argument, L{endpoints.clientFromString} returns a L{TCP4ClientEndpoint} instance initialized with the values from the string. z8tcp:host=example.com:1234:timeout=7:bindAddress=10.0.0.2r`r)Nr|rxrUrUrVtest_tcpPortPositionalArg@ s z+ClientStringTests.test_tcpPortPositionalArgcCs0t}t|d}||jd||jdS)z{ A TCP strports description may omit I{timeout} or I{bindAddress} to allow the default to be used. ztcp:host=example.com:port=1234rN)rrrtrrvrrwrxrUrUrVtest_tcpDefaultsM s z"ClientStringTests.test_tcpDefaultscCZt}t|d}||tj||j|||jd||j d| |j dS)z When passed a UNIX strports description, L{endpoints.clientFromString} returns a L{UNIXClientEndpoint} instance initialized with the values from the string. z+unix:path=/var/foo/bar:lockfile=1:timeout=9rB N rrrtrrrEr~rrrvr _checkPIDrxrUrUrVrHW zClientStringTests.test_unixcCs,ttd}||jd||jdS)zz A UNIX strports description may omit I{lockfile} or I{timeout} to allow the defaults to be used. zunix:path=/var/foo/barrN)rrtrrrvrr)rTrrUrUrVtest_unixDefaultsg sz#ClientStringTests.test_unixDefaultscCr)z When passed a UNIX strports description specifying path as a positional argument, L{endpoints.clientFromString} returns a L{UNIXClientEndpoint} instance initialized with the values from the string. z&unix:/var/foo/bar:lockfile=1:timeout=9rBrNrrxrUrUrVtest_unixPathPositionalArgp rz,ClientStringTests.test_unixPathPositionalArgcCrN) z L{endpoints.clientFromString} looks up plugins of type L{IStreamClientEndpoint} and constructs endpoints from them. crfake:alpha:beta:cee=dee:num=1rfakeClientWithReactoralphabetadee1ceenumN) rVrrrtrWrrErXrrr.rY)rTrZclientEndpointrrUrUrVr\ s z%ClientStringTests.test_typeFromPlugincCrI)zq L{endpoints.clientFromString} raises C{ValueError} when given an unknown endpoint type. NrJrK)rrrrtrr8rLrUrUrVr rMz"ClientStringTests.test_unknownTypec CsVt|t}t|d}ddlm}||j|j|j f||ddft dddfd S) z L{endpoints.clientFromString} will pass a reactor to plugins implementing the L{IStreamClientEndpointStringParserWithReactor} interface. rrrrrrrrN) rVrrrtrWrrrXrr.rY)rTrrrrUrUrVtest_stringParserWithReactor s  z.ClientStringTests.test_stringParserWithReactorN)rhrirjrkrrzr}r~rrHrrr\rrrUrUrUrVrp s    rpc@rM) SSLClientStringTestszU Tests for L{twisted.internet.endpoints.clientFromString} which require SSL. cs`t}t|dtttf}||tj||j|| |j d| |j d| |j d| |j d|j}||t| |jt||jt@|}||t| t|jtt|j}|t|j| |tddt dt d fD}gGfd d d }|j!"|| t#d d Ddddt#|ddddS) When passed an SSL strports description, L{clientFromString} returns a L{SSL4ClientEndpoint} instance initialized with the values from the string. zdssl:host=example.net:port=4321:privateKey=%s:certKey=%s:bindAddress=10.0.0.3:timeout=3:caCertsDir=%s example.netr"rz10.0.0.3rcSs,g|]}|drt|qS)z.pem)basenamelowerendswithrDr%r(r)xrUrUrVr+ s  z1SSLClientStringTests.test_ssl.. thing1.pem thing2.pemceZdZfddZdS)z.SSLClientStringTests.test_ssl..ListCtxcsGfddd}|S)Ncr)zLSSLClientStringTests.test_ssl..ListCtx.get_cert_store..Storecs|dSr`r)rTcert addedCertsrUrVadd_cert rzUSSLClientStringTests.test_ssl..ListCtx.get_cert_store..Store.add_certN)rhrirjrrUrrUrVStore rrU)rTrrrUrVget_cert_store sz=SSLClientStringTests.test_ssl..ListCtx.get_cert_storeN)rhrirjrrUrrUrVListCtx rrcss|]}t|VqdSr`rDrrUrUrV sz0SSLClientStringTests.test_ssl..cS|Sr`r0rrUrUrVr z/SSLClientStringTests.test_ssl..)keycSrr`rrrUrUrVr rN)$rrrtrescapedCAsPathNamerrrEr~rrurrvrwrrErrBrr#rArrrDrtestCertificaterH_setPrivateKeyrGrtestPrivateCertificater&r' trustRoot_addCACertsToContextsorted)rTrr certOptionsr  privateCert expectedCertsrrUrrVr! sF    zSSLClientStringTests.test_sslcCstt}t|dtttf}||tj||j|| |j d| |j d| |j d| |j ddS)rzZssl:example.net:4321:privateKey=%s:certKey=%s:bindAddress=10.0.0.3:timeout=3:caCertsDir=%srr"rrN)rrrtrrrrrEr~rrurrvrwrxrUrUrVtest_sslPositionalArgs sz+SSLClientStringTests.test_sslPositionalArgscCszt}t|d}||tj||j|||jd||j d|j }||j t | |j| |jdS)z When passed an SSL strports description without extra arguments, L{clientFromString} returns a L{SSL4ClientEndpoint} instance whose context factory is initialized with default values. zssl:example.net:4321rr"N)rrrtrrrEr~rrurrrrBrrr)rTrrrrUrUrVr$s  z)SSLClientStringTests.test_sslWithDefaultscCsXGdddt}td}||_|ddt|jDt td gdS)z If a certificate in the directory is unreadable, L{endpoints._loadCAsFromDir} will ignore that certificate. c@seZdZddZdS)zKSSLClientStringTests.test_unreadableCertificate..UnreadableFilePathcSs(t|}|tdkrtt|S)Nr)r9r(r&r'OSErrorrrbrUrUrVr(s zVSSLClientStringTests.test_unreadableCertificate..UnreadableFilePath.getContentN)rhrirjr(rUrUrUrVUnreadableFilePaths rrmcSsg|]}t|qSrUrrrUrUrVr+'szCSSLClientStringTests.test_unreadableCertificate..rN) r9r&r'parent clonePathrr_loadCAsFromDir_caCertsrDr%r()rTr casPathClonerUrUrVtest_unreadableCertificates z/SSLClientStringTests.test_unreadableCertificatecCsHt}t|d}|j}||t||j|}||t dS)z When passed an SSL strports description without any extra parameters, L{clientFromString} returns a simple non-verifying endpoint that will speak SSL. z%ssl:host=simple.example.org:port=4321N) rrrtrrrErverifyrr)rTrrrr rUrUrVtest_sslSimple+s  z#SSLClientStringTests.test_sslSimpleN) rhrirjrkr!rr$rrrUrUrUrVr s4 rc@r) AdoptedStreamServerEndpointTestszA Tests for adopted socket-based stream server endpoints. cCs&t|||}dd|_dd|_|S)z Create an L{AdoptedStreamServerEndpoint} which may safely be used with an invalid file descriptor. This is convenient for a number of unit tests. cSrr`rUrirUrUrVrJrzPAdoptedStreamServerEndpointTests._createStubbedAdoptedEndpoint..cSrr`rUrrUrUrVrKr)rAdoptedStreamServerEndpoint_close_setNonBlocking)rTrfileno addressFamilyrrUrUrV_createStubbedAdoptedEndpointAs  z>AdoptedStreamServerEndpointTests._createStubbedAdoptedEndpointcCs2d}t}||||}tddd}||||f|fS)a Create a new L{AdoptedStreamServerEndpoint} for use by a test. @return: A three-tuple: - The endpoint - A tuple of the arguments expected to be passed to the underlying reactor method - An IAddress object which will match the result of L{IListeningPort.getHost} on the port returned by the endpoint. rrrr))rrr)rTrrrrrKrrUrUrVr%Ns   z5AdoptedStreamServerEndpointTests.createServerEndpointcCr)z @return: The ports which were actually adopted by C{reactor} via calls to its L{IReactorSocket.adoptStreamPort} implementation. ) adoptedPortsrrUrUrVr-`sz0AdoptedStreamServerEndpointTests.expectedServerscCsiS)zx @return: A C{dict} of additional keyword arguments to pass to the C{createServerEndpoint}. rUrSrUrUrVr5gsz+AdoptedStreamServerEndpointTests.listenArgscsRtdt}|t|ttj}fdd}|||S)z L{AdoptedStreamServerEndpoint.listen} can only be used once. The file descriptor given is closed after the first use, and subsequent calls to C{listen} return a L{Deferred} that fails with L{AlreadyListened}. csdtjdSr[)rrrrmrrTrUrV listenFailedyszEAdoptedStreamServerEndpointTests.test_singleUse..listenFailed) rrrr,rrrAlreadyListenedr)rTrKrrrUrrVtest_singleUsens  z/AdoptedStreamServerEndpointTests.test_singleUsecsRt}|dt}gfdd}||_|t}fdd}|||S)zv L{AdoptedStreamServerEndpoint.listen} sets the file description given to it to non-blocking. rcsd|fdS)NsetNonBlockingrr)eventsrUrVrr^zTAdoptedStreamServerEndpointTests.test_descriptionNonBlocking..setNonBlockingcdgdS)N)rrrrrrTrUrVlistenedr^zNAdoptedStreamServerEndpointTests.test_descriptionNonBlocking..listened)rrrrr,rr)rTrrKrrrrUrrVtest_descriptionNonBlockings   z.closecr)N)r5rr\rrrrUrVrr^zHAdoptedStreamServerEndpointTests.test_descriptorClosed..listened)rrrrr,rr)rTrKr5rrrU)rrrTrVtest_descriptorCloseds  z6AdoptedStreamServerEndpointTests.test_descriptorClosedN) rhrirjrkrr%r-r5rrrrUrUrUrVr<s  rc@sFeZdZdZejZddZddZddZ dd Z d d Z d d Z dS)SystemdEndpointPluginTestsz Unit tests for the systemd stream server endpoint and endpoint string description parser. @see: U{systemd} cC>tttj}|D] }t||jrdSq |d|dS)z L{endpoints._SystemdParser} is found as a plugin for L{interfaces.IStreamServerEndpointStringParser} interface. zDid not find systemd parser in Nrir2r!IStreamServerEndpointStringParserr7 _parserClassrrTparsersrrUrUrVtest_pluginDiscoverys  z/SystemdEndpointPluginTests.test_pluginDiscoverycC|}|ttj|dS)zx L{endpoints._SystemdParser} instances provide L{interfaces.IStreamServerEndpointStringParser}. NrrrrrrTrXrUrUrVr z)SystemdEndpointPluginTests.test_interfacecCsjt}gd}d}|}t||_|j||t|d}||j|||j |||j ||dS)a Helper for unit tests for L{endpoints._SystemdParser.parseStreamServer} for different address families. Handling of the address family given will be verify. If there is a problem a test-failing exception will be raised. @param addressFamily: An address family constant, like L{socket.AF_INET}. @param addressFamilyString: A string which should be recognized by the parser as representing C{addressFamily}. )rrrCrr)domainindexN) rrr; _sddaemonparseStreamServerr8rErrrr)rTraddressFamilyStringr descriptorsrrXrrUrUrV_parseStreamServerTests  z1SystemdEndpointPluginTests._parseStreamServerTestcC|tddS)zC IPv4 can be specified using the string C{"INET"}. INETN)rrrSrUrUrVtest_parseStreamServerINETrz5SystemdEndpointPluginTests.test_parseStreamServerINETcCr)zD IPv6 can be specified using the string C{"INET6"}. INET6N)rrrSrUrUrVtest_parseStreamServerINET6rz6SystemdEndpointPluginTests.test_parseStreamServerINET6cCs:zddlm}Wn tytdw||ddS)zS A UNIX domain socket can be specified using the string C{"UNIX"}. r)AF_UNIXzPlatform lacks AF_UNIX supportrN)socketr ImportErrorr>SkipTestr)rTrrUrUrVtest_parseStreamServerUNIXs   z5SystemdEndpointPluginTests.test_parseStreamServerUNIXN) rhrirjrkr_SystemdParserrrrrrrrrUrUrUrVrs   rc@.eZdZdZejZddZddZddZ dS) TCP6ServerEndpointPluginTestsz[ Unit tests for the TCP IPv6 stream server endpoint string description parser. cCr)z L{endpoints._TCP6ServerParser} is found as a plugin for L{interfaces.IStreamServerEndpointStringParser} interface. z*Did not find TCP6ServerEndpoint parser in NrrrUrUrVr   z2TCP6ServerEndpointPluginTests.test_pluginDiscoverycCr)z{ L{endpoints._TCP6ServerParser} instances provide L{interfaces.IStreamServerEndpointStringParser}. NrrrUrUrVrrz,TCP6ServerEndpointPluginTests.test_interfacecCsXttd}||tj||jt||jd||jd||j ddS)z L{serverFromString} returns a L{TCP6ServerEndpoint} instance with a 'tcp6' endpoint string description. z$tcp6:8080:backlog=12:interface=\:\:1irrN) rrrrr r~rrrrr,rUrUrVtest_stringDescriptionsz4TCP6ServerEndpointPluginTests.test_stringDescriptionN) rhrirjrkr_TCP6ServerParserrrrrrUrUrUrVrs  rc@r) StandardIOEndpointPluginTestszM Unit tests for the Standard I/O endpoint string description parser. cCr)z L{endpoints._StandardIOParser} is found as a plugin for L{interfaces.IStreamServerEndpointStringParser} interface. z*Did not find StandardIOEndpoint parser in NrrrUrUrVr5rz2StandardIOEndpointPluginTests.test_pluginDiscoverycCr)z{ L{endpoints._StandardIOParser} instances provide L{interfaces.IStreamServerEndpointStringParser}. NrrrUrUrVrArz,StandardIOEndpointPluginTests.test_interfacecCs.ttd}||tj||jtdS)z L{serverFromString} returns a L{StandardIOEndpoint} instance with a 'stdio' endpoint string description. zstdio:N)rrrrrDr~r,rUrUrVrKsz4StandardIOEndpointPluginTests.test_stringDescriptionN) rhrirjrkr_StandardIOParserrrrrrUrUrUrVr.s  rc@ru)ConnectProtocolTestsz' Tests for C{connectProtocol}. cCslt}t|dd}t}t|||t|jd|jddj}| |t j | | d|dS)z C{endpoints.connectProtocol} calls the given endpoint's C{connect()} method with a factory that will build the given protocol. r rr\rN)rrrrconnectProtocolrrr_wrappedFactoryrrr(rEr)rTrrK theProtocolrrUrUrV"test_connectProtocolCreatesFactoryZs z7ConnectProtocolTests.test_connectProtocolCreatesFactorycs:tGfddd}|}|t|tdS)z~ C{endpoints.connectProtocol} returns the result of calling the given endpoint's C{connect()} method. cr)zOConnectProtocolTests.test_connectProtocolReturnsConnectResult..EndpointcS)zR Return a marker object for use in our assertion. rU)rTrrnrUrVrtszWConnectProtocolTests.test_connectProtocolReturnsConnectResult..Endpoint.connectN)rhrirjrrUrrUrVEndpointsrrN)rrrErrr)rTrrKrUrrV(test_connectProtocolReturnsConnectResultlsz=ConnectProtocolTests.test_connectProtocolReturnsConnectResultN)rhrirjrkrrrUrUrUrVrUs rcs4eZdZdZfddZfddZddZZS)UppercaseWrapperProtocolzL A wrapper protocol which uppercases all strings passed through it. ct|dS)z Uppercase a string passed in from the transport. @param data: The string to uppercase. @type data: L{bytes} N)rWrcupperrbr\rUrVrcz%UppercaseWrapperProtocol.dataReceivedcr )z Uppercase a string passed out to the transport. @param data: The string to uppercase. @type data: L{bytes} N)rWr_r rbr\rUrVr_r zUppercaseWrapperProtocol.writecCs|D]}||qdS)zy Uppercase a series of strings passed out to the transport. @param seq: An iterable of strings. Nr^)rTseqrPrUrUrVrs z&UppercaseWrapperProtocol.writeSequence)rhrirjrkrcr_rrmrUrUr\rVr ~s    r c@r)UppercaseWrapperFactoryzK A wrapper factory which uppercases all strings passed through it. N)rhrirjrkr rrUrUrUrVrsrc@ru)NetstringTrackerz A netstring receiver which keeps track of the strings received. @ivar strings: A L{list} of received strings, in order. cCs g|_dSr`)stringsrSrUrUrVrWrszNetstringTracker.__init__cCs|j|dS)z Receive a string and append it to C{self.strings}. @param string: The string to be appended to C{self.strings}. N)rra)rTrrUrUrVstringReceivedszNetstringTracker.stringReceivedN)rhrirjrkrWrrUrUrUrVrs rc@r7) FakeErrorz An error which isn't really an error. This is raised in the L{wrapClientTLS} tests in place of a 'real' exception. Nr9rUrUrUrVrr:rc@r)WrapperClientEndpointTestsz. Tests for L{_WrapperClientEndpoint}. cCs6t\|_|_t|_t|jt|_t t |_ dSr`) r<rK completerrcontextr_WrapperEndpointrrr(rrrrSrUrUrVrLs z WrapperClientEndpointTests.setUpcCsL|j|j}|j}||}|jjd| | |j dgdS)z Any modifications performed by the underlying L{ProtocolWrapper} propagate through to the wrapped L{Protocol}. s5:hello,sHELLON) rrrr succeedOncerHrrr_flushrrrT connectingpumprrUrUrVtest_wrappingBehaviors   z0WrapperClientEndpointTests.test_wrappingBehaviorcCsB|j|j}|j}||}|d||j ddS)z Methods defined on the wrapped L{Protocol} are accessible from the L{Protocol} returned from C{connect}'s L{Deferred}. sspams4:SPAM,N) rrrrrrH sendStringrclientIO getOutBufferrrUrUrVtest_methodsAvailables    z0WrapperClientEndpointTests.test_methodsAvailablecCs6|j|j}|||jt||tdS)zS Connection failures propagate upward to C{connect}'s L{Deferred}. N)rrrassertNoResultrfailOncerrrTrrUrUrVtest_connectionFailures z1WrapperClientEndpointTests.test_connectionFailurecCs0|j|j}|||||tdS)zM Cancellation propagates upward to C{connect}'s L{Deferred}. N)rrrr!rrr!r#rUrUrVtest_connectionCancellations z6WrapperClientEndpointTests.test_connectionCancellationcCs8|j|j}|j}||}||jj|jdS)z| The transport of the wrapped L{Protocol}'s transport is the transport passed to C{makeConnection}. N) rrrrrrHrErrrrUrUrV*test_transportOfTransportOfWrappedProtocols  zEWrapperClientEndpointTests.test_transportOfTransportOfWrappedProtocolN) rhrirjrkrLrr r$r%r&rUrUrUrVrs   rcCs |djS)a, Given a L{MemoryReactor} and the result of calling L{wrapClientTLS}, extract the L{IOpenSSLClientConnectionCreator} associated with it. Implementation presently uses private attributes but could (and should) be refactored to just call C{.connect()} on the endpoint, when L{HostnameEndpoint} starts directing its C{getaddrinfo} call through the reactor it is passed somehow rather than via the global threadpool. @param memoryReactor: the reactor attached to the given endpoint. (Presently unused, but included so tests won't need to be modified to honor it.) @param tlsEndpoint: The result of calling L{wrapClientTLS}. @return: the client connection creator associated with the endpoint wrapper. @rtype: L{IOpenSSLClientConnectionCreator} N)_wrapperFactory_connectionCreator)r tlsEndpointrUrUrVconnectionCreatorFromEndpoints r*c@r#) WrapClientTLSParserTestsz0 Tests for L{_TLSClientEndpointParser}. cCsjt}t|td}|j}||j|||jd||j d||j d||j tddS)zm A L{HostnameEndpoint} is constructed from parameters passed to L{clientFromString}. z4tls:example.com:443:timeout=10:bindAddress=127.0.0.1rrrr N) rrrtr6_wrappedEndpointrEr~rrrrvrw)rTrrKhostnameEndpointrUrUrV!test_hostnameEndpointConstruction!sz:WrapClientTLSParserTests.test_hostnameEndpointConstructioncCs>t}t|d}||jjdt||}||jddS)z The hostname passed to L{clientFromString} is treated as utf-8 bytes; it is then encoded as IDNA when it is passed along to L{HostnameEndpoint}, and passed as unicode to L{optionsForClientTLS}. stls:éxample.example.com:443sxn--xample-9ua.example.comuéxample.example.comN)rrrtrr,rr* _hostname)rTrrKconnectionCreatorrUrUrVtest_utf8Encoding2s z*WrapClientTLSParserTests.test_utf8Encodingc s|t}tt|dgdttttj  d}| t t}|j\}}}}}|d||dus=Jtt} t| jj| jttjg| d} tt| dt fddd dtfd dfd d\} } } jd ||}|jd | |!jj"|!|jj"|!jj#|!|jj#t$j}|%|ttdS)z When passed a string endpoint description beginning with C{tls:}, L{clientFromString} returns a client endpoint initialized with the values from the string. r z=tls:localhost:4321:privateKey={}:certificate={}:trustRoots={}asciiN)rrr/rFcrr`rUrU) plainServerrUrVrqrz3WrapClientTLSParserTests.test_tls..)isClientwrappedFactorycrr`rUrU)serverProtocolrUrVrtrcrr`rUrU)clientProtocolrUrVrurshello s hi you too )&rrrtrLr:rr pemPathrrrencoderr(rr)rpoprr!rHr%r(rEroriginalrD chainPathrJr=rr_rHrr disconnecting disconnectedpeerFromTransportr)rTrrKrrr(rrr serverCert serverOptionssProtocProtor plainClientpeerCertificaterU)r7r3r6rVtest_tlsBsX          z!WrapClientTLSParserTests.test_tlscCs>t}t|d}t||}||jd||jjddS)z When passed a C{tls:} strports description without extra arguments, L{clientFromString} returns a client endpoint whose context factory is initialized with default values. stls:example.com:443r`rN)rrrtr*rr/r,r)rTrrKcreatorrUrUrVtest_tlsWithDefaultss   z-WrapClientTLSParserTests.test_tlsWithDefaultsN)rhrirjrkr.r1rFrHrUrUrUrVr+s  Ar+cKsz|j}|j}Wnty|j}|j}Ynw|D] }||vr'td|qi}||||t||}|||j <|S)a Create a copy of the given function with the given globals substituted. The globals must already exist in the function's existing global scope. @param function: any function object. @type function: L{types.FunctionType} @param newGlobals: each keyword argument should be a global to set in the new function's returned scope. @type newGlobals: L{dict} @return: a new function, like C{function}, but with new global scope. zr zope.interfacer r r zope.interface.interfacerzope.interface.verifyrrtwistedrrurrrrrrrrtwisted.internet.abstractrtwisted.internet.addressrrrrrtwisted.internet.endpointsr twisted.internet.errorr!twisted.internet.interfacesr"r#r$r%r&twisted.internet.protocolr'r(r)twisted.internet.stdior*twisted.internet.taskr+twisted.internet.testingr,rr-r.r/twisted.loggerr0r1twisted.pluginr2twisted.protocolsr3r4twisted.pythonr5twisted.python.compatr6twisted.python.componentsr7twisted.python.failurer8twisted.python.filepathr9twisted.python.modulesr:twisted.python.systemdr;twisted.test.iosimr<r= twisted.trialrkrlr8noTrailingNewlineKeyPemPathnoTrailingNewlineCertPemPathrhr&r'r<r rrrr?r@rr. OpenSSL.SSLr@rrArBrCtwisted.internet.sslrDrErFrGrHtwisted.protocols.tlsrJtwisted.test.test_sslverifyrKr%r(rrr]r^rrr8rNrrmrrvrr{rrTestCaserrr$r8r;r@rCrPIProcessTransportrTIReactorProcessrnrzrrrrr#r5rLSynchronousTestCaserMrlr{rrrrrrrrrrrrrVrprrrrrrProtocolWrapperr WrappingFactoryrNetstringReceiverrrrrr*r+rTrUrUrUrUrVs*      (                         P) #  $ ooks <   44IvHFq b+pU-')! At$