U  W[Ϩ@sdZddlmZmZeZddlmZddlm Z ddl m Z ddl m Z mZddlmZmZddlmZmZmZmZdd lmZdd lmZdd lmZdd lmZmZm Z m!Z!dd l"m#Z#m$Z$m%Z%m&Z&m'Z'ddl"m(Z(m)Z)ddl"m*Z*m+Z+ddl"m,Z,ddl"m-Z-m.Z.ddl"m/Z/ddl"m0Z0m1Z1ddl"m2Z2m3Z3m4Z4ddl5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>ddl?m@Z@ddlAmBZBddlCmDZDmEZEddlFmGZGGdddeHZIGdddeHZJe@ddgiZKd d!ZLd"d#ZMd$d%ZNd&d'ZOd(d)ZPGd*d+d+eZQGd,d-d-eRZSGd.d/d/eSeZTGd0d1d1eSeZUGd2d3d3eZVGd4d5d5ZWGd6d7d7ZXGd8d9d9eZYeeDGd:d;d;ZZGdd?d?eZ\Gd@dAdAeZ]GdBdCdCeZ^GdDdEdEeZ_dFS)Gz& Tests for L{twisted.web._newclient}. )divisionabsolute_import) implementer) verifyObject)Failure) IConsumer IPushProducer)ConnectionDoneConnectionLost)DeferredsucceedfailCancelledError)Protocol) LineReceiver)TestCase)AccumulatingProtocolEventLoggingObserverStringTransport StringTransportWithDisconnection)UNKNOWN_LENGTHSTATUSHEADERBODYDONE) HTTPParserHTTPClientParser)BadResponseVersion ParseError)ChunkedEncoder)WrongBodyLengthRequestNotSent)ConnectionAborted) BadHeaders ExcessWrite)TransportProxyProducerLengthEnforcingConsumermakeStatefulDispatcher) HTTP11ClientProtocolPotentialDataLossRequestRequestGenerationFailedRequestTransmissionFailedResponse ResponseDoneResponseFailedResponseNeverReceived)Headers) _DataLoss) IBodyProducer IResponse)globalLogPublisherc@seZdZdZdS)ArbitraryExceptionze A unique, arbitrary exception type which L{twisted.web._newclient} knows nothing about. N__name__ __module__ __qualname____doc__r<r<A/usr/lib/python3/dist-packages/twisted/web/test/test_newclient.pyr66sr6c@seZdZdZdS)AnotherArbitraryExceptionzI Similar to L{ArbitraryException} but with a different identity. Nr7r<r<r<r=r>=sr>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. csFt|jD]\}}||q t|jtd|jf|S)Nzlen(%s) != len(%s))zipreasonstrap assertEquallen)errreasontype reasonTypesselfr<r=cbFailed`s   z-assertWrapperExceptionTypes..cbFailed) assertFailure addCallback)rKdeferredZmainTyperJrLdr<rIr=assertWrapperExceptionTypesHs  rQcCst||t|S)zo A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{ResponseFailed}. )rQr/rKrOrJr<r<r=assertResponseFailedlsrScCst||t|S)zx A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{RequestGenerationFailed}. )rQr+rRr<r<r=assertRequestGenerationFailedusrTcCst||t|S)zz A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{RequestTransmissionFailed}. )rQr,rRr<r<r=assertRequestTransmissionFailed~srUcCstdddt|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. sHTTPrWOK)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<rKr<r<r=barszGMakeStatefulDispatcherTests.test_functionCalledByState..Foo.barZquuxcSsdS)Nar<r`r<r<r=_quux_AszKMakeStatefulDispatcherTests.test_functionCalledByState..Foo._quux_AcSsdS)Nbr<r`r<r<r=_quux_BszKMakeStatefulDispatcherTests.test_functionCalledByState..Foo._quux_BN)r8r9r:_staterar'rcrer<r<r<r=Foos  rgrbBrdCN)rDrarf assertRaises RuntimeError)rKrgZstatefulr<r<r=test_functionCalledByStates z6MakeStatefulDispatcherTests.test_functionCalledByStateN)r8r9r:r;rlr<r<r<r=r]sr]c@sdeZdZdZdZddZddZddZd d Zd d Z d dZ ddZ ddZ ddZ ddZdS)_HTTPParserTestszt Base test class for L{HTTPParser} which is responsible for the bulk of the task of parsing HTTP bytes. NcCs\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) rappendstatusReceivedmakeConnectionrrDstater dataReceivedsepr)rKstatusprotocolr<r<r=test_statusCallbacks z$_HTTPParserTests.test_statusCallbackcCs6i}t}|j|_|t|d|j||fS)Nrn)r __setitem__headerReceivedrqrrsrtrKheaderrvr<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|rsrtrDrrrrzr<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 quuxr}s bar baz quuxNrrzr<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~)r}sX-BarN)r|rtjoinrsrD)rKr{rvvaluer<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_dSr_)rorrrr<Zcalledrvr<r=allHeadersReceiveds zD_HTTPParserTests.test_allHeadersCallback..allHeadersReceivedN)r|rrsrtrDrrrr)rKr{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}. Nrrzr<r<r=test_noHeaderCallback s   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}. rnr X-Foo: bazr}r~bazN) rrqrrsrtrDlistheadersgetAllRawHeaders)rKrvexpectedr<r<r=test_headersSavedOnResponses  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)rKrvZconnHeaderNamesr{r<r<r=test_connectionControlHeaders$s*z._HTTPParserTests.test_connectionControlHeaderscCs4t}|t|t|t|jtdS)zi L{HTTPParser.switchToBodyMode} raises L{RuntimeError} if called more than once. N)rrqrZswitchToBodyModeobjectrjrkrKrvr<r<r=test_switchToBodyMode:s  z&_HTTPParserTests.test_switchToBodyMode)r8r9r:r;rtrwr|rrrrrrrrr<r<r<r=rms  rmc@seZdZdZdZdS)$HTTPParserRFCComplaintDelimeterTestsz< L{_HTTPParserTests} using standard CR LF newlines.  Nr8r9r:r;rtr<r<r<r=rFsrc@seZdZdZdZdS)'HTTPParserNonRFCComplaintDelimeterTestsz5 L{_HTTPParserTests} using bare LF newlines.  Nrr<r<r<r=rNsrc@seZdZdZddZddZddZdd 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:S);HTTPClientParserTestszd 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)rrD parseVersionrr<r<r=test_parseVersion[s  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|dSr_)rjrDdatasexcefrKr<r= checkParsingosz@HTTPClientParserTests.test_parseBadVersion..checkParsingfoos foo/bar/bazsfoo/sfoo/..sfoo/a.bs foo/-1.-1)rrr)rKrvrr<rr=test_parseBadVersionfs 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 rVrXrY r*rZrrqrrsrDresponseversioncodephraserKrequestrvr<r<r=test_responseStatusParsing}s   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 rVrXrrrr<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|dSr_)rjrrprDrrrvrKr<r=rszBHTTPClientParserTests.test_badResponseStatus..checkParsingrsHTTP/1.1 bar OK)r)rKrr<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 dSNTror<ZbodyDataFinishedr<r=rz3HTTPClientParserTests._noBodyTest.. producingrTr)rrorxryrrqrsr_bodyDataReceived_bodyDataFinishedrD producerStaterrrlength) rKrrurr{finishedbodyrvr[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*rZrrD)rKrrurr{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*rZrrKrrurr<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. rrNcSsdSr_r<restr<r<r=rrz.rs X-Foo: bar rx-foor~)rr*rZrqrrsrD connHeadersr1rrassertIdenticalrrrr<r<r=test_responseHeaderss"      z*HTTPClientParserTests.test_responseHeaderscCsttddtddd}|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. rrNcSsdSr_r<rr<r<r=rrz>HTTPClientParserTests.test_connectionHeaders..rContent-Length: 123 sConnection: close r123sclose)rr{ rr*rZrqrrsrDrrr1rrrr<r<r=test_connectionHeaderss(      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. rrNcSsdSr_r<rr<r<r=r,rzRHTTPClientParserTests.test_headResponseContentLengthEntityHeader..rrrrrrrrr<r<r=*test_headResponseContentLengthEntityHeader%s"      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)rr*rZrorrqrsrrrDrrrrrrKrrvr[rr<r<r=test_contentLength:s*        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) rr*rZrorqrrsrrrDrrrrrKrrvrr<r<r=test_zeroContentLengthZs       z,HTTPClientParserTests.test_zeroContentLengthcCs4ttddtdd}|t|t|jddS)z If a response includes multiple 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 )rr*rZrqrrj ValueErrorrsrr<r<r=!test_multipleContentLengthHeadersts  z7HTTPClientParserTests.test_multipleContentLengthHeaderscCsdg}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! rr*rZrorqrrsrDrrrrKrrvr<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) rr*rZrorqrrsrrrDrrrrr<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. rrNrrrr~zsimulated end of connectionr) rr*rZrorrqrsrrrDconnectionLostr rr<r<r=test_unknownContentLengths        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) rr*rZrorrqrsrrrDrr<r<r=%test_contentLengthAndTransferEncodings     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) rrr*rZrq_responseDeferredrrr6rS)rKr[rvZresponseDeferredr<r<r=test_connectionLostBeforeBodys  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 tdSr_r6)rFr<r<r=fakeBodyDataFinished1szPHTTPClientParserTests.test_connectionLostWithError..fakeBodyDataFinishedrW log_failure)N)rcreateWithCleanupr5rrr*rZrqrrNrorsrr assertEqualsrEassertIsInstancerr6flushLoggedErrors)rK logObserverr[rvrreventrr<r<r=test_connectionLostWithErrors.   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}. rrNcSsdSr_r<Zignr<r<r=rDrz.) rr*rZrrqrrr rMr0rKrvrPr<r<r=test_noResponseAtAll=s   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}. rrNcSsdSr_r<rr<r<r=rTrzBHTTPClientParserTests.test_someResponseButNotAll..2) rr*rZrrqrrsrr rMr/rNrrr<r<r=test_someResponseButNotAllLs     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 rrNcSsdSr_r<rr<r<r=rmrzCHTTPClientParserTests.test_1XXResponseIsSwallowed..rr)rr*rZrqrrsrgetattrrDrrrrErrrrZ_everReceivedData)rKsample103Responservr<r<r=test_1XXResponseIsSwallowed^s   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 rrNcSsdSr_r<rr<r<r=rrzUHTTPClientParserTests.test_1XXFollowedByFinalResponseOnlyEmitsFinal..rXrrr rr*rZrqrrsrDrrrr1rrrKrZfollowing200Responservr<r<r=-test_1XXFollowedByFinalResponseOnlyEmitsFinalzs(   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. rrrrNcSsdSr_r<rr<r<r=rrzKHTTPClientParserTests.test_multiple1XXResponsesAreIgnored..rXrrrrrr<r<r=#test_multiple1XXResponsesAreIgnoreds8   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. rrrNcSsdSr_r<rr<r<r=rrzHHTTPClientParserTests.test_ignored1XXResponseCausesLog..rWr log_formatz#Ignoring unexpected {code} responserg) rrr5rr*rZrqrrsrrE)rKrrrvrr<r<r= test_ignored1XXResponseCausesLogs&   z6HTTPClientParserTests.test_ignored1XXResponseCausesLogN) r8r9r:r;rrrrrrrrrrrrrrrrrrrrrrrrrrrr r<r<r<r=rVs: &   &$#(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|_|jSr_)r rrKr[r<r<r=writeToszSlowRequest.writeTocCs d|_dSrstoppedr`r<r<r= stopWritingszSlowRequest.stopWritingN) r8r9r:r;methodr persistentrrr<r<r<r=r s  r c@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)writer r r<r<r=rs zSimpleRequest.writeToN)r8r9r:r;rrr<r<r<r=rsrc@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(rvrqr`r<r<r=setUpszHTTP11ClientProtocolTests.setUpcCs$|jt||jddS)z L{HTTP11ClientProtocol.request} accepts a L{Request} and calls its C{writeTo} method with its own transport. rN)rvrrrDr[rr`r<r<r= test_requestsz&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. csjddSNrrDr[rZignoredr`r<r= cbNotSent,sz?HTTP11ClientProtocolTests.test_secondRequest..cbNotSent)rvrr rMrr!rNrKrrPr<r`r=test_secondRequest%s   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 transportcsjddSrrrr`r<r=r<szLHTTP11ClientProtocolTests.test_requestAfterConnectionLost..cbNotSent) rvrrr rMrrr!rNrr<r`r=test_requestAfterConnectionLost4s    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 ttSr_)r r6r r<r<r=rMszKHTTP11ClientProtocolTests.test_failedWriteTo..BrokenRequest.writeToNr8r9r:rrr<r<r<r= BrokenRequestKsr"cs&jjjttddS)Nzyou asked for it)rr[ disconnectingrvrrr rr`r<r=rLQs z>HTTP11ClientProtocolTests.test_failedWriteTo..cbFailed)rvrrTr6rN)rKr"rPrLr<r`r=test_failedWriteToDs   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 tdSr_rr r<r<r=rdszUHTTP11ClientProtocolTests.test_synchronousWriteToError..BrokenRequest.writeToNr!r<r<r<r=r"bsr")rvrrTr6)rKr"rPr<r<r=test_synchronousWriteToError\sz6HTTP11ClientProtocolTests.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. callbackNerrbackrW)r rvrrUr6rrrrrrr&r'r>rrDrE)rKmoderrPerrorsr<r<r=*test_connectionLostDuringRequestGenerationks    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. r&r*r`r<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. r'r+r`r<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)NrWrrr zJError writing request, but not in valid state to finalize request: {state}rrCONNECTION_LOST)rrEassertInrD)ignorerrrKr<r=checks  znHTTP11ClientProtocolTests.test_errorMessageOnConnectionLostBeforeGenerationFailedDoesNotConfuse..checkr')rrr5r*rN)rKr2r<r1r=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)NrX QUIESCENT) rDrrr1rr[r#rvrrrr`r<r= cbRequestszIHTTP11ClientProtocolTests.test_receiveSimplestResponse..cbRequests9HTTP/1.1 200 OK Content-Length: 0 Connection: close rvrr*rZrNrsrKrPr6r<r`r=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)Nrr~r)r1rDr)rrr`r<r=r6szHHTTP11ClientProtocolTests.test_receiveResponseHeaders..cbRequests+HTTP/1.1 200 OK X-Foo: bar X-Foo: baz r7r8r<r`r=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 jfSr_rrprr<r=rrzoHTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone..cbResponse..) rr closedDeferred deliverBodyrDrrrr#rNr whenFinished)rvquiescentResultrKr[r<r= cbResponses     z]HTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone..cbResponsecsf|\}}|jd|jd|jd|jtddgi|djddS)NrVrXrYrr~foobar)rDrrrrr1rr&)resultrrrrKr<r= cbAllResponses z`HTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone..cbAllResponse)rr(rorqr rrsrNrKrPrCrGr<)rvrBrrKr[r=/test_receiveResponseBeforeRequestGenerationDones      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(rvrqrZ MAX_LENGTHrr*rZrsrSr )rKr[rvZlongLinerPr<r<r="test_receiveResponseHeadersTooLongs   z.cbResponse..)rr r>r?rNr@r<r<r=rC8s    zrHTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDone..cbResponsecs2jdjttjjddS)Nr.)rr&rvrrr6rDrf)r0rFr<r=rG?s zuHTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDone..cbAllResponse)r rvrrsrNrHr<rFr=Dtest_connectionLostAfterReceivingResponseBeforeRequestGenerationDone+s   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 rrrr~csjdjtdS)NrD)rDr closedReasonrCr.rrr<r=rGiszIHTTP11ClientProtocolTests.test_receiveResponseBody..cbAllResponse) rr r>rvrr*rZrsrNrorDr?)rKrArequestDeferredrErrGr<rr=test_receiveResponseBodyHs"         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 rrr~rDz low-level transport disconnected)rvrr*rZrsrNrorr?rDrrrr rLrCr)rKrMrErrvr<r<r=Etest_responseBodyFinishedWhenConnectionLostWhenContentLengthIsUnknownps&      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 rD)rvrr*rZrsrNrorr?rDrrrr6rSr rLr2rOr<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[r#rDrBrrrvrrr rr`r<r=rLs  zLHTTP11ClientProtocolTests.test_parserDataReceivedException..cbFailed)rvrr*rZrsrSrrN)rKrMrPrLr<r`r= 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) rvrr*rZ_parserr[r _producerZ_disconnectParserrr rS)rKrMr[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(rqabortrNrorDrr#rrr )rKr[rvZr1Zr2r<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(rqrrr rXrNrorDrfrKr[rvrEr<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(rqrr*rZrXrr#rrr rSr"rZr<r<r=test_abortBeforeResponseBodys  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)ZlenientrrNrcs(eZdZdZfddZfddZdS)zQHTTP11ClientProtocolTests.test_abortAfterResponseHeaders..BodyDestinationzl A body response protocol which immediately aborts the HTTP connection. cs dS)z< Abort the HTTP connection. N)rXr`)rvr<r=connectionMade-sz`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)r'rKrG) testResultr<r=r3sz`HTTP11ClientProtocolTests.test_abortAfterResponseHeaders..BodyDestination.connectionLostN)r8r9r:r;r]rr<)rvr_r<r=BodyDestination(s r`cs,|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)r?rr#rrr r5)r`rvrKr[r<r=r?;s  zMHTTP11ClientProtocolTests.test_abortAfterResponseHeaders..deliverBodycs|jtdSr_)rrr-)errorr`r<r= checkErrorFszLHTTP11ClientProtocolTests.test_abortAfterResponseHeaders..checkError) rr(rqrr*rZrsr rrNrSr"r2)rKrEr?rbrOr<)r`rvrKr_r[r=test_abortAfterResponseHeaderss    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|dSNr4rDrrror=rvrBrKr<r=r&]s zHHTTP11ClientProtocolTests.test_quiescentCallbackCalled..callbackrrNTrs&HTTP/1.1 200 OK Content-length: 3 rcs dS)N response donerr)rBr<r=ryrzHHTTP11ClientProtocolTests.test_quiescentCallbackCalled..rri)rr(rqrr*rZrsrDrNrorr r>r?rLrCr.rUZ_finishedRequestZ_currentRequestZ_transportProxyr)rKr&r[rMrEr bodyProtocolr<rgr=test_quiescentCallbackCalledPs:        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|dSrdrerfrgr<r=r&s z]HTTP11ClientProtocolTests.test_transportProducingWhenQuiescentAfterFullBody..callbackrrNTrhs)HTTP/1.1 200 OK Content-length: 3 BBBZDEFERRED_CLOSErWr) rr(rqrr*rZrsZsuccessResultOfrDrfrEr)rKr&r[rMrr<rgr=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|dSrdrerfrgr<r=r&s zUHTTP11ClientProtocolTests.test_quiescentCallbackCalledEmptyResponse..callbackrrNTrh&HTTP/1.1 200 OK Content-length: 0 rrrW)rr(rqrr*rZrNrorsrDrErrr-)rKr&r[rMr<rgr=)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. rrNTrhs9HTTP/1.1 200 OK Content-length: 0 Connection: close rrr(rorqrr*rZrsrNrr?rLrCr.rDrr#rKrBr[rvrMrErrjr<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. rrNFrhrmrrorpr<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 tdSr_)ZeroDivisionErrorrfr<r<r=r&szHHTTP11ClientProtocolTests.test_quiescentCallbackThrows..callbackrrNTrhrmrrWr)rrr5rr(rqrr*rZrsrNrorr?rLrCr.rrErrrsrrr#) rKr&rr[rvrMrErrjrrr<r<r=test_quiescentCallbackThrows s4     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(rqrr*rZcancelr disconnectedrQr0rrZr<r<r=test_cancelBeforeResponse5s  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(rqrr*rZrsrurrvrSrrZr<r<r=test_cancelDuringResponseFs   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)NTryr<r)nonLocalr<r=rudszJHTTP11ClientProtocolTests.assertCancelDuringBodyProduction..cancelcs|_t_jSr_consumerr r)r|)ruproducerr<r=startProducingfs zRHTTP11ClientProtocolTests.assertCancelDuringBodyProduction..startProducingPOST/barsxxxxx)rr(rqStringProducerr~rr*rZr|rrurrvrTr)rKZproducerLengthr[rvr~rEr<)rurzr}r= assertCancelDuringBodyProductionWs      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. )rr`r<r<r=test_cancelDuringBodyProductionusz9HTTP11ClientProtocolTests.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. )rrr`r<r<r=&test_cancelDuringChunkedBodyProductionsz@HTTP11ClientProtocolTests.test_cancelDuringChunkedBodyProduction)N)'r8r9r:r;rrrr r$r%r*r,r-r3r9r:rIrJrKrNrPrRrTrWrYr[r\rcrkrlrnrqrrrtrwrxrrrr<r<r<r=rsH   !  1( @:-( rc@s,eZdZdZdZddZddZddZd 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 ||_dSr_)r)rKrr<r<r=__init__szStringProducer.__init__cCs||_t|_|jSr_r{)rKr|r<r<r=r~szStringProducer.startProducingcCs d|_dSrrr`r<r<r= stopProducingszStringProducer.stopProducingN)r8r9r:r;rrr~rr<r<r<r=rs  rc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"d#Zd$d%Zd3d'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd&S)4 RequestTestsz Tests for L{Request}. cCs t|_dSr_)rr[r`r<r<r=rszRequestTests.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*rZrr[rDrr`r<r<r=test_sendSimplestRequests z%RequestTests.test_sendSimplestRequestcCs4tddtddd}||j||jddS)zO A pesistent request does not send 'Connection: close' header. rrNTrhs%GET / HTTP/1.1 Host: example.com r)rKZreqr<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. r~rr@)rr?r/fooNrrsGET /foo HTTP/1.1rsConnection: closesHost: example.comrr)r1r*rr[rsplitrDsort)rKrlinesr<r<r=test_sendRequestHeaderss"z$RequestTests.test_sendRequestHeaderscCstt}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*rZrr[assertNotIdenticalr|rr}r streamingrDrclearrrr&rKr}rr<r<r=test_sendChunkedRequestBodys&     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)rDr[rrr}rr`r<r=rLszCRequestTests.test_sendChunkedRequestBodyWithError..cbFailed) rrr*rZrr[rrr'r6rMrN)rKr}r writeDeferredrLrPr<r`r=$test_sendChunkedRequestBodyWithErrors      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*rZrr[rr|rr}rrrDrrrrr&rr<r<r=test_sendRequestBodyWithLengths    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)rKrrr<r<r=_sendRequestEmptyBodyWithLength9s  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. sPUTNrr`r<r<r=test_sendPUTRequestEmptyBodyNsz)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. rNrr`r<r<r=test_sendPOSTRequestEmptyBodyWsz*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*rZrr[r|rrr&rr}rMr rKr}rrr<r<r=#test_sendRequestBodyWithTooFewBytes`s   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)rDr[rrrjr$r|rrSfinisherr}rKr<r=rLs zCRequestTests._sendRequestBodyWithTooManyBytesTest..cbFailed)rr*rZrr[r|rrrrrr}rMr rN)rKrrrrLrPr<rr=$_sendRequestBodyWithTooManyBytesTestps        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|jddSr_rr&r}r<r<r=rszCRequestTests.test_sendRequestBodyWithTooManyBytes..finisher)rrKrr<r<r=$test_sendRequestBodyWithTooManyBytessz1RequestTests.test_sendRequestBodyWithTooManyBytescs$ttfdd}|S)rcsV|jtd}d||d}|jtt}t|ddS)NrrrW) rr'r6r/rrrrDrE)r}rrr)r1r<r=rs  zHRequestTests.test_sendRequestBodyErrorWithTooManyBytes..finisher)rrr5rrr<r1r=)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. rrrrNrrrW)rrr5rr*rZrr[r|Z _finishedrrr&r'r6r/rrrDrEr)rKrr}rZfinishedConsumingrrr<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*rZrr[r|rrr}rrjr$rDr)rKrr}rrr<r<r=-_sendRequestBodyFinishedEarlyThenTooManyBytess   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|jddSr_rrr<r<r=r szPRequestTests.test_sendRequestBodyFinishedEarlyThenTooManyBytes..finisher)rMrr 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|jtdSr_)rr'r6rr<r<r=r szORequestTests.test_sendRequestBodyErroredEarlyThenTooManyBytes..finisher)rMrr6rr<r<r=0test_sendRequestBodyErroredEarlyThenTooManyBytes 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*rZrr[rr&rrjr$r|rrDr)rKZ_withr}rrr<r<r=0test_sendChunkedRequestBodyFinishedThenWriteMore# 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. )rrr6rM)rKrPr<r<r=9test_sendChunkedRequestBodyFinishedWithErrorThenWriteMore5 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*rZrr[rr}rrr|rrDrrr#rr'rr6rMrr<r<r=test_sendRequestBodyWithErrorA 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. rrNrsHostr@s example.org)r*r1rjr#rr[rDr)rKrr<r<r=test_hostHeaderRequiredh sz$RequestTests.test_hostHeaderRequiredcCsFtd}tddt|}||j||j|||jdS)zc L{Request.stopWriting} calls its body producer's C{stopProducing} method. rrrN) rr*rZrr[rrrrrr<r<r=test_stopWritingw 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..brokenStopProducingrrrWrrN)rrr5rrr*rZrr[rrDrErr6rr/rr)rKrr}rrrrr<r<r=test_brokenStopProducing s&   z%RequestTests.test_brokenStopProducing)N)r8r9r:r;rrrrrrrrrrrrrrrrrrrrrrrrr<r<r<r=rs2 %  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)r rErr}rr[r&enforcerr`r<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)rrrDr[rrr`r<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)rrrjr _noMoreWritesExpectedr`r<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) rrrr}rrrrMrEr )rKZ_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) rrrrr}rrjr$rr`r<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)rr`r<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)rrrrr`r<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)rrr}r6r<r`r<r=r s zRLengthEnforcingConsumerTests.test_stopProducingRaises..brokenStopProducingcsttddS)NrW)rDrErr6rr`r<r= cbFinished s zILengthEnforcingConsumerTests.test_stopProducingRaises..cbFinished)r}rrrN)rKrrrPr<r`r=test_stopProducingRaises s    z5LengthEnforcingConsumerTests.test_stopProducingRaisesN)F) r8r9r:r;rrrrrrrrr<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)rrrrrr`r<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. rrQsxxxxxxxxxxxxxxxxs10 xxxxxxxxxxxxxxxx N)rrrrDrr)rKr[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 ) rrrZregisterProducerrr}rrZunregisterProducerrDr)rKr[r}rr<r<r=test_producerRegistration$ s  z2RequestBodyConsumerTests.test_producerRegistrationN)r8r9r:r;rrrr<r<r<r=r src@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)rrrr%r`r<r<r=r< s z*TransportProxyProducerTests.test_interfacecCs6t}t|}||j||||jddS)z~ L{TransportProxyProducer.stopProxying} drops the reference to the wrapped L{IPushProducer} provider. N)rr%rrV stopProxyingrKr[proxyr<r<r=%test_stopProxyingUnreferencesProducerD 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)rpauseProducingr%rDrresumeProducingrrr<r<r=test_resumeProducingP 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%rDrrrrrr<r<r=test_pauseProducingg 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%rDrrrrr<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) rrrqrvr%r connectedrDrloseConnectionrrKr[rvrr<r<r= test_loseConnectionWhileProxying s  z.SomeProtocolcs|dSr_r)rKr}Z producersr<r=rq szFResponseTests.test_makeConnection..SomeProtocol.makeConnectionNr8r9r:rqr<rr<r= SomeProtocol srrrN)rrr\r?rrDrr)rKr[rr|rZ 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|dSr_rrKrbytesr<r=rs szBResponseTests.test_dataReceived..ListConsumer.dataReceivedNr8r9r:rsr<rr<r= ListConsumer srrN)rr\rr?rrDrKrr|rr<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|dSr_rr^Zlostr<r=r szFResponseTests.test_connectionLost..ListConsumer.connectionLostN)r8r9r:rr<rr<r=r srrrWN) rr\rr?rrCr.rDrErZ _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|dSr_rrrr<r=rs szEResponseTests.test_bufferEarlyData..ListConsumer.dataReceivedNrr<rr<r=r srrr~rN)rr\rrr?rDrZ _bodyBuffer)rKrrvrr<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\rr?rrjrkrr<r<r= test_multipleStartProducingFails" s  z.ResponseTests.test_multipleStartProducingFailscCs4tt}|t||t|jtdS)zw L{Response.deliverBody} raises L{RuntimeError} if called after L{Response._bodyDataFinished}. N)r\rr?rrrjrkrr<r<r=%test_startProducingAfterFinishedFails, 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\rrrjrkrrr<r<r='test_bodyDataReceivedAfterFinishedFails7 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\rrr?rrjrkrrr<r<r='test_bodyDataReceivedAfterDeliveryFailsA s  z5ResponseTests.test_bodyDataReceivedAfterDeliveryFailscCs$tt}||t|jdS)zh L{Response._bodyDataFinished} raises L{RuntimeError} if called more than once. N)r\rrrjrkrr<r<r='test_bodyDataFinishedAfterFinishedFailsL s z5ResponseTests.test_bodyDataFinishedAfterFinishedFailscCs0tt}||t|t|jdS)z{ L{Response._bodyDataFinished} raises L{RuntimeError} if called after the body has been delivered. N)r\rrr?rrjrkrr<r<r='test_bodyDataFinishedAfterDeliveryFailsV 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|jdSr_)rorr ZtransportStater<r=rqh szHResponseTests.test_transportResumed..ListConsumer.makeConnectionNrr<rr<r=rg srrrN)rrrr\rDrr?)rKrr[rvrr<rr=test_transportResumeda 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. rr~rDN) rr\rrrr?rDrrLrCr.rKr[rrvr<r<r=)test_bodyDataFinishedBeforeStartProducingu 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\rr?rDrfrrr6rLrCrr<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\rDrfrrr6rr?rLrCrr<r<r=!test_finishedWithErrorWhenInitial s z/ResponseTests.test_finishedWithErrorWhenInitialN)r8r9r:r;rrrrrrrrrrrrrrrr<r<r<r=r s       rN)`r;Z __future__rrrHZ __metaclass__Zzope.interfacerZzope.interface.verifyrZtwisted.python.failurerZtwisted.internet.interfacesrrZtwisted.internet.errorr r Ztwisted.internet.deferr r r rZtwisted.internet.protocolrZtwisted.protocols.basicrZtwisted.trial.unittestrZtwisted.test.proto_helpersrrrrZtwisted.web._newclientrrrrrrrrrrr r!r"r#r$r%r&r'Ztwisted.web.clientr(r)r*r+r,r-r.r/r0Ztwisted.web.http_headersr1Ztwisted.web.httpr2Ztwisted.web.iwebr3r4Ztwisted.loggerr5 Exceptionr6r>rZrQrSrTrUr\r]rrmrrrr rrrrrrrrr<r<r<r=s        ,   $    yi/