tfʷdZddlmZddlmZddlmZddlmZm Z m Z m Z ddl m Z mZddlmZmZddlmZdd lmZmZmZmZdd lmZdd lmZdd lmZdd lm Z ddl!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mm?Z?ddl@mAZAddlBmCZCmDZDddlEmFZFmGZGGddeHZIGddeHZJeAddgiZKdZLdZMdZNdZOdZPGdd e ZQGd!d"ZRGd#d$eRe ZSGd%d&eRe ZTGd'd(e ZUGd)d*ZVGd+d,ZWGd-d.e ZXeeCGd/d0ZYGd1d2e ZZGd3d4e Z[Gd5d6e Z\Gd7d8e Z]Gd9d:e Z^d;S).cbFailedns [99  LFD KK            73; 7 7 7 7 7    r@) assertFailure addCallback)rRdeferredmainTyperQrSds` ` rAassertWrapperExceptionTypesrYUsP2 8X..AMM( Hr@c0t||t|S)zo A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{ResponseFailed}. )rYr0rRrVrQs rAassertResponseFailedr\}s 'tX~{ S SSr@c0t||t|S)zx A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{RequestGenerationFailed}. )rYr,r[s rAassertRequestGenerationFailedr^s ' h/  r@c0t||t|S)zz A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{RequestTransmissionFailed}. )rYr-r[s rAassertRequestTransmissionFailedr`s ' h1;  r@c2tdddt|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. sHTTPrcOK)r._boringHeaders) transports rAjustTransportResponserhs OS% K KKr@ceZdZdZdZdS)MakeStatefulDispatcherTestsz. Tests for L{makeStatefulDispatcher}. c0Gdd}|}||dd|_||dd|_|t|jdS)z A method defined with L{makeStatefulDispatcher} invokes a second method based on the current state of the object. c<eZdZdZdZedeZdZdZdS)CMakeStatefulDispatcherTests.test_functionCalledByState..FooAcdSNr?rRs rAbarzGMakeStatefulDispatcherTests.test_functionCalledByState..Foo.barsr@quuxcdS)Nar?rqs rA_quux_AzKMakeStatefulDispatcherTests.test_functionCalledByState..Foo._quux_Asr@cdS)Nbr?rqs rA_quux_BzKMakeStatefulDispatcherTests.test_functionCalledByState..Foo._quux_Brwr@N)r;r<r=_staterrr(rvrzr?r@rAFoormsZF   )(55C        r@r|ruBryCN)rLrrr{ assertRaises RuntimeError)rRr|statefuls rAtest_functionCalledByStatez6MakeStatefulDispatcherTests.test_functionCalledByStates        355 --- --- , 55555r@N)r;r<r=r>rr?r@rArjrjs-66666r@rjcjeZdZUdZdZeeed<dZdZ dZ dZ dZ d Z d Zd Zd Zd ZdS)_HTTPParserTestszt Base test class for L{HTTPParser} which is responsible for the bulk of the task of parsing HTTP bytes. Nsepchg}t}|j|_|t ||jt|d|j z||dg||jtdS)zj L{HTTPParser} calls its C{statusReceived} method when it receives a status line. HTTP/1.1 200 OKN) r"appendstatusReceivedmakeConnectionrrLstater dataReceivedrr)rRstatusprotocols rAtest_statusCallbackz$_HTTPParserTests.test_statusCallbacks <<"(- 1 1222 000048;<<< "4!5666 00000r@ci}t}|j|_|t |d|jz||fS)Nr)r" __setitem__headerReceivedrrrrrRheaderrs rA_headerTestSetupz!_HTTPParserTests._headerTestSetups\<<"("4 1 1222048;<<<xr@c|\}}|d|jz||j||ddi||jt dS)ze L{HTTPParser} calls its C{headerReceived} method when it receives a header. s X-Foo:barX-FoobarNrrrrLrrrs rAtest_headerCallbackz$_HTTPParserTests.test_headerCallbacks  0022lTX5666 dh''' (F!3444 .....r@c|\}}|d|jz|d|jz|d|jz||j||ddi||jt dS)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 rAtest_continuedHeaderCallbackz-_HTTPParserTests.test_continuedHeaderCallbacks  0022mdh6777g0111i$(2333dh''' (,>> .....r@c2|\}}|jgd}|d|z|d|z||j||ddddS)z Leading and trailing linear whitespace is stripped from the header value passed to the C{headerReceived} callback. )s s bar s r@sX-Bar:sX-Foo:r)rsX-BarN)rrjoinrrL)rRrrvalues rAtest_fieldContentWhitespacez,_HTTPParserTests.test_fieldContentWhitespaces  0022 @@@AAi%/000i%/000dh''' Ff!E!EFFFFFr@cg|\}fd}|_|j|t g|jtdS)zg After the last header is received, L{HTTPParser} calls C{allHeadersReceived}. cTjt_dSrp)rrr)calledrsrAallHeadersReceivedzD_HTTPParserTests.test_allHeadersCallback..allHeadersReceiveds" MM(. ) ) )#HNNNr@N)rrrrrLrrr)rRrrrrs @@rAtest_allHeadersCallbackz(_HTTPParserTests.test_allHeadersCallbacks 0022 $ $ $ $ $ $'9#dh''' &*** 00000r@c|\}}||j||i||jt dS)zp If there are no headers in the message, L{HTTPParser} does not call C{headerReceived}. Nrrs rAtest_noHeaderCallbackz&_HTTPParserTests.test_noHeaderCallbacksd  0022dh''' $$$ .....r@ct}|t|d|jz|d|jz|d|jz||jdddgfg}||t |jdS)zc All headers received by L{HTTPParser} are added to L{HTTPParser.headers}. rr X-Foo: bazrrbazN) r"rrrrrLlistheadersgetAllRawHeaders)rRrexpecteds rAtest_headersSavedOnResponsez,_HTTPParserTests.test_headersSavedOnResponse#s << 1 1222048;<<<mdh6777mdh6777dh'''/01 4(8(I(I(K(K#L#LMMMMMr@ct}gd}|D]/}|||d|d0||dddS)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)rRrconnHeaderNamesrs rAtest_connectionControlHeadersz._HTTPParserTests.test_connectionControlHeaders1s <<    &  F OO226:::"FF%       . .w 7 7 4     r@ct}|t|t |t |jt dS)zi L{HTTPParser.switchToBodyMode} raises L{RuntimeError} if called more than once. N)r"rrswitchToBodyModeobjectrrrRrs rAtest_switchToBodyModez&_HTTPParserTests.test_switchToBodyModeOsd << 1 1222!!&((+++ ,(A688LLLLLr@)r;r<r=r>rrbytes__annotations__rrrrrrrrrrr?r@rArrs  C% 1 1 1    / / / / / / G G G111"/// N N N   <MMMMMr@rceZdZdZdZdS)$HTTPParserRFCComplaintDelimeterTestsz< L{_HTTPParserTests} using standard CR LF newlines.  Nr;r<r=r>rr?r@rArrZs CCCr@rceZdZdZdZdS)'HTTPParserNonRFCComplaintDelimeterTestsz5 L{_HTTPParserTests} using bare LF newlines.  Nrr?r@rArrbs CCCr@rceZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!d Z"d!Z#d"Z$d#Z%d$S)%HTTPClientParserTestszd Tests for L{HTTPClientParser} which is responsible for parsing HTTP response messages. cxtdd}||dddS)zj L{HTTPClientParser.parseVersion} parses a status line into its three components. Ns CANDY/7.2)sCANDY)r!rL parseVersionrs rAtest_parseVersionz'HTTPClientParserTests.test_parseVersionps> $D$// ..|<<>NOOOOOr@ctdd}t|jfd}|d|d|d|d|d|ddS) zr L{HTTPClientParser.parseVersion} raises L{ValueError} when passed an unparsable version. Ncl|}|j|dSrp)rrLdata)sexcefrRs rA checkParsingz@HTTPClientParserTests.test_parseBadVersion..checkParsings8##Aq!,,C   SXq ) ) ) ) )r@foos foo/bar/bazsfoo/sfoo/..sfoo/a.bs foo/-1.-1)r!rr)rRrrrrs` @@rAtest_parseBadVersionz*HTTPClientParserTests.test_parseBadVersionxs $D$//   ! * * * * * * *  V ^$$$ W Y Z    \"""""r@ctddtd}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 rbrdre r+rfr!rrrrLresponseversioncodephraserRrequestrs rAtest_responseStatusParsingz0HTTPClientParserTests.test_responseStatusParsings &$==#GT22 1 12224555 *2ODDD */555 *1599999r@ctddtd}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 rbrdr@rrs rA test_responseStatusWithoutPhrasez6HTTPClientParserTests.test_responseStatusWithoutPhrases &$==#GT22 1 12221222 *2ODDD */555 *1377777r@cbtddfd}|d|ddS)z L{HTTPClientParser.statusReceived} raises L{ParseError} if it is called with a status line which cannot be parsed. Nctj|}|j|dSrp)rr$rrLr)rrrrRs rArzBHTTPClientParserTests.test_badResponseStatus..checkParsings;##J0GKKC   SXq ) ) ) ) )r@rsHTTP/1.1 bar OK)r!)rRrrs` @rAtest_badResponseStatusz,HTTPClientParserTests.test_badResponseStatuss^ $D$// * * * * * *  V  '(((((r@cr i}g}g}g t||j}|j|_t }|||||j|j_ fd|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. c.dSNTr)bodyDataFinishedsrAz3HTTPClientParserTests._noBodyTest..s6F6M6Md6S6Sr@ producingr@Tr)r!rrrrrrr_bodyDataReceived_bodyDataFinishedrL producerStaterrlength) rRrrrrfinishedbodyrrgrs @rA _noBodyTestz!HTTPClientParserTests._noBodyTests9#GX_=="("4#%%  *** f%%%.2k+.S.S.S.S+h''' 0+>>> ... r""" C5))) )D6222 *11555 r@ctddtd}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+rfrrL)rRrrrrs rAtest_headResponsez'HTTPClientParserTests.test_headResponsesZ '4>>'4!!'68<< "3U!;<<<<.dr@rs X-Foo: bar rx-foorr!r+rfrrrrL connHeadersr3rrassertIdenticalrrrs rAtest_responseHeadersz*HTTPClientParserTests.test_responseHeaderss $ FD.$ 7 79J9J    1 12224555/000g&&& -wr{{;;; *2GXx.rr@rsX-Multiline: a s b rs x-multilinesa brrs rAtest_responseHeadersMultilinez3HTTPClientParserTests.test_responseHeadersMultilines  $ FD.$ 7 79J9J    1 122245553444l+++g&&& -wr{{;;;    %w /L'M'M    X.5~FFFFFr@c0ttddtdd}|t |d|d|d|d||jjti||j td gd gd ||jj d dS) zv The connection control headers are added to the parser's C{connHeaders} L{Headers} instance. rrNcdSrpr?rs rArz>HTTPClientParserTests.test_connectionHeaders..)rr@rContent-Length: 123 sConnection: close r123sclose)rr{ r!r+rfrrrrLrrr3rrrs rAtest_connectionHeadersz,HTTPClientParserTests.test_connectionHeaders#s $ FD.$ 7 79J9J    1 1222455589996777g&&& *2GBKK@@@   (LL M M    *1377777r@cttddtdd}|t |d|d|d||jjtdd gi||j ti||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. rrNcdSrpr?rs rArzRHTTPClientParserTests.test_headResponseContentLengthEntityHeader..=str@rrrrrrrrs rA*test_headResponseContentLengthEntityHeaderz@HTTPClientParserTests.test_headResponseContentLengthEntityHeader7s $ GT>4 8 8:K:K    1 122245558999g&&&    %w0AF8/L'M'M    -wr{{;;; *1155555r@cg}ttddtd|j}t }|||dg}|j|j_|d|d| |j d| |j t|d| |dg| |j t|d | |dd g| |j t| |d gdS) z If a response includes a body with a length given by the I{Content-Length} header, the bytes which make up the body are passed to the C{_bodyDataReceived} callback on the L{HTTPParser}. rrNrsContent-Length: 10 rpausedsxxxxxxsyyyyr@)r!r+rfrrrrrrrLrrrrrRrrrgrs rAtest_contentLengthz(HTTPClientParserTests.test_contentLengthIsz # FD.$ 7 7  $%%  ***4555.2k+7888g&&& 0(;;; ...h''' z*** ...h''' (3444 ... C5)))))r@cg}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 rr@r) r!r+rfrrrrrrrLrrrrRrrrs rAtest_zeroContentLengthz,HTTPClientParserTests.test_zeroContentLengthhs # FD.$ 7 7    1 12224555.2k+6777g&&& ... r""" C5))) *1155555r@cttddtdd}|t |t |jddS)z If a response includes multiple, distinct I{Content-Length} headers, L{HTTPClientParser.dataReceived} raises L{ValueError} to indicate that the response is invalid and the transport is now unusable. rrNs9HTTP/1.1 200 OK Content-Length: 1 Content-Length: 2 r!r+rfrrr ValueErrorrrs rA)test_multipleDistinctContentLengthHeadersz?HTTPClientParserTests.test_multipleDistinctContentLengthHeaderssl $GFD.$$O$OQUVV 1 1222    !      r@c<ttddtdd}|t |d||jjd||j tdS)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 rc r!r+rfrrrrLrrrrrs rA&test_multipleEqualContentLengthHeadersz?????r@cg}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 r0r1r2r3s rAtest_extraBytesPassedBackHEADz3HTTPClientParserTests.test_extraBytesPassedBackHEADs # GT>4 8 8(/    1 122245557888;<<< ... $=#>?????r@cg}ttddtd|j}|t |dg}|j|j_|d|d| |g| |jj t|d| |dg|d | |dd g|d | |d gdS) z If the response headers indicate the response body is encoded with the I{chunked} transfer encoding, the body is decoded according to that transfer encoding before being passed to L{Response._bodyDataReceived}. rrNrsTransfer-Encoding: chunked rs3 aasbc sbcs 0 extrasextra) r!r+rfrrrrrrrLrrrrs rAtest_chunkedResponseBodyz.HTTPClientParserTests.test_chunkedResponseBodys` # FD.$ 7 7    1 12224555.2k+?@@@g&&& r""" X.5~FFF i((( v&&&i((( e}--- /000 H:.....r@cg}ttddtd|j}t }|||dg}|j|j_|d|d|d| |ddg| td| |d gdS) z If a response does not include a I{Transfer-Encoding} or a I{Content-Length}, the end of response body is indicated by the connection being closed. rrNrrrrzsimulated end of connectionr@) r!r+rfrrrrrrrLconnectionLostr rs rAtest_unknownContentLengthz/HTTPClientParserTests.test_unknownContentLength)s # FD.$ 7 7  $%%  ***4555.2k+g&&&f%%%f%%% /000/L M MNNN C5)))))r@czg}ttddtd|j}t }|||dg}|j|j_|d| |dg| |dgdS)z According to RFC 2616, section 4.4, point 3, if I{Content-Length} and I{Transfer-Encoding: chunked} are present, I{Content-Length} MUST be ignored rrNrs@Content-Length: 102 Transfer-Encoding: chunked 3 abc 0 abcr@) r!r+rfrrrrrrrLrs rA%test_contentLengthAndTransferEncodingz;HTTPClientParserTests.test_contentLengthAndTransferEncodingAs # FD.$ 7 7  $%%  ***4555.2k+     x((( C5)))))r@c*t}ttddtdd}|||j}|ttt||tgS)z If L{HTTPClientParser.connectionLost} is called before the headers are finished, the C{_responseDeferred} is fired with the L{Failure} passed to C{connectionLost}. rrN) rr!r+rfr_responseDeferredr;rr9r\)rRrgrresponseDeferreds rAtest_connectionLostBeforeBodyz3HTTPClientParserTests.test_connectionLostBeforeBody_s $%% #GFD.$$O$OQUVV ***#5(:(<(< = =>>>#D*:=O.fakeBodyDataFinisheds$&& &r@rc log_failurerp)rcreateWithCleanuprrr!r+rfrrArUrrrr; assertEqualsrMassertIsInstancerr9flushLoggedErrors)rR logObserverrgrrrHeventrs rAtest_connectionLostWithErrorz2HTTPClientParserTests.test_connectionLostWithErrorns' +.rr@) r!r+rfrArrr;r rTr1rRrrXs rAtest_noResponseAtAllz*HTTPClientParserTests.test_noResponseAtAlls $ GT>4 8 8:J:J    & 1 1222 0 0111!!!%:;;;r@c|ttddtdd}|j}|t |d|t| |t |j tS)z If a partial response was received and the connection is lost, the resulting error is L{ResponseFailed}, but not L{ResponseNeverReceived}. rrNcdSrpr?rSs rArzBHTTPClientParserTests.test_someResponseButNotAll..rr@2) r!r+rfrArrrr;r rTr0rUrLrUs rAtest_someResponseButNotAllz0HTTPClientParserTests.test_someResponseButNotAlls $ GT>4 8 8:J:J    & 1 1222d### 0 0111!!!^44@@  !>   r@cd}ttddtdd}|t |||t|dddu||j t|tt|j d|tt|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 rrNcdSrpr?rSs rArzCHTTPClientParserTests.test_1XXResponseIsSwallowed..Tr@rr)r!r+rfrrrrgetattrrLrrrMrrrr_everReceivedData)rRsample103Responsers rAtest_1XXResponseIsSwallowedz1HTTPClientParserTests.test_1XXResponseIsSwalloweds'   $ FD.$ 7 79I9I    1 1222/000 *d;;tCDDD 000 T("2"C"C"E"EFFGGKKK T("6"G"G"I"IJJKKQOOO 233333r@cd}d}ttddtdd}|t |||z||jjd||jj ti||j tdd 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 rrNcdSrpr?rSs rArzUHTTPClientParserTests.test_1XXFollowedByFinalResponseOnlyEmitsFinal..r^r@rdrrr r!r+rfrrrrLrrrr3rrrRrafollowing200Responsers rA-test_1XXFollowedByFinalResponseOnlyEmitsFinalzCHTTPClientParserTests.test_1XXFollowedByFinalResponseOnlyEmitsFinals    Y# FD.$ 7 79I9I    1 1222/2FFGGG */555 *2GBKK@@@ -w8IF87T/U/UVVV *1377777r@cd}d}ttddtdd}|t |||z|z|z||jjd||jj ti||j tdd gi||jj d dS) zp It is acceptable for multiple 1XX responses to come through, all of which get ignored. r\rdrrNcdSrpr?rSs rArzKHTTPClientParserTests.test_multiple1XXResponsesAreIgnored..r^r@rdrrrrfrgs rA#test_multiple1XXResponsesAreIgnoredz9HTTPClientParserTests.test_multiple1XXResponsesAreIgnoreds    Y# FD.$ 7 79I9I    1 1222   # #    */555 *2GBKK@@@ -w8IF87T/U/UVVV *1377777r@ctj|t}d}tt ddt dd}|t||| dt||d}| |dd | |d d dS) zF When a 1XX response is ignored, Twisted emits a log. r\rrNcdSrpr?rSs rArzHHTTPClientParserTests.test_ignored1XXResponseCausesLog.. r^r@rcr log_formatz#Ignoring unexpected {code} responserg) rrJrr!r+rfrrrrKrM)rRrNrarrOs rA test_ignored1XXResponseCausesLogz6HTTPClientParserTests.test_ignored1XXResponseCausesLogs+rrrrrrrrrr r rrrrr"r%r'r)r+r.r4r6r9r<r?rCrPrVrZrbrirlrqr?r@rArrjs0 PPP###, : : : 8 8 8)))&"""H = = =444444GGG GGG&888(666$***>6662   $///$    ///        @@@"@@@"#/#/#/J***0***< R R R333: < < <   $44448882888<.....r@rc*eZdZdZdZdZdZdZdZdS) 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}. rFc6t|_|jSrp)rrrRrgs rAwriteTozSlowRequest.writeTo%s  }r@cd|_dSrstoppedrqs rA stopWritingzSlowRequest.stopWriting)  r@N) r;r<r=r>methodry persistentrvrzr?r@rArsrssM  FGJr@rsceZdZdZdZdZdS) 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. FcJ|dtdS)N SOME BYTES)writer rus rArvzSimpleRequest.writeTo7s  &&&t}}r@N)r;r<r=r>r}rvr?r@rArr-s4Jr@rceZdZdZdZdZdZdZdZdZ d&d Z d Z d Z d Z d ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ d Z!d!Z"d"Z#d#Z$d$Z%d%Z&dS)'HTTP11ClientProtocolTestsz] Tests for the HTTP 1.1 client protocol implementation, L{HTTP11ClientProtocol}. ct|_t|_|j|jdS)zR Create an L{HTTP11ClientProtocol} connected to a fake transport. N)rrgr)rrrqs rAsetUpzHTTP11ClientProtocolTests.setUpBs<)**,..  $$T^44444r@c|jt||jddS)z L{HTTP11ClientProtocol.request} accepts a L{Request} and calls its C{writeTo} method with its own transport. rN)rrrrLrgrrqs rA test_requestz&HTTP11ClientProtocolTests.test_requestJsH moo... --//?????r@cjtfd}jt t }|||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. cbjddSNr@rLrgrignoredrRs rA cbNotSentz?HTTP11ClientProtocolTests.test_secondRequest..cbNotSentZ-   T^1133S 9 9 9 9 9r@)rrrsrTrr%rUrRrrXs` rAtest_secondRequestz,HTTP11ClientProtocolTests.test_secondRequestRsz kmm,,, : : : : :   t}44]__EE~ V V i   r@c"jttdfd}jt t}|||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 transportcbjddSrrrs rArzLHTTP11ClientProtocolTests.test_requestAfterConnectionLost..cbNotSentirr@) rr;rr rTrrr%rUrs` rAtest_requestAfterConnectionLostz9HTTP11ClientProtocolTests.test_requestAfterConnectionLostas $$W^O-L-L%M%MNNN : : : : :   t}44]__EE~ V V i   r@cGdd}j|}fd}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. ceZdZdZdZdS)CHTTP11ClientProtocolTests.test_failedWriteTo..BrokenRequestFc8ttSrp)rr9rus rArvzKHTTP11ClientProtocolTests.test_failedWriteTo..BrokenRequest.writeTo{s.00111r@Nr;r<r=r}rvr?r@rA BrokenRequestrxs(J 2 2 2 2 2r@rcjjjt t ddS)Nzyou asked for it)rrg disconnectingrr;rr rs rArSz>HTTP11ClientProtocolTests.test_failedWriteTo..cbFailedsI OODN8 9 9 9 M ( (@R1S1S)T)T U U U U Ur@)rrr^r9rU)rRrrXrSs` rAtest_failedWriteToz,HTTP11ClientProtocolTests.test_failedWriteTops 2 2 2 2 2 2 2 2 M ! !--// 2 2 V V V V V *$4F3G H H hr@cGdd}|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. ceZdZdZdZdS)MHTTP11ClientProtocolTests.test_synchronousWriteToError..BrokenRequestFctrprGrus rArvzUHTTP11ClientProtocolTests.test_synchronousWriteToError..BrokenRequest.writeTos(***r@Nrr?r@rArrs(J + + + + +r@r)rrr^r9)rRrrXs rAtest_synchronousWriteToErrorz6HTTP11ClientProtocolTests.test_synchronousWriteToErrors] + + + + + + + + M ! !--// 2 2,T17I6JKKKr@Nct}|j|}t||tg}||j|jtt | |j|dkr|j dnx|dkrq|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. callbackNerrbackrc)rsrrr`r9rryr;rrrrrrCrMrLrM)rRmoderrXerrorss rA*test_connectionLostDuringRequestGenerationzDHTTP11ClientProtocolTests.test_connectionLostDuringRequestGenerations-- M ! !' * * +D!6H5I J J ))) $$W-?-A-A%B%BCCC ((( :     % %d + + + + Y     $ $W-F-H-H%I%I J J J++,EFFF   S[[! , , , , r@c,|dS)z If the request passed to L{HTTP11ClientProtocol} finishes generation successfully after the L{HTTP11ClientProtocol}'s connection has been lost, nothing happens. rrrqs rA+test_connectionLostBeforeGenerationFinishedzEHTTP11ClientProtocolTests.test_connectionLostBeforeGenerationFinisheds >>zJJJr@c,|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. rrrqs rA)test_connectionLostBeforeGenerationFailedzCHTTP11ClientProtocolTests.test_connectionLostBeforeGenerationFaileds >>yIIIr@ctjtfd}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. cdtd}d||dd|dddS)NrcrrIrozJError writing request, but not in valid state to finalize request: {state}rCONNECTION_LOST)rKrMassertInrL)ignorerOrNrRs rAcheckznHTTP11ClientProtocolTests.test_errorMessageOnConnectionLostBeforeGenerationFailedDoesNotConfuse..checks   a[!1!1 2 2 2NE MM- / / /   l#/      U7^-> ? ? ? ? ?r@r)rrJrrrU)rRrrNs` @rAEtest_errorMessageOnConnectionLostBeforeGenerationFailedDoesNotConfusez_HTTP11ClientProtocolTests.test_errorMessageOnConnectionLostBeforeGenerationFailedDoesNotConfusesh+>yIIUU    r@cjtddtd}fd}||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. rrNc |jd|jtjjjjddS)Nrd QUIESCENT) rLrrr3rrgrrr)rrRs rA cbRequestzIHTTP11ClientProtocolTests.test_receiveSimplestResponse..cbRequestsp   X]C 0 0 0   X-wyy 9 9 9 OODN8 9 9 9   T]0+ > > > > >r@s9HTTP/1.1 200 OK Content-Length: 0 Connection: close rrr+rfrUrrRrXrs` rAtest_receiveSimplestResponsez6HTTP11ClientProtocolTests.test_receiveSimplestResponses{ M ! !'&$"M"M N N ? ? ? ? ? i    ""    r@cjtddtd}fd}||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. rrNcdtdddgi}|j|dS)Nrrr)r3rLr)rrrRs rArzHHTTP11ClientProtocolTests.test_receiveResponseHeaders..cbRequests966*:;<.cbResponse..*168Jr@) rrclosedDeferred deliverBodyrLrrrrU)r whenFinishedrrquiescentResultrRrgs` @rA cbResponsez]HTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone..cbResponse#s$&&A.6jj 8L1+   # # #   X^-T U U U OOI3 4 4 4   _b 1 1 1++,J,J,J,J,JKK Kr@cj|\}}|jd|jd|jd|jt ddgi|djddS)Nrbrdrerrfoobar)rLrrrrr3rr)resultrrrrRs rA cbAllResponsez`HTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone..cbAllResponse.s#NHd   X- ? ? ?   X]C 0 0 0   X_e 4 4 4   X-w6(7K/L/L M M M   T9 - - -   % %d + + + + +r@)rr)rrrsrrrU)rRrXrrrrrrgs` @@@@rA/test_receiveResponseBeforeRequestGenerationDonezIHTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone s#%% '(>?? ***--   W % %     L L L L L L L L j!!! , , , , , , m$$$r@cHt}t}||_||dtjz}|tddtd}| d|zdzt||tgS)zy The connection is closed when the server respond with a header which is above the maximum line. r8rrNsHTTP/1.1 200 OK X-Foo: s X-Ignored: ignored ) rr)rrr MAX_LENGTHrr+rfrr\r )rRrgrlongLinerXs rA"test_receiveResponseHeadersTooLongz4HH I I ! "%    $D!n-=>>>r@ctj}jdd}||fd}|||S)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 tiskcttx}_|fdS)NcjfSrprrs rArzHTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDone..cbResponse..jrr@)rrrrrU)rrrs` @rArzrHTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDone..cbResponsefsU$&&A.6jj 8L1+   # # #++,J,J,J,J,JKK Kr@cjdjt t jjddS)Nr)rrrr;rr9rLr{)rrrRs rArzuHTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDone..cbAllResponsensa   % %d + + + M ( (1C1E1E)F)F G G G   T]13D E E E E Er@)rsrrrrU)rRrXrrrs` @rADtest_connectionLostAfterReceivingResponseBeforeRequestGenerationDonez^HTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDoneWs -- M ! !' * * ""     L L L j!!! F F F F F F m$$$r@cRttx}_jt ddt d}jdg}||j  |gjd|d}| jdjdfd }|||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 rrrrc|jdjtdS)Nr)rLr closedReasonrKr/)rrrRs rArzIHTTP11ClientProtocolTests.test_receiveResponseBody..cbAllResponses8   X]I 6 6 6  ! & &| 4 4 4 4 4r@) rrrrrr+rfrrUrrLr)rRrrequestDeferredrrrrs` @rAtest_receiveResponseBodyz2HTTP11ClientProtocolTests.test_receiveResponseBodyws7 ())19; x.-// FD.$ 7 7   "" A   ##FM222 $$$ ""5)))!9X&&& ""6*** ""6*** 5 5 5 5 5 5   ///r@cj|jtddtd}|jdg}||j|d}t}|||jd|jd| |j d|j ttd |jt dS) 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 rrrrz low-level transport disconnected)rrr+rfrrUrrrrLrr;rr rrKr*rRrrrrs rAEtest_responseBodyFinishedWhenConnectionLostWhenContentLengthIsUnknownz_HTTP11ClientProtocolTests.test_responseBodyFinishedWhenConnectionLostWhenContentLengthIsUnknowns-// FD.$ 7 7   ""#ABBB##FM222!9'))X&&& ""6*** ""6***  222 $$ N#EFF G G    ""#455555r@c|jtddtd}|jdg}||j|d}t}|||jd|jd| |j d|j ttt|t|jtt"gS) 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 r)rrr+rfrrUrrrrLrr;rr9r\rrr2rs rA4test_chunkedResponseBodyUnfinishedWhenConnectionLostzNHTTP11ClientProtocolTests.test_chunkedResponseBodyUnfinishedWhenConnectionLosts#-// FD.$ 7 7   "" L   ##FM222!9'))X&&& ""?333 ""?333  222 $$W-?-A-A%B%BCCC# $x,--0BI/N   r@cjtddtd}jdt |t g}fd}|||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 cjj|jdjjdjttddS)Nrsunparseable garbage goes herez it is done) rrgrrLrJrrrr;rr )rrRs rArSzLHTTP11ClientProtocolTests.test_parserDataReceivedException..cbFailedsr OODN8 9 9 9    A$)+K    M ( ( 1M1M)N)N O O O O Or@)rrr+rfrr\r$rU)rRrrXrSs` rA test_parserDataReceivedExceptionz:HTTP11ClientProtocolTests.test_parserDataReceivedExceptions-// FD.$ 7 7   ""#GHHH  E E P P P P P hr@c|jtddtd}|jjj}||j|j|jttd||jdt||tgS)z When the HTTP response parser is disconnected, the L{TransportProxyProducer} which was connected to it as a transport is stopped. rrNzconnection done) rrr+rf_parserrgr _producer_disconnectParserrr r\)rRrrgs rAtest_proxyStoppedz+HTTP11ClientProtocolTests.test_proxyStoppeds -// FD.$ 7 7  M)3  Y0$.AAA ''?P0Q0Q(R(RSSS Y0$777#D/N;KLLLr@c@t}t}||g}g}||j||j|||fggf||j| tt||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)rabortrUrrLrrr;rr )rRrgrr1r2s rAtest_abortClosesConnectionz4HTTP11ClientProtocolTests.test_abortClosesConnections $%% ')) ***  $$RY///$$RY/// "bB8,,,  /000 (8(8 9 9::: dV$$$ dV$$$$$r@ct}t}|||t t g}||j| |dg| |j ddS)z L{HTTP11ClientProtocol.abort} called after the connection is lost returns a C{Deferred} that fires immediately. Nr) rr)rr;rr rrUrrLr{rRrgrrs rAtest_abortAfterConnectionLostz7HTTP11ClientProtocolTests.test_abortAfterConnectionLosts $%% ')) ***(8(8 9 9:::$$V]333 $((( *;<<<<.BodyDestinationzl A body response protocol which immediately aborts the HTTP connection. c0dS)z< Abort the HTTP connection. N)rrs rAconnectionMadez`HTTP11ClientProtocolTests.test_abortAfterResponseHeaders..BodyDestination.connectionMadeVs     r@c2|dS)z Make the reason for the losing of the connection available to the unit test via C{testResult}. N)r)rRrO testResults rAr;z`HTTP11ClientProtocolTests.test_abortAfterResponseHeaders..BodyDestination.connectionLost\s ""6*****r@N)r;r<r=r>rr;)rrsrABodyDestinationrPsQ    ! ! ! ! !  + + + + + + +r@rc|jt t dS)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)rrrr;rr )rrrrRrgs rArzMHTTP11ClientProtocolTests.test_abortAfterResponseHeaders..deliverBodycs^  !2!2 3 3 3 OOI3 4 4 4  # #GN,<,<$=$= > > > > >r@cH|jtdSrp)rLrr.)errorrRs rA checkErrorzLHTTP11ClientProtocolTests.test_abortAfterResponseHeaders..checkErrorms!  ! !%.( ; ; ; ; ;r@) rr)rrr+rfrrrrUr\rr2) rRrrrrVrrrrgs ` @@@@rAtest_abortAfterResponseHeadersz8HTTP11ClientProtocolTests.test_abortAfterResponseHeaders<s9$D111 ')) ***!!'&$"M"MNNUVVVZZ  + + + + + + + +h + + +& ? ? ? ? ? ? ? ? < < < < < ;'''' *0)<  ##J///r@c gfd}t}t||t ddt dd}dgg}||j |d}t}t|_ |j fd | |d |jt d 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. c||jd|dSNrrLrrrrrrRs rArzHHTTP11ClientProtocolTests.test_quiescentCallbackCalled..callbackK   Q ) ) )   QWk 2 2 2  " "1 % % % % %r@rrNTr}s&HTTP/1.1 200 OK Content-length: 3 rc.dS)N response doner)rTrs rArzHHTTP11ClientProtocolTests.test_quiescentCallbackCalled..s..??r@r>r)rr)rrr+rfrrLrUrrrrrrrKr/r_finishedRequest_currentRequest_transportProxyrA) rRrrgrrr bodyProtocolrrs ` @@rAtest_quiescentCallbackCalledz6HTTP11ClientProtocolTests.test_quiescentCallbackCalledvs & & & & & & & $%% '11 ***"** FD.$4 H H H   UVVV "---##FM222!9,-- &.jj ##// ? ? ? ?    \***f%%%!&&|444 8_*EFFF )4000 2D999 14888 14888 3T:::::r@c gfd}t}t||t ddt dd}d|}|j dtd |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. c||jd|dSrr r s rArz]HTTP11ClientProtocolTests.test_transportProducingWhenQuiescentAfterFullBody..callbackr r@rrNTr s)HTTP/1.1 200 OK Content-length: 3 BBBDEFERRED_CLOSErcr) rr)rrr+rfrsuccessResultOfrLr{rMr)rRrrgrrrrs` @@rA1test_transportProducingWhenQuiescentAfterFullBodyzKHTTP11ClientProtocolTests.test_transportProducingWhenQuiescentAfterFullBodys & & & & & & & $%% '11 ***"** FD.$4 H H H       ''88 *:;;; _--q111 0+>>>>>r@c gfd}t}t||t ddt dd}|jd td d  d tdS) z The quiescentCallback is called before the request C{Deferred} fires, in cases where the response has no body. c||jd|dSrr r s rArzUHTTP11ClientProtocolTests.test_quiescentCallbackCalledEmptyResponse..callbackr r@rrNTr &HTTP/1.1 200 OK Content-length: 0 rrrc)rr)rrr+rfrUrrrLrMrrLr.)rRrrgrrrs` @@rA)test_quiescentCallbackCalledEmptyResponsezCHTTP11ClientProtocolTests.test_quiescentCallbackCalledEmptyResponses  & & & & & & & $%% '11 ***"** FD.$4 H H H   ##O$:;;;UVVV _--q111 _Q/::: oa0(;;;;;r@c &g}t}t|j}|||t ddt dd}|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. rrNTr s9HTTP/1.1 200 OK Content-length: 0 Connection: close rrr)rrrr+rfrrUrrrrKr/rLrrrRrrgrrrrrs rAtest_quiescentCallbackNotCalledz9HTTP11ClientProtocolTests.test_quiescentCallbackNotCalleds #%% '(>?? ***"** FD.$4 H H H       ##FM222!9+-- \***!&&|444 "---  /00000r@c &g}t}t|j}|||t ddt dd}|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. rrNFr rrrrs rA1test_quiescentCallbackNotCalledNonPersistentQueryzKHTTP11ClientProtocolTests.test_quiescentCallbackNotCalledNonPersistentQuerys #%% '(>?? ***"** FD.$5 I I I   UVVV##FM222!9+-- \***!&&|444 "---  /00000r@c d}tj|t}t}t |}|||tddtdd}| 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. ctrp)ZeroDivisionError)rs rArzHHTTP11ClientProtocolTests.test_quiescentCallbackThrows..callback5s#%% %r@rrNTr rrrcrI)rrJrrr)rrr+rfrrUrrrrrKr/rKrMrLrr%rMrr) rRrrNrgrrrrrrOrs rAtest_quiescentCallbackThrowsz6HTTP11ClientProtocolTests.test_quiescentCallbackThrows/sh  & & &+2BCCCr@ct}t}||t|ddifdfd}|_|t ddt}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. cancelledFcdd<dS)NTr.r?)rTnonLocals rAr(zJHTTP11ClientProtocolTests.assertCancelDuringBodyProduction..cancels$(H[ ! ! !r@cH|_t_jSrpconsumerrr)r3r(producers rAstartProducingzRHTTP11ClientProtocolTests.assertCancelDuringBodyProduction..startProducings$ (H  ( 0 0H $ $r@POST/barsxxxxx)rr)rStringProducerr5rr+rfr3rr(rr)r^r) rRproducerLengthrgrr5rr(r0r4s @@@rA assertCancelDuringBodyProductionz:HTTP11ClientProtocolTests.assertCancelDuringBodyProductionss$%% ')) ***!.11' ) ) ) ) ) % % % % % % #1!!''7NH"U"UVV)))   ./// -...,T6N;KLLLr@c,|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. )r:rqs rAtest_cancelDuringBodyProductionz9HTTP11ClientProtocolTests.test_cancelDuringBodyProductions44R888r@c6|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. )r:rrqs rA&test_cancelDuringChunkedBodyProductionz@HTTP11ClientProtocolTests.test_cancelDuringChunkedBodyProductions44^DDDr@rp)'r;r<r=r>rrrrrrrrrrrrrrrrrrrrrrrrrrrr r"r&r*r,r:r=r?r?r@rArr<sV 555@@@      4LLL @KKKJJJ   0.$000d???4@'''R666:   @8 M M M%%%* = = =GGG 808080t7;7;7;r,?,?,?\<<<4111>1112!1!1!1F   "DDD MMM>999EEEEEr@rc4eZdZdZdZdZdZdZdZdZ dS) r8a 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}. Fc||_dSrp)r)rRrs rA__init__zStringProducer.__init__s  r@cD||_t|_|jSrpr2)rRr3s rAr5zStringProducer.startProducings    }r@cd|_dSrrxrqs rA stopProducingzStringProducer.stopProducingr{r@cdSrpr?rqs rApauseProducingzStringProducer.pauseProducing r@cdSrpr?rqs rAresumeProducingzStringProducer.resumeProducingrHr@N) r;r<r=r>ryrBr5rErGrJr?r@rAr8r8sp  G         r@r8ceZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdZddZdZdZdZdZdZdS) RequestTestsz Tests for L{Request}. c,t|_dSrp)rrgrqs rArzRequestTests.setUps(**r@ctddtd|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+rfrvrgrLrrqs rAtest_sendSimplestRequestz%RequestTests.test_sendSimplestRequests` nd33;;DNKKK  N " "      r@ctddtdd}||j||jddS)zO A pesistent request does not send 'Connection: close' header. rrNTr s%GET / HTTP/1.1 Host: example.com rO)rRreqs rA"test_sendSimplestPersistentRequestz/RequestTests.test_sendSimplestPersistentRequestsffdNDTJJJ DN###  N " " B     r@ctddgdgd}tdd|d|j|jd}||d d ||d dd d g|d =|d d=|||gd dS)zf L{Request.writeTo} formats header data and writes it to the given transport. rrrE)rrDr/fooNrrGET /foo HTTP/1.1r@)Connection: closesHost: example.comrr)r3r+rvrgrsplitrLsort)rRrliness rAtest_sendRequestHeadersz$RequestTests.test_sendRequestHeaderss ff%5@PQQRR$//77GGG$$&&,,W55 q#7888 rssc3Z000 !HeBCCj    V V V     r@cHtD]}t||gddgi}t}tdd|d||d}||dd||d dd d g|d=|d d=|d |d d ttg}|||gdS)z_ Linear whitespace in request headers is replaced with a single space. rDsexample.invalidrrUNrrrVrWr@rXsHost: example.invalids: ) r6r3rr+rvrrYrLremoverr7)rR componentrrgr[sanitizedHeaderLines rA-test_sanitizeLinearWhitespaceInRequestHeadersz:RequestTests.test_sanitizeLinearWhitespaceInRequestHeaderss+ 9 ; ;Iy9+wAS@TUVVG'))I FGWd 3 3 ; ;I F F FOO%%++G44E   U1X'; < < <   U233Z#s 4 4 4a%* LL- . . . LL1 2 2 2"'**nn-M"N"N    U%8$9 : : : : ; ;r@ctt}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. r6r7NsXPOST /bar HTTP/1.1 Connection: close Transfer-Encoding: chunked Host: example.com sxxxsyyyyyyyyyyyyyyys!3 xxx f yyyyyyyyyyyyyyy 0 )r8rr+rfrvrgassertNotIdenticalr3rr4r streamingrLrclearrrrrRr4rs rAtest_sendChunkedRequestBodyz(RequestTests.test_sendChunkedRequestBody s] ".11'7NHEE'''  14888 T^4h??? 0111  N " "     ))) ***""4((( T^4d;;;  N " " P     r@cztt}tddt|}|j}j|jtfd} |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. r6r7cjdjjddSr)rLrgrrr4rs rArSzCRequestTests.test_sendChunkedRequestBodyWithError..cbFailed=sH   T^1133S 9 9 9  !8$ ? ? ? ? ?r@) r8rr+rfrvrgrerrr9rTrU)rRr4r writeDeferredrSrXs` rA$test_sendChunkedRequestBodyWithErrorz1RequestTests.test_sendChunkedRequestBodyWithError.s".11'7NHEE77  !!"4"6"6777 @ @ @ @ @   }.@ A A hr@ctd}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. r6r7NsOPOST /bar HTTP/1.1 Connection: close Content-Length: 3 Host: example.com r>)r8r+rfrvrgrcr3rr4rrdrLrrerrrrfs rAtest_sendRequestBodyWithLengthz+RequestTests.test_sendRequestBodyWithLengthEs: "!$$'7NHEE'''  14888 T^4h??? 0111  N " "     '''""4((( T^4d;;; --//88888r@ct|dtd}||j||j|dzdS)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} rUNsK /foo HTTP/1.1 Connection: close Content-Length: 0 Host: example.com rO)rRr|rs rA_sendRequestEmptyBodyWithLengthz,RequestTests._sendRequestEmptyBodyWithLengthbsk&'>4@@'''  N " "       r@c0|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. sPUTNrprqs rAtest_sendPUTRequestEmptyBodyz)RequestTests.test_sendPUTRequestEmptyBodyws ,,V44444r@c0|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. r6Nrrrqs rAtest_sendPOSTRequestEmptyBodyz*RequestTests.test_sendPOSTRequestEmptyBodys ,,W55555r@c`td}tddt|}||j}|jd|jd| |jj d| |tS)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. rmr6r7abN) r8r+rfrvrgr3rrrrr4rTr'rRr4rrjs rA#test_sendRequestBodyWithTooFewBytesz0RequestTests.test_sendRequestBodyWithTooFewBytess"!$$'7NHEE77 &&&""4((( T^4d;;;!!-AAAr@c tdtddt}|j}jdjjd j jj dfd} |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. rmr6r7rwcdNcPjdjt jjdjddS)NsQPOST /bar HTTP/1.1 Connection: close Content-Length: 3 Host: example.com absefr@)rLrgrrerr r3r)rfinisherr4rRs rArSzCRequestTests._sendRequestBodyWithTooManyBytesTest..cbFaileds   $$&&    N " " "   k8+<+BE J J J HX      T^1133S 9 9 9 9 9r@)r8r+rfrvrgr3rrryrrr4rTr'rU)rRr}rrjrSrXr4s`` @rA$_sendRequestBodyWithTooManyBytesTestz1RequestTests._sendRequestBodyWithTooManyBytesTests"!$$'7NHEE77 &&& )***&&& ())) T^4d;;; : : : : : : ::   }o > > hr@c2d}||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. c:|jddSrprrr4s rAr}zCRequestTests.test_sendRequestBodyWithTooManyBytes..finisher   & &t , , , , ,r@)r~rRr}s rA$test_sendRequestBodyWithTooManyBytesz1RequestTests.test_sendRequestBodyWithTooManyBytess' - - -88BBBr@cptjtfd}|S)rcZ|jtd}d||d}|jtt}t|ddS)NrrIrc) rrr9rrLrrMrLrM)r4rOrrrNrRs rAr}zHRequestTests.test_sendRequestBodyErrorWithTooManyBytes..finishers   % %&8&:&: ; ; ;NE MM- / / /m$A  ! !!'+= > > >++,>??F   S[[! , , , , ,r@)rrJrr~)rRr}rNs` @rA)test_sendRequestBodyErrorWithTooManyBytesz6RequestTests.test_sendRequestBodyErrorWithTooManyBytessM+NrrIrc)rrJrr8r+rfrvrgr3 _finishedrrrrr9rrLrrLrMrM)rRrNr4rfinishedConsumingrOrs rA*test_sendRequestBodyErrorWithConsumerErrorz7RequestTests.test_sendRequestBodyErrorWithConsumerErrors+FFF --//555r@cdd}|||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}. c:|jddSrprrs rAr}zPRequestTests.test_sendRequestBodyFinishedEarlyThenTooManyBytes..finisher. rr@)rTrr'rs rA1test_sendRequestBodyFinishedEarlyThenTooManyBytesz>RequestTests.test_sendRequestBodyFinishedEarlyThenTooManyBytes& s? - - -!!  > >x H H    r@cdd}|||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. cR|jtdSrp)rrr9rs rAr}zORequestTests.test_sendRequestBodyErroredEarlyThenTooManyBytes..finisher> s&   % %&8&:&: ; ; ; ; ;r@)rTrr9rs rA0test_sendRequestBodyErroredEarlyThenTooManyBytesz=RequestTests.test_sendRequestBodyErroredEarlyThenTooManyBytes6 s? < < <!!  > >x H H    r@Nctt}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. r6r7rr@)r8rr+rfrvrgrrrerr r3rrLr)rR_withr4rrjs rA0test_sendChunkedRequestBodyFinishedThenWriteMorez=RequestTests.test_sendChunkedRequestBodyFinishedThenWriteMoreF s".11'7NHEE77 ""5)))  +x'8'>GGG --//555r@c|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. )rrr9rT)rRrXs rA9test_sendChunkedRequestBodyFinishedWithErrorThenWriteMorezFRequestTests.test_sendChunkedRequestBodyFinishedWithErrorThenWriteMoreW sD  A A &(( ) )  !!!%7888r@ctd}tddt|}||j}||jj|||jj|j d| |j d| |jj|jt#t%| |jj||jjd||t$S)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}. r6r7rwsQPOST /bar HTTP/1.1 Connection: close Content-Length: 5 Host: example.com abN)r8r+rfrvrgrr4rrdr3rrLrrrrrrr9rTrxs rAtest_sendRequestBodyWithErrorz*RequestTests.test_sendRequestBodyWithErrorc s@"!$$'7NHEE77  T^4h??? 0111&&&  N " "     5666!!'*<*>*>"?"?@@@ 5666 T^4d;;;!!-1CDDDr@c tddtid}|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. rrNr@sHostrEs example.org)r+r3rrrvrgrLr)rRrs rAtest_hostHeaderRequiredz$RequestTests.test_hostHeaderRequired s &$ T:: *got~FFF --//555 D'7^^,L"MNNPT   *got~FFF --//55555r@ctd}tddt|}||j||j|||jdS)zc L{Request.stopWriting} calls its body producer's C{stopProducing} method. rmrrN) r8r+rfrvrgrryrzrrfs rAtest_stopWritingzRequestTests.test_stopWriting s| "!$$&$AA''' )*** ()))))r@c>tj|t}td}d}||_t ddt |}||j| | t| td|dt||d}|d||d}||jtdS) z If the body producer's C{stopProducing} method raises an exception, L{Request.stopWriting} logs it and does not re-raise it. rmc tdNzstopProducing is bustedrGr?r@rAbrokenStopProducingzBRequestTests.test_brokenStopProducing..brokenStopProducing s$%>?? ?r@rrrcrrIN)rrJrr8rEr+rfrvrgrzrLrMrMr9rKrrLr)rRrNr4rrrOrs rAtest_brokenStopProducingz%RequestTests.test_brokenStopProducing s  +rrPrSr\rargrkrnrprsruryr~rrrrrrrrrrrrr?r@rArLrLs+++           ";;;$   B.999:   *555666 B B B???B C C CCCC(MMM6&      " 9 9 9%E%E%EN 6 6 6 * * *;;;;;r@rLcDeZdZdZdZdZdZd dZdZdZ d Z d Z d S) LengthEnforcingConsumerTestsz/ Tests for L{LengthEnforcingConsumer}. ct|_td|_t |_t |j|j|j|_dS)Nr<)rrr8r4rrgr#enforcerrqs rArz"LengthEnforcingConsumerTests.setUp sKjj &r** (**/ M4>4;   r@cT|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. r>sdefN)rrrLrgrrerqs rA test_writez'LengthEnforcingConsumerTests.test_write s F### --//888  F### --//88888r@c|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)rrrr'_noMoreWritesExpectedrqs rAtest_finishedEarlyz/LengthEnforcingConsumerTests.test_finishedEarly s; H%%% /4=+NOOOOOr@Fc\|jd||jj|jd||jj|r|j||jtS)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) rrrr4ryrrrTrr')rR_unregisterAfters rAtest_writeTooManyz.LengthEnforcingConsumerTests.test_writeTooMany s I&&& ./// D!!!  -...  2 M / / 1 1 1!!$+???r@c4|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) rrrrr4ryrr rrqs rAtest_writeAfterNoMoreExpectedz:LengthEnforcingConsumerTests.test_writeAfterNoMoreExpected s I&&& ++--- ./// +t}':DAAA  -.....r@c,|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)rrqs rAtest_finishedLatez.LengthEnforcingConsumerTests.test_finishedLate s %%d+++r@c|jd||jddS)z If L{LengthEnforcingConsumer._noMoreWritesExpected} is called after the correct number of bytes have been written it returns L{None}. rN)rrrrrqs rA test_finishedz*LengthEnforcingConsumerTests.test_finished sD I&&& T]@@BBDIIIIIr@cfd}|j_fd}}|||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}. c`tjtdr)r8rEr4r9rqsrArzRLengthEnforcingConsumerTests.test_stopProducingRaises..brokenStopProducing s(  ( ( 7 7 7$%>?? ?r@c~ttddS)Nrc)rLrMrMr9rs rA cbFinishedzILengthEnforcingConsumerTests.test_stopProducingRaises..cbFinished s6   S!7!78J!K!KLLa P P P P Pr@)r4rErrU)rRrrrXs` rAtest_stopProducingRaisesz5LengthEnforcingConsumerTests.test_stopProducingRaises su @ @ @ @ @': # Q Q Q Q Q  " " $ $ j!!!r@N)F) r;r<r=r>rrrrrrrrr?r@rArr s    9 9 9PPP@@@@ / / /,,,JJJr@rc$eZdZdZdZdZdZdS)RequestBodyConsumerTestsz Tests for L{ChunkedEncoder} which sits between an L{ITransport} and a request/response body producer and chunked encodes everything written to it. c |tttt dS)zC L{ChunkedEncoder} instances provide L{IConsumer}. N)rrr rrrqs rAtest_interfacez'RequestBodyConsumerTests.test_interface) s4  Y?P?P0Q0QRRSSSSSr@c\t}t|}|d||d||d||ddS)z} L{ChunkedEncoder.write} writes to the transport the chunked encoded form of the bytes passed to it. rrsxxxxxxxxxxxxxxxxs10 xxxxxxxxxxxxxxxx N)rrrrLrre)rRrgencoders rArz#RequestBodyConsumerTests.test_write/ s $%%  ++ f **O<<< i    **,KLLLLLr@ct}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 ) rrrregisterProducerrr4rrdunregisterProducerrLr)rRrgr4rs rAtest_producerRegistrationz2RequestBodyConsumerTests.test_producerRegistration< s$%% 88 ++  4000 Y/:::  +,,,""$$$ Y/666 **L99999r@N)r;r<r=r>rrrr?r@rArr" sQ TTT M M M:::::r@rc<eZdZdZdZdZdZdZdZdZ dZ d S) TransportProxyProducerTestszn Tests for L{TransportProxyProducer} which proxies the L{IPushProducer} interface of a transport. cp|tttddS)zO L{TransportProxyProducer} instances provide L{IPushProducer}. N)rrr r&rqs rArz*TransportProxyProducerTests.test_interfaceT s/  ]4J44P4PQQRRRRRr@ct}t|}||j||||jddS)z~ L{TransportProxyProducer.stopProxying} drops the reference to the wrapped L{IPushProducer} provider. N)rr&rr stopProxyingrRrgproxys rA%test_stopProxyingUnreferencesProducerzATransportProxyProducerTests.test_stopProxyingUnreferencesProducerZ sd $%% &y11 U_i888  U_d33333r@ct}|t|}||jd|||jd|||||jddS)z L{TransportProxyProducer.resumeProducing} calls the wrapped transport's C{resumeProducing} method unless told to stop proxying. rrN)rrGr&rLrrJrrs rAtest_resumeProducingz0TransportProxyProducerTests.test_resumeProducinge s $%%   """&y11 0(;;;  0+>>>  """   0(;;;;;r@ct}t|}||jd|||jd|||||jddS)z L{TransportProxyProducer.pauseProducing} calls the wrapped transport's C{pauseProducing} method unless told to stop proxying. rrN)rr&rLrrGrJrrs rAtest_pauseProducingz/TransportProxyProducerTests.test_pauseProducing{ s $%% &y11 0+>>>  0(;;;!!###   0+>>>>>r@ct}t|}||jd|||jdt}t|}||||jddS)z L{TransportProxyProducer.stopProducing} calls the wrapped transport's C{stopProducing} method unless told to stop proxying. rryN)rr&rLrrErrs rAtest_stopProducingz.TransportProxyProducerTests.test_stopProducing s $%% &y11 0+>>>  0)<<<#%% &y11   0+>>>>>r@ct}t}||||_t |}||j||jd| ||jd| |jdS)zs L{TransportProxyProducer.loseConnection} calls the wrapped transport's C{loseConnection}. rN) rrrrr&r connectedrLrloseConnectionrrRrgrrs rA test_loseConnectionWhileProxyingz>>  0+>>> ,-----r@cLt}t}||||_t |}|||j|||jdS)zm L{TransportProxyProducer.loseConnection} does nothing when the proxy is not active. N) rrrrr&rrrrrs rAtest_loseConnectionNotProxyingz:TransportProxyProducerTests.test_loseConnectionNotProxying s 566 ')) ***% &y11   +,,,   +,,,,,r@N) r;r<r=r>rrrrrrrr?r@rArrN s SSS 4 4 4<<<,???*???(...*-----r@rcleZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdS) ResponseTestsz Tests for L{Response}. ctt}|tt|dS)z= L{Response} instances provide L{IResponse}. N)rhrrrr5rRrs rAtest_verifyInterfacez"ResponseTests.test_verifyInterface s9)):):;;  Y99:::::r@crgt}Gfddt}|}t|}||\}|||jd|||jddS)z The L{IProtocol} provider passed to L{Response.deliverBody} has its C{makeConnection} method called with an L{IPushProducer} provider hooked up to the response as an argument. ceZdZfdZdS)7ResponseTests.test_makeConnection..SomeProtocolc2|dSrpr)rRr4 producerss rArzFResponseTests.test_makeConnection..SomeProtocol.makeConnection s  *****r@Nr;r<r=r)rsrA SomeProtocolr s. + + + + + + +r@rrrN)rrrhrrGrLrrJ)rRrgrr3r theProducerrs @rAtest_makeConnectionz!ResponseTests.test_makeConnection s  #%%  + + + + + + +8 + + + <>>(33X&&&! ""$$$ 0(;;;##%%% 0+>>>>>r@cgGfddt}|}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. ceZdZfdZdS)5ResponseTests.test_dataReceived..ListConsumerc2|dSrprrRrrs rArzBResponseTests.test_dataReceived..ListConsumer.dataReceived  T"""""r@Nr;r<r=rrsrA ListConsumerr . # # # # # # #r@rrN)rrhrrrrL)rRrr3rrs @rAtest_dataReceivedzResponseTests.test_dataReceived s  # # # # # # #8 # # # <>>():):;;X&&&""6*** )))))r@cgGfddt}|}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. ceZdZfdZdS)7ResponseTests.test_connectionLost..ListConsumerc2|dSrpr)rRrOlosts rAr;zFResponseTests.test_connectionLost..ListConsumer.connectionLost s F#####r@N)r;r<r=r;)rsrArr s. $ $ $ $ $ $ $r@rrrcN) rrhrrrrKr/rLrMr _bodyProtocol)rRrr3rrs @rAtest_connectionLostz!ResponseTests.test_connectionLost s $ $ $ $ $ $ $8 $ $ $ <>>():):;;X&&&""$$$ Q \""" TA&&& X3T:::::r@cgGfddt}|}tt}|d|d|||d|gd||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. ceZdZfdZdS)8ResponseTests.test_bufferEarlyData..ListConsumerc2|dSrprrs rArzEResponseTests.test_bufferEarlyData..ListConsumer.dataReceived# rr@NrrsrArr" rr@rrrr)rrrN)rrhrrrrLr _bodyBuffer)rRrrrrs @rAtest_bufferEarlyDataz"ResponseTests.test_bufferEarlyData s  # # # # # # #8 # # # <>>():):;;""6***""6***X&&&""6***  8 8 8999 X1488888r@ctt}|t|t |jtdS)zb L{Response.deliverBody} raises L{RuntimeError} if called more than once. N)rhrrrrrrs rA test_multipleStartProducingFailsz.ResponseTests.test_multipleStartProducingFails1 sT )):):;;XZZ((( ,(.ListConsumerc<|jdSrp)rr)rRrgtransportStates rArzHResponseTests.test_transportResumed..ListConsumer.makeConnectionr s %%i&=>>>>>r@Nr)rsrArrq s. ? ? ? ? ? ? ?r@rrrN)rrrGrhrLrr)rRrrgrrrs @rAtest_transportResumedz#ResponseTests.test_transportResumedj s  ? ? ? ? ? ? ?8 ? ? ?$%%   """<>>(33 0(;;;X&&& (444 0+>>>>>r@cvt}t|}|d|d|t }||||jd|j tdS)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. rrrN) rrhrrrrrLrrrKr/rRrgrrs rA)test_bodyDataFinishedBeforeStartProducingz7ResponseTests.test_bodyDataFinishedBeforeStartProducing~ s$%% (33""6***""6***""$$$'))X&&&  222""<00000r@cVt}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. CONNECTEDN) rrhrrrLr{rrr9rrKrs rA#test_finishedWithErrorWhenConnectedz1ResponseTests.test_finishedWithErrorWhenConnected s$%% (33'))X&&& +666""7+=+?+?#@#@AAA""#566666r@cVt}t|}||jd|t t t}|||j t dS)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. INITIALN) rrhrLr{rrr9rrrrKrs rA!test_finishedWithErrorWhenInitialz/ResponseTests.test_finishedWithErrorWhenInitial s$%% (33 )444""7+=+?+?#@#@AAA'))X&&&""#566666r@N)r;r<r=r>rrrrrrrr r rrrrrrr?r@rArr s;;;???,***&;;;2999.JJJJJJLLLLLLDDDDDD???(111$777&77777r@rN)_r>typingrzope.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 Exceptionr9rCrfrYr\r^r`rhrjrrrrrsrrr8rLrrrrr?r@rAr3sL&&&&&&......JJJJJJJJJJJJAAAAAAAA@@@@@@@@...... .-----000000******++++++(                      '&&&&&,,,,,,55555555  'N#3455% % % PTTTLLL66666(666BSMSMSMSMSMSMSMSMl+;X.>h .h .h .h .h .Hh .h .h .V0        f Ef Ef Ef Ef Ef Ef Ef ER ]          Fq;q;q;q;q;8q;q;q;hbbbbb8bbbJ):):):):):x):):):X{-{-{-{-{-({-{-{-|h7h7h7h7h7Hh7h7h7h7h7r@