כhSrSSKJr SSKJr SSKJr SSKJrJ r J r J r SSK J r Jr SSKJrJr SSKJr SS KJrJrJrJr SS KJr SS KJr SS KJr SS KJ r SSK!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3 SSK4J5r5J6r6J7r7J8r8J9r9J:r:J;r;JJ?r? SSK@JArA SSKBJCrCJDrD SSKEJFrFJGrG "SS\H5rI"SS\H5rJ\A"SS/05rKSrLSrMSrNSrOSrP"SS \ 5rQ"S!S"5rR"S#S$\R\ 5rS"S%S&\R\ 5rT"S'S(\ 5rU"S)S*5rV"S+S,5rW"S-S.\ 5rX\"\C5"S/S055rY"S1S2\ 5rZ"S3S4\ 5r["S5S6\ 5r\"S7S8\ 5r]"S9S:\ 5r^g;)[URT5HupURU5 M TR[ UR5[ T5SURSTS35 U$)Nzlen(z ) != len())zipreasonstrap assertEquallen)errreasontype reasonTypesselfs rDcbFailed-assertWrapperExceptionTypes..cbFailednse [9LF KK :     3;;-y Q 7  rC) assertFailure addCallback)rVdeferredmainTyperUrWds` ` rDassertWrapperExceptionTypesr^Us+2 8.AMM( HrCc$[X[U5$)zc A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{ResponseFailed}. )r^r0rVr[rUs rDassertResponseFailedra}s 't~{ SSrCc$[X[U5$)zl A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{RequestGenerationFailed}. )r^r,r`s rDassertRequestGenerationFailedrcs ' / rCc$[X[U5$)zn A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{RequestTransmissionFailed}. )r^r-r`s rDassertRequestTransmissionFailedres ' 1; rCc([SSS[U5$)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. sHTTPrhOK)r._boringHeaders transports rDjustTransportResponserns OS% KKrCc\rSrSrSrSrSrg)MakeStatefulDispatcherTestsz& Tests for L{makeStatefulDispatcher}. c"SS5nU"5nURUR5S5 SUlURUR5S5 SUlUR[UR5 g)zs A method defined with L{makeStatefulDispatcher} invokes a second method based on the current state of the object. c<\rSrSrSrSr\"S\5rSrSrSr g) CMakeStatefulDispatcherTests.test_functionCalledByState..FooAcgNr;rVs rDbarGMakeStatefulDispatcherTests.test_functionCalledByState..Foo.barsrCquuxcg)Nar;rys rD_quux_AKMakeStatefulDispatcherTests.test_functionCalledByState..Foo._quux_ArCcg)Nbr;rys rD_quux_BKMakeStatefulDispatcherTests.test_functionCalledByState..Foo._quux_BrrCr;N) r=r>r?r@_staterzr(rrrBr;rCrDFoorts$F )5C  rCrr~BrCN)rPrzr assertRaises RuntimeError)rVrstatefuls rDtest_functionCalledByState6MakeStatefulDispatcherTests.test_functionCalledByStatesc  5 - - , 5rCr;N)r=r>r?r@rArrBr;rCrDrprps 6rCrpcj\rSrSr%SrSr\\\S'Sr Sr Sr Sr S r S rS rS rS rSrSrg)_HTTPParserTestszh Base test class for L{HTTPParser} which is responsible for the bulk of the task of parsing HTTP bytes. NsepcR/n[5nURUlUR[ 55 UR UR [5 URSUR-5 UR US/5 UR UR [5 g)zR L{HTTPParser} calls its C{statusReceived} method when it receives a status line. HTTP/1.1 200 OKN) r"appendstatusReceivedmakeConnectionrrPstater dataReceivedrr)rVstatusprotocols rDtest_statusCallback$_HTTPParserTests.test_statusCallbacks <"(-- 12 00488;< "4!56 0rCc0n[5nURUlUR[ 55 UR SUR -5 X4$)Nr)r" __setitem__headerReceivedrrrrrVheaderrs rD_headerTestSetup!_HTTPParserTests._headerTestSetupsN<"("4"4 120488;<rCcUR5upURSUR-5 URUR5 URUSS05 URUR[ 5 g)zM L{HTTPParser} calls its C{headerReceived} method when it receives a header. s X-Foo:barX-FoobarNrrrrPrrrs rDtest_headerCallback$_HTTPParserTests.test_headerCallbacksi  002lTXX56 dhh' (F!34 .rCczUR5upURSUR-5 URSUR-5 URSUR-5 URUR5 URUSS05 URUR[ 5 g)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 quuxNrrs rDtest_continuedHeaderCallback-_HTTPParserTests.test_continuedHeaderCallbacks  002mdhh67g01i$((23dhh' (, .rCcUR5upURR/SQ5nURSU-5 URSU-5 URUR5 UR USSS.5 g)zt Leading and trailing linear whitespace is stripped from the header value passed to the C{headerReceived} callback. )s s bar s rCsX-Bar:sX-Foo:r)rsX-BarN)rrjoinrrP)rVrrvalues rDtest_fieldContentWhitespace,_HTTPParserTests.test_fieldContentWhitespacesu  002 @Ai%/0i%/0dhh' Ff!EFrCc^^/mUR5unmUU4SjnUTlTRUR5 UR T[ /5 UR TR [5 g)zO After the last header is received, L{HTTPParser} calls C{allHeadersReceived}. cR>TRTR5 [Tlgrx)rrr)calledrsrDallHeadersReceivedD_HTTPParserTests.test_allHeadersCallback..allHeadersReceiveds MM(.. )#HNrCN)rrrrrPrrr)rVrrrrs @@rDtest_allHeadersCallback(_HTTPParserTests.test_allHeadersCallbacksd 002 $'9#dhh' &* 0rCcUR5upURUR5 URU05 URUR[ 5 g)zX If there are no headers in the message, L{HTTPParser} does not call C{headerReceived}. Nrrs rDtest_noHeaderCallback&_HTTPParserTests.test_noHeaderCallbacksK  002dhh' $ .rCc[5nUR[55 URSUR-5 URSUR-5 URSUR-5 URUR5 SSS/4/nUR U[ URR555 g)zK All headers received by L{HTTPParser} are added to L{HTTPParser.headers}. rr X-Foo: bazrrbazN) r"rrrrrPlistheadersgetAllRawHeaders)rVrexpecteds rDtest_headersSavedOnResponse,_HTTPParserTests.test_headersSavedOnResponse#s < 120488;<mdhh67mdhh67dhh'/01 4(8(8(I(I(K#LMrCc[5n/SQnUH)nURURU5SU<S35 M+ URURS5S5 g)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 z. 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" assertTrueisConnectionControlHeader assertFalse)rVrconnHeaderNamesrs rDtest_connectionControlHeaders._HTTPParserTests.test_connectionControlHeaders1sc <  &F OO226:"% &   . .w 7 4 rCc[5nUR[55 UR[ 55 UR [ UR[ 55 g)zQ L{HTTPParser.switchToBodyMode} raises L{RuntimeError} if called more than once. N)r"rrswitchToBodyModeobjectrrrVrs rDtest_switchToBodyMode&_HTTPParserTests.test_switchToBodyModeOsF < 12!!&(+ ,(A(A68LrCr;)r=r>r?r@rArrbytes__annotations__rrrrrrrrrrrBr;rCrDrrsL  C% 1  / / G1"/ N <MrCrc\rSrSrSrSrSrg)$HTTPParserRFCComplaintDelimeterTestsiZz4 L{_HTTPParserTests} using standard CR LF newlines.  r;Nr=r>r?r@rArrBr;rCrDrrZs CrCrc\rSrSrSrSrSrg)'HTTPParserNonRFCComplaintDelimeterTestsibz- L{_HTTPParserTests} using bare LF newlines.  r;Nrr;rCrDrrbs CrCrc\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSr Sr!S r"S!r#S"r$S#r%S$r&S%r'g&)'HTTPClientParserTestsijzX Tests for L{HTTPClientParser} which is responsible for parsing HTTP response messages. c^[SS5nURURS5S5 g)zR L{HTTPClientParser.parseVersion} parses a status line into its three components. Ns CANDY/7.2)sCANDY)r!rP parseVersionrs rDtest_parseVersion'HTTPClientParserTests.test_parseVersionps, $D$/ ..|<>NOrCc^^^[SS5n[mURmUUU4SjnU"S5 U"S5 U"S5 U"S5 U"S5 U"S5 g) zZ L{HTTPClientParser.parseVersion} raises L{ValueError} when passed an unparsable version. Ncd>TRTTU5nTRURU5 grx)rrPdata)sexcefrVs rD checkParsing@HTTPClientParserTests.test_parseBadVersion..checkParsings+##Aq!,C   SXXq )rCfoos foo/bar/bazsfoo/sfoo/..sfoo/a.bs foo/-1.-1)r!rr)rVrrrrs` @@rDtest_parseBadVersion*HTTPClientParserTests.test_parseBadVersionxsX $D$/   ! ! * V^$WYZ \"rCcx[SS[S5n[US5nUR[ 55 UR S5 UR URRS5 UR URRS5 UR URRS5 g)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 rgrirj r+rkr!rrrrPresponseversioncodephraserVrequestrs rDtest_responseStatusParsing0HTTPClientParserTests.test_responseStatusParsings &$=#GT2 1245 **22OD **//5 **1159rCcx[SS[S5n[US5nUR[ 55 UR S5 UR URRS5 UR URRS5 UR URRS5 g)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 rgrirCrrs rD test_responseStatusWithoutPhrase6HTTPClientParserTests.test_responseStatusWithoutPhrases &$=#GT2 1212 **22OD **//5 **1137rCcN^^[SS5mUU4SjnU"S5 U"S5 g)zt L{HTTPClientParser.statusReceived} raises L{ParseError} if it is called with a status line which cannot be parsed. Nc>TR[TRU5nTRURU5 grx)rr$rrPr)rrrrVs rDrBHTTPClientParserTests.test_badResponseStatus..checkParsings1##J0G0GKC   SXXq )rCrsHTTP/1.1 bar OK)r!)rVrrs` @rDtest_badResponseStatus,HTTPClientParserTests.test_badResponseStatuss+ $D$/ * V '(rCcr^ 0n/n/n/m [XR5nURUl[ 5nUR U5 UR U5 URURlU 4SjURl UR U5 URURS5 URUR[5 URU/5 URUS/5 URT S/5 URURRS5 U$)a 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. c&>TRS5$NTr)bodyDataFinishedsrD3HTTPClientParserTests._noBodyTest..s6F6M6Md6SrC producingrCTr)r!rrrrrrr_bodyDataReceived_bodyDataFinishedrP producerStaterrlength) rVrrrrfinishedbodyrrmr s @rD _noBodyTest!HTTPClientParserTests._noBodyTests #G__="("4"4#%  * f%.2kk+.S+h' 00+> . r" C5) )D62 **1115 rCc|[SS[S5nSnSnURXU5nURUSS05 g)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+rkrrP)rVrrrrs rDtest_headResponse'HTTPClientParserTests.test_headResponsesF '4>'4!!'8< "3U!;.drCrs X-Foo: bar rx-foorr!r+rkrrrrP connHeadersr3rrassertIdenticalrrrs rDtest_responseHeaders*HTTPClientParserTests.test_responseHeaderss $ FD.$ 79J   1245/0g& --wr{; **22GXx.r)rCrsX-Multiline: a s b rs x-multilinesa br+rs rDtest_responseHeadersMultiline3HTTPClientParserTests.test_responseHeadersMultilines $ FD.$ 79J   124534l+g& --wr{;     % %w /L'M  X..55~FrCc[[SS[S5S5nUR[ 55 UR S5 UR S5 UR S5 UR S5 UR URR[055 UR UR[S /S /S .55 UR URRS 5 g) z^ The connection control headers are added to the parser's C{connHeaders} L{Headers} instance. rrNcgrxr;r&s rDr >HTTPClientParserTests.test_connectionHeaders..)r)rCrContent-Length: 123 sConnection: close r123sclose)rr{ r!r+rkrrrrPrrr3r,rrs rDtest_connectionHeaders,HTTPClientParserTests.test_connectionHeaders#s $ FD.$ 79J   12458967g& **22GBK@   (L M  **1137rCc[[SS[S5S5nUR[ 55 UR S5 UR S5 UR S5 UR URR[SS /055 UR UR[055 UR URRS 5 g) 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. rrNcgrxr;r&s rDr RHTTPClientParserTests.test_headResponseContentLengthEntityHeader..=strCrr8rrr9rr;rs rD*test_headResponseContentLengthEntityHeader@HTTPClientParserTests.test_headResponseContentLengthEntityHeader7s $ GT>4 8:K   124589g&     % %w0AF8/L'M  --wr{; **1115rCc/n[[SS[S5UR5n[ 5nUR U5 UR S5 /nURURlUR S5 UR S5 URURS5 URUR[5 UR S5 URUS/5 URUR[5 UR S 5 URUSS /5 URUR[5 URUS /5 g) 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 rpausedsxxxxxxsyyyyrC)r!r+rkrrrrrrrPrrrrrVrrrmrs rDtest_contentLength(HTTPClientParserTests.test_contentLengthIs+ # FD.$ 7 $%  *45.2kk+78g& 00(; .h' z* .h' (34 . C5)rCc/n[[SS[S5UR5nUR [ 55 UR S5 /nURURlUR S5 UR S5 URUR[5 URU/5 URUS/5 URURRS5 g) 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 rrCr) r!r+rkrrrrrrrPrrrrVrrrs rDtest_zeroContentLength,HTTPClientParserTests.test_zeroContentLengthhs # FD.$ 7   1245.2kk+67g& . r" C5) **1115rCc[[SS[S5S5nUR[ 55 UR [ URS5 g)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+rkrrr ValueErrorrrs rD)test_multipleDistinctContentLengthHeaders?HTTPClientParserTests.test_multipleDistinctContentLengthHeaderssL $GFD.$$OQUV 12    ! !  rCc[[SS[S5S5nUR[ 55 UR S5 UR URRS5 UR UR[5 g)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 rh r!r+rkrrrrPrrrrrs rD&test_multipleEqualContentLengthHeaders?rCcR/n[[SS[S5UR5nUR [ 55 UR S5 UR S5 UR S5 URUR[5 URUS/5 g)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 rdrerfrgs rDtest_extraBytesPassedBackHEAD3HTTPClientParserTests.test_extraBytesPassedBackHEADs # GT>4 8(//   124578;< . $=#>?rCcx/n[[SS[S5UR5nUR [ 55 UR S5 /nURURlUR S5 UR S5 URU/5 URURR[5 UR S5 URUS/5 UR S 5 URUSS /5 UR S 5 URUS /5 g) 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+rkrrrrrrrPr-rrrJs rDtest_chunkedResponseBody.HTTPClientParserTests.test_chunkedResponseBodys # FD.$ 7   1245.2kk+?@g& r" X..55~F i( v&i( e}- /0 H:.rCc/n[[SS[S5UR5n[ 5nUR U5 UR S5 /nURURlUR S5 UR S5 UR S5 URUSS/5 UR[S55 URUS /5 g) 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 connectionrC) r!r+rkrrrrrrrPconnectionLostr rEs rDtest_unknownContentLength/HTTPClientParserTests.test_unknownContentLength)s # FD.$ 7 $%  *45.2kk+g&f%f% /0/L MN C5)rCcT/n[[SS[S5UR5n[ 5nUR U5 UR S5 /nURURlUR S5 URUS/5 URUS/5 g)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 abcrC) r!r+rkrrrrrrrPrEs rD%test_contentLengthAndTransferEncoding;HTTPClientParserTests.test_contentLengthAndTransferEncodingAs # FD.$ 7 $%  *45.2kk+   x( C5)rCc[5n[[SS[S5S5nUR U5 UR nUR [[555 [X[/5$)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+rkr_responseDeferredrrrr9ra)rVrmrresponseDeferreds rDtest_connectionLostBeforeBody3HTTPClientParserTests.test_connectionLostBeforeBody_sf $% #GFD.$$OQUV *#55(:(< =>#D=O.fakeBodyDataFinisheds $& &rCrh log_failurerx)rcreateWithCleanuprrr!r+rkrrzrZrrrrr assertEqualsrQassertIsInstancerr9flushLoggedErrors)rV logObserverrmrrreventrs rDtest_connectionLostWithError2HTTPClientParserTests.test_connectionLostWithErrorns +<.r)rC) r!r+rkrzrrrrr rYr1rVrr]s rDtest_noResponseAtAll*HTTPClientParserTests.test_noResponseAtAllsb $ GT>4 8:J   & & 12 01!!!%:;;rCcB[[SS[S5S5nURnUR [ 55 UR S5 UR[55 URU[5RUR[5$)z If a partial response was received and the connection is lost, the resulting error is L{ResponseFailed}, but not L{ResponseNeverReceived}. rrNcgrxr;rs rDr BHTTPClientParserTests.test_someResponseButNotAll..r)rC2) r!r+rkrzrrrrrr rYr0rZrrs rDtest_someResponseButNotAll0HTTPClientParserTests.test_someResponseButNotAlls $ GT>4 8:J   & & 12d# 01!!!^4@@  ! !>  rCc8Sn[[SS[S5S5nUR[ 55 UR U5 UR [USS5SL5 URUR[5 UR[[URR555S5 UR[[URR555S5 UR UR 5 g)za 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 rrNcgrxr;rs rDr CHTTPClientParserTests.test_1XXResponseIsSwallowed..TrCrr)r!r+rkrrrrgetattrrPrrrQrrrr,_everReceivedData)rVsample103Responsers rDtest_1XXResponseIsSwallowed1HTTPClientParserTests.test_1XXResponseIsSwalloweds   $ FD.$ 79I   12/0 *d;tCD 0 T("2"2"C"C"EFGK T("6"6"G"G"IJKQO 223rCcSnSn[[SS[S5S5nUR[ 55 UR X-5 UR URRS5 UR URR[055 UR UR[SS /055 UR URRS 5 g) zy 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 rrNcgrxr;rs rDr UHTTPClientParserTests.test_1XXFollowedByFinalResponseOnlyEmitsFinal..rrCrirr9r: r!r+rkrrrrPrrrr3r,rrVrfollowing200Responsers rD-test_1XXFollowedByFinalResponseOnlyEmitsFinalCHTTPClientParserTests.test_1XXFollowedByFinalResponseOnlyEmitsFinals    Y# FD.$ 79I   12/FG **//5 **22GBK@ --w8IF87T/UV **1137rCcSnSn[[SS[S5S5nUR[ 55 UR UU-U-U-5 UR URRS5 UR URR[055 UR UR[SS /055 UR URRS 5 g) zX It is acceptable for multiple 1XX responses to come through, all of which get ignored. rrrrNcgrxr;rs rDr KHTTPClientParserTests.test_multiple1XXResponsesAreIgnored..rrCrirr9r:rrs rD#test_multiple1XXResponsesAreIgnored9HTTPClientParserTests.test_multiple1XXResponsesAreIgnoreds    Y# FD.$ 79I   12   # #  **//5 **22GBK@ --w8IF87T/UV **1137rCc`[R"U[5nSn[[ SS[ S5S5nUR [55 URU5 URS[U55 USnURUSS 5 URUS S 5 g) z6 When a 1XX response is ignored, Twisted emits a log. rrrNcgrxr;rs rDr HHTTPClientParserTests.test_ignored1XXResponseCausesLog.. rrCrhr log_formatz#Ignoring unexpected {code} responserg) rrrr!r+rkrrrrrQ)rVrrrrs rD test_ignored1XXResponseCausesLog6HTTPClientParserTests.test_ignored1XXResponseCausesLogs+<r?r@rArrrrrrrrr"r.r3r<rArFrKrPrTrWrZr]rarhrkrorsrwr|rrrrrrrrBr;rCrDrrjs P#, : 8)&"H =44G G&8(6$*>62 $/$  /    @"@"#/J*0*< R3: < $44828<.rCrc0\rSrSrSrSrSrSrSrSr Sr g) SlowRequestiah 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}. rFc8[5UlUR$rx)rrrVrms rDwriteToSlowRequest.writeTo%s  }}rCcSUlgr stoppedrys rD stopWritingSlowRequest.stopWriting)  rC)rrN) r=r>r?r@rAmethodr persistentrrrBr;rCrDrrs" FGJrCrc"\rSrSrSrSrSrSrg) SimpleRequesti-z 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. Fc:URS5 [S5$)N SOME BYTES)writer rs rDrSimpleRequest.writeTo7s &t}rCr;N)r=r>r?r@rArrrBr;rCrDrr-sJrCrc\rSrSrSrSrSrSrSrSr Sr S(S jr S r S r S rSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSr S r!S!r"S"r#S#r$S$r%S%r&S&r'S'r(g ))HTTP11ClientProtocolTestsi<zQ Tests for the HTTP 1.1 client protocol implementation, L{HTTP11ClientProtocol}. c[5Ul[5UlURR UR5 g)zB Create an L{HTTP11ClientProtocol} connected to a fake transport. N)rrmr)rrrys rDsetUpHTTP11ClientProtocolTests.setUpBs.)*,.  $$T^^4rCcURR[55 URURR 5S5 g)zn L{HTTP11ClientProtocol.request} accepts a L{Request} and calls its C{writeTo} method with its own transport. rN)rrrrPrmrrys rD test_request&HTTP11ClientProtocolTests.test_requestJs5 mo. --/?rCc^TRR[55 U4SjnTRTRR[ 55[ 5nUR U5 U$)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. cZ>TRTRR5S5 gNrCrPrmrignoredrVs rD cbNotSent?HTTP11ClientProtocolTests.test_secondRequest..cbNotSentZ   T^^113S 9rC)rrrrYrr%rZrVrr]s` rDtest_secondRequest,HTTP11ClientProtocolTests.test_secondRequestRsT km, :   t}}44]_E~ V i rCc^TRR[[S555 U4SjnTR TRR [ 55[5nURU5 U$)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 transportcZ>TRTRR5S5 grrrs rDrLHTTP11ClientProtocolTests.test_requestAfterConnectionLost..cbNotSentirrC) rrrrr rYrrr%rZrs` rDtest_requestAfterConnectionLost9HTTP11ClientProtocolTests.test_requestAfterConnectionLostas\ $$W^O-L%MN :   t}}44]_E~ V i rCc^"SS5nTRRU"55nU4Sjn[TU[/5nUR U5 U$)z 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\rSrSrSrSrSrg)CHTTP11ClientProtocolTests.test_failedWriteTo..BrokenRequestixFc([[55$rx)rr9rs rDrKHTTP11ClientProtocolTests.test_failedWriteTo..BrokenRequest.writeTo{s.011rCr;Nr=r>r?r@rrrBr;rCrD BrokenRequestrxs J 2rCrc>TRTRR5 TRR [ [ S555 g)Nzyou asked for it)rrm disconnectingrrrrr rs rDrW>HTTP11ClientProtocolTests.test_failedWriteTo..cbFaileds8 OODNN88 9 MM ( (@R1S)T UrC)rrrcr9rZ)rVrr]rWs` rDtest_failedWriteTo,HTTP11ClientProtocolTests.test_failedWriteTopsP 2 2 MM ! !-/ 2 V *$4F3G H hrCcx"SS5nURRU"55n[X[/5$)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\rSrSrSrSrSrg)MHTTP11ClientProtocolTests.test_synchronousWriteToError..BrokenRequestiFc[5erxrrs rDrUHTTP11ClientProtocolTests.test_synchronousWriteToError..BrokenRequest.writeTos (**rCr;Nrr;rCrDrrs J +rCr)rrrcr9)rVrr]s rDtest_synchronousWriteToError6HTTP11ClientProtocolTests.test_synchronousWriteToErrors5 + + MM ! !-/ 2,T7I6JKKrCNcF[5nURRU5n[X[/5nUR UR 5 URR[[ 555 URUR 5 US:XaURRS5 U$US:Xa^URR[[555 UR[5nUR[!U5S5 U$U$)a  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. callbackNerrbackrh)rrrrer9rrrrrrrrrrFrrPrQ)rVmoderr]errorss rD*test_connectionLostDuringRequestGenerationDHTTP11ClientProtocolTests.test_connectionLostDuringRequestGenerations- MM ! !' * +D6H5I J ) $$W-?-A%BC ( :     % %d +Y     $ $W-F-H%I J++,EFF   S[! , rCc$URS5$)z If the request passed to L{HTTP11ClientProtocol} finishes generation successfully after the L{HTTP11ClientProtocol}'s connection has been lost, nothing happens. rrrys rD+test_connectionLostBeforeGenerationFinishedEHTTP11ClientProtocolTests.test_connectionLostBeforeGenerationFinisheds >>zJJrCc$URS5$)z If the request passed to L{HTTP11ClientProtocol} finished generation with an error after the L{HTTP11ClientProtocol}'s connection has been lost, nothing happens. rrrys rD)test_connectionLostBeforeGenerationFailedCHTTP11ClientProtocolTests.test_connectionLostBeforeGenerationFaileds >>yIIrCc^^[R"T[5mUU4SjnTRS5R U5$)z 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. c>TRS[T55 TSnTRSU5 TRUSS5 TRUSS5 g)NrhrrrzJError writing request, but not in valid state to finalize request: {state}rCONNECTION_LOST)rrQassertInrP)ignorerrrVs rDchecknHTTP11ClientProtocolTests.test_errorMessageOnConnectionLostBeforeGenerationFailedDoesNotConfuse..checksa   a[!1 2NE MM- /   l#/    U7^-> ?rCr)rrrrrZ)rVr rs` @rDEtest_errorMessageOnConnectionLostBeforeGenerationFailedDoesNotConfuse_HTTP11ClientProtocolTests.test_errorMessageOnConnectionLostBeforeGenerationFailedDoesNotConfusesA+<>yIUU   rCc^TRR[SS[S55nU4SjnUR U5 TRR S5 U$)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. rrNc>TRURS5 TRUR[55 TR TR R 5 TRTRRS5 g)Nri QUIESCENT) rPrrr3rrmrrr)rrVs rD cbRequestIHTTP11ClientProtocolTests.test_receiveSimplestResponse..cbRequests_   X]]C 0   X--wy 9 OODNN88 9   T]]00+ >rCs9HTTP/1.1 200 OK Content-Length: 0 Connection: close rrr+rkrZrrVr]rs` rDtest_receiveSimplestResponse6HTTP11ClientProtocolTests.test_receiveSimplestResponsesU MM ! !'&$"M N ? i  ""  rCc^TRR[SS[S55nU4SjnUR U5 TRR S5 U$)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. rrNc\>[SSS/05nTRURU5 g)Nr*rr)r3rPr)rrrVs rDrHHTTP11ClientProtocolTests.test_receiveResponseHeaders..cbRequests-66*:;^^[5m[5=nTlTRT5 TR TR S5 TR TR5 TR T/5 URUU4Sj5$)N%TRANSMITTING_AFTER_RECEIVING_RESPONSEc >TTR4$rxrrprs rDr oHTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone..cbResponse..*1668JrC) rrclosedDeferred deliverBodyrPrrrrZ)r whenFinishedr%rquiescentResultrVrms` @rD cbResponse]HTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone..cbResponse#sq$&A.6j 8L1+   #   X^^-T U OOI33 4   _b 1++,JK KrCc`>UupTRURS5 TRURS5 TRURS5 TRUR[ SS/055 TRUS5 TR RS5 g)Nrgrirjr*rfoobar)rPrrrrr3rr)resultrrrrVs rD cbAllResponse`HTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone..cbAllResponse.s#NH   X-- ?   X]]C 0   X__e 4   X--w6(7K/L M   T9 -    % %d +rC)rr)rrrrrrZ)rVr]r,r1rr+rrms` @@@@rD/test_receiveResponseBeforeRequestGenerationDoneIHTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone s#% '(>(>? *-   W %   L L j! , m$rCc[5n[5nX!lURU5 S[R -nUR [SS[S55nURSU-S-5 [X[/5$)za The connection is closed when the server respond with a header which is above the maximum line. rnrrNsHTTP/1.1 200 OK X-Foo: s X-Ignored: ignored ) rr)rrr MAX_LENGTHrr+rkrrar )rVrmrlongLiner]s rD"test_receiveResponseHeadersTooLong4H I ! "%  $Dn-=>>rCc^^[5mTRRT5nTRRS5 SnUR U5 UU4SjnUR U5 U$)z If response bytes are delivered to L{HTTP11ClientProtocol} before the request completes, calling C{connectionLost} on the protocol will result in protocol being moved to C{'CONNECTION_LOST'} state. s8HTTP/1.1 400 BAD REQUEST Content-Length: 9 tisk tiskc^^[5m[5=nTlTRT5 UR UU4Sj5$)Nc >TTR4$rxr#r$s rDr ڄHTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDone..cbResponse..jr'rC)rrr(r)rZ)rr*r%s` @rDr,rHTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDone..cbResponsefs:$&A.6j 8L1+   #++,JK KrCc>TRRS5 TRR[ [ 555 TR TRRS5 g)Nr )rrrrrrr9rPr)r rrVs rDr1uHTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDone..cbAllResponsensM    % %d + MM ( (1C1E)F G   T]]113D ErC)rrrrrZ)rVr]r,r1rs` @rDDtest_connectionLostAfterReceivingResponseBeforeRequestGenerationDone^HTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDoneWsd - MM ! !' * ""   L j! F m$rCc(^^[5m[5=nTlTRR [ SS[ S55nTRRS5 /nURUR5 TRU/5 TRRS5 USnURT5 TRRS5 TRRS5 UU4S jnURU5 U$) 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 rrrrc|>TRTRS5 TRR[5 g)Nr/)rPr closedReasonrOr/)rrrVs rDr1IHTTP11ClientProtocolTests.test_receiveResponseBody..cbAllResponses+   X]]I 6  ! ! & &| 4rC) rrr(rrr+rkrrZrrPr))rVr*requestDeferredr0rr1rs` @rDtest_receiveResponseBody2HTTP11ClientProtocolTests.test_receiveResponseBodyws ()19; x.--// FD.$ 7  "" A ##FMM2 $ ""5)!9X& ""6* ""6* 5   /rCcFURR[SS[S55nURR S5 /nUR UR 5 USn[5nURU5 URR S5 URR S5 URURS5 URR[[S 555 URR[ 5 g) 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 rrrr/z low-level transport disconnected)rrr+rkrrZrrr)rPrrrrr rErOr*rVrGr0rrs rDEtest_responseBodyFinishedWhenConnectionLostWhenContentLengthIsUnknown_HTTP11ClientProtocolTests.test_responseBodyFinishedWhenConnectionLostWhenContentLengthIsUnknowns--// FD.$ 7  ""#AB##FMM2!9')X& ""6* ""6*  2 $$ N#EF G  ""#45rCcXURR[SS[S55nURR S5 /nUR UR 5 USn[5nURU5 URR S5 URR S5 URURS5 URR[[555 [U[UR 5[["/5$) z 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 r/)rrr+rkrrZrrr)rPrrrrr9rarrEr2rKs rD4test_chunkedResponseBodyUnfinishedWhenConnectionLostNHTTP11ClientProtocolTests.test_chunkedResponseBodyUnfinishedWhenConnectionLosts--// FD.$ 7  "" L ##FMM2!9')X& ""?3 ""?3  2 $$W-?-A%BC# $x,,-0BI/N  rCc^TRR[SS[S55nTRR S5 [ TU[ /5nU4SjnURU5 U$)z 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 c>TRTRR5 TRURSR R S5 TRR[[S555 g)Nrsunparseable garbage goes herez it is done) rrmrrPrNrrrrrrr )rrVs rDrWLHTTP11ClientProtocolTests.test_parserDataReceivedException..cbFaileds_ OODNN88 9    A$$))+K  MM ( ( 1M)N OrC)rrr+rkrrar$rZ)rVrGr]rWs` rD test_parserDataReceivedException:HTTP11ClientProtocolTests.test_parserDataReceivedExceptionse--// FD.$ 7  ""#GH  E P hrCcURR[SS[S55nURRR nUR URUR 5 URR[[S555 UR URS5 [X[/5$)z When the HTTP response parser is disconnected, the L{TransportProxyProducer} which was connected to it as a transport is stopped. rrNzconnection done) rrr+rk_parserrmr- _producer_disconnectParserrr ra)rVrGrms rDtest_proxyStopped+HTTP11ClientProtocolTests.test_proxyStoppeds --// FD.$ 7 MM))33  Y00$..A ''?P0Q(RS Y00$7#DN;KLLrCc[5n[5nURU5 /n/nUR5R UR 5 UR5R UR 5 UR X44//45 URUR5 UR[[555 UR US/5 UR US/5 g)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)rabortrZrrPrrrrrr )rVrmrr1r2s rDtest_abortClosesConnection4HTTP11ClientProtocolTests.test_abortClosesConnections $% ') *  $$RYY/$$RYY/ "B8,  //0 (8 9: dV$ dV$rCcF[5n[5nURU5 UR[ [ 555 /nUR 5RUR5 URUS/5 URURS5 g)zq L{HTTP11ClientProtocol.abort} called after the connection is lost returns a C{Deferred} that fires immediately. Nr ) rr)rrrrr r^rZrrPrrVrmrr0s rDtest_abortAfterConnectionLost7HTTP11ClientProtocolTests.test_abortAfterConnectionLosts} $% ') *(8 9:$$V]]3 $( *;\rSrSrSrU4SjrU4SjrSrg)QHTTP11ClientProtocolTests.test_abortAfterResponseHeaders..BodyDestinationiPzH A body response protocol which immediately aborts the HTTP connection. c&>TR5 g)z Abort the HTTP connection. N)r^rs rDconnectionMade`HTTP11ClientProtocolTests.test_abortAfterResponseHeaders..BodyDestination.connectionMadeVs rCc(>TRU5 g)z` Make the reason for the losing of the connection available to the unit test via C{testResult}. N)r)rVrS testResults rDrr`HTTP11ClientProtocolTests.test_abortAfterResponseHeaders..BodyDestination.connectionLost\s ""6*rCr;N)r=r>r?r@rArorrrB)rrrsrDBodyDestinationrmPs   !  + +rCrtc>URT"55 TRTR5 TR[ [ 555 g)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)rrrrrr )rrtrrVrms rDr)MHTTP11ClientProtocolTests.test_abortAfterResponseHeaders..deliverBodycs>  !2 3 OOI33 4  # #GN,<$= >rCcF>TRUR[5 grx)rrr.)errorrVs rD checkErrorLHTTP11ClientProtocolTests.test_abortAfterResponseHeaders..checkErrorms  ! !%..( ;rC) rr)rrr+rkrrrrZrarr2) rVr0r)ryr[rtrrrrms ` @@@@rDtest_abortAfterResponseHeaders8HTTP11ClientProtocolTests.test_abortAfterResponseHeaders<s$D1 ') *!!'&$"MNUVZ  + +h +& ? ? < ;'' *0)< ##J//rCc f^^^/mUUU4Sjn[5n[U5mTRU5 TR[ SS[ SSS95nTR S5 TRT/5 /nURUR5 USn[5n[5Ul URRU4S j5 URU5 TR S 5 URR[ 5 TRTTS /5 TRTR"S5 TRTR$S5 TRTR&S5 TRTR(S5 TRTR*S5 g) 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. c>TRUT5 TRURS5 TRU5 gNrrPrrr%rr+rVs rDrHHTTP11ClientProtocolTests.test_quiescentCallbackCalled..callback5   Q )   QWWk 2  " "1 %rCrrNTrs&HTTP/1.1 200 OK Content-length: 3 rc&>TRS5$)N response doner )rr+s rDr HHTTP11ClientProtocolTests.test_quiescentCallbackCalled..s..?rCrvr)rr)rrr+rkrrPrZrrrr(r)rErOr/rX_finishedRequest_currentRequest_transportProxyrz) rVrrmrGr0r bodyProtocolrr+s ` @@rDtest_quiescentCallbackCalled6HTTP11ClientProtocolTests.test_quiescentCallbackCalledvsx & $% '1 *"** FD.$4 H  UV "-##FMM2!9,- &.j ###// ?  \*f%!!&&|4 8_*EF ))40 22D9 1148 1148 33T:rCc ^^^/mUUU4Sjn[5n[U5mTRU5 TR[ SS[ SSS95nTR S5 TRU5nTRURS5 TR[T5S 5 TRURS 5 g) 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. c>TRUT5 TRURS5 TRU5 grrrs rDr]HTTP11ClientProtocolTests.test_transportProducingWhenQuiescentAfterFullBody..callbackrrCrrNTrs)HTTP/1.1 200 OK Content-length: 3 BBBDEFERRED_CLOSErhr) rr)rrr+rkrsuccessResultOfrPrrQr)rVrrmrGrrr+s` @@rD1test_transportProducingWhenQuiescentAfterFullBodyKHTTP11ClientProtocolTests.test_transportProducingWhenQuiescentAfterFullBodys & $% '1 *"** FD.$4 H    ''8 *:; _-q1 00+>rCc ^^^/mUUU4Sjn[5n[U5mTRU5 TR[ SS[ SSS95nUR TR5 TRS5 TR[T5S5 TRTS T5 TRTS [5 g) zp The quiescentCallback is called before the request C{Deferred} fires, in cases where the response has no body. c>TRUT5 TRURS5 TRU5 grrrs rDrUHTTP11ClientProtocolTests.test_quiescentCallbackCalledEmptyResponse..callbackrrCrrNTr&HTTP/1.1 200 OK Content-length: 0 rrrh)rr)rrr+rkrZrrrPrQr-rr.)rVrrmrGrr+s` @@rD)test_quiescentCallbackCalledEmptyResponseCHTTP11ClientProtocolTests.test_quiescentCallbackCalledEmptyResponses  & $% '1 *"** FD.$4 H  ##O$:$:;UV _-q1 _Q/: oa0(;rCc /n[5n[UR5nURU5 UR [ SS[ SSS95nURS5 /nURUR5 USn[5nURU5 URR[5 URU/5 URUR 5 g)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. rrNTrs9HTTP/1.1 200 OK Content-length: 0 Connection: close rrr)rrrr+rkrrZrr)rErOr/rPrrrVr+rmrrGr0rrs rDtest_quiescentCallbackNotCalled9HTTP11ClientProtocolTests.test_quiescentCallbackNotCalleds #% '(>(>? *"** FD.$4 H    ##FMM2!9+- \*!!&&|4 "-  //0rCc /n[5n[UR5nURU5 UR [ SS[ SSS95nURS5 /nURUR5 USn[5nURU5 URR[5 URU/5 URUR 5 g)z If the request was non-persistent (i.e. sent C{Connection: close}), the C{quiescentCallback} is not called and the connection is lost. rrNFrrrrrs rD1test_quiescentCallbackNotCalledNonPersistentQueryKHTTP11ClientProtocolTests.test_quiescentCallbackNotCalledNonPersistentQuerys #% '(>(>? *"** FD.$5 I  UV##FMM2!9+- \*!!&&|4 "-  //0rCc Sn[R"U[5n[5n[ U5nUR U5 UR [SS[SSS95nURS5 /nURUR5 USn[5nURU5 URR[ 5 UR#S [%U55 USn U S n UR'U R([*5 UR-[*5 UR/UR05 g) z` If C{quiescentCallback} throws an exception, the error is logged and protocol is disconnected. c[5erx)ZeroDivisionError)r%s rDrHHTTP11ClientProtocolTests.test_quiescentCallbackThrows..callback5s #% %rCrrNTrrrrhr)rrrrr)rrr+rkrrZrrr)rErOr/rrQrrrrrr) rVrrrmrrGr0rrrrs rDtest_quiescentCallbackThrows6HTTP11ClientProtocolTests.test_quiescentCallbackThrows/s  &+<2BCCrCc^^^[5n[5nURU5 [U5mSS0mU4SjmUU4SjnUTlUR [ SS[T55nTRRS5 UR5 URUR5 URTS5 [X[/5$)z 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. cancelledFc>STS'g)NTrr;)rnonLocals rDrJHTTP11ClientProtocolTests.assertCancelDuringBodyProduction..cancels $(H[ !rCcJ>UTl[T5TlTR$rxconsumerrr)rrproducers rDstartProducingRHTTP11ClientProtocolTests.assertCancelDuringBodyProduction..startProducings$ (H  ( 0H $$ $rCPOST/barsxxxxx)rr)rStringProducerrrr+rkrrrrrrcr) rVproducerLengthrmrrr0rrrs @@@rD assertCancelDuringBodyProduction:HTTP11ClientProtocolTests.assertCancelDuringBodyProductionss$% ') *!.1' ) % #1!!''7NH"UV)   ../ -.,TN;KLLrCc$URS5$)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. )rrys rDtest_cancelDuringBodyProduction9HTTP11ClientProtocolTests.test_cancelDuringBodyProductions44R88rCc,UR[5$)z 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. )rrrys rD&test_cancelDuringChunkedBodyProduction@HTTP11ClientProtocolTests.test_cancelDuringChunkedBodyProductions44^DDrC)rrmrx))r=r>r?r@rArrrrrrrrrrrrr3r8rArHrLrPrUr[rarerhr{rrrrrrrrrrrrBr;rCrDrr<s 5@  4L @KJ 0.$0d?4@'R6: @8 M%* =G 80t7;r,?\<41>12!1F "D M>9ErCrc:\rSrSrSrSrSrSrSrSr Sr S r g ) ria 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}. FcXlgrx)r)rVrs rD__init__StringProducer.__init__s rCcDXl[5UlUR$rxr)rVrs rDrStringProducer.startProducings   }}rCcSUlgr rrys rD stopProducingStringProducer.stopProducingrrCcgrxr;rys rDpauseProducingStringProducer.pauseProducing rCcgrxr;rys rDresumeProducingStringProducer.resumeProducingrrC)rrrrN) r=r>r?r@rArrrrrrrBr;rCrDrrs' G   rCrc\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrSrSrSSjrSrSrSrSrSrSrg) RequestTestsiz Tests for L{Request}. c"[5Ulgrx)rrmrys rDrRequestTests.setUps (*rCc[SS[S5RUR5 UR URR 5S5 g)zS L{Request.writeTo} formats the request data and writes it to the given transport. rrNs8GET / HTTP/1.1 Connection: close Host: example.com r+rkrrmrPrrys rDtest_sendSimplestRequest%RequestTests.test_sendSimplestRequestsD nd3;;DNNK  NN "  rCc[SS[SSS9nURUR5 UR URR 5S5 g)z? A pesistent request does not send 'Connection: close' header. rrNTrs%GET / HTTP/1.1 Host: example.com r)rVreqs rD"test_sendSimplestPersistentRequest/RequestTests.test_sendSimplestPersistentRequestsGfdNDTJ DNN#  NN " B rCcv[SS/S/S.5n[SSUS5RUR5 URR 5R S5nUR US S 5 UR US SS S /5 US US S2 UR5 UR U/S Q5 g)zN L{Request.writeTo} formats header data and writes it to the given transport. rrrIr*rHr/fooNrrGET /foo HTTP/1.1rC)Connection: closesHost: example.comrr)r3r+rrmrsplitrPsort)rVrliness rDtest_sendRequestHeaders$RequestTests.test_sendRequestHeaderss ff%5@PQR$/77G$$&,,W5 q#78 rsc3Z0 !HeBCj    V rCc[Hn[U/S/S.5n[5n[SSUS5R U5 UR 5R S5nURUSS5 URUS SS S /5 US US S2 URS 5 URS 5 URUS [-/5 M g)zM Linear whitespace in request header values is replaced with a single space. sexample.invalidrrrNrrrrrCrsHost: example.invalidsX-Foo: ) r6r3rr+rrrrPremover7)rV componentrrmrs rD-test_sanitizeLinearWhitespaceInRequestHeaders:RequestTests.test_sanitizeLinearWhitespaceInRequestHeaderss 9I)@R?STUG')I FGWd 3 ; ;I FOO%++G4E   U1X'; <   U23Z#s 4a%* LL- . LL1 2   UZ.%@$A B9rCc[[5n[SS[U5nUR UR 5 UR URS5 URUR RU5 URUR R5 URUR R5S5 UR R5 URRS5 URRS5 UR R#S5 URUR RS5 URUR R5S5 g)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+rkrrmassertNotIdenticalrr-rr streamingrPrclearrrrrVrrs rDtest_sendChunkedRequestBody(RequestTests.test_sendChunkedRequestBody s  ".1'7NHE'  1 148 T^^44h? 001  NN "   ) *""4( T^^44d;  NN " P rCcT^[[5n[SS[U5nUR TR 5nTR R 5 URR[55 U4SjnTRU[5nURU5 U$)ab 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. rrc>TRTRR5S5 TRTRRS5 gr)rPrmrr-rrs rDrWCRequestTests.test_sendChunkedRequestBodyWithError..cbFailed<s:   T^^113S 9  !8!8$ ?rC) rrr+rkrrmrrrr9rYrZ)rVrr writeDeferredrWr]s` rD$test_sendChunkedRequestBodyWithError1RequestTests.test_sendChunkedRequestBodyWithError-s".1'7NHE7  !!"4"67 @   }.@ A hrCc[S5n[SS[U5nURUR5 UR UR S5 URURRU5 URURR5 URURR5S5 URR5 UR RS5 URR!S5 URURRS5 URURR5S5 g)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 rv)rr+rkrrmrrr-rrrrPrrrrrrs rDtest_sendRequestBodyWithLength+RequestTests.test_sendRequestBodyWithLengthDs "!$'7NHE'  1 148 T^^44h? 001  NN "   '""4( T^^44d; --/8rCc[US[S5nURUR5 UR URR 5US-5 g)z 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)rVrrs rD_sendRequestEmptyBodyWithLength,RequestTests._sendRequestEmptyBodyWithLengthasO&'>4@'  NN "   rCc&URS5 g)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. sPUTNrrys rDtest_sendPUTRequestEmptyBody)RequestTests.test_sendPUTRequestEmptyBodyvs ,,V4rCc&URS5 g)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. rNr rys rDtest_sendPOSTRequestEmptyBody*RequestTests.test_sendPOSTRequestEmptyBody~s ,,W5rCcV[S5n[SS[U5nURUR5nUR R S5 URRS5 URURRS5 URU[5$)z 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+rkrrmrrrrr-rrYr'rVrrrs rD#test_sendRequestBodyWithTooFewBytes0RequestTests.test_sendRequestBodyWithTooFewBytess"!$'7NHE7 &""4( T^^44d;!!-AArCc^^^[S5m[SS[T5nURTR5nTR R S5 TRTR5 TR R S5 TRTR5 TRTRRS5 UUU4SjnTRU[5nURU5 U$)a 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. rrrrcdNcH>TRTRR5S5 TRR5 TR [ TR RS5 T"T5 TRTRR5S5 g)NsQPOST /bar HTTP/1.1 Connection: close Content-Length: 3 Host: example.com absefrC)rPrmrrrr rr)rfinisherrrVs rDrWCRequestTests._sendRequestBodyWithTooManyBytesTest..cbFaileds   $$&  NN "   k8+<+<+B+BE J X    T^^113S 9rC)rr+rkrrmrrrrrr-rrYr'rZ)rVrrrrWr]rs`` @rD$_sendRequestBodyWithTooManyBytesTest1RequestTests._sendRequestBodyWithTooManyBytesTests"!$'7NHE7 & ))*& (() T^^44d; ::   }o > hrCc*SnURU5$) 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. c:URRS5 grxrrrs rDrCRequestTests.test_sendRequestBodyWithTooManyBytes..finisher    & &t ,rC)rrVrs rD$test_sendRequestBodyWithTooManyBytes1RequestTests.test_sendRequestBodyWithTooManyBytess -88BBrCcl^^[R"T[5mUU4SjnTRU5$)rc$>URR[55 TSnTRSU5 USnTR UR [5 TR [5nTR[U5S5 g)Nrrrh) rrr9r rrrrPrQ)rrrrrrVs rDrHRequestTests.test_sendRequestBodyErrorWithTooManyBytes..finishersv    % %&8&: ;NE MM- /m$A  ! !!''+= >++,>?F   S[! ,rC)rrrr)rVrrs` @rD)test_sendRequestBodyErrorWithTooManyBytes6RequestTests.test_sendRequestBodyErrorWithTooManyBytess0+<'>F --/5rCcRSnURURU5[5$)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}. c:URRS5 grxrr s rDrPRequestTests.test_sendRequestBodyFinishedEarlyThenTooManyBytes..finisher- r"rC)rYr1r'r#s rD1test_sendRequestBodyFinishedEarlyThenTooManyBytes>RequestTests.test_sendRequestBodyFinishedEarlyThenTooManyBytes% s- -!!  > >x H   rCcRSnURURU5[5$)a  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. cJURR[55 grx)rrr9r s rDrORequestTests.test_sendRequestBodyErroredEarlyThenTooManyBytes..finisher= s    % %&8&: ;rC)rYr1r9r#s rD0test_sendRequestBodyErroredEarlyThenTooManyBytes=RequestTests.test_sendRequestBodyErroredEarlyThenTooManyBytes5 s- <!!  > >x H   rCNc[[5n[SS[U5nUR UR 5nUR RU5 UR R5 UR[URRS5 URUR R5S5 U$)z 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. rrrrC)rrr+rkrrmrrrrr rrrPr)rV_withrrrs rD0test_sendChunkedRequestBodyFinishedThenWriteMore=RequestTests.test_sendChunkedRequestBodyFinishedThenWriteMoreE s".1'7NHE7 ""5)  +x'8'8'>'>G --/5rCcrUR[[555nURU[5$)z 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. )r?rr9rY)rVr]s rD9test_sendChunkedRequestBodyFinishedWithErrorThenWriteMoreFRequestTests.test_sendChunkedRequestBodyFinishedWithErrorThenWriteMoreV s6  A A &( ) !!!%788rCc[S5n[SS[U5nURUR5nUR URR U5 URURR5 URRS5 URURR5S5 URURR5 URR![#[%555 URURR5 UR URR S5 UR'U[$5$)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+rkrrmr-rrrrrrPrrrrrrr9rYrs rDtest_sendRequestBodyWithError*RequestTests.test_sendRequestBodyWithErrorb s"!$'7NHE7  T^^44h? 001&  NN "   556!!'*<*>"?@ 556 T^^44d;!!-1CDDrCc [SS[05S5nUR[URUR 5 UR UR R5S5 [SS[SSS/05S5nUR[URUR 5 UR UR R5S5 g)z L{Request.writeTo} raises L{BadHeaders} if there is not exactly one I{Host} header and writes nothing to the given transport. rrNrCsHostrIs example.org)r+r3rrrrmrPr)rVrs rDtest_hostHeaderRequired$RequestTests.test_hostHeaderRequired s &$ T: *goot~~F --/5 D'7^^,L"MNPT  *goot~~F --/5rCc[S5n[SS[U5nURUR5 UR UR 5 UR5 URUR 5 g)zK L{Request.stopWriting} calls its body producer's C{stopProducing} method. rrrN) rr+rkrrmrrrrrs rDtest_stopWritingRequestTests.test_stopWriting s` "!$&$A' ))* (()rCc[R"U[5n[S5nSnX2l[ SS[ U5nURUR5 UR5 UR[UR[55S5 URS[U55 USnURSU5 USnUR!UR"[5 g) z~ If the body producer's C{stopProducing} method raises an exception, L{Request.stopWriting} logs it and does not re-raise it. rc[S5eNzstopProducing is bustedrr;rCrDbrokenStopProducingBRequestTests.test_brokenStopProducing..brokenStopProducing s$%>? ?rCrrrhrrN)rrrrrr+rkrrmrrPrQrr9rr rr)rVrrrQrrrs rDtest_brokenStopProducing%RequestTests.test_brokenStopProducing s +<r?r@rArrrrrrrrrr rrrr$r)r.r1r6r;r?rBrFrIrLrSrBr;rCrDrrs+     "C" B.9: *56 B?B CC(M6&  " 9%EN 6 *;rCrcL\rSrSrSrSrSrSrS SjrSr Sr S r S r S r g )LengthEnforcingConsumerTestsi z' Tests for L{LengthEnforcingConsumer}. c[5Ul[S5Ul[ 5Ul[ URUR UR5Ulg)Nr)rr0rrrrmr#enforcerrys rDr"LengthEnforcingConsumerTests.setUp s@j &r* (*/ MM4>>4;;  rCcLURRS5 URURR 5S5 URR 5 URRS5 URURR 5S5 g)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. rvsdefN)rXrrPrmrrrys rD test_write'LengthEnforcingConsumerTests.test_write sr F# --/8  F# --/8rCcURRS5 UR[URR5 g)z L{LengthEnforcingConsumer._noMoreWritesExpected} raises L{WrongBodyLength} if it is called before the indicated number of bytes have been written. s xxxxxxxxxN)rXrrr'_noMoreWritesExpectedrys rDtest_finishedEarly/LengthEnforcingConsumerTests.test_finishedEarly s0 H% /4==+N+NOrCcURRS5 URURR5 URRS5 UR URR5 U(aURR 5 URUR[5$)a 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) rXrrrrrr^rYr0r')rV_unregisterAfters rDtest_writeTooMany.LengthEnforcingConsumerTests.test_writeTooMany s I& ../ D!  --.  MM / / 1!!$++??rCcXURRS5 URR5 URURR 5 UR [URRS5 URURR 5 g)z If L{LengthEnforcingConsumer.write} is called after L{LengthEnforcingConsumer._noMoreWritesExpected}, it calls the producer's C{stopProducing} method and raises L{ExcessWrite}. rbrcN) rXrr^rrrrr rrys rDtest_writeAfterNoMoreExpected:LengthEnforcingConsumerTests.test_writeAfterNoMoreExpected sp I& ++- ../ +t}}':':DA  --.rCc$URS5$)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)rerys rDtest_finishedLate.LengthEnforcingConsumerTests.test_finishedLate s %%d++rCcURRS5 URURR5S5 g)z If L{LengthEnforcingConsumer._noMoreWritesExpected} is called after the correct number of bytes have been written it returns L{None}. rbN)rXrr-r^rys rD test_finished*LengthEnforcingConsumerTests.test_finished s3 I& T]]@@BDIrCc^U4SjnUTRlU4SjnTR5nURU5 U$)a 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}. cX>[RTR5 [S5erP)rrrr9rysrDrQRLengthEnforcingConsumerTests.test_stopProducingRaises..brokenStopProducing s!  ( ( 7$%>? ?rCcb>TR[TR[55S5 g)Nrh)rPrQrr9rs rD cbFinishedILengthEnforcingConsumerTests.test_stopProducingRaises..cbFinished s$   S!7!78J!KLa PrC)rrrerZ)rVrQrtr]s` rDtest_stopProducingRaises5LengthEnforcingConsumerTests.test_stopProducingRaises s> @': # Q  " " $ j!rC)rXrr0rmN)F)r=r>r?r@rArr[r_rerhrkrnrvrBr;rCrDrVrV s2  9P@ /,JrCrVc*\rSrSrSrSrSrSrSrg)RequestBodyConsumerTestsi! z Tests for L{ChunkedEncoder} which sits between an L{ITransport} and a request/response body producer and chunked encodes everything written to it. c dUR[[[[ 5555 g)z3 L{ChunkedEncoder} instances provide L{IConsumer}. N)rrr rrrys rDtest_interface'RequestBodyConsumerTests.test_interface( s  Y?P0QRSrCc[5n[U5nURS5 URUR 5S5 UR 5 URS5 URUR 5S5 g)ze L{ChunkedEncoder.write} writes to the transport the chunked encoded form of the bytes passed to it. rrOsxxxxxxxxxxxxxxxxs10 xxxxxxxxxxxxxxxx N)rrrrPrr)rVrmencoders rDr[#RequestBodyConsumerTests.test_write. sg $%  + f *O< i  *,KLrCcl[5n[5n[U5nURUS5 UR UR U5 UR UR5 UR5 UR UR S5 URUR5S5 g)z 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 ) rrrregisterProducerr-rrrunregisterProducerrPr)rVrmrr~s rDtest_producerRegistration2RequestBodyConsumerTests.test_producerRegistration; s$% 8 +  40 Y//:  ++,""$ Y//6 *L9rCr;N) r=r>r?r@rAr{r[rrBr;rCrDryry! s T M:rCrycB\rSrSrSrSrSrSrSrSr Sr S r S r g ) TransportProxyProducerTestsiM zb Tests for L{TransportProxyProducer} which proxies the L{IPushProducer} interface of a transport. cTUR[[[S555 g)z? L{TransportProxyProducer} instances provide L{IPushProducer}. N)rrr r&rys rDr{*TransportProxyProducerTests.test_interfaceS s  ]4J44PQRrCc[5n[U5nURURU5 UR 5 URURS5 g)zf L{TransportProxyProducer.stopProxying} drops the reference to the wrapped L{IPushProducer} provider. N)rr&r-rY stopProxyingrVrmproxys rD%test_stopProxyingUnreferencesProducerATransportProxyProducerTests.test_stopProxyingUnreferencesProducerY sJ $% &y1 U__i8  U__d3rCcv[5nUR5 [U5nURURS5 UR 5 URURS5 UR5 UR 5 UR 5 URURS5 g)z L{TransportProxyProducer.resumeProducing} calls the wrapped transport's C{resumeProducing} method unless told to stop proxying. rDrN)rrr&rPrrrrs rDtest_resumeProducing0TransportProxyProducerTests.test_resumeProducingd s $%   "&y1 00(;  00+>  "   00(;rCcV[5n[U5nURURS5 UR 5 URURS5 UR 5 UR 5 UR 5 URURS5 g)z L{TransportProxyProducer.pauseProducing} calls the wrapped transport's C{pauseProducing} method unless told to stop proxying. rrDN)rr&rPrrrrrs rDtest_pauseProducing/TransportProxyProducerTests.test_pauseProducingz s $% &y1 00+>  00(;!!#   00+>rCc`[5n[U5nURURS5 UR 5 URURS5 [5n[U5nUR 5 UR 5 URURS5 g)z} L{TransportProxyProducer.stopProducing} calls the wrapped transport's C{stopProducing} method unless told to stop proxying. rrN)rr&rPrrrrs rDtest_stopProducing.TransportProxyProducerTests.test_stopProducing s $% &y1 00+>  00)<#% &y1   00+>rCcl[5n[5nURU5 X!l[ U5nUR UR 5 URURS5 UR5 URURS5 URUR 5 g)z[ L{TransportProxyProducer.loseConnection} calls the wrapped transport's C{loseConnection}. rN) rrrrr&r connectedrPrloseConnectionrrVrmrrs rD test_loseConnectionWhileProxying  00+> ,,-rCc[5n[5nURU5 X!l[ U5nUR 5 UR UR5 UR5 UR UR5 g)zU L{TransportProxyProducer.loseConnection} does nothing when the proxy is not active. N) rrrrr&rrrrrs rDtest_loseConnectionNotProxying:TransportProxyProducerTests.test_loseConnectionNotProxying sp 56 ') *%&y1   ++,   ++,rCr;N) r=r>r?r@rAr{rrrrrrrBr;rCrDrrM s+ S 4<,?*?(.*-rCrcr\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrg) ResponseTestsi z Tests for L{Response}. ch[[55nUR[[U55 g)z- L{Response} instances provide L{IResponse}. N)rnrrrr5rVrs rDtest_verifyInterface"ResponseTests.test_verifyInterface s$)):;  Y9:rCc@^/m[5n"U4SjS[5nU"5n[U5nURU5 TunUR 5 UR UR S5 UR5 UR UR S5 g)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. c">\rSrSrU4SjrSrg)7ResponseTests.test_makeConnection..SomeProtocoli c(>TRU5 grxr )rVr producerss rDrFResponseTests.test_makeConnection..SomeProtocol.makeConnection s  *rCr;Nr=r>r?r@rrB)rsrD SomeProtocolr s  + +rCrrDrN)rrrnr)rrPrr)rVrmrrr theProducerrs @rDtest_makeConnection!ResponseTests.test_makeConnection s  #%  +8 + >(3X&! ""$ 00(;##% 00+>rCc^/m"U4SjS[5nU"5n[[55nURU5 UR S5 UR TS/5 g)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. c">\rSrSrU4SjrSrg)5ResponseTests.test_dataReceived..ListConsumeri c(>TRU5 grxr rVrrs rDrBResponseTests.test_dataReceived..ListConsumer.dataReceived  T"rCr;Nr=r>r?r@rrBrsrD ListConsumerr  # #rCrrN)rrnrr)rrP)rVrrrrs @rDtest_dataReceivedResponseTests.test_dataReceived sZ  #8 # >():;X&""6* )rCcB^/m"U4SjS[5nU"5n[[55nURU5 UR 5 TSR [ 5 UR[T5S5 URURS5 g)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. c">\rSrSrU4SjrSrg)7ResponseTests.test_connectionLost..ListConsumeri c(>TRU5 grxr )rVrSlosts rDrrFResponseTests.test_connectionLost..ListConsumer.connectionLost s F#rCr;N)r=r>r?r@rrrB)rsrDrr s  $ $rCrrrhN) rrnrr)rrOr/rPrQr- _bodyProtocol)rVrrrrs @rDtest_connectionLost!ResponseTests.test_connectionLost s $8 $ >():;X&""$ Q \" TA& X33T:rCcJ^/m"U4SjS[5nU"5n[[55nURS5 URS5 UR U5 URS5 UR T/SQ5 UR URS5 g)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. c">\rSrSrU4SjrSrg)8ResponseTests.test_bufferEarlyData..ListConsumeri! c(>TRU5 grxr rs rDrEResponseTests.test_bufferEarlyData..ListConsumer.dataReceived" rrCr;NrrsrDrr! rrCrrrr)rrrN)rrnrrr)rPr- _bodyBuffer)rVrrrrs @rDtest_bufferEarlyData"ResponseTests.test_bufferEarlyData s  #8 # >():;""6*""6*X&""6*  89 X1148rCc[[55nUR[55 UR [ UR[55 g)zJ L{Response.deliverBody} raises L{RuntimeError} if called more than once. N)rnrr)rrrrs rD test_multipleStartProducingFails.ResponseTests.test_multipleStartProducingFails0 s; )):;XZ( ,(<(^/m"U4SjS[5n[5nUR5 U"5n[U5nUR UR S5 UR U5 UR TS/5 UR UR S5 g)z~ L{Response.deliverBody} resumes the HTTP connection's transport after passing it to the consumer's C{makeConnection} method. c">\rSrSrU4SjrSrg)9ResponseTests.test_transportResumed..ListConsumerip c<>TRUR5 grx)rr)rVrmtransportStates rDrHResponseTests.test_transportResumed..ListConsumer.makeConnectionq s%%i&=&=>rCr;Nr)rsrDrrp s  ? ?rCrrDrN)rrrrnrPrr))rVrrmrrrs @rDtest_transportResumed#ResponseTests.test_transportResumedi s  ?8 ?$%   ">(3 00(;X& (4 00+>rCc>[5n[U5nURS5 URS5 UR5 [ 5nUR U5 UR URS5 URR[5 g)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. rrr/N) rrnrrrr)rPrrErOr/rVrmrrs rD)test_bodyDataFinishedBeforeStartProducing7ResponseTests.test_bodyDataFinishedBeforeStartProducing} s|$% (3""6*""6*""$')X&  2""<0rCc[5n[U5n[5nURU5 UR UR S5 UR [[555 URR[5 g)z 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. CONNECTEDN) rrnrr)rPrrrr9rErOrs rD#test_finishedWithErrorWhenConnected1ResponseTests.test_finishedWithErrorWhenConnected sn$% (3')X& +6""7+=+?#@A""#56rCc[5n[U5nURURS5 UR [ [ 555 [5nURU5 URR[ 5 g)z 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. INITIALN) rrnrPrrrr9rr)rErOrs rD!test_finishedWithErrorWhenInitial/ResponseTests.test_finishedWithErrorWhenInitial sn$% (3 )4""7+=+?#@A')X&""#56rCr;N)r=r>r?r@rArrrrrrrrrrrrrrrrBr;rCrDrr sX;?,*&;29.JJLLDD?(1$7&7rCrN)_rAtypingrzope.interfacerzope.interface.verifyrtwisted.internet.deferrrrr twisted.internet.errorr r twisted.internet.interfacesr r twisted.internet.protocolrtwisted.internet.testingrrrrtwisted.loggerrtwisted.protocols.basicrtwisted.python.failurertwisted.trial.unittestrtwisted.web._newclientrrrrrrrrrr r!r"r#r$r%r&r'r(twisted.web.clientr)r*r+r,r-r.r/r0r1twisted.web.httpr2twisted.web.http_headersr3twisted.web.iwebr4r5twisted.web.test.requesthelperr6r7 Exceptionr9rFrkr^rarcrernrprrrrrrrrrrVryrrr;rCrDr s&.JJA@. .0*+(   ',5  'N#345% PTL6(6BSMSMl+;X.>h .Hh .V0  f Ef ER ]     Fp;8p;fb8bJ):x):X{-({-|h7Hh7rC