U 2ܟj@sdZddlmZddlmZddlmZddlmZm Z m Z m Z ddl m Z mZddlmZmZddlmZdd lmZmZmZmZdd lmZdd lmZdd lmZdd lm Z ddl!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mm?Z?ddl@mAZAddlBmCZCmDZDddlEmFZFmGZGGdddeHZIGdddeHZJeAddgiZKddZLddZMddZNd d!ZOd"d#ZPGd$d%d%e ZQGd&d'd'ZRGd(d)d)eRe ZSGd*d+d+eRe ZTGd,d-d-e ZUGd.d/d/ZVGd0d1d1ZWGd2d3d3e ZXeeCGd4d5d5ZYGd6d7d7e ZZGd8d9d9e Z[Gd:d;d;e Z\Gdd?d?e Z^d@S)Az& Tests for L{twisted.web._newclient}. )Optional) implementer) verifyObject)CancelledErrorDeferredfailsucceed)ConnectionDoneConnectionLost) IConsumer IPushProducer)Protocol)AccumulatingProtocolEventLoggingObserverStringTransport StringTransportWithDisconnection)globalLogPublisher) LineReceiver)Failure)TestCase)BODYDONEHEADERSTATUSUNKNOWN_LENGTH BadHeadersBadResponseVersionChunkedEncoderConnectionAborted ExcessWriteHTTPClientParser HTTPParserLengthEnforcingConsumer ParseErrorRequestNotSentTransportProxyProducerWrongBodyLengthmakeStatefulDispatcher) HTTP11ClientProtocolPotentialDataLossRequestRequestGenerationFailedRequestTransmissionFailedResponse ResponseDoneResponseFailedResponseNeverReceived) _DataLoss)Headers) IBodyProducer IResponse)bytesLinearWhitespaceComponentssanitizedBytesc@seZdZdZdS)ArbitraryExceptionze A unique, arbitrary exception type which L{twisted.web._newclient} knows nothing about. N__name__ __module__ __qualname____doc__r=r=C/tmp/pip-unpacked-wheel-4b529toj/twisted/web/test/test_newclient.pyr7Csr7c@seZdZdZdS)AnotherArbitraryExceptionzI Similar to L{ArbitraryException} but with a different identity. Nr8r=r=r=r>r?Jsr?host example.comcs(fdd}||}|||S)a Assert that the given L{Deferred} fails with the exception given by C{mainType} and that the exceptions wrapped by the instance of C{mainType} it fails with match the list of exception types given by C{reasonTypes}. This is a helper for testing failures of exceptions which subclass L{_newclient._WrapperException}. @param self: A L{TestCase} instance which will be used to make the assertions. @param deferred: The L{Deferred} which is expected to fail with C{mainType}. @param mainType: A L{_newclient._WrapperException} subclass which will be trapped on C{deferred}. @param reasonTypes: A sequence of exception types which will be trapped on the resulting C{mainType} exception instance's C{reasons} sequence. @return: A L{Deferred} which fires with the C{mainType} instance C{deferred} fails with, or which fails somehow. c sLt|jD]\}}||q t|jtd|jdd|S)Nzlen(z ) != len())zipreasonstrap assertEquallen)errreasontype reasonTypesselfr=r>cbFailedns z-assertWrapperExceptionTypes..cbFailed) assertFailure addCallback)rMdeferredZmainTyperLrNdr=rKr>assertWrapperExceptionTypesUs  rScCst||t|S)zo A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{ResponseFailed}. )rSr/rMrQrLr=r=r>assertResponseFailed}srUcCst||t|S)zx A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{RequestGenerationFailed}. )rSr+rTr=r=r>assertRequestGenerationFaileds rVcCst||t|S)zz A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{RequestTransmissionFailed}. )rSr,rTr=r=r>assertRequestTransmissionFaileds rWcCstdddt|S)z Helper function for creating a Response which uses the given transport. All of the other parameters to L{Response.__init__} are filled with arbitrary values. Only use this method if you don't care about any of them. sHTTPrYOK)r-_boringHeaders) transportr=r=r>justTransportResponsesr^c@seZdZdZddZdS)MakeStatefulDispatcherTestsz. Tests for L{makeStatefulDispatcher}. cCsRGddd}|}||dd|_||dd|_|t|jdS)z A method defined with L{makeStatefulDispatcher} invokes a second method based on the current state of the object. c@s2eZdZdZddZedeZddZddZd S) zCMakeStatefulDispatcherTests.test_functionCalledByState..FooAcSsdSNr=rMr=r=r>barszGMakeStatefulDispatcherTests.test_functionCalledByState..Foo.barZquuxcSsdS)Nar=rbr=r=r>_quux_AszKMakeStatefulDispatcherTests.test_functionCalledByState..Foo._quux_AcSsdS)Nbr=rbr=r=r>_quux_BszKMakeStatefulDispatcherTests.test_functionCalledByState..Foo._quux_BN)r9r:r;_statercr'rergr=r=r=r>Foos  rirdBrfCN)rFrcrh assertRaises RuntimeError)rMriZstatefulr=r=r>test_functionCalledByStatesz6MakeStatefulDispatcherTests.test_functionCalledByStateN)r9r:r;r<rnr=r=r=r>r_sr_c@sreZdZUdZdZeeed<ddZddZ dd Z d d Z d d Z ddZ ddZddZddZddZdS)_HTTPParserTestszt Base test class for L{HTTPParser} which is responsible for the bulk of the task of parsing HTTP bytes. NsepcCs\g}t}|j|_|t||jt|d|j ||dg||jt dS)zj L{HTTPParser} calls its C{statusReceived} method when it receives a status line. HTTP/1.1 200 OKN) r!appendstatusReceivedmakeConnectionrrFstater dataReceivedrpr)rMstatusprotocolr=r=r>test_statusCallbacks z$_HTTPParserTests.test_statusCallbackcCs6i}t}|j|_|t|d|j||fS)Nrq)r! __setitem__headerReceivedrtrrvrprMheaderrxr=r=r>_headerTestSetups  z!_HTTPParserTests._headerTestSetupcCsJ|\}}|d|j||j||ddi||jtdS)ze L{HTTPParser} calls its C{headerReceived} method when it receives a header. s X-Foo:barX-FoobarNr~rvrprFrurr|r=r=r>test_headerCallbacks   z$_HTTPParserTests.test_headerCallbackcCsj|\}}|d|j|d|j|d|j||j||ddi||jtdS)z If a header is split over multiple lines, L{HTTPParser} calls C{headerReceived} with the entire value once it is received. X-Foo: bars bazs quuxrs bar baz quuxNrr|r=r=r>test_continuedHeaderCallbacks  z-_HTTPParserTests.test_continuedHeaderCallbackcCs^|\}}|jddddg}|d||d|||j||dddd S) z Leading and trailing linear whitespace is stripped from the header value passed to the C{headerReceived} callback. s s bar s sX-Bar:sX-Foo:r)rsX-BarN)r~rpjoinrvrF)rMr}rxvaluer=r=r>test_fieldContentWhitespaces   z,_HTTPParserTests.test_fieldContentWhitespacecsPg|\}fdd}|_|j|tg|jtdS)zg After the last header is received, L{HTTPParser} calls C{allHeadersReceived}. csjt_dSra)rrrurr=calledrxr=r>allHeadersReceiveds zD_HTTPParserTests.test_allHeadersCallback..allHeadersReceivedN)r~rrvrprFrrur)rMr}rr=rr>test_allHeadersCallbacks  z(_HTTPParserTests.test_allHeadersCallbackcCs6|\}}||j||i||jtdS)zp If there are no headers in the message, L{HTTPParser} does not call C{headerReceived}. Nrr|r=r=r>test_noHeaderCallbacks   z&_HTTPParserTests.test_noHeaderCallbackcCsvt}|t|d|j|d|j|d|j||jdddgfg}||t|jdS)zc All headers received by L{HTTPParser} are added to L{HTTPParser.headers}. rqr X-Foo: bazrrbazN) r!rtrrvrprFlistheadersgetAllRawHeaders)rMrxexpectedr=r=r>test_headersSavedOnResponse#s  z,_HTTPParserTests.test_headersSavedOnResponsecCsRt}ddddddddg}|D]}|||d |fq||d d d S) z L{HTTPParser.isConnectionControlHeader} returns C{True} for headers which are always connection control headers (similar to "hop-by-hop" headers from RFC 2616 section 13.5.1) and C{False} for other headers. content-length connections keep-alivestestrailersstransfer-encodingsupgradesproxy-connectionz:Expecting %r to be a connection control header, but wasn'tsdatez`Expecting the arbitrarily selected 'date' header to not be a connection control header, but was.N)r! assertTrueZisConnectionControlHeader assertFalse)rMrxZconnHeaderNamesr}r=r=r>test_connectionControlHeaders1s* z._HTTPParserTests.test_connectionControlHeaderscCs4t}|t|t|t|jtdS)zi L{HTTPParser.switchToBodyMode} raises L{RuntimeError} if called more than once. N)r!rtrZswitchToBodyModeobjectrlrmrMrxr=r=r>test_switchToBodyModeOs  z&_HTTPParserTests.test_switchToBodyMode)r9r:r;r<rprbytes__annotations__ryr~rrrrrrrrr=r=r=r>ros     roc@seZdZdZdZdS)$HTTPParserRFCComplaintDelimeterTestsz< L{_HTTPParserTests} using standard CR LF newlines.  Nr9r:r;r<rpr=r=r=r>rZsrc@seZdZdZdZdS)'HTTPParserNonRFCComplaintDelimeterTestsz5 L{_HTTPParserTests} using bare LF newlines.  Nrr=r=r=r>rbsrc@s eZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8d9Zd:d;Z dd?Z"d@dAZ#dBdCZ$dDdEZ%dFS)GHTTPClientParserTestszd Tests for L{HTTPClientParser} which is responsible for parsing HTTP response messages. cCs tdd}||dddS)zj L{HTTPClientParser.parseVersion} parses a status line into its three components. Ns CANDY/7.2)sCANDY)r rF parseVersionrr=r=r>test_parseVersionps z'HTTPClientParserTests.test_parseVersioncsXtdd}t|jfdd}|d|d|d|d|d|d dS) zr L{HTTPClientParser.parseVersion} raises L{ValueError} when passed an unparsable version. Ncs |}|j|dSra)rlrFdatasexcefrMr=r> checkParsingsz@HTTPClientParserTests.test_parseBadVersion..checkParsingfoos foo/bar/bazsfoo/sfoo/..sfoo/a.bs foo/-1.-1)r rr)rMrxrr=rr>test_parseBadVersionxs z*HTTPClientParserTests.test_parseBadVersioncCsbtddtd}t|d}|t|d||jjd||jj d||jj ddS)z L{HTTPClientParser.statusReceived} parses the version, code, and phrase from the status line and stores them on the response object. GET/NHTTP/1.1 200 OK rXrZr[ r*r\r rtrrvrFresponseversioncodephraserMrequestrxr=r=r>test_responseStatusParsings   z0HTTPClientParserTests.test_responseStatusParsingcCsbtddtd}t|d}|t|d||jjd||jj d||jj ddS)z L{HTTPClientParser.statusReceived} can parse a status line without a phrase (though such lines are a violation of RFC 7230, section 3.1.2; nevertheless some broken servers omit the phrase). rrNsHTTP/1.1 200 rXrZrrrr=r=r> test_responseStatusWithoutPhrases   z6HTTPClientParserTests.test_responseStatusWithoutPhrasecs,tddfdd}|d|ddS)z L{HTTPClientParser.statusReceived} raises L{ParseError} if it is called with a status line which cannot be parsed. Ncs"tj|}|j|dSra)rlr#rsrFrrrxrMr=r>rszBHTTPClientParserTests.test_badResponseStatus..checkParsingrsHTTP/1.1 bar OK)r )rMrr=rr>test_badResponseStatuss z,HTTPClientParserTests.test_badResponseStatusc si}g}g}gt||j}|j|_t}|||||j|j_fdd|j_ ||| |j d| |j t | |g| |dg| dg| |jjd|S)a0 Assert that L{HTTPClientParser} parses the given C{response} to C{request}, resulting in a response with no body and no extra bytes and leaving the transport in the producing state. @param request: A L{Request} instance which might have caused a server to return the given response. @param status: A string giving the status line of the response to be parsed. @param response: A string giving the response to be parsed. @return: A C{dict} of headers from the response. cs dSNTrrr=ZbodyDataFinishedr=r>rz3HTTPClientParserTests._noBodyTest.. producingrTr)r rrrzr{rrtrvr_bodyDataReceived_bodyDataFinishedrF producerStaterurlength) rMrrwrr}finishedbodyrxr]r=rr> _noBodyTests&      z!HTTPClientParserTests._noBodyTestcCs8tddtd}d}d}||||}||ddidS)z If the response is to a HEAD request, no body is expected, the body callback is not invoked, and the I{Content-Length} header is passed to the header callback. HEADrNrsContent-Length: 10 sContent-Lengths10)r*r\rrF)rMrrwrr}r=r=r>test_headResponses z'HTTPClientParserTests.test_headResponsecCs(tddtd}d}d}||||dS)z If the response code is I{NO CONTENT} (204), no body is expected and the body callback is not invoked. rrNsHTTP/1.1 204 NO CONTENT rr*r\rrMrrwrr=r=r>test_noContentResponsesz,HTTPClientParserTests.test_noContentResponsecCs(tddtd}d}d}||||dS)z If the response code is I{NOT MODIFIED} (304), no body is expected and the body callback is not invoked. rrNsHTTP/1.1 304 NOT MODIFIED rrrr=r=r>test_notModifiedResponsesz.HTTPClientParserTests.test_notModifiedResponsecCsttddtddd}|t|d|d|d||jti||j j td d gi| |j j t dS) zq The response headers are added to the response object's C{headers} L{Headers} instance. rrNcSsdSrar=restr=r=r>rrz.rs X-Foo: bar rx-foorr r*r\rtrrvrF connHeadersr2rrassertIdenticalrrrr=r=r>test_responseHeaderss     z*HTTPClientParserTests.test_responseHeaderscCsttddtddd}|t|d|d|d|d ||jti||j j td d gi| |j j t dS) z The multi-line response headers are folded and added to the response object's C{headers} L{Headers} instance. rrNcSsdSrar=rr=r=r>rrzEHTTPClientParserTests.test_responseHeadersMultiline..rsX-Multiline: a s b rs x-multilinesa brrr=r=r>test_responseHeadersMultilines       z3HTTPClientParserTests.test_responseHeadersMultilinecCsttddtddd}|t|d|d|d|d ||jjt i||j t d gd gd ||jj d dS)zv The connection control headers are added to the parser's C{connHeaders} L{Headers} instance. rrNcSsdSrar=rr=r=r>r)rz>HTTPClientParserTests.test_connectionHeaders..rContent-Length: 123 sConnection: close r123sclose)rr{ r r*r\rtrrvrFrrr2rrrr=r=r>test_connectionHeaders#s      z,HTTPClientParserTests.test_connectionHeaderscCsttddtddd}|t|d|d|d||jjt d d gi||j t i||jj d dS) z If a HEAD request is made, the I{Content-Length} header in the response is added to the response headers, not the connection control headers. rrNcSsdSrar=rr=r=r>r=rzRHTTPClientParserTests.test_headResponseContentLengthEntityHeader..rrrrrrrrr=r=r>*test_headResponseContentLengthEntityHeader7s      z@HTTPClientParserTests.test_headResponseContentLengthEntityHeadercCsg}ttddtd|j}t}|||dg}|j|j_|d|d| |j d| |j t |d| |dg| |j t |d | |dd g| |j t | |d gdS) z If a response includes a body with a length given by the I{Content-Length} header, the bytes which make up the body are passed to the C{_bodyDataReceived} callback on the L{HTTPParser}. rrNrsContent-Length: 10 rpausedsxxxxxxsyyyyr)r r*r\rrrrtrvrrrFrrurrrMrrxr]rr=r=r>test_contentLengthIs*        z(HTTPClientParserTests.test_contentLengthcCsg}ttddtd|j}|t|dg}|j|j_|d|d| |j t | |g| |dg| |jj ddS) z If a response includes a I{Content-Length} header indicating zero bytes in the response, L{Response.length} is set accordingly and no data is delivered to L{Response._bodyDataReceived}. rrNrContent-Length: 0 rrr) r r*r\rrrtrrvrrrFrurrrMrrxrr=r=r>test_zeroContentLengthhs       z,HTTPClientParserTests.test_zeroContentLengthcCs4ttddtdd}|t|t|jddS)z If a response includes multiple, distinct I{Content-Length} headers, L{HTTPClientParser.dataReceived} raises L{ValueError} to indicate that the response is invalid and the transport is now unusable. rrNs9HTTP/1.1 200 OK Content-Length: 1 Content-Length: 2 r r*r\rtrrl ValueErrorrvrr=r=r>)test_multipleDistinctContentLengthHeaderss z?HTTPClientParserTests.test_multipleDistinctContentLengthHeaderscCsLttddtdd}|t|d||jjd||j t dS)z If a response includes multiple, yet equal, I{Content-Length} headers, L{HTTPClientParser.dataReceived} successfully handles and passes single length for body processing rrNs9HTTP/1.1 200 OK Content-Length: 1 Content-Length: 1 rY r r*r\rtrrvrFrrrurrr=r=r>&test_multipleEqualContentLengthHeaderss z3test_multipleDistinctContentLengthHeaderFieldValuess zIHTTPClientParserTests.test_multipleDistinctContentLengthHeaderFieldValuescCsLttddtdd}|t|d||jjd||j t dS)a% If a response includes multiple, equal I{Content-Length} header field-values, L{HTTPClientParser.dataReceived} successfully handles and passes single content-length header for body processing. Field-values are considered equal by parsed decimal value. rrNs+HTTP/1.1 200 OK Content-Length: 1, 001 rYrrr=r=r>0test_multipleEqualContentLengthHeaderFieldValuess zFHTTPClientParserTests.test_multipleEqualContentLengthHeaderFieldValuescCs4ttddtdd}|t|t|jddS)z If the I{Content-Length} header contains anything other than digits L{HTTPClientParser.dataReceived} raises L{ValueError} to indicate that the response is invalid and the transport is now unusable. rrNs'HTTP/1.1 200 OK Content-Length: +1 rrr=r=r>test_contentLengthTooPositives z3HTTPClientParserTests.test_contentLengthTooPositivecCs4ttddtdd}|t|t|jddS)z If the I{Content-Length} header has a negative value L{HTTPClientParser.dataReceived} raises L{ValueError} to indicate that the response is invalid and the transport is now unusable. rrNs'HTTP/1.1 200 OK Content-Length: -1 rrr=r=r>test_contentLengthNegatives z0HTTPClientParserTests.test_contentLengthNegativecCsdg}ttddtd|j}|t|d|d|d||jt ||dgdS)zy If extra bytes are received past the end of a response, they are passed to the finish callback. rrNrr Here is another thing!Here is another thing! r r*r\rrrtrrvrFrurrMrrxr=r=r>test_extraBytesPassedBacks     z/HTTPClientParserTests.test_extraBytesPassedBackcCsdg}ttddtd|j}|t|d|d|d||jt ||dgdS)z If extra bytes are received past the end of the headers of a response to a HEAD request, they are passed to the finish callback. rrNrsContent-Length: 12 rrrrr=r=r>test_extraBytesPassedBackHEADs     z3HTTPClientParserTests.test_extraBytesPassedBackHEADcCsg}ttddtd|j}|t|dg}|j|j_|d|d| |g| |jj t |d| |dg|d | |dd g|d | |d gdS) z If the response headers indicate the response body is encoded with the I{chunked} transfer encoding, the body is decoded according to that transfer encoding before being passed to L{Response._bodyDataReceived}. rrNrsTransfer-Encoding: chunked rs3 aasbc sbcs 0 extrasextra) r r*r\rrrtrrvrrrFrrrrr=r=r>test_chunkedResponseBodys&          z.HTTPClientParserTests.test_chunkedResponseBodycCsg}ttddtd|j}t}|||dg}|j|j_|d|d|d| |ddg| t d| |d gdS) z If a response does not include a I{Transfer-Encoding} or a I{Content-Length}, the end of response body is indicated by the connection being closed. rrNrrrrzsimulated end of connectionr) r r*r\rrrrtrvrrrFconnectionLostr rr=r=r>test_unknownContentLength)s        z/HTTPClientParserTests.test_unknownContentLengthcCslg}ttddtd|j}t}|||dg}|j|j_|d| |dg| |dgdS)z According to RFC 2616, section 4.4, point 3, if I{Content-Length} and I{Transfer-Encoding: chunked} are present, I{Content-Length} MUST be ignored rrNrs@Content-Length: 102 Transfer-Encoding: chunked 3 abc 0 abcr) r r*r\rrrrtrvrrrFrr=r=r>%test_contentLengthAndTransferEncodingAs     z;HTTPClientParserTests.test_contentLengthAndTransferEncodingcCsHt}ttddtdd}|||j}|ttt ||tgS)z If L{HTTPClientParser.connectionLost} is called before the headers are finished, the C{_responseDeferred} is fired with the L{Failure} passed to C{connectionLost}. rrN) rr r*r\rt_responseDeferredrrr7rU)rMr]rxZresponseDeferredr=r=r>test_connectionLostBeforeBody_s  z3HTTPClientParserTests.test_connectionLostBeforeBodycCst|t}t}ttddtdd}||g}|j |j | d|d}d dd}||_ | d|dt||d}|d }||jt|tdS) z If one of the L{Response} methods called by L{HTTPClientParser.connectionLost} raises an exception, the exception is logged and not re-raised. rrN&HTTP/1.1 200 OK Content-Length: 1 rcSs tdSrar7)rHr=r=r>fakeBodyDataFinishedszPHTTPClientParserTests.test_connectionLostWithError..fakeBodyDataFinishedrY log_failure)N)rcreateWithCleanuprrr r*r\rtrrPrrrvrr assertEqualsrGassertIsInstancerr7flushLoggedErrors)rM logObserverr]rxrreventrr=r=r>test_connectionLostWithErrorns      z2HTTPClientParserTests.test_connectionLostWithErrorcCsBttddtddd}|j}|t|t||t S)z If no response at all was received and the connection is lost, the resulting error is L{ResponseNeverReceived}. rrNcSsdSrar=Zignr=r=r>rrz.) r r*r\rrtrrr rOr0rMrxrRr=r=r>test_noResponseAtAlls   z*HTTPClientParserTests.test_noResponseAtAllcCsVttddtddd}|j}|t|d|t| |t  |j t S)z If a partial response was received and the connection is lost, the resulting error is L{ResponseFailed}, but not L{ResponseNeverReceived}. rrNcSsdSrar=r r=r=r>rrzBHTTPClientParserTests.test_someResponseButNotAll..2) r r*r\rrtrrvrr rOr/rPrr r=r=r>test_someResponseButNotAlls     z0HTTPClientParserTests.test_someResponseButNotAllcCsd}ttddtddd}|t|||t|dddk||j t |t t |j d|t t |jd||jdS) zy If a response in the 1XX range is received it just gets swallowed and the parser resets itself. HTTP/1.1 103 Early Hints Server: socketserver/1.0.0 Link: ; rel=preload; as=style Link: ; rel=preload; as=script rrNcSsdSrar=r r=r=r>rrzCHTTPClientParserTests.test_1XXResponseIsSwallowed..rr)r r*r\rtrrvrgetattrrFrurrGrrrrZ_everReceivedData)rMsample103Responserxr=r=r>test_1XXResponseIsSwalloweds   z1HTTPClientParserTests.test_1XXResponseIsSwallowedcCsd}d}ttddtddd}|t|||||jjd||jj t i||j t d d gi||jj d dS) z When a 1XX response is swallowed, the final response that follows it is the only one that gets sent to the application. r(HTTP/1.1 200 OK Content-Length: 123 rrNcSsdSrar=r r=r=r>rrzUHTTPClientParserTests.test_1XXFollowedByFinalResponseOnlyEmitsFinal..rZrrr r r*r\rtrrvrFrrrr2rrrMrZfollowing200Responserxr=r=r>-test_1XXFollowedByFinalResponseOnlyEmitsFinals  zCHTTPClientParserTests.test_1XXFollowedByFinalResponseOnlyEmitsFinalcCsd}d}ttddtddd}|t|||||||jjd||jj t i||j t d d gi||jj d dS) zp It is acceptable for multiple 1XX responses to come through, all of which get ignored. rrrrNcSsdSrar=r r=r=r>rrzKHTTPClientParserTests.test_multiple1XXResponsesAreIgnored..rZrrrrrr=r=r>#test_multiple1XXResponsesAreIgnoreds*  z9HTTPClientParserTests.test_multiple1XXResponsesAreIgnoredcCszt|t}d}ttddtddd}|t||| dt ||d}| |d d | |d d dS) zF When a 1XX response is ignored, Twisted emits a log. rrrNcSsdSrar=r r=r=r>r rzHHTTPClientParserTests.test_ignored1XXResponseCausesLog..rYr log_formatz#Ignoring unexpected {code} responserg) rrrr r*r\rtrrvrrG)rMrrrxrr=r=r> test_ignored1XXResponseCausesLogs    z6HTTPClientParserTests.test_ignored1XXResponseCausesLogN)&r9r:r;r<rrrrrrrrrrrrrrrrrrrrrrrrrrrrr r rrrrr=r=r=r>rjsF $   %rc@s,eZdZdZdZdZdZddZddZdS) SlowRequesta L{SlowRequest} is a fake implementation of L{Request} which is easily controlled externally (for example, by code in a test method). @ivar stopped: A flag indicating whether C{stopWriting} has been called. @ivar finished: After C{writeTo} is called, a L{Deferred} which was returned by that method. L{SlowRequest} will never fire this L{Deferred}. rFcCst|_|jSra)rrrMr]r=r=r>writeTo%szSlowRequest.writeTocCs d|_dSrstoppedrbr=r=r> stopWriting)szSlowRequest.stopWritingN) r9r:r;r<methodr persistentrrr=r=r=r>rs  rc@seZdZdZdZddZdS) SimpleRequesta L{SimpleRequest} is a fake implementation of L{Request} which writes a short, fixed string to the transport passed to its C{writeTo} method and returns a succeeded L{Deferred}. This vaguely emulates the behavior of a L{Request} with no body producer. FcCs|dtdS)N SOME BYTES)writerrr=r=r>r7s zSimpleRequest.writeToN)r9r:r;r<r!rr=r=r=r>r"-sr"c@s*eZdZdZddZddZddZdd Zd d Zd d Z dIddZ ddZ ddZ ddZ ddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zd9d:Zd;d<Z d=d>Z!d?d@Z"dAdBZ#dCdDZ$dEdFZ%dGdHZ&dS)JHTTP11ClientProtocolTestsz] Tests for the HTTP 1.1 client protocol implementation, L{HTTP11ClientProtocol}. cCs"t|_t|_|j|jdS)zR Create an L{HTTP11ClientProtocol} connected to a fake transport. N)rr]r(rxrtrbr=r=r>setUpBszHTTP11ClientProtocolTests.setUpcCs$|jt||jddS)z L{HTTP11ClientProtocol.request} accepts a L{Request} and calls its C{writeTo} method with its own transport. r#N)rxrr"rFr]rrbr=r=r> test_requestJsz&HTTP11ClientProtocolTests.test_requestcs>jtfdd}jtt}|||S)z The second time L{HTTP11ClientProtocol.request} is called, it returns a L{Deferred} which immediately fires with a L{Failure} wrapping a L{RequestNotSent} exception. csjddSNrrFr]rZignoredrbr=r> cbNotSentZsz?HTTP11ClientProtocolTests.test_secondRequest..cbNotSent)rxrrrOr"r$rPrMr+rRr=rbr>test_secondRequestRs   z,HTTP11ClientProtocolTests.test_secondRequestcsDjttdfdd}jtt}|||S)z L{HTTP11ClientProtocol.request} returns a L{Deferred} which immediately fires with a L{Failure} wrapping a L{RequestNotSent} if called after the protocol has been disconnected. z sad transportcsjddSr(r)r*rbr=r>r+iszLHTTP11ClientProtocolTests.test_requestAfterConnectionLost..cbNotSent) rxrrr rOrr"r$rPr,r=rbr>test_requestAfterConnectionLostas   z9HTTP11ClientProtocolTests.test_requestAfterConnectionLostcsDGddd}j|}fdd}t|tg}|||S)a% If the L{Deferred} returned by L{Request.writeTo} fires with a L{Failure}, L{HTTP11ClientProtocol.request} disconnects its transport and returns a L{Deferred} which fires with a L{Failure} of L{RequestGenerationFailed} wrapping the underlying failure. c@seZdZdZddZdS)zCHTTP11ClientProtocolTests.test_failedWriteTo..BrokenRequestFcSs ttSra)rr7rr=r=r>r{szKHTTP11ClientProtocolTests.test_failedWriteTo..BrokenRequest.writeToNr9r:r;r!rr=r=r=r> BrokenRequestxsr0cs&jjjttddS)Nzyou asked for it)rr] disconnectingrxrrr r*rbr=r>rNsz>HTTP11ClientProtocolTests.test_failedWriteTo..cbFailed)rxrrVr7rP)rMr0rRrNr=rbr>test_failedWriteTops   z,HTTP11ClientProtocolTests.test_failedWriteTocCs*Gddd}|j|}t||tgS)z If L{Request.writeTo} raises an exception, L{HTTP11ClientProtocol.request} returns a L{Deferred} which fires with a L{Failure} of L{RequestGenerationFailed} wrapping that exception. c@seZdZdZddZdS)zMHTTP11ClientProtocolTests.test_synchronousWriteToError..BrokenRequestFcSs tdSrarrr=r=r>rszUHTTP11ClientProtocolTests.test_synchronousWriteToError..BrokenRequest.writeToNr/r=r=r=r>r0sr0)rxrrVr7)rMr0rRr=r=r>test_synchronousWriteToErrorsz6HTTP11ClientProtocolTests.test_synchronousWriteToErrorNcCst}|j|}t||tg}||j|jtt| |j|dkr`|j dn6|dkr|j tt |t }|t|dn|S)a2 If L{HTTP11ClientProtocol}'s transport is disconnected before the L{Deferred} returned by L{Request.writeTo} fires, the L{Deferred} returned by L{HTTP11ClientProtocol.request} fires with a L{Failure} of L{RequestTransmissionFailed} wrapping the underlying failure. callbackNerrbackrY)rrxrrWr7rrrrrrr4r5r?rrFrG)rMmoderrRerrorsr=r=r>*test_connectionLostDuringRequestGenerations    zDHTTP11ClientProtocolTests.test_connectionLostDuringRequestGenerationcCs |dS)z If the request passed to L{HTTP11ClientProtocol} finishes generation successfully after the L{HTTP11ClientProtocol}'s connection has been lost, nothing happens. r4r8rbr=r=r>+test_connectionLostBeforeGenerationFinishedszEHTTP11ClientProtocolTests.test_connectionLostBeforeGenerationFinishedcCs |dS)z If the request passed to L{HTTP11ClientProtocol} finished generation with an error after the L{HTTP11ClientProtocol}'s connection has been lost, nothing happens. r5r9rbr=r=r>)test_connectionLostBeforeGenerationFailedszCHTTP11ClientProtocolTests.test_connectionLostBeforeGenerationFailedcs*ttfdd}d|S)a  If the request passed to L{HTTP11ClientProtocol} finished generation with an error after the L{HTTP11ClientProtocol}'s connection has been lost, an error is logged that gives a non-confusing hint to user on what went wrong. csHdtd}d||dd|dddS)NrYrrrzJError writing request, but not in valid state to finalize request: {state}ruCONNECTION_LOST)rrGassertInrF)ignorerrrMr=r>checks znHTTP11ClientProtocolTests.test_errorMessageOnConnectionLostBeforeGenerationFailedDoesNotConfuse..checkr5)rrrr8rP)rMr@r=r?r>Etest_errorMessageOnConnectionLostBeforeGenerationFailedDoesNotConfuses   z_HTTP11ClientProtocolTests.test_errorMessageOnConnectionLostBeforeGenerationFailedDoesNotConfusecs<jtddtd}fdd}||jd|S)z When a response is delivered to L{HTTP11ClientProtocol}, the L{Deferred} previously returned by the C{request} method is called back with a L{Response} instance and the connection is closed. rrNcs@|jd|jtjjjjddS)NrZ QUIESCENT) rFrrr2rr]r1rxrurrbr=r> cbRequestszIHTTP11ClientProtocolTests.test_receiveSimplestResponse..cbRequests9HTTP/1.1 200 OK Content-Length: 0 Connection: close rxrr*r\rPrvrMrRrDr=rbr>test_receiveSimplestResponses  z6HTTP11ClientProtocolTests.test_receiveSimplestResponsecs<jtddtd}fdd}||jd|S)z The headers included in a response delivered to L{HTTP11ClientProtocol} are included on the L{Response} instance passed to the callback returned by the C{request} method. rrNcs"tdddgi}|j|dS)Nrrr)r2rFr)rrrbr=r>rDszHHTTP11ClientProtocolTests.test_receiveResponseHeaders..cbRequests+HTTP/1.1 200 OK X-Foo: bar X-Foo: baz rErFr=rbr>test_receiveResponseHeaderss  z5HTTP11ClientProtocolTests.test_receiveResponseHeaderscspgttjt}dfdd}||fdd}|||S)a[ If response bytes are delivered to L{HTTP11ClientProtocol} before the L{Deferred} returned by L{Request.writeTo} fires, those response bytes are parsed as part of the response. The connection is also closed, because we're in a confusing state, and therefore the C{quiescentCallback} isn't called. s8HTTP/1.1 200 OK X-Foo: bar Content-Length: 6 foobarcsVtt}_jdjg|fddS)NZ%TRANSMITTING_AFTER_RECEIVING_RESPONSEcs jfSrarr prr=r>r*rzoHTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone..cbResponse..) rrclosedDeferred deliverBodyrFrurr1rPr whenFinished)rxquiescentResultrMr]rJr> cbResponse#s    z]HTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone..cbResponsecsf|\}}|jd|jd|jd|jtddgi|djddS)NrXrZr[rrfoobar)rFrrrrr2rr4)resultrrrrMr=r> cbAllResponse.s z`HTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone..cbAllResponse)rr(rrrtrrrvrPrMrRrQrUr=)rxrPrrMr]r>/test_receiveResponseBeforeRequestGenerationDone s      zIHTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDonecCsZt}t}||_||dtj}|tddtd}| d|dt ||t gS)zy The connection is closed when the server respond with a header which is above the maximum line. rrrNsHTTP/1.1 200 OK X-Foo: s X-Ignored: ignored ) rr(rxrtrZ MAX_LENGTHrr*r\rvrUr )rMr]rxZlongLinerRr=r=r>"test_receiveResponseHeadersTooLong=s   zrjrzHTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDone..cbResponse..)rrrLrMrPrNr=rJr>rQfs  zrHTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDone..cbResponsecs2jdjttjjddS)Nr<)rr4rxrrr7rFrh)r>rTr=r>rUns zuHTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDone..cbAllResponse)rrxrrvrPrVr=rTr>Dtest_connectionLostAfterReceivingResponseBeforeRequestGenerationDoneWs   z^HTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDonecstt}_jtddtd}jdg}||j  |gjd|d}| jdjdfd d }|||S) z The C{deliverBody} method of the response object with which the L{Deferred} returned by L{HTTP11ClientProtocol.request} fires can be used to get the body of the response. rrNs%HTTP/1.1 200 OK Content-Length: 6 rrrrcsjdjtdS)NrR)rFr closedReasonrEr.r*rr=r>rUszIHTTP11ClientProtocolTests.test_receiveResponseBody..cbAllResponse) rrrLrxrr*r\rvrPrrrFrM)rMrOrequestDeferredrSrrUr=rr>test_receiveResponseBodyws&         z2HTTP11ClientProtocolTests.test_receiveResponseBodycCs|jtddtd}|jdg}||j|d}t}|||jd|jd| |j d|j t t d |jtdS) z If the length of the response body is unknown, the protocol passed to the response's C{deliverBody} method has its C{connectionLost} method called with a L{Failure} wrapping a L{PotentialDataLoss} exception. rrNsHTTP/1.1 200 OK rrrrRz low-level transport disconnected)rxrr*r\rvrPrrrrMrFrrrr rZrEr)rMr[rSrrxr=r=r>Etest_responseBodyFinishedWhenConnectionLostWhenContentLengthIsUnknowns        z_HTTP11ClientProtocolTests.test_responseBodyFinishedWhenConnectionLostWhenContentLengthIsUnknowncCs|jtddtd}|jdg}||j|d}t}|||jd|jd| |j d|j t t t|t|jt tgS) a If the final chunk has not been received when the connection is lost (for any reason), the protocol passed to C{deliverBody} has its C{connectionLost} method called with a L{Failure} wrapping the exception for that reason. rrNs/HTTP/1.1 200 OK Transfer-Encoding: chunked r3 foo s3 bar rR)rxrr*r\rvrPrrrrMrFrrrr7rUrrZr1r]r=r=r>4test_chunkedResponseBodyUnfinishedWhenConnectionLosts(     zNHTTP11ClientProtocolTests.test_chunkedResponseBodyUnfinishedWhenConnectionLostcsJjtddtd}jdt|tg}fdd}|||S)a! If the parser L{HTTP11ClientProtocol} delivers bytes to in C{dataReceived} raises an exception, the exception is wrapped in a L{Failure} and passed to the parser's C{connectionLost} and then the L{HTTP11ClientProtocol}'s transport is disconnected. rrNsunparseable garbage goes here cs<jj|jdjjdjt t ddS)Nrsunparseable garbage goes herez it is done) rr]r1rFrDrrrxrrr rrbr=r>rNs  zLHTTP11ClientProtocolTests.test_parserDataReceivedException..cbFailed)rxrr*r\rvrUr#rP)rMr[rRrNr=rbr> test_parserDataReceivedExceptions   z:HTTP11ClientProtocolTests.test_parserDataReceivedExceptioncCs`|jtddtd}|jjj}||j|j|jt t d||jdt ||t gS)z When the HTTP response parser is disconnected, the L{TransportProxyProducer} which was connected to it as a transport is stopped. rrNzconnection done) rxrr*r\_parserr]r _producerZ_disconnectParserrr rU)rMr[r]r=r=r>test_proxyStoppeds  z+HTTP11ClientProtocolTests.test_proxyStoppedcCst}t}||g}g}||j||j|||fggf||j| t t ||dg||dgdS)z L{HTTP11ClientProtocol.abort} will tell the transport to close its connection when it is invoked, and returns a C{Deferred} that fires when the connection is lost. N) rr(rtabortrPrrrFrr1rrr )rMr]rxZr1Zr2r=r=r>test_abortClosesConnections  z4HTTP11ClientProtocolTests.test_abortClosesConnectioncCsZt}t}|||ttg}||j| |dg| |j ddS)z L{HTTP11ClientProtocol.abort} called after the connection is lost returns a C{Deferred} that fires immediately. Nr<) rr(rtrrr rfrPrrrFrhrMr]rxrSr=r=r>test_abortAfterConnectionLosts z7HTTP11ClientProtocolTests.test_abortAfterConnectionLostcCs\t}t}|||tddtd}|||j| t t t ||t gS)a The Deferred returned by L{HTTP11ClientProtocol.request} will fire with a L{ResponseFailed} failure containing a L{ConnectionAborted} exception, if the connection was aborted before all response headers have been received. rrN)rr(rtrr*r\rfrr1rrr rUrrhr=r=r>test_abortBeforeResponseBody,s  z6HTTP11ClientProtocolTests.test_abortBeforeResponseBodycstddttddtd}dtGfdddtfd d }fd d }| |t t t g}| |S) aS When the connection is aborted after the response headers have been received and the L{Response} has been made available to application code, the response body protocol's C{connectionLost} method will be invoked with a L{ResponseFailed} failure containing a L{ConnectionAborted} exception. T)lenientrrNrcs(eZdZdZfddZfddZdS)zQHTTP11ClientProtocolTests.test_abortAfterResponseHeaders..BodyDestinationzl A body response protocol which immediately aborts the HTTP connection. cs dS)z< Abort the HTTP connection. N)rfrb)rxr=r>connectionMadeVsz`HTTP11ClientProtocolTests.test_abortAfterResponseHeaders..BodyDestination.connectionMadecs|dS)z Make the reason for the losing of the connection available to the unit test via C{testResult}. N)r5rMrI) testResultr=r>r\sz`HTTP11ClientProtocolTests.test_abortAfterResponseHeaders..BodyDestination.connectionLostN)r9r:r;r<rlrr=)rxrnr=r>BodyDestinationPs rocs,|jttdS)z Connect the L{BodyDestination} response body protocol to the response, and then simulate connection loss after ensuring that the HTTP connection has been aborted. N)rMrr1rrr rC)rorxrMr]r=r>rMcs  zMHTTP11ClientProtocolTests.test_abortAfterResponseHeaders..deliverBodycs|jtdSra)rrr-)errorrbr=r> checkErrormszLHTTP11ClientProtocolTests.test_abortAfterResponseHeaders..checkError) rr(rtrr*r\rvrr rPrUrr1)rMrSrMrqrQr=)rorxrMrnr]r>test_abortAfterResponseHeaders<s     z8HTTP11ClientProtocolTests.test_abortAfterResponseHeadersc sgfdd}t}t||tddtddd}dgg}||j |d }t }t |_ |j fd d | |d |jtd gjdjdjdjdjddS)a If after a response is done the {HTTP11ClientProtocol} stays open and returns to QUIESCENT state, all per-request state is reset and the C{quiescentCallback} is called with the protocol instance. This is useful for implementing a persistent connection pool. The C{quiescentCallback} is called *before* the response-receiving protocol's C{connectionLost}, so that new requests triggered by end of first request can re-use a persistent connection. cs(||jd|dSNrBrFrurrrKrxrPrMr=r>r4s zHHTTP11ClientProtocolTests.test_quiescentCallbackCalled..callbackrrNTr!s&HTTP/1.1 200 OK Content-length: 3 rcs dS)N response donerr )rPr=r>rrzHHTTP11ClientProtocolTests.test_quiescentCallbackCalled..rrx)rr(rtrr*r\rvrFrPrrrrrLrMrZrEr.rcZ_finishedRequestZ_currentRequestZ_transportProxyr)rMr4r]r[rSr bodyProtocolr=rvr>test_quiescentCallbackCalledvs6         z6HTTP11ClientProtocolTests.test_quiescentCallbackCalledc sgfdd}t}t||tddtddd}d|}|j d t d |j d dS) a The C{quiescentCallback} passed to L{HTTP11ClientProtocol} will only be invoked once that protocol is in a state similar to its initial state. One of the aspects of this initial state is the producer-state of its transport; an L{HTTP11ClientProtocol} begins with a transport that is producing, i.e. not C{pauseProducing}'d. Therefore, when C{quiescentCallback} is invoked the protocol will still be producing. cs(||jd|dSrsrtrurvr=r>r4s z]HTTP11ClientProtocolTests.test_transportProducingWhenQuiescentAfterFullBody..callbackrrNTrws)HTTP/1.1 200 OK Content-length: 3 BBBZDEFERRED_CLOSErYr) rr(rtrr*r\rvZsuccessResultOfrFrhrGr)rMr4r]r[rr=rvr>1test_transportProducingWhenQuiescentAfterFullBodys   zKHTTP11ClientProtocolTests.test_transportProducingWhenQuiescentAfterFullBodyc sgfdd}t}t||tddtddd}|jd t d  d  d t dS) z The quiescentCallback is called before the request C{Deferred} fires, in cases where the response has no body. cs(||jd|dSrsrtrurvr=r>r4s zUHTTP11ClientProtocolTests.test_quiescentCallbackCalledEmptyResponse..callbackrrNTrw&HTTP/1.1 200 OK Content-length: 0 rrrY)rr(rtrr*r\rPrrrvrFrGrrr-)rMr4r]r[r=rvr>)test_quiescentCallbackCalledEmptyResponses   zCHTTP11ClientProtocolTests.test_quiescentCallbackCalledEmptyResponsec Csg}t}t|j}|||tddtddd}|dg}||j|d}t }| ||j t ||g||jdS)z If after a response is done the {HTTP11ClientProtocol} returns a C{Connection: close} header in the response, the C{quiescentCallback} is not called and the connection is lost. rrNTrws9HTTP/1.1 200 OK Content-length: 0 Connection: close rrr(rrrtrr*r\rvrPrrMrZrEr.rFrr1rMrPr]rxr[rSrryr=r=r>test_quiescentCallbackNotCalleds$      z9HTTP11ClientProtocolTests.test_quiescentCallbackNotCalledc Csg}t}t|j}|||tddtddd}|dg}||j|d}t }| ||j t ||g||jdS)z If the request was non-persistent (i.e. sent C{Connection: close}), the C{quiescentCallback} is not called and the connection is lost. rrNFrwr|rr~rr=r=r>1test_quiescentCallbackNotCalledNonPersistentQuerys        zKHTTP11ClientProtocolTests.test_quiescentCallbackNotCalledNonPersistentQueryc Csdd}t|t}t}t|}|||tddtddd}| dg}| |j |d }t }| ||jt|d t||d } | d } || jt|t||jdS) zx If C{quiescentCallback} throws an exception, the error is logged and protocol is disconnected. cSs tdSra)ZeroDivisionErrorrur=r=r>r45szHHTTP11ClientProtocolTests.test_quiescentCallbackThrows..callbackrrNTrwr|rrYr)rrrrr(rtrr*r\rvrPrrrrMrZrEr.rrGrrrrrr1) rMr4rr]rxr[rSrryrrr=r=r>test_quiescentCallbackThrows/s*       z6HTTP11ClientProtocolTests.test_quiescentCallbackThrowscCsNt}t}|||tddtd}|||jt ||t t gS)a The L{Deferred} returned by L{HTTP11ClientProtocol.request} will fire with a L{ResponseNeverReceived} failure containing a L{CancelledError} exception if the request was cancelled before any response headers were received. rrN) rr(rtrr*r\cancelr disconnectedrSr0rrhr=r=r>test_cancelBeforeResponseRs  z3HTTP11ClientProtocolTests.test_cancelBeforeResponsecCsVt}t}|||tddtd}|d|||j t ||t gS)a The L{Deferred} returned by L{HTTP11ClientProtocol.request} will fire with a L{ResponseFailed} failure containing a L{CancelledError} exception if the request was cancelled before all response headers were received. rrNr) rr(rtrr*r\rvrrrrUrrhr=r=r>test_cancelDuringResponsecs   z3HTTP11ClientProtocolTests.test_cancelDuringResponsecst}t}||t|ddifddfdd}|_|tddt}j d | | |j | dt ||tgS) a The L{Deferred} returned by L{HTTP11ClientProtocol.request} will fire with a L{RequestGenerationFailed} failure containing a L{CancelledError} exception if the request was cancelled before a C{bodyProducer} has finished producing. cancelledFcs dd<dS)NTrr=r )nonLocalr=r>rszJHTTP11ClientProtocolTests.assertCancelDuringBodyProduction..cancelcs|_t_jSraconsumerrr)r)rproducerr=r>startProducings zRHTTP11ClientProtocolTests.assertCancelDuringBodyProduction..startProducingPOST/barsxxxxx)rr(rtStringProducerrrr*r\rr$rrrrVr)rMZproducerLengthr]rxrrSr=)rrrr> assertCancelDuringBodyProductionss    z:HTTP11ClientProtocolTests.assertCancelDuringBodyProductioncCs |dS)a( The L{Deferred} returned by L{HTTP11ClientProtocol.request} will fire with a L{RequestGenerationFailed} failure containing a L{CancelledError} exception if the request was cancelled before a C{bodyProducer} with an explicit length has finished producing. )rrbr=r=r>test_cancelDuringBodyProductionsz9HTTP11ClientProtocolTests.test_cancelDuringBodyProductioncCs |tS)a' The L{Deferred} returned by L{HTTP11ClientProtocol.request} will fire with a L{RequestGenerationFailed} failure containing a L{CancelledError} exception if the request was cancelled before a C{bodyProducer} with C{UNKNOWN_LENGTH} has finished producing. )rrrbr=r=r>&test_cancelDuringChunkedBodyProductionsz@HTTP11ClientProtocolTests.test_cancelDuringChunkedBodyProduction)N)'r9r:r;r<r&r'r-r.r2r3r8r:r;rArGrHrWrXrYr\r^r`rbrergrirjrrrzr{r}rrrrrrrrr=r=r=r>r%<sH 2 ) :9.# r%c@s<eZdZdZdZddZddZddZd d Zd d Z d S)ra L{StringProducer} is a dummy body producer. @ivar stopped: A flag which indicates whether or not C{stopProducing} has been called. @ivar consumer: After C{startProducing} is called, the value of the C{consumer} argument to that method. @ivar finished: After C{startProducing} is called, a L{Deferred} which was returned by that method. L{StringProducer} will never fire this L{Deferred}. FcCs ||_dSra)r)rMrr=r=r>__init__szStringProducer.__init__cCs||_t|_|jSrar)rMrr=r=r>rszStringProducer.startProducingcCs d|_dSrrrbr=r=r> stopProducingszStringProducer.stopProducingcCsdSrar=rbr=r=r>pauseProducingszStringProducer.pauseProducingcCsdSrar=rbr=r=r>resumeProducingszStringProducer.resumeProducingN) r9r:r;r<rrrrrrr=r=r=r>rs rc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd5d)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd(S)6 RequestTestsz Tests for L{Request}. cCs t|_dSra)rr]rbr=r=r>r&szRequestTests.setUpcCs,tddtd|j||jddS)zk L{Request.writeTo} formats the request data and writes it to the given transport. rrNs8GET / HTTP/1.1 Connection: close Host: example.com r*r\rr]rFrrbr=r=r>test_sendSimplestRequests z%RequestTests.test_sendSimplestRequestcCs4tddtddd}||j||jddS)zO A pesistent request does not send 'Connection: close' header. rrNTrws%GET / HTTP/1.1 Host: example.com r)rMreqr=r=r>"test_sendSimplestPersistentRequests  z/RequestTests.test_sendSimplestPersistentRequestcCstddgdgd}tdd|d|j|jd}||d d ||d dd d g|d =|d d=|||d dddgdS)zf L{Request.writeTo} formats header data and writes it to the given transport. rrrArr@r/fooNrrGET /foo HTTP/1.1rConnection: closesHost: example.comrr)r2r*rr]rsplitrFsort)rMrlinesr=r=r>test_sendRequestHeaderss z$RequestTests.test_sendRequestHeaderscCstD]}t|gdgd}t}tdd|d||d}||dd||d dd d g|d=|d d=|d |d ||d t gqdS)ze Linear whitespace in request header values is replaced with a single space. sexample.invalidrrrNrrrrrrsHost: example.invalidsX-Foo: ) r5r2rr*rrrrFremover6)rM componentrr]rr=r=r>-test_sanitizeLinearWhitespaceInRequestHeaderss  z:RequestTests.test_sanitizeLinearWhitespaceInRequestHeaderscCstt}tddt|}||j||jd||jj || |jj | |j d|j|jd|jd|jd||jj d| |j ddS)z L{Request.writeTo} uses chunked encoding to write data from the request body producer to the given transport. It registers the request body producer with the transport. rrNsXPOST /bar HTTP/1.1 Connection: close Transfer-Encoding: chunked Host: example.com sxxxsyyyyyyyyyyyyyyys!3 xxx f yyyyyyyyyyyyyyy 0 )rrr*r\rr]assertNotIdenticalrrrr streamingrFrclearr$rr4rMrrr=r=r>test_sendChunkedRequestBody s&     z(RequestTests.test_sendChunkedRequestBodycs`tt}tddt|}|j}j|jt fdd} |t }| ||S)a If L{Request} is created with a C{bodyProducer} without a known length and the L{Deferred} returned from its C{startProducing} method fires with a L{Failure}, the L{Deferred} returned by L{Request.writeTo} fires with that L{Failure} and the body producer is unregistered from the transport. The final zero-length chunk is not written to the transport. rrcs&jdjjddSr()rFr]rrrr*rbr=r>rN<szCRequestTests.test_sendChunkedRequestBodyWithError..cbFailed) rrr*r\rr]rrr5r7rOrP)rMrr writeDeferredrNrRr=rbr>$test_sendChunkedRequestBodyWithError-s      z1RequestTests.test_sendChunkedRequestBodyWithErrorcCstd}tddt|}||j||jd||jj|| |jj | |j d|j |jd|jd||jjd| |j ddS)z If L{Request} is created with a C{bodyProducer} with a known length, that length is sent as the value for the I{Content-Length} header and chunked encoding is not used. rrNsOPOST /bar HTTP/1.1 Connection: close Content-Length: 3 Host: example.com r)rr*r\rr]rrrrrrrFrrr$rr4rr=r=r>test_sendRequestBodyWithLengthDs    z+RequestTests.test_sendRequestBodyWithLengthcCs4t|dtd}||j||j|ddS)a" Verify that the message generated by a L{Request} initialized with the given method and C{None} as the C{bodyProducer} includes I{Content-Length: 0} in the header. @param method: The HTTP method issue in the request. @type method: L{bytes} rNsK /foo HTTP/1.1 Connection: close Content-Length: 0 Host: example.com r)rMr rr=r=r>_sendRequestEmptyBodyWithLengthas  z,RequestTests._sendRequestEmptyBodyWithLengthcCs|ddS)z If I{PUT} L{Request} is created without a C{bodyProducer}, I{Content-Length: 0} is included in the header and chunked encoding is not used. sPUTNrrbr=r=r>test_sendPUTRequestEmptyBodyvsz)RequestTests.test_sendPUTRequestEmptyBodycCs|ddS)z If I{POST} L{Request} is created without a C{bodyProducer}, I{Content-Length: 0} is included in the header and chunked encoding is not used. rNrrbr=r=r>test_sendPOSTRequestEmptyBody~sz*RequestTests.test_sendPOSTRequestEmptyBodycCsVtd}tddt|}||j}|jd|jd| |jj d| |t S)a If L{Request} is created with a C{bodyProducer} with a known length and the producer does not produce that many bytes, the L{Deferred} returned by L{Request.writeTo} fires with a L{Failure} wrapping a L{WrongBodyLength} exception. rrrabN) rr*r\rr]rr$rr4rrrOr&rMrrrr=r=r>#test_sendRequestBodyWithTooFewBytess   z0RequestTests.test_sendRequestBodyWithTooFewBytescstdtddt}|j}jdjjd j jj dfdd} |t }|||S) a7 Verify that when too many bytes have been written by a body producer and then the body producer's C{startProducing} L{Deferred} fires that the producer is unregistered from the transport and that the L{Deferred} returned from L{Request.writeTo} is fired with a L{Failure} wrapping a L{WrongBodyLength}. @param finisher: A callable which will be invoked with the body producer after too many bytes have been written to the transport. It should fire the startProducing Deferred somehow. rrrrcdNcsLjdjtjjdjddS)NsQPOST /bar HTTP/1.1 Connection: close Content-Length: 3 Host: example.com absefr)rFr]rrrlrrr$rafinisherrrMr=r>rNs zCRequestTests._sendRequestBodyWithTooManyBytesTest..cbFailed)rr*r\rr]rr$rrrrrrOr&rP)rMrrrrNrRr=rr>$_sendRequestBodyWithTooManyBytesTests        z1RequestTests._sendRequestBodyWithTooManyBytesTestcCsdd}||S) If L{Request} is created with a C{bodyProducer} with a known length and the producer tries to produce more than than many bytes, the L{Deferred} returned by L{Request.writeTo} fires with a L{Failure} wrapping a L{WrongBodyLength} exception. cSs|jddSrarr4rr=r=r>rszCRequestTests.test_sendRequestBodyWithTooManyBytes..finisher)rrMrr=r=r>$test_sendRequestBodyWithTooManyBytessz1RequestTests.test_sendRequestBodyWithTooManyBytescs$ttfdd}|S)rcsV|jtd}d||d}|jtt}t|ddS)NrrrY) rr5r7r=rrrrFrG)rrrr7r?r=r>rs  zHRequestTests.test_sendRequestBodyErrorWithTooManyBytes..finisher)rrrrrr=r?r>)test_sendRequestBodyErrorWithTooManyBytess  z6RequestTests.test_sendRequestBodyErrorWithTooManyBytescCst|t}td}tddt|}||j|jj }|j d|j d| t|d}|d||d}||jt|t|tddS) a Though there should be no way for the internal C{finishedConsuming} L{Deferred} in L{Request._writeToBodyProducerContentLength} to fire a L{Failure} after the C{finishedProducing} L{Deferred} has fired, in case this does happen, the error should be logged with a message about how there's probably a bug in L{Request}. This is a whitebox test. rrrrNrrrY)rrrrr*r\rr]r _finishedr$rr4r5r7r=rrrFrGr)rMrrrZfinishedConsumingrrr=r=r>*test_sendRequestBodyErrorWithConsumerErrors      z7RequestTests.test_sendRequestBodyErrorWithConsumerErrorcCsxtd}tddt|}||j}|jd||||jjd|j | t |jjd| |j d|S)a Verify that if the body producer fires its Deferred and then keeps writing to the consumer that the extra writes are ignored and the L{Deferred} returned by L{Request.writeTo} fires with a L{Failure} wrapping the most appropriate exception type. rrrrNrr)rr*r\rr]rr$rrrrlrrFr)rMrrrrr=r=r>-_sendRequestBodyFinishedEarlyThenTooManyBytes s   z:RequestTests._sendRequestBodyFinishedEarlyThenTooManyBytescCsdd}|||tS)a- If the request body producer indicates it is done by firing the L{Deferred} returned from its C{startProducing} method but then goes on to write too many bytes, the L{Deferred} returned by {Request.writeTo} fires with a L{Failure} wrapping L{WrongBodyLength}. cSs|jddSrarrr=r=r>r- szPRequestTests.test_sendRequestBodyFinishedEarlyThenTooManyBytes..finisher)rOrr&rr=r=r>1test_sendRequestBodyFinishedEarlyThenTooManyBytes% s z>RequestTests.test_sendRequestBodyFinishedEarlyThenTooManyBytescCsdd}|||tS)a3 If the request body producer indicates an error by firing the L{Deferred} returned from its C{startProducing} method but then goes on to write too many bytes, the L{Deferred} returned by {Request.writeTo} fires with that L{Failure} and L{WrongBodyLength} is logged. cSs|jtdSra)rr5r7rr=r=r>r= szORequestTests.test_sendRequestBodyErroredEarlyThenTooManyBytes..finisher)rOrr7rr=r=r>0test_sendRequestBodyErroredEarlyThenTooManyBytes5 s z=RequestTests.test_sendRequestBodyErroredEarlyThenTooManyBytesNcCs`tt}tddt|}||j}|j||j| t |j j d| |jd|S)a If the request body producer with an unknown length tries to write after firing the L{Deferred} returned by its C{startProducing} method, the C{write} call raises an exception and does not write anything to the underlying transport. rrrr)rrr*r\rr]rr4rrlrrr$rFr)rMZ_withrrrr=r=r>0test_sendChunkedRequestBodyFinishedThenWriteMoreE s   z=RequestTests.test_sendChunkedRequestBodyFinishedThenWriteMorecCs|tt}||tS)a$ If the request body producer with an unknown length tries to write after firing the L{Deferred} returned by its C{startProducing} method with a L{Failure}, the C{write} call raises an exception and does not write anything to the underlying transport. )rrr7rO)rMrRr=r=r>9test_sendChunkedRequestBodyFinishedWithErrorThenWriteMoreV szFRequestTests.test_sendChunkedRequestBodyFinishedWithErrorThenWriteMorecCstd}tddt|}||j}||jj|||jj|j d| |j d| |jj|jtt| |jj||jjd||tS)z If the L{Deferred} returned from the C{startProducing} method of the L{IBodyProducer} passed to L{Request} fires with a L{Failure}, the L{Deferred} returned from L{Request.writeTo} fails with that L{Failure}. rrrsQPOST /bar HTTP/1.1 Connection: close Content-Length: 5 Host: example.com abN)rr*r\rr]rrrrrr$rFrrr1rr5rr7rOrr=r=r>test_sendRequestBodyWithErrorb s   z*RequestTests.test_sendRequestBodyWithErrorcCsxtddtid}|t|j|j||jdtddtdddgid}|t|j|j||jddS)z L{Request.writeTo} raises L{BadHeaders} if there is not exactly one I{Host} header and writes nothing to the given transport. rrNrsHostrAs example.org)r*r2rlrrr]rFr)rMrr=r=r>test_hostHeaderRequired sz$RequestTests.test_hostHeaderRequiredcCsFtd}tddt|}||j||j|||jdS)zc L{Request.stopWriting} calls its body producer's C{stopProducing} method. rrrN) rr*r\rr]rrrrrr=r=r>test_stopWriting s   zRequestTests.test_stopWritingcCst|t}td}dd}||_tddt|}||j| | t | t d|dt ||d}|d||d}||jt d S) z If the body producer's C{stopProducing} method raises an exception, L{Request.stopWriting} logs it and does not re-raise it. rcSs tddSNzstopProducing is bustedrr=r=r=r>brokenStopProducing szBRequestTests.test_brokenStopProducing..brokenStopProducingrrrYrrN)rrrrrr*r\rr]rrFrGrr7rr=rr)rMrrrrrrr=r=r>test_brokenStopProducing s   z%RequestTests.test_brokenStopProducing)N)r9r:r;r<r&rrrrrrrrrrrrrrrrrrrrrrrrr=r=r=r>rs4 !A   ' rc@sReZdZdZddZddZddZdd d Zd d Zd dZ ddZ ddZ dS)LengthEnforcingConsumerTestsz/ Tests for L{LengthEnforcingConsumer}. cCs2t|_td|_t|_t|j|j|j|_dS)Nr)rrSrrrr]r"enforcerrbr=r=r>r& s z"LengthEnforcingConsumerTests.setUpcCsJ|jd||jd|j|jd||jddS)z L{LengthEnforcingConsumer.write} calls the wrapped consumer's C{write} method with the bytes it is passed as long as there are fewer of them than the C{length} attribute indicates remain to be received. rsdefN)rr$rFr]rrrbr=r=r> test_write s    z'LengthEnforcingConsumerTests.test_writecCs |jd|t|jjdS)z L{LengthEnforcingConsumer._noMoreWritesExpected} raises L{WrongBodyLength} if it is called before the indicated number of bytes have been written. s xxxxxxxxxN)rr$rlr&_noMoreWritesExpectedrbr=r=r>test_finishedEarly s z/LengthEnforcingConsumerTests.test_finishedEarlyFcCsP|jd||jj|jd||jj|rB|j||jt S)aN If it is called with a total number of bytes exceeding the indicated limit passed to L{LengthEnforcingConsumer.__init__}, L{LengthEnforcingConsumer.write} fires the L{Deferred} with a L{Failure} wrapping a L{WrongBodyLength} and also calls the C{stopProducing} method of the producer. xxxxxxxxxxx) rr$rrrrrrOrSr&)rMZ_unregisterAfterr=r=r>test_writeTooMany s   z.LengthEnforcingConsumerTests.test_writeTooManycCsH|jd|j||jj|t|jjd||jjdS)z If L{LengthEnforcingConsumer.write} is called after L{LengthEnforcingConsumer._noMoreWritesExpected}, it calls the producer's C{stopProducing} method and raises L{ExcessWrite}. rrN) rr$rrrrrlrrrbr=r=r>test_writeAfterNoMoreExpected s   z:LengthEnforcingConsumerTests.test_writeAfterNoMoreExpectedcCs |dS)z L{LengthEnforcingConsumer._noMoreWritesExpected} does nothing (in particular, it does not raise any exception) if called after too many bytes have been passed to C{write}. T)rrbr=r=r>test_finishedLate sz.LengthEnforcingConsumerTests.test_finishedLatecCs"|jd||jddS)z If L{LengthEnforcingConsumer._noMoreWritesExpected} is called after the correct number of bytes have been written it returns L{None}. rN)rr$rrrbr=r=r> test_finished s z*LengthEnforcingConsumerTests.test_finishedcs6fdd}|j_fdd}}|||S)a8 If L{LengthEnforcingConsumer.write} calls the producer's C{stopProducing} because too many bytes were written and the C{stopProducing} method raises an exception, the exception is logged and the L{LengthEnforcingConsumer} still errbacks the finished L{Deferred}. cstjtddSr)rrrr7r=rbr=r>r s zRLengthEnforcingConsumerTests.test_stopProducingRaises..brokenStopProducingcsttddS)NrY)rFrGrr7r*rbr=r> cbFinished szILengthEnforcingConsumerTests.test_stopProducingRaises..cbFinished)rrrrP)rMrrrRr=rbr>test_stopProducingRaises s   z5LengthEnforcingConsumerTests.test_stopProducingRaisesN)F) r9r:r;r<r&rrrrrrrr=r=r=r>r s   rc@s(eZdZdZddZddZddZdS) RequestBodyConsumerTestsz Tests for L{ChunkedEncoder} which sits between an L{ITransport} and a request/response body producer and chunked encodes everything written to it. cCs|ttttdS)zC L{ChunkedEncoder} instances provide L{IConsumer}. N)rrr rrrbr=r=r>test_interface( sz'RequestBodyConsumerTests.test_interfacecCsNt}t|}|d||d||d||ddS)z} L{ChunkedEncoder.write} writes to the transport the chunked encoded form of the bytes passed to it. rr_sxxxxxxxxxxxxxxxxs10 xxxxxxxxxxxxxxxx N)rrr$rFrr)rMr]encoderr=r=r>r. s  z#RequestBodyConsumerTests.test_writecCsdt}t}t|}||d||j|||j|||jd| | ddS)a L{ChunkedEncoder.registerProducer} registers the given streaming producer with its transport and L{ChunkedEncoder.unregisterProducer} writes a zero-length chunk to its transport and unregisters the transport's producer. TNs0 ) rrrZregisterProducerrrrrZunregisterProducerrFr)rMr]rrr=r=r>test_producerRegistration; s  z2RequestBodyConsumerTests.test_producerRegistrationN)r9r:r;r<rrrr=r=r=r>r! s rc@sHeZdZdZddZddZddZdd Zd d Zd d Z ddZ dS)TransportProxyProducerTestszn Tests for L{TransportProxyProducer} which proxies the L{IPushProducer} interface of a transport. cCs|tttddS)zO L{TransportProxyProducer} instances provide L{IPushProducer}. N)rrr r%rbr=r=r>rS sz*TransportProxyProducerTests.test_interfacecCs6t}t|}||j||||jddS)z~ L{TransportProxyProducer.stopProxying} drops the reference to the wrapped L{IPushProducer} provider. N)rr%rrd stopProxyingrMr]proxyr=r=r>%test_stopProxyingUnreferencesProducerY s zATransportProxyProducerTests.test_stopProxyingUnreferencesProducercCsdt}|t|}||jd|||jd|||||jddS)z L{TransportProxyProducer.resumeProducing} calls the wrapped transport's C{resumeProducing} method unless told to stop proxying. rrN)rrr%rFrrrrr=r=r>test_resumeProducingd sz0TransportProxyProducerTests.test_resumeProducingcCs\t}t|}||jd|||jd|||||jddS)z L{TransportProxyProducer.pauseProducing} calls the wrapped transport's C{pauseProducing} method unless told to stop proxying. rrN)rr%rFrrrrrr=r=r>test_pauseProducingz sz/TransportProxyProducerTests.test_pauseProducingcCsbt}t|}||jd|||jdt}t|}||||jddS)z L{TransportProxyProducer.stopProducing} calls the wrapped transport's C{stopProducing} method unless told to stop proxying. rrN)rr%rFrrrrr=r=r>test_stopProducing sz.TransportProxyProducerTests.test_stopProducingcCsdt}t}||||_t|}||j||jd| ||jd| |jdS)zs L{TransportProxyProducer.loseConnection} calls the wrapped transport's C{loseConnection}. rN) rrrtrxr%r connectedrFrloseConnectionrrMr]rxrr=r=r> test_loseConnectionWhileProxying s  ztest_loseConnectionNotProxying s  z:TransportProxyProducerTests.test_loseConnectionNotProxyingN) r9r:r;r<rrrrrrrr=r=r=r>rM s rc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd S)! ResponseTestsz Tests for L{Response}. cCstt}|tt|dS)z= L{Response} instances provide L{IResponse}. N)r^rrrr4rMrr=r=r>test_verifyInterface s z"ResponseTests.test_verifyInterfacecslgt}Gfdddt}|}t|}||\}|||jd|||jddS)z The L{IProtocol} provider passed to L{Response.deliverBody} has its C{makeConnection} method called with an L{IPushProducer} provider hooked up to the response as an argument. cseZdZfddZdS)z7ResponseTests.test_makeConnection..SomeProtocolcs|dSrar)rMrZ producersr=r>rt szFResponseTests.test_makeConnection..SomeProtocol.makeConnectionNr9r:r;rtr=rr=r> SomeProtocol srrrN)rr r^rMrrFrr)rMr]rrrZ theProducerr=rr>test_makeConnection s z!ResponseTests.test_makeConnectioncsNgGfdddt}|}tt}|||d|dgdS)z The L{IProtocol} provider passed to L{Response.deliverBody} has its C{dataReceived} method called with bytes received as part of the response body. cseZdZfddZdS)z5ResponseTests.test_dataReceived..ListConsumercs|dSrarrMrrr=r>rv szBResponseTests.test_dataReceived..ListConsumer.dataReceivedNr9r:r;rvr=rr=r> ListConsumer srrN)r r^rrMrrFrMrrrr=rr>test_dataReceived s   zResponseTests.test_dataReceivedcsjgGfdddt}|}tt}|||dt|td| |j ddS)z The L{IProtocol} provider passed to L{Response.deliverBody} has its C{connectionLost} method called with a L{Failure} wrapping L{ResponseDone} when the response's C{_bodyDataFinished} method is called. cseZdZfddZdS)z7ResponseTests.test_connectionLost..ListConsumercs|dSrarrmZlostr=r>r szFResponseTests.test_connectionLost..ListConsumer.connectionLostN)r9r:r;rr=rr=r>r srrrYN) r r^rrMrrEr.rFrGrZ _bodyProtocolrr=rr>test_connectionLost s  z!ResponseTests.test_connectionLostcstgGfdddt}|}tt}|d|d|||d|dddg||jddS)z If data is delivered to the L{Response} before a protocol is registered with C{deliverBody}, that data is buffered until the protocol is registered and then is delivered. cseZdZfddZdS)z8ResponseTests.test_bufferEarlyData..ListConsumercs|dSrarrrr=r>rv" szEResponseTests.test_bufferEarlyData..ListConsumer.dataReceivedNrr=rr=r>r! srrrrN)r r^rrrMrFrZ _bodyBuffer)rMrrxrr=rr>test_bufferEarlyData s     z"ResponseTests.test_bufferEarlyDatacCs,tt}|t|t|jtdS)zb L{Response.deliverBody} raises L{RuntimeError} if called more than once. N)r^rrMr rlrmrr=r=r> test_multipleStartProducingFails0 s  z.ResponseTests.test_multipleStartProducingFailscCs4tt}|t||t|jtdS)zw L{Response.deliverBody} raises L{RuntimeError} if called after L{Response._bodyDataFinished}. N)r^rrMr rrlrmrr=r=r>%test_startProducingAfterFinishedFails9 s  z3ResponseTests.test_startProducingAfterFinishedFailscCs&tt}||t|jddS)z L{Response._bodyDataReceived} raises L{RuntimeError} if called after L{Response._bodyDataFinished} but before L{Response.deliverBody}. rN)r^rrrlrmrrr=r=r>'test_bodyDataReceivedAfterFinishedFailsC s z5ResponseTests.test_bodyDataReceivedAfterFinishedFailscCs2tt}||t|t|jddS)z L{Response._bodyDataReceived} raises L{RuntimeError} if called after L{Response._bodyDataFinished} and after L{Response.deliverBody}. rN)r^rrrMr rlrmrrr=r=r>'test_bodyDataReceivedAfterDeliveryFailsL s  z5ResponseTests.test_bodyDataReceivedAfterDeliveryFailscCs$tt}||t|jdS)zh L{Response._bodyDataFinished} raises L{RuntimeError} if called more than once. N)r^rrrlrmrr=r=r>'test_bodyDataFinishedAfterFinishedFailsV s z5ResponseTests.test_bodyDataFinishedAfterFinishedFailscCs0tt}||t|t|jdS)z{ L{Response._bodyDataFinished} raises L{RuntimeError} if called after the body has been delivered. N)r^rrrMr rlrmrr=r=r>'test_bodyDataFinishedAfterDeliveryFails_ s  z5ResponseTests.test_bodyDataFinishedAfterDeliveryFailscslgGfdddt}t}||}t|}||jd|||dg||jddS)z L{Response.deliverBody} resumes the HTTP connection's transport after passing it to the consumer's C{makeConnection} method. cseZdZfddZdS)z9ResponseTests.test_transportResumed..ListConsumercs|jdSra)rrrrZtransportStater=r>rtq szHResponseTests.test_transportResumed..ListConsumer.makeConnectionNrr=rr=r>rp srrrN)r rrr^rFrrM)rMrr]rxrr=rr>test_transportResumedi s z#ResponseTests.test_transportResumedcCsXt}t|}|d|d|t}||||jd|j t dS)z If the entire body is delivered to the L{Response} before the response's C{deliverBody} method is called, the protocol passed to C{deliverBody} is immediately given the body data and then disconnected. rrrRN) rr^rrrrMrFrrZrEr.rMr]rrxr=r=r>)test_bodyDataFinishedBeforeStartProducing} s   z7ResponseTests.test_bodyDataFinishedBeforeStartProducingcCsLt}t|}t}||||jd|tt|j tdS)a  The L{Failure} passed to L{Response._bodyDataFinished} when the response is in the I{connected} state is passed to the C{connectionLost} method of the L{IProtocol} provider passed to the L{Response}'s C{deliverBody} method. Z CONNECTEDN) rr^rrMrFrhrrr7rZrErr=r=r>#test_finishedWithErrorWhenConnected s z1ResponseTests.test_finishedWithErrorWhenConnectedcCsLt}t|}||jd|ttt}|||j tdS)a The L{Failure} passed to L{Response._bodyDataFinished} when the response is in the I{initial} state is passed to the C{connectionLost} method of the L{IProtocol} provider passed to the L{Response}'s C{deliverBody} method. ZINITIALN) rr^rFrhrrr7rrMrZrErr=r=r>!test_finishedWithErrorWhenInitial s z/ResponseTests.test_finishedWithErrorWhenInitialN)r9r:r;r<rrrrrrrrrrrrr r r r=r=r=r>r s       rN)_r<typingrZzope.interfacerZzope.interface.verifyrZtwisted.internet.deferrrrrZtwisted.internet.errorr r Ztwisted.internet.interfacesr r Ztwisted.internet.protocolr Ztwisted.internet.testingrrrrZtwisted.loggerrZtwisted.protocols.basicrZtwisted.python.failurerZtwisted.trial.unittestrZtwisted.web._newclientrrrrrrrrrrr r!r"r#r$r%r&r'Ztwisted.web.clientr(r)r*r+r,r-r.r/r0Ztwisted.web.httpr1Ztwisted.web.http_headersr2Ztwisted.web.iwebr3r4Ztwisted.web.test.requesthelperr5r6 Exceptionr7r?r\rSrUrVrWr^r_rorrrrr"r%rrrrrrr=r=r=r>sp        P,  (   !0o#ve,~