o b6@sdZddlmZddlmZddlmZddlmZm Z m Z m Z ddl m Z mZddlmZmZddlmZdd lmZdd lmZdd lmZdd lmZmZmZmZdd lm Z ddl!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mm?Z?ddl@mAZAddlBmCZCmDZDddlEmFZFmGZGGdddeHZIGdddeHZJeAddgiZKddZLddZMddZNd d!ZOd"d#ZPGd$d%d%e ZQGd&d'd'ZRGd(d)d)eRe ZSGd*d+d+eRe ZTGd,d-d-e ZUGd.d/d/ZVGd0d1d1ZWGd2d3d3e ZXeeCGd4d5d5ZYGd6d7d7e ZZGd8d9d9e Z[Gd:d;d;e Z\Gdd?d?e Z^d@S)Az& Tests for L{twisted.web._newclient}. )Optional) implementer) verifyObject)CancelledErrorDeferredfailsucceed)ConnectionDoneConnectionLost) IConsumer IPushProducer)Protocol)globalLogPublisher) LineReceiver)Failure)AccumulatingProtocolEventLoggingObserverStringTransport StringTransportWithDisconnection)TestCase)BODYDONEHEADERSTATUSUNKNOWN_LENGTH BadHeadersBadResponseVersionChunkedEncoderConnectionAborted ExcessWriteHTTPClientParser HTTPParserLengthEnforcingConsumer ParseErrorRequestNotSentTransportProxyProducerWrongBodyLengthmakeStatefulDispatcher) HTTP11ClientProtocolPotentialDataLossRequestRequestGenerationFailedRequestTransmissionFailedResponse ResponseDoneResponseFailedResponseNeverReceived) _DataLoss)Headers) IBodyProducer IResponse)bytesLinearWhitespaceComponentssanitizedBytesc@eZdZdZdS)ArbitraryExceptionze A unique, arbitrary exception type which L{twisted.web._newclient} knows nothing about. N__name__ __module__ __qualname____doc__r>r>A/usr/lib/python3/dist-packages/twisted/web/test/test_newclient.pyr8Cr8c@r7)AnotherArbitraryExceptionzI Similar to L{ArbitraryException} but with a different identity. Nr9r>r>r>r?rAJr@rAhost example.comcs(fdd}||}|||S)a Assert that the given L{Deferred} fails with the exception given by C{mainType} and that the exceptions wrapped by the instance of C{mainType} it fails with match the list of exception types given by C{reasonTypes}. This is a helper for testing failures of exceptions which subclass L{_newclient._WrapperException}. @param self: A L{TestCase} instance which will be used to make the assertions. @param deferred: The L{Deferred} which is expected to fail with C{mainType}. @param mainType: A L{_newclient._WrapperException} subclass which will be trapped on C{deferred}. @param reasonTypes: A sequence of exception types which will be trapped on the resulting C{mainType} exception instance's C{reasons} sequence. @return: A L{Deferred} which fires with the C{mainType} instance C{deferred} fails with, or which fails somehow. c sLt|jD] \}}||qt|jtd|jdd|S)Nzlen(z ) != len())zipreasonstrap assertEquallen)errreasontype reasonTypesselfr>r?cbFailedns z-assertWrapperExceptionTypes..cbFailed) assertFailure addCallback)rOdeferredmainTyperNrPdr>rMr?assertWrapperExceptionTypesUs rVcCt||t|S)zo A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{ResponseFailed}. )rVr/rOrSrNr>r>r?assertResponseFailed}rYcCrW)zx A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{RequestGenerationFailed}. )rVr+rXr>r>r?assertRequestGenerationFailedr[cCrW)zz A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{RequestTransmissionFailed}. )rVr,rXr>r>r?assertRequestTransmissionFailedr\r]cCstdddt|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. sHTTPr_OK)r-_boringHeaders) transportr>r>r?justTransportResponsesrdc@eZdZdZddZdS)MakeStatefulDispatcherTestsz. Tests for L{makeStatefulDispatcher}. cCsRGddd}|}||dd|_||dd|_|t|jdS)z A method defined with L{makeStatefulDispatcher} invokes a second method based on the current state of the object. c@s2eZdZdZddZedeZddZddZd S) zCMakeStatefulDispatcherTests.test_functionCalledByState..FooAcSdSNr>rOr>r>r?barzGMakeStatefulDispatcherTests.test_functionCalledByState..Foo.barquuxcSdS)Nar>rjr>r>r?_quux_ArlzKMakeStatefulDispatcherTests.test_functionCalledByState..Foo._quux_AcSrn)Nbr>rjr>r>r?_quux_BrlzKMakeStatefulDispatcherTests.test_functionCalledByState..Foo._quux_BN)r:r;r<_staterkr'rprrr>r>r>r?Foos   rtroBrqCN)rHrkrs assertRaises RuntimeError)rOrtstatefulr>r>r?test_functionCalledByStatesz6MakeStatefulDispatcherTests.test_functionCalledByStateN)r:r;r<r=rzr>r>r>r?rfs rfc@sreZdZUdZdZeeed<ddZddZ dd Z d d Z d d Z ddZ ddZddZddZddZdS)_HTTPParserTestszt Base test class for L{HTTPParser} which is responsible for the bulk of the task of parsing HTTP bytes. NsepcCs\g}t}|j|_|t||jt|d|j ||dg||jt dS)zj L{HTTPParser} calls its C{statusReceived} method when it receives a status line. HTTP/1.1 200 OKN) r!appendstatusReceivedmakeConnectionrrHstater dataReceivedr|r)rOstatusprotocolr>r>r?test_statusCallbacks z$_HTTPParserTests.test_statusCallbackcCs6i}t}|j|_|t|d|j||fS)Nr})r! __setitem__headerReceivedrrrr|rOheaderrr>r>r?_headerTestSetups  z!_HTTPParserTests._headerTestSetupcCsJ|\}}|d|j||j||ddi||jtdS)ze L{HTTPParser} calls its C{headerReceived} method when it receives a header. s X-Foo:barX-FoobarNrrr|rHrrrr>r>r?test_headerCallbacks  z$_HTTPParserTests.test_headerCallbackcCsj|\}}|d|j|d|j|d|j||j||ddi||jtdS)z If a header is split over multiple lines, L{HTTPParser} calls C{headerReceived} with the entire value once it is received. X-Foo: bars bazs quuxrs bar baz quuxNrrr>r>r?test_continuedHeaderCallbacks  z-_HTTPParserTests.test_continuedHeaderCallbackcCsZ|\}}|jgd}|d||d|||j||ddddS)z Leading and trailing linear whitespace is stripped from the header value passed to the C{headerReceived} callback. )s s bar s sX-Bar:sX-Foo:r)rsX-BarN)rr|joinrrH)rOrrvaluer>r>r?test_fieldContentWhitespaces  z,_HTTPParserTests.test_fieldContentWhitespacecsPg|\}fdd}|_|j|tg|jtdS)zg After the last header is received, L{HTTPParser} calls C{allHeadersReceived}. csjt_dSri)r~rrr>calledrr>r?allHeadersReceiveds  zD_HTTPParserTests.test_allHeadersCallback..allHeadersReceivedN)rrrr|rHrrr)rOrrr>rr?test_allHeadersCallbacks  z(_HTTPParserTests.test_allHeadersCallbackcCs6|\}}||j||i||jtdS)zp If there are no headers in the message, L{HTTPParser} does not call C{headerReceived}. Nrrr>r>r?test_noHeaderCallbacks   z&_HTTPParserTests.test_noHeaderCallbackcCsvt}|t|d|j|d|j|d|j||jdddgfg}||t|jdS)zc All headers received by L{HTTPParser} are added to L{HTTPParser.headers}. r}r X-Foo: bazrrbazN) r!rrrr|rHlistheadersgetAllRawHeaders)rOrexpectedr>r>r?test_headersSavedOnResponse#s  z,_HTTPParserTests.test_headersSavedOnResponsecCsFt}gd}|D]}|||d|fq ||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 %r to be a connection control header, but wasn'tsdatez`Expecting the arbitrarily selected 'date' header to not be a connection control header, but was.N)r! assertTrueisConnectionControlHeader assertFalse)rOrconnHeaderNamesrr>r>r?test_connectionControlHeaders1s z._HTTPParserTests.test_connectionControlHeaderscCs4t}|t|t|t|jtdS)zi L{HTTPParser.switchToBodyMode} raises L{RuntimeError} if called more than once. N)r!rrswitchToBodyModeobjectrwrxrOrr>r>r?test_switchToBodyModeOs  z&_HTTPParserTests.test_switchToBodyMode)r:r;r<r=r|rbytes__annotations__rrrrrrrrrrr>r>r>r?r{s      r{c@eZdZdZdZdS)$HTTPParserRFCComplaintDelimeterTestsz< L{_HTTPParserTests} using standard CR LF newlines.  Nr:r;r<r=r|r>r>r>r?rZrc@r)'HTTPParserNonRFCComplaintDelimeterTestsz5 L{_HTTPParserTests} using bare LF newlines.  Nrr>r>r>r?rbrrc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8d9Zd:d;Z dr>r?test_parseVersionps z'HTTPClientParserTests.test_parseVersioncsXtdd}t|jfdd}|d|d|d|d|d|d dS) zr L{HTTPClientParser.parseVersion} raises L{ValueError} when passed an unparsable version. Ncs |}|j|dSri)rwrHdatasexcefrOr>r? checkParsingsz@HTTPClientParserTests.test_parseBadVersion..checkParsingfoos foo/bar/bazsfoo/sfoo/..sfoo/a.bs foo/-1.-1)r rr)rOrrr>rr?test_parseBadVersionxs  z*HTTPClientParserTests.test_parseBadVersioncCbtddtd}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 r^r`ra r*rbr rrrrHresponseversioncodephraserOrequestrr>r>r?test_responseStatusParsings   z0HTTPClientParserTests.test_responseStatusParsingcCr)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 r^r`rrrr>r>r? test_responseStatusWithoutPhrases   z6HTTPClientParserTests.test_responseStatusWithoutPhrasecs,tddfdd}|d|ddS)z L{HTTPClientParser.statusReceived} raises L{ParseError} if it is called with a status line which cannot be parsed. Ncs"tj|}|j|dSri)rwr#rrHrrrrOr>r?rzBHTTPClientParserTests.test_badResponseStatus..checkParsingrsHTTP/1.1 bar OK)r )rOrr>rr?test_badResponseStatuss  z,HTTPClientParserTests.test_badResponseStatusc si}g}g}gt||j}|j|_t}|||||j|j_fdd|j_ ||| |j d| |j t | |g| |dg| dg| |jjd|S)a0 Assert that L{HTTPClientParser} parses the given C{response} to C{request}, resulting in a response with no body and no extra bytes and leaving the transport in the producing state. @param request: A L{Request} instance which might have caused a server to return the given response. @param status: A string giving the status line of the response to be parsed. @param response: A string giving the response to be parsed. @return: A C{dict} of headers from the response. c dSNTr~r>bodyDataFinishedr>r? z3HTTPClientParserTests._noBodyTest.. producingrTr)r r~rrrrrr_bodyDataReceived_bodyDataFinishedrH producerStaterrlength) rOrrrrfinishedbodyrrcr>rr? _noBodyTests&      z!HTTPClientParserTests._noBodyTestcCs8tddtd}d}d}||||}||ddidS)z If the response is to a HEAD request, no body is expected, the body callback is not invoked, and the I{Content-Length} header is passed to the header callback. HEADrNrsContent-Length: 10 sContent-Lengths10)r*rbrrH)rOrrrrr>r>r?test_headResponses z'HTTPClientParserTests.test_headResponsecC(tddtd}d}d}||||dS)z If the response code is I{NO CONTENT} (204), no body is expected and the body callback is not invoked. rrNsHTTP/1.1 204 NO CONTENT rr*rbrrOrrrr>r>r?test_noContentResponsez,HTTPClientParserTests.test_noContentResponsecCr)z If the response code is I{NOT MODIFIED} (304), no body is expected and the body callback is not invoked. rrNsHTTP/1.1 304 NOT MODIFIED rrrr>r>r?test_notModifiedResponserz.HTTPClientParserTests.test_notModifiedResponsecCsttddtddd}|t|d|d|d||jti||j j td d gi| |j j t dS) zq The response headers are added to the response object's C{headers} L{Headers} instance. rrNcSrhrir>restr>r>r?rz.rs X-Foo: bar rx-foorr r*rbrrrrH connHeadersr2rrassertIdenticalrrrr>r>r?test_responseHeaderss    z*HTTPClientParserTests.test_responseHeaderscCsttddtddd}|t|d|d|d|d ||jti||j j td d gi| |j j t dS) z The multi-line response headers are folded and added to the response object's C{headers} L{Headers} instance. rrNcSrhrir>rr>r>r?rrzEHTTPClientParserTests.test_responseHeadersMultiline..rsX-Multiline: a s b rs x-multilinesa brrr>r>r?test_responseHeadersMultilines     z3HTTPClientParserTests.test_responseHeadersMultilinecCsttddtddd}|t|d|d|d|d ||jjt i||j t d gd gd ||jj d dS)zv The connection control headers are added to the parser's C{connHeaders} L{Headers} instance. rrNcSrhrir>rr>r>r?r)rz>HTTPClientParserTests.test_connectionHeaders..rContent-Length: 123 sConnection: close r123sclose)rr{ r r*rbrrrrHrrr2rrrr>r>r?test_connectionHeaders#s     z,HTTPClientParserTests.test_connectionHeaderscCsttddtddd}|t|d|d|d||jjt d d gi||j t i||jj d dS) z If a HEAD request is made, the I{Content-Length} header in the response is added to the response headers, not the connection control headers. rrNcSrhrir>rr>r>r?r=rzRHTTPClientParserTests.test_headResponseContentLengthEntityHeader..rrrrrrrrr>r>r?*test_headResponseContentLengthEntityHeader7s    z@HTTPClientParserTests.test_headResponseContentLengthEntityHeadercCsg}ttddtd|j}t}|||dg}|j|j_|d|d| |j d| |j t |d| |dg| |j t |d | |dd g| |j t | |d gdS) z If a response includes a body with a length given by the I{Content-Length} header, the bytes which make up the body are passed to the C{_bodyDataReceived} callback on the L{HTTPParser}. rrNrsContent-Length: 10 rpausedsxxxxxxsyyyyr)r r*rbr~rrrrrrHrrrrrOrrrcrr>r>r?test_contentLengthIs(       z(HTTPClientParserTests.test_contentLengthcCsg}ttddtd|j}|t|dg}|j|j_|d|d| |j t | |g| |dg| |jj ddS) z If a response includes a I{Content-Length} header indicating zero bytes in the response, L{Response.length} is set accordingly and no data is delivered to L{Response._bodyDataReceived}. rrNrContent-Length: 0 rrr) r r*rbr~rrrrrrHrrrrOrrrr>r>r?test_zeroContentLengthhs      z,HTTPClientParserTests.test_zeroContentLengthcCs4ttddtdd}|t|t|jddS)z If a response includes multiple I{Content-Length} headers, L{HTTPClientParser.dataReceived} raises L{ValueError} to indicate that the response is invalid and the transport is now unusable. rrNs9HTTP/1.1 200 OK Content-Length: 1 Content-Length: 2 )r r*rbrrrw ValueErrorrrr>r>r?!test_multipleContentLengthHeaderss z7HTTPClientParserTests.test_multipleContentLengthHeaderscCdg}ttddtd|j}|t|d|d|d||jt ||dgdS)zy If extra bytes are received past the end of a response, they are passed to the finish callback. rrNrr Here is another thing!Here is another thing! r r*rbr~rrrrHrrrOrrr>r>r?test_extraBytesPassedBack    z/HTTPClientParserTests.test_extraBytesPassedBackcCr)z If extra bytes are received past the end of the headers of a response to a HEAD request, they are passed to the finish callback. rrNrsContent-Length: 12 rrrrr>r>r?test_extraBytesPassedBackHEADrz3HTTPClientParserTests.test_extraBytesPassedBackHEADcCsg}ttddtd|j}|t|dg}|j|j_|d|d| |g| |jj t |d| |dg|d | |dd g|d | |d gdS) z If the response headers indicate the response body is encoded with the I{chunked} transfer encoding, the body is decoded according to that transfer encoding before being passed to L{Response._bodyDataReceived}. rrNrsTransfer-Encoding: chunked rs3 aasbc sbcs 0 extrasextra) r r*rbr~rrrrrrHrrrrr>r>r?test_chunkedResponseBodys$         z.HTTPClientParserTests.test_chunkedResponseBodycCsg}ttddtd|j}t}|||dg}|j|j_|d|d|d| |ddg| t d| |d gdS) z If a response does not include a I{Transfer-Encoding} or a I{Content-Length}, the end of response body is indicated by the connection being closed. rrNrrrrzsimulated end of connectionr) r r*rbr~rrrrrrHconnectionLostr rr>r>r?test_unknownContentLengths      z/HTTPClientParserTests.test_unknownContentLengthcCslg}ttddtd|j}t}|||dg}|j|j_|d| |dg| |dgdS)z According to RFC 2616, section 4.4, point 3, if I{Content-Length} and I{Transfer-Encoding: chunked} are present, I{Content-Length} MUST be ignored rrNrs@Content-Length: 102 Transfer-Encoding: chunked 3 abc 0 abcr) r r*rbr~rrrrrrHrr>r>r?%test_contentLengthAndTransferEncodings    z;HTTPClientParserTests.test_contentLengthAndTransferEncodingcCsHt}ttddtdd}|||j}|ttt ||tgS)z If L{HTTPClientParser.connectionLost} is called before the headers are finished, the C{_responseDeferred} is fired with the L{Failure} passed to C{connectionLost}. rrN) rr r*rbr_responseDeferredr rr8rY)rOrcrresponseDeferredr>r>r?test_connectionLostBeforeBodys  z3HTTPClientParserTests.test_connectionLostBeforeBodycCst|t}t}ttddtdd}||g}|j |j | d|d}d dd}||_ | d|dt||d}|d }||jt|tdS) z If one of the L{Response} methods called by L{HTTPClientParser.connectionLost} raises an exception, the exception is logged and not re-raised. rrN&HTTP/1.1 200 OK Content-Length: 1 rcStrir8)rJr>r>r?fakeBodyDataFinished0zPHTTPClientParserTests.test_connectionLostWithError..fakeBodyDataFinishedr_ log_failureri)rcreateWithCleanuprrr r*rbrrrRr~rrr  assertEqualsrIassertIsInstancerr8flushLoggedErrors)rO logObserverrcrrreventrr>r>r?test_connectionLostWithErrors     z2HTTPClientParserTests.test_connectionLostWithErrorcCsBttddtddd}|j}|t|t||t S)z If no response at all was received and the connection is lost, the resulting error is L{ResponseNeverReceived}. rrNcSrhrir>ignr>r>r?rBrz.) r r*rbrrrr r rQr0rOrrUr>r>r?test_noResponseAtAll<s   z*HTTPClientParserTests.test_noResponseAtAllcCsVttddtddd}|j}|t|d|t| |t  |j t S)z If a partial response was received and the connection is lost, the resulting error is L{ResponseFailed}, but not L{ResponseNeverReceived}. rrNcSrhrir>r r>r>r?rQrzBHTTPClientParserTests.test_someResponseButNotAll..2) r r*rbrrrrr r rQr/rRrr"r>r>r?test_someResponseButNotAllJs    z0HTTPClientParserTests.test_someResponseButNotAllcCsd}ttddtddd}|t|||t|dddu||j t |t t |j d|t t |jd||jdS) zy If a response in the 1XX range is received it just gets swallowed and the parser resets itself. HTTP/1.1 103 Early Hints Server: socketserver/1.0.0 Link: ; rel=preload; as=style Link: ; rel=preload; as=script rrNcSrhrir>r r>r>r?rjrzCHTTPClientParserTests.test_1XXResponseIsSwallowed..rr)r r*rbrrrrgetattrrHrrrIrrrr_everReceivedData)rOsample103Responserr>r>r?test_1XXResponseIsSwallowed\s  z1HTTPClientParserTests.test_1XXResponseIsSwallowedcCsd}d}ttddtddd}|t|||||jjd||jj t i||j t d d gi||jj d dS) z When a 1XX response is swallowed, the final response that follows it is the only one that gets sent to the application. r&(HTTP/1.1 200 OK Content-Length: 123 rrNcSrhrir>r r>r>r?rrzUHTTPClientParserTests.test_1XXFollowedByFinalResponseOnlyEmitsFinal..r`rrr r r*rbrrrrHrrrr2rrrOr)following200Responserr>r>r?-test_1XXFollowedByFinalResponseOnlyEmitsFinalvs zCHTTPClientParserTests.test_1XXFollowedByFinalResponseOnlyEmitsFinalcCsd}d}ttddtddd}|t|||||||jjd||jj t i||j t d d gi||jj d dS) zp It is acceptable for multiple 1XX responses to come through, all of which get ignored. r&r+rrNcSrhrir>r r>r>r?rrzKHTTPClientParserTests.test_multiple1XXResponsesAreIgnored..r`rrrr,r-r>r>r?#test_multiple1XXResponsesAreIgnoreds( z9HTTPClientParserTests.test_multiple1XXResponsesAreIgnoredcCszt|t}d}ttddtddd}|t||| dt ||d}| |d d | |d d dS) zF When a 1XX response is ignored, Twisted emits a log. r&rrNcSrhrir>r r>r>r?rrzHHTTPClientParserTests.test_ignored1XXResponseCausesLog..r_r log_formatz#Ignoring unexpected {code} responserg) rrrr r*rbrrrrrI)rOrr)rrr>r>r? test_ignored1XXResponseCausesLogs   z6HTTPClientParserTests.test_ignored1XXResponseCausesLogN)!r:r;r<r=rrrrrrrrrrrrrrrrrr r r rrrr#r%r*r/r0r3r>r>r>r?rjs> $   % rc@s,eZdZdZdZdZdZddZddZdS) SlowRequesta L{SlowRequest} is a fake implementation of L{Request} which is easily controlled externally (for example, by code in a test method). @ivar stopped: A flag indicating whether C{stopWriting} has been called. @ivar finished: After C{writeTo} is called, a L{Deferred} which was returned by that method. L{SlowRequest} will never fire this L{Deferred}. rFcCst|_|jSri)rrrOrcr>r>r?writeToszSlowRequest.writeTocC d|_dSrstoppedrjr>r>r? stopWriting zSlowRequest.stopWritingN) r:r;r<r=methodr9 persistentr6r:r>r>r>r?r4s  r4c@seZdZdZdZddZdS) SimpleRequesta L{SimpleRequest} is a fake implementation of L{Request} which writes a short, fixed string to the transport passed to its C{writeTo} method and returns a succeeded L{Deferred}. This vaguely emulates the behavior of a L{Request} with no body producer. FcCs|dtdS)N SOME BYTES)writerr5r>r>r?r6s zSimpleRequest.writeToN)r:r;r<r=r=r6r>r>r>r?r>s r>c@s*eZdZdZddZddZddZdd Zd d Zd d Z dIddZ ddZ ddZ ddZ ddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd5d6Zd7d8Zd9d:Zd;d<Z d=d>Z!d?d@Z"dAdBZ#dCdDZ$dEdFZ%dGdHZ&dS)JHTTP11ClientProtocolTestsz] Tests for the HTTP 1.1 client protocol implementation, L{HTTP11ClientProtocol}. cCs"t|_t|_|j|jdS)zR Create an L{HTTP11ClientProtocol} connected to a fake transport. N)rrcr(rrrjr>r>r?setUpszHTTP11ClientProtocolTests.setUpcCs$|jt||jddS)z L{HTTP11ClientProtocol.request} accepts a L{Request} and calls its C{writeTo} method with its own transport. r?N)rrr>rHrcrrjr>r>r? test_requestsz&HTTP11ClientProtocolTests.test_requestcs>jtfdd}jtt}|||S)z The second time L{HTTP11ClientProtocol.request} is called, it returns a L{Deferred} which immediately fires with a L{Failure} wrapping a L{RequestNotSent} exception. cjddSNrrHrcrignoredrjr>r? cbNotSent z?HTTP11ClientProtocolTests.test_secondRequest..cbNotSent)rrr4rQr>r$rRrOrIrUr>rjr?test_secondRequests   z,HTTP11ClientProtocolTests.test_secondRequestcsDjttdfdd}jtt}|||S)z L{HTTP11ClientProtocol.request} returns a L{Deferred} which immediately fires with a L{Failure} wrapping a L{RequestNotSent} if called after the protocol has been disconnected. z sad transportcrDrErFrGrjr>r?rIrJzLHTTP11ClientProtocolTests.test_requestAfterConnectionLost..cbNotSent) rr rr rQrr>r$rRrKr>rjr?test_requestAfterConnectionLosts   z9HTTP11ClientProtocolTests.test_requestAfterConnectionLostcsDGddd}j|}fdd}t|tg}|||S)a% If the L{Deferred} returned by L{Request.writeTo} fires with a L{Failure}, L{HTTP11ClientProtocol.request} disconnects its transport and returns a L{Deferred} which fires with a L{Failure} of L{RequestGenerationFailed} wrapping the underlying failure. c@re)zCHTTP11ClientProtocolTests.test_failedWriteTo..BrokenRequestFcSs ttSri)rr8r5r>r>r?r6,r;zKHTTP11ClientProtocolTests.test_failedWriteTo..BrokenRequest.writeToNr:r;r<r=r6r>r>r>r? BrokenRequest) rOcs&jjjttddS)Nzyou asked for it)rrc disconnectingrr rr rGrjr>r?rP1sz>HTTP11ClientProtocolTests.test_failedWriteTo..cbFailed)rrr[r8rR)rOrOrUrPr>rjr?test_failedWriteTo!s   z,HTTP11ClientProtocolTests.test_failedWriteTocCs*Gddd}|j|}t||tgS)z If L{Request.writeTo} raises an exception, L{HTTP11ClientProtocol.request} returns a L{Deferred} which fires with a L{Failure} of L{RequestGenerationFailed} wrapping that exception. c@re)zMHTTP11ClientProtocolTests.test_synchronousWriteToError..BrokenRequestFcSrrirr5r>r>r?r6ErzUHTTP11ClientProtocolTests.test_synchronousWriteToError..BrokenRequest.writeToNrNr>r>r>r?rOBrPrO)rrr[r8)rOrOrUr>r>r?test_synchronousWriteToError;sz6HTTP11ClientProtocolTests.test_synchronousWriteToErrorNcCst}|j|}t||tg}||j|jtt| |j|dkr1|j d|S|dkrM|j tt |t }|t|d|S |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. callbackNerrbackr_)r4rrr]r8rr9r rrrrTrUrArrHrI)rOmoderrUerrorsr>r>r?*test_connectionLostDuringRequestGenerationKs      zDHTTP11ClientProtocolTests.test_connectionLostDuringRequestGenerationcC |dS)z If the request passed to L{HTTP11ClientProtocol} finishes generation successfully after the L{HTTP11ClientProtocol}'s connection has been lost, nothing happens. rTrXrjr>r>r?+test_connectionLostBeforeGenerationFinishedk zEHTTP11ClientProtocolTests.test_connectionLostBeforeGenerationFinishedcCrY)z If the request passed to L{HTTP11ClientProtocol} finished generation with an error after the L{HTTP11ClientProtocol}'s connection has been lost, nothing happens. rUrZrjr>r>r?)test_connectionLostBeforeGenerationFailedsr\zCHTTP11ClientProtocolTests.test_connectionLostBeforeGenerationFailedcs*ttfdd}d|S)a  If the request passed to L{HTTP11ClientProtocol} finished generation with an error after the L{HTTP11ClientProtocol}'s connection has been lost, an error is logged that gives a non-confusing hint to user on what went wrong. csHdtd}d||dd|dddS)Nr_rrr1zJError writing request, but not in valid state to finalize request: {state}rCONNECTION_LOST)rrIassertInrH)ignorerrrOr>r?checks znHTTP11ClientProtocolTests.test_errorMessageOnConnectionLostBeforeGenerationFailedDoesNotConfuse..checkrU)rrrrXrR)rOrbr>rar?Etest_errorMessageOnConnectionLostBeforeGenerationFailedDoesNotConfuse{s  z_HTTP11ClientProtocolTests.test_errorMessageOnConnectionLostBeforeGenerationFailedDoesNotConfusec<jtddtd}fdd}||jd|S)z When a response is delivered to L{HTTP11ClientProtocol}, the L{Deferred} previously returned by the C{request} method is called back with a L{Response} instance and the connection is closed. rrNcs@|jd|jtjjjjddS)Nr` QUIESCENT) rHrrr2rrcrQrrrrjr>r? cbRequestszIHTTP11ClientProtocolTests.test_receiveSimplestResponse..cbRequests9HTTP/1.1 200 OK Content-Length: 0 Connection: close rrr*rbrRrrOrUrgr>rjr?test_receiveSimplestResponses  z6HTTP11ClientProtocolTests.test_receiveSimplestResponsecrd)z The headers included in a response delivered to L{HTTP11ClientProtocol} are included on the L{Response} instance passed to the callback returned by the C{request} method. rrNcs"tdddgi}|j|dS)Nrrr)r2rHr)rrrjr>r?rgrzHHTTP11ClientProtocolTests.test_receiveResponseHeaders..cbRequests+HTTP/1.1 200 OK X-Foo: bar X-Foo: baz rhrir>rjr?test_receiveResponseHeaderss  z5HTTP11ClientProtocolTests.test_receiveResponseHeaderscspgttjt}dfdd}||fdd}|||S)a[ If response bytes are delivered to L{HTTP11ClientProtocol} before the L{Deferred} returned by L{Request.writeTo} fires, those response bytes are parsed as part of the response. The connection is also closed, because we're in a confusing state, and therefore the C{quiescentCallback} isn't called. s8HTTP/1.1 200 OK X-Foo: bar Content-Length: 6 foobarcsVtt}_jdjg|fddS)N%TRANSMITTING_AFTER_RECEIVING_RESPONSEc jfSrirr prr>r?rrzoHTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone..cbResponse..) rrclosedDeferred deliverBodyrHrrrQrRr whenFinished)rquiescentResultrOrcror? cbResponses    z]HTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone..cbResponsecsf|\}}|jd|jd|jd|jtddgi|djddS)Nr^r`rarrfoobar)rHrrrrr2rrT)resultrrrrOr>r? cbAllResponses z`HTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone..cbAllResponse)rr(r~rr4rrrRrOrUrvrzr>)rrurrOrcr?/test_receiveResponseBeforeRequestGenerationDones      zIHTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDonecCsZt}t}||_||dtj}|tddtd}| d|dt ||t gS)zy The connection is closed when the server respond with a header which is above the maximum line. r rrNsHTTP/1.1 200 OK X-Foo: s X-Ignored: ignored ) rr(rrr MAX_LENGTHrr*rbrrYr )rOrcrlongLinerUr>r>r?"test_receiveResponseHeadersTooLongs   zr?rrzHTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDone..cbResponse..)rrrqrrrRrsr>ror?rvs  zrHTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDone..cbResponsecs2jdjttjjddS)Nr^)rrTrr rr8rHrs)r`ryr>r?rzs zuHTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDone..cbAllResponse)r4rrrrRr{r>ryr?Dtest_connectionLostAfterReceivingResponseBeforeRequestGenerationDones   z^HTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDonecstt}_jtddtd}jdg}||j  |gjd|d}| jdjdfd d }|||S) z The C{deliverBody} method of the response object with which the L{Deferred} returned by L{HTTP11ClientProtocol.request} fires can be used to get the body of the response. rrNs%HTTP/1.1 200 OK Content-Length: 6 rrrrcsjdjtdS)Nrw)rHr closedReasonrGr.rGrr>r?rzJszIHTTP11ClientProtocolTests.test_receiveResponseBody..cbAllResponse) rrrqrrr*rbrrRr~rHrr)rOrtrequestDeferredrxrrzr>rr?test_receiveResponseBody(s&         z2HTTP11ClientProtocolTests.test_receiveResponseBodycCs|jtddtd}|jdg}||j|d}t}|||jd|jd| |j d|j t t d |jtdS) z If the length of the response body is unknown, the protocol passed to the response's C{deliverBody} method has its C{connectionLost} method called with a L{Failure} wrapping a L{PotentialDataLoss} exception. rrNsHTTP/1.1 200 OK rrrrwz low-level transport disconnected)rrr*rbrrRr~rrrrHrr rr rrGr)rOrrxrrr>r>r?Etest_responseBodyFinishedWhenConnectionLostWhenContentLengthIsUnknownQs        z_HTTP11ClientProtocolTests.test_responseBodyFinishedWhenConnectionLostWhenContentLengthIsUnknowncCs|jtddtd}|jdg}||j|d}t}|||jd|jd| |j d|j t t t|t|jt tgS) a If the final chunk has not been received when the connection is lost (for any reason), the protocol passed to C{deliverBody} has its C{connectionLost} method called with a L{Failure} wrapping the exception for that reason. rrNs/HTTP/1.1 200 OK Transfer-Encoding: chunked r3 foo s3 bar rw)rrr*rbrrRr~rrrrHrr rr8rYrrr1rr>r>r?4test_chunkedResponseBodyUnfinishedWhenConnectionLostns$     zNHTTP11ClientProtocolTests.test_chunkedResponseBodyUnfinishedWhenConnectionLostcsJjtddtd}jdt|tg}fdd}|||S)a! If the parser L{HTTP11ClientProtocol} delivers bytes to in C{dataReceived} raises an exception, the exception is wrapped in a L{Failure} and passed to the parser's C{connectionLost} and then the L{HTTP11ClientProtocol}'s transport is disconnected. rrNsunparseable garbage goes here cs<jj|jdjjdjt t ddS)Nrsunparseable garbage goes herez it is done) rrcrQrHrFrrrr rr rrjr>r?rPs zLHTTP11ClientProtocolTests.test_parserDataReceivedException..cbFailed)rrr*rbrrYr#rR)rOrrUrPr>rjr? test_parserDataReceivedExceptions    z:HTTP11ClientProtocolTests.test_parserDataReceivedExceptioncCs`|jtddtd}|jjj}||j|j|jt t d||jdt ||t gS)z When the HTTP response parser is disconnected, the L{TransportProxyProducer} which was connected to it as a transport is stopped. rrNzconnection done) rrr*rb_parserrcr _producer_disconnectParserrr rY)rOrrcr>r>r?test_proxyStoppeds  z+HTTP11ClientProtocolTests.test_proxyStoppedcCst}t}||g}g}||j||j|||fggf||j| t t ||dg||dgdS)z L{HTTP11ClientProtocol.abort} will tell the transport to close its connection when it is invoked, and returns a C{Deferred} that fires when the connection is lost. N) rr(rabortrRr~rHrrQr rr )rOrcrr1r2r>r>r?test_abortClosesConnections  z4HTTP11ClientProtocolTests.test_abortClosesConnectioncCsZt}t}|||ttg}||j| |dg| |j ddS)z L{HTTP11ClientProtocol.abort} called after the connection is lost returns a C{Deferred} that fires immediately. Nr^) rr(rr rr rrRr~rHrsrOrcrrxr>r>r?test_abortAfterConnectionLosts z7HTTP11ClientProtocolTests.test_abortAfterConnectionLostcCs\t}t}|||tddtd}|||j| t t t ||t gS)a The Deferred returned by L{HTTP11ClientProtocol.request} will fire with a L{ResponseFailed} failure containing a L{ConnectionAborted} exception, if the connection was aborted before all response headers have been received. rrN)rr(rrr*rbrrrQr rr rYrrr>r>r?test_abortBeforeResponseBodys  z6HTTP11ClientProtocolTests.test_abortBeforeResponseBodycstddttddtd}dtGfdddtfd d }fd d }| |t t t g}| |S) aS When the connection is aborted after the response headers have been received and the L{Response} has been made available to application code, the response body protocol's C{connectionLost} method will be invoked with a L{ResponseFailed} failure containing a L{ConnectionAborted} exception. T)lenientrrNrcs(eZdZdZfddZfddZdS)zQHTTP11ClientProtocolTests.test_abortAfterResponseHeaders..BodyDestinationzl A body response protocol which immediately aborts the HTTP connection. cs dS)z< Abort the HTTP connection. N)rrj)rr>r?connectionMades z`HTTP11ClientProtocolTests.test_abortAfterResponseHeaders..BodyDestination.connectionMadecs|dS)z Make the reason for the losing of the connection available to the unit test via C{testResult}. N)rUrOrK) testResultr>r?r  rZz`HTTP11ClientProtocolTests.test_abortAfterResponseHeaders..BodyDestination.connectionLostN)r:r;r<r=rr r>)rrr>r?BodyDestinations rcs,|jttdS)z Connect the L{BodyDestination} response body protocol to the response, and then simulate connection loss after ensuring that the HTTP connection has been aborted. N)rrrrQr rr rf)rrrOrcr>r?rrs  zMHTTP11ClientProtocolTests.test_abortAfterResponseHeaders..deliverBodycs|jtdSri)rrr-)errorrjr>r? checkErrorzLHTTP11ClientProtocolTests.test_abortAfterResponseHeaders..checkError) rr(rrr*rbrrr rRrYrr1)rOrxrrrrSr>)rrrOrrcr?test_abortAfterResponseHeaderss      z8HTTP11ClientProtocolTests.test_abortAfterResponseHeadersc sgfdd}t}t||tddtddd}dgg}||j |d }t }t |_ |j fd d | |d |jtd gjdjdjdjdjddS)a If after a response is done the {HTTP11ClientProtocol} stays open and returns to QUIESCENT state, all per-request state is reset and the C{quiescentCallback} is called with the protocol instance. This is useful for implementing a persistent connection pool. The C{quiescentCallback} is called *before* the response-receiving protocol's C{connectionLost}, so that new requests triggered by end of first request can re-use a persistent connection. c(||jd|dSNrerHrr~rprrurOr>r?rT5 zHHTTP11ClientProtocolTests.test_quiescentCallbackCalled..callbackrrNTr=s&HTTP/1.1 200 OK Content-length: 3 rcr)N response donerr )rur>r?rOrzHHTTP11ClientProtocolTests.test_quiescentCallbackCalled..rr)rr(rrr*rbrrHrRr~rrrqrrrrGr.r_finishedRequest_currentRequest_transportProxyr)rOrTrcrrxr bodyProtocolr>rr?test_quiescentCallbackCalled's6         z6HTTP11ClientProtocolTests.test_quiescentCallbackCalledc sgfdd}t}t||tddtddd}d|}|j d t d |j d dS) a The C{quiescentCallback} passed to L{HTTP11ClientProtocol} will only be invoked once that protocol is in a state similar to its initial state. One of the aspects of this initial state is the producer-state of its transport; an L{HTTP11ClientProtocol} begins with a transport that is producing, i.e. not C{pauseProducing}'d. Therefore, when C{quiescentCallback} is invoked the protocol will still be producing. crrrrrr>r?rTmrz]HTTP11ClientProtocolTests.test_transportProducingWhenQuiescentAfterFullBody..callbackrrNTrs)HTTP/1.1 200 OK Content-length: 3 BBBDEFERRED_CLOSEr_r) rr(rrr*rbrsuccessResultOfrHrsrIr)rOrTrcrrr>rr?1test_transportProducingWhenQuiescentAfterFullBody`s   zKHTTP11ClientProtocolTests.test_transportProducingWhenQuiescentAfterFullBodyc sgfdd}t}t||tddtddd}|jd t d  d  d t dS) z The quiescentCallback is called before the request C{Deferred} fires, in cases where the response has no body. crrrrrr>r?rTrzUHTTP11ClientProtocolTests.test_quiescentCallbackCalledEmptyResponse..callbackrrNTr&HTTP/1.1 200 OK Content-length: 0 rrr_)rr(rrr*rbrRr~rrHrIrrr-)rOrTrcrr>rr?)test_quiescentCallbackCalledEmptyResponses   zCHTTP11ClientProtocolTests.test_quiescentCallbackCalledEmptyResponsec Cg}t}t|j}|||tddtddd}|dg}||j|d}t }| ||j t ||g||jdS)z If after a response is done the {HTTP11ClientProtocol} returns a C{Connection: close} header in the response, the C{quiescentCallback} is not called and the connection is lost. rrNTrs9HTTP/1.1 200 OK Content-length: 0 Connection: close rrr(r~rrr*rbrrRrrrrrGr.rHrrQrOrurcrrrxrrr>r>r?test_quiescentCallbackNotCalleds$      z9HTTP11ClientProtocolTests.test_quiescentCallbackNotCalledc Cr)z If the request was non-persistent (i.e. sent C{Connection: close}), the C{quiescentCallback} is not called and the connection is lost. rrNFrrrrrr>r>r?1test_quiescentCallbackNotCalledNonPersistentQuerys        zKHTTP11ClientProtocolTests.test_quiescentCallbackNotCalledNonPersistentQueryc Csdd}t|t}t}t|}|||tddtddd}| dg}| |j |d }t }| ||jt|d t||d } | d } || jt|t||jdS) zx If C{quiescentCallback} throws an exception, the error is logged and protocol is disconnected. cSrri)ZeroDivisionErrorrr>r>r?rTrzHHTTP11ClientProtocolTests.test_quiescentCallbackThrows..callbackrrNTrrrr_r)rrrrr(rrr*rbrrRr~rrrrrGr.rrIrrrrrrQ) rOrTrrcrrrxrrrrr>r>r?test_quiescentCallbackThrowss*       z6HTTP11ClientProtocolTests.test_quiescentCallbackThrowscCsNt}t}|||tddtd}|||jt ||t t gS)a The L{Deferred} returned by L{HTTP11ClientProtocol.request} will fire with a L{ResponseNeverReceived} failure containing a L{CancelledError} exception if the request was cancelled before any response headers were received. rrN) rr(rrr*rbcancelr disconnectedrVr0rrr>r>r?test_cancelBeforeResponses   z3HTTP11ClientProtocolTests.test_cancelBeforeResponsecCsVt}t}|||tddtd}|d|||j t ||t gS)a The L{Deferred} returned by L{HTTP11ClientProtocol.request} will fire with a L{ResponseFailed} failure containing a L{CancelledError} exception if the request was cancelled before all response headers were received. rrNr) rr(rrr*rbrrrrrYrrr>r>r?test_cancelDuringResponses   z3HTTP11ClientProtocolTests.test_cancelDuringResponsecst}t}||t|ddifddfdd}|_|tddt}j d | | |j | dt ||tgS) a The L{Deferred} returned by L{HTTP11ClientProtocol.request} will fire with a L{RequestGenerationFailed} failure containing a L{CancelledError} exception if the request was cancelled before a C{bodyProducer} has finished producing. cancelledFcs dd<dS)NTrr>r )nonLocalr>r?r2 zJHTTP11ClientProtocolTests.assertCancelDuringBodyProduction..cancelcs|_t_jSriconsumerrr)r)rproducerr>r?startProducing5s zRHTTP11ClientProtocolTests.assertCancelDuringBodyProduction..startProducingPOST/barsxxxxx)rr(rStringProducerrrr*rbrr@rrrr[r)rOproducerLengthrcrrrxr>)rrrr? assertCancelDuringBodyProduction$s    z:HTTP11ClientProtocolTests.assertCancelDuringBodyProductioncCrY)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. )rrjr>r>r?test_cancelDuringBodyProductionC z9HTTP11ClientProtocolTests.test_cancelDuringBodyProductioncCs |tS)a' The L{Deferred} returned by L{HTTP11ClientProtocol.request} will fire with a L{RequestGenerationFailed} failure containing a L{CancelledError} exception if the request was cancelled before a C{bodyProducer} with C{UNKNOWN_LENGTH} has finished producing. )rrrjr>r>r?&test_cancelDuringChunkedBodyProductionLrz@HTTP11ClientProtocolTests.test_cancelDuringChunkedBodyProductionri)'r:r;r<r=rBrCrLrMrRrSrXr[r]rcrjrkr|rrrrrrrrrrrrrrrrrrrrrrr>r>r>r?rAsJ  2 ) :9.# rAc@s<eZdZdZdZddZddZddZd d Zd d Z d S)ra L{StringProducer} is a dummy body producer. @ivar stopped: A flag which indicates whether or not C{stopProducing} has been called. @ivar consumer: After C{startProducing} is called, the value of the C{consumer} argument to that method. @ivar finished: After C{startProducing} is called, a L{Deferred} which was returned by that method. L{StringProducer} will never fire this L{Deferred}. FcCs ||_dSri)r)rOrr>r>r?__init__fr;zStringProducer.__init__cCs||_t|_|jSrir)rOrr>r>r?riszStringProducer.startProducingcCr7rr8rjr>r>r? stopProducingnr;zStringProducer.stopProducingcCrhrir>rjr>r>r?pauseProducingqzStringProducer.pauseProducingcCrhrir>rjr>r>r?resumeProducingurzStringProducer.resumeProducingN) r:r;r<r=r9rrrrrr>r>r>r?rVs  rc@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd5d)d*Zd+d,Zd-d.Zd/d0Zd1d2Zd3d4Zd(S)6 RequestTestsz Tests for L{Request}. cCs t|_dSri)rrcrjr>r>r?rBrzRequestTests.setUpcCs,tddtd|j||jddS)zk L{Request.writeTo} formats the request data and writes it to the given transport. rrNs8GET / HTTP/1.1 Connection: close Host: example.com r*rbr6rcrHrrjr>r>r?test_sendSimplestRequests z%RequestTests.test_sendSimplestRequestcCs4tddtddd}||j||jddS)zO A pesistent request does not send 'Connection: close' header. rrNTrs%GET / HTTP/1.1 Host: example.com r)rOreqr>r>r?"test_sendSimplestPersistentRequests  z/RequestTests.test_sendSimplestPersistentRequestcCstddgdgd}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. rrrC)rrBr/fooNrrGET /foo HTTP/1.1r)Connection: closesHost: example.comrr)r2r*r6rcrsplitrHsort)rOrlinesr>r>r?test_sendRequestHeaderssz$RequestTests.test_sendRequestHeaderscCstD]T}t||gddgi}t}tdd|d||d}||dd||d dd d g|d=|d d=|d |d d t t g}|||gqdS)z_ Linear whitespace in request headers is replaced with a single space. rBsexample.invalidrrNrrrrrrsHost: example.invalids: ) r5r2rr*r6rrrHremoverr6)rO componentrrcrsanitizedHeaderLiner>r>r?-test_sanitizeLinearWhitespaceInRequestHeaderss  z:RequestTests.test_sanitizeLinearWhitespaceInRequestHeaderscCstt}tddt|}||j||jd||jj || |jj | |j d|j|jd|jd|jd||jj d| |j ddS)z L{Request.writeTo} uses chunked encoding to write data from the request body producer to the given transport. It registers the request body producer with the transport. rrNsXPOST /bar HTTP/1.1 Connection: close Transfer-Encoding: chunked Host: example.com sxxxsyyyyyyyyyyyyyyys!3 xxx f yyyyyyyyyyyyyyy 0 )rrr*rbr6rcassertNotIdenticalrrrr streamingrHrclearr@rrTrOrrr>r>r?test_sendChunkedRequestBodys&     z(RequestTests.test_sendChunkedRequestBodycs`tt}tddt|}|j}j|jt fdd} |t }| ||S)a If L{Request} is created with a C{bodyProducer} without a known length and the L{Deferred} returned from its C{startProducing} method fires with a L{Failure}, the L{Deferred} returned by L{Request.writeTo} fires with that L{Failure} and the body producer is unregistered from the transport. The final zero-length chunk is not written to the transport. rrcs&jdjjddSrE)rHrcrrrrGrjr>r?rPszCRequestTests.test_sendChunkedRequestBodyWithError..cbFailed) rrr*rbr6rcrrrUr8rQrR)rOrr writeDeferredrPrUr>rjr?$test_sendChunkedRequestBodyWithErrors      z1RequestTests.test_sendChunkedRequestBodyWithErrorcCstd}tddt|}||j||jd||jj|| |jj | |j d|j |jd|jd||jjd| |j ddS)z If L{Request} is created with a C{bodyProducer} with a known length, that length is sent as the value for the I{Content-Length} header and chunked encoding is not used. rrNsOPOST /bar HTTP/1.1 Connection: close Content-Length: 3 Host: example.com r)rr*rbr6rcrrrrrrrHrrr@rrTrr>r>r?test_sendRequestBodyWithLengths    z+RequestTests.test_sendRequestBodyWithLengthcCs4t|dtd}||j||j|ddS)a" Verify that the message generated by a L{Request} initialized with the given method and C{None} as the C{bodyProducer} includes I{Content-Length: 0} in the header. @param method: The HTTP method issue in the request. @type method: L{bytes} rNsK /foo HTTP/1.1 Connection: close Content-Length: 0 Host: example.com r)rOr<rr>r>r?_sendRequestEmptyBodyWithLengths  z,RequestTests._sendRequestEmptyBodyWithLengthcC|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. sPUTNrrjr>r>r?test_sendPUTRequestEmptyBody(z)RequestTests.test_sendPUTRequestEmptyBodycCr)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. rNrrjr>r>r?test_sendPOSTRequestEmptyBody0rz*RequestTests.test_sendPOSTRequestEmptyBodycCsVtd}tddt|}||j}|jd|jd| |jj d| |t S)a If L{Request} is created with a C{bodyProducer} with a known length and the producer does not produce that many bytes, the L{Deferred} returned by L{Request.writeTo} fires with a L{Failure} wrapping a L{WrongBodyLength} exception. rrrabN) rr*rbr6rcrr@rrTrrrQr&rOrrrr>r>r?#test_sendRequestBodyWithTooFewBytes8s    z0RequestTests.test_sendRequestBodyWithTooFewBytescstdtddt}|j}jdjjd j jj dfdd} |t }|||S) a7 Verify that when too many bytes have been written by a body producer and then the body producer's C{startProducing} L{Deferred} fires that the producer is unregistered from the transport and that the L{Deferred} returned from L{Request.writeTo} is fired with a L{Failure} wrapping a L{WrongBodyLength}. @param finisher: A callable which will be invoked with the body producer after too many bytes have been written to the transport. It should fire the startProducing Deferred somehow. rrrrcdNcsLjdjtjjdjddS)NsQPOST /bar HTTP/1.1 Connection: close Content-Length: 3 Host: example.com absefr)rHrcrrrwrrr@rfinisherrrOr>r?rPgs zCRequestTests._sendRequestBodyWithTooManyBytesTest..cbFailed)rr*rbr6rcrr@rr9rrrrQr&rR)rOrrrrPrUr>rr?$_sendRequestBodyWithTooManyBytesTestGs        z1RequestTests._sendRequestBodyWithTooManyBytesTestcCsdd}||S) If L{Request} is created with a C{bodyProducer} with a known length and the producer tries to produce more than than many bytes, the L{Deferred} returned by L{Request.writeTo} fires with a L{Failure} wrapping a L{WrongBodyLength} exception. cS|jddSrirrTrr>r>r?rzCRequestTests.test_sendRequestBodyWithTooManyBytes..finisher)rrOrr>r>r?$test_sendRequestBodyWithTooManyBytess z1RequestTests.test_sendRequestBodyWithTooManyBytescs$ttfdd}|S)rcsV|jtd}d||d}|jtt}t|ddS)Nrrr_) rrUr8r_rrrrHrI)rrrrWrar>r?rs  zHRequestTests.test_sendRequestBodyErrorWithTooManyBytes..finisher)rrrrrr>rar?)test_sendRequestBodyErrorWithTooManyBytess  z6RequestTests.test_sendRequestBodyErrorWithTooManyBytescCst|t}td}tddt|}||j|jj }|j d|j d| t|d}|d||d}||jt|t|tddS) a Though there should be no way for the internal C{finishedConsuming} L{Deferred} in L{Request._writeToBodyProducerContentLength} to fire a L{Failure} after the C{finishedProducing} L{Deferred} has fired, in case this does happen, the error should be logged with a message about how there's probably a bug in L{Request}. This is a whitebox test. rrrrNrrr_)rrrrr*rbr6rcr _finishedr@rrTrUr8r_rrrHrIr)rOrrrfinishedConsumingrrr>r>r?*test_sendRequestBodyErrorWithConsumerErrors      z7RequestTests.test_sendRequestBodyErrorWithConsumerErrorcCsxtd}tddt|}||j}|jd||||jjd|j | t |jjd| |j d|S)a Verify that if the body producer fires its Deferred and then keeps writing to the consumer that the extra writes are ignored and the L{Deferred} returned by L{Request.writeTo} fires with a L{Failure} wrapping the most appropriate exception type. rrrrNrr)rr*rbr6rcrr@rrrrwrrHr)rOrrrrr>r>r?-_sendRequestBodyFinishedEarlyThenTooManyBytess   z:RequestTests._sendRequestBodyFinishedEarlyThenTooManyBytescCdd}|||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}. cSrrirrr>r>r?rrzPRequestTests.test_sendRequestBodyFinishedEarlyThenTooManyBytes..finisher)rQrr&rr>r>r?1test_sendRequestBodyFinishedEarlyThenTooManyBytes z>RequestTests.test_sendRequestBodyFinishedEarlyThenTooManyBytescCr)a3 If the request body producer indicates an error by firing the L{Deferred} returned from its C{startProducing} method but then goes on to write too many bytes, the L{Deferred} returned by {Request.writeTo} fires with that L{Failure} and L{WrongBodyLength} is logged. cSs|jtdSri)rrUr8rr>r>r?rrzORequestTests.test_sendRequestBodyErroredEarlyThenTooManyBytes..finisher)rQrr8rr>r>r?0test_sendRequestBodyErroredEarlyThenTooManyBytesrz=RequestTests.test_sendRequestBodyErroredEarlyThenTooManyBytesNcCs`tt}tddt|}||j}|j||j| t |j j d| |jd|S)a If the request body producer with an unknown length tries to write after firing the L{Deferred} returned by its C{startProducing} method, the C{write} call raises an exception and does not write anything to the underlying transport. rrrr)rrr*rbr6rcrrTrrwrrr@rHr)rO_withrrrr>r>r?0test_sendChunkedRequestBodyFinishedThenWriteMores   z=RequestTests.test_sendChunkedRequestBodyFinishedThenWriteMorecCs|tt}||tS)a$ If the request body producer with an unknown length tries to write after firing the L{Deferred} returned by its C{startProducing} method with a L{Failure}, the C{write} call raises an exception and does not write anything to the underlying transport. )rrr8rQ)rOrUr>r>r?9test_sendChunkedRequestBodyFinishedWithErrorThenWriteMore s zFRequestTests.test_sendChunkedRequestBodyFinishedWithErrorThenWriteMorecCstd}tddt|}||j}||jj|||jj|j d| |j d| |jj|jtt| |jj||jjd||tS)z If the L{Deferred} returned from the C{startProducing} method of the L{IBodyProducer} passed to L{Request} fires with a L{Failure}, the L{Deferred} returned from L{Request.writeTo} fails with that L{Failure}. rrrsQPOST /bar HTTP/1.1 Connection: close Content-Length: 5 Host: example.com abN)rr*rbr6rcrrrrrr@rHrrrQrrUrr8rQrr>r>r?test_sendRequestBodyWithError s    z*RequestTests.test_sendRequestBodyWithErrorcCsxtddtid}|t|j|j||jdtddtdddgid}|t|j|j||jddS)z L{Request.writeTo} raises L{BadHeaders} if there is not exactly one I{Host} header and writes nothing to the given transport. rrNrsHostrCs example.org)r*r2rwrr6rcrHr)rOrr>r>r?test_hostHeaderRequired; sz$RequestTests.test_hostHeaderRequiredcCsFtd}tddt|}||j||j|||jdS)zc L{Request.stopWriting} calls its body producer's C{stopProducing} method. rrrN) rr*rbr6rcrr9r:rrr>r>r?test_stopWritingJ s   zRequestTests.test_stopWritingcCst|t}td}dd}||_tddt|}||j| | t | t d|dt ||d}|d||d}||jt d S) z If the body producer's C{stopProducing} method raises an exception, L{Request.stopWriting} logs it and does not re-raise it. rcSstdNzstopProducing is bustedrr>r>r>r?brokenStopProducing^ szBRequestTests.test_brokenStopProducing..brokenStopProducingrrr_rrN)rrrrrr*rbr6rcr:rHrIrr8rr_rr)rOrrrrrrr>r>r?test_brokenStopProducingV s   z%RequestTests.test_brokenStopProducingri)r:r;r<r=rBrrrrrrrrrrrrrrrrrrrr r r r rr>r>r>r?rzs6 !A   ' rc@sReZdZdZddZddZddZdd d Zd d Zd dZ ddZ ddZ dS)LengthEnforcingConsumerTestsz/ Tests for L{LengthEnforcingConsumer}. cCs2t|_td|_t|_t|j|j|j|_dS)Nr)rrxrrrrcr"enforcerrjr>r>r?rBs s    z"LengthEnforcingConsumerTests.setUpcCsJ|jd||jd|j|jd||jddS)z L{LengthEnforcingConsumer.write} calls the wrapped consumer's C{write} method with the bytes it is passed as long as there are fewer of them than the C{length} attribute indicates remain to be received. rsdefN)rr@rHrcrrrjr>r>r? test_write{ s   z'LengthEnforcingConsumerTests.test_writecCs |jd|t|jjdS)z L{LengthEnforcingConsumer._noMoreWritesExpected} raises L{WrongBodyLength} if it is called before the indicated number of bytes have been written. s xxxxxxxxxN)rr@rwr&_noMoreWritesExpectedrjr>r>r?test_finishedEarly s z/LengthEnforcingConsumerTests.test_finishedEarlyFcCsP|jd||jj|jd||jj|r!|j||jt S)aN If it is called with a total number of bytes exceeding the indicated limit passed to L{LengthEnforcingConsumer.__init__}, L{LengthEnforcingConsumer.write} fires the L{Deferred} with a L{Failure} wrapping a L{WrongBodyLength} and also calls the C{stopProducing} method of the producer. xxxxxxxxxxx) rr@rrr9rrrQrxr&)rO_unregisterAfterr>r>r?test_writeTooMany s   z.LengthEnforcingConsumerTests.test_writeTooManycCsH|jd|j||jj|t|jjd||jjdS)z If L{LengthEnforcingConsumer.write} is called after L{LengthEnforcingConsumer._noMoreWritesExpected}, it calls the producer's C{stopProducing} method and raises L{ExcessWrite}. rrN) rr@rrrr9rwrrrjr>r>r?test_writeAfterNoMoreExpected s  z:LengthEnforcingConsumerTests.test_writeAfterNoMoreExpectedcCrY)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)rrjr>r>r?test_finishedLate r\z.LengthEnforcingConsumerTests.test_finishedLatecCs"|jd||jddS)z If L{LengthEnforcingConsumer._noMoreWritesExpected} is called after the correct number of bytes have been written it returns L{None}. rN)rr@rrrjr>r>r? test_finished s z*LengthEnforcingConsumerTests.test_finishedcs6fdd}|j_fdd}}|||S)a8 If L{LengthEnforcingConsumer.write} calls the producer's C{stopProducing} because too many bytes were written and the C{stopProducing} method raises an exception, the exception is logged and the L{LengthEnforcingConsumer} still errbacks the finished L{Deferred}. cstjtdr)rrrr8r>rjr>r?r s zRLengthEnforcingConsumerTests.test_stopProducingRaises..brokenStopProducingcsttddS)Nr_)rHrIrr8rGrjr>r? cbFinished szILengthEnforcingConsumerTests.test_stopProducingRaises..cbFinished)rrrrR)rOrrrUr>rjr?test_stopProducingRaises s   z5LengthEnforcingConsumerTests.test_stopProducingRaisesN)F) r:r;r<r=rBrrrrrrrr>r>r>r?rn s   rc@s(eZdZdZddZddZddZdS) RequestBodyConsumerTestsz Tests for L{ChunkedEncoder} which sits between an L{ITransport} and a request/response body producer and chunked encodes everything written to it. cCs|ttttdS)zC L{ChunkedEncoder} instances provide L{IConsumer}. N)rrr rrrjr>r>r?test_interface sz'RequestBodyConsumerTests.test_interfacecCsNt}t|}|d||d||d||ddS)z} L{ChunkedEncoder.write} writes to the transport the chunked encoded form of the bytes passed to it. rrsxxxxxxxxxxxxxxxxs10 xxxxxxxxxxxxxxxx N)rrr@rHrr)rOrcencoderr>r>r?r s  z#RequestBodyConsumerTests.test_writecCsdt}t}t|}||d||j|||j|||jd| | ddS)a L{ChunkedEncoder.registerProducer} registers the given streaming producer with its transport and L{ChunkedEncoder.unregisterProducer} writes a zero-length chunk to its transport and unregisters the transport's producer. TNs0 ) rrrregisterProducerrrrrunregisterProducerrHr)rOrcrr!r>r>r?test_producerRegistration s  z2RequestBodyConsumerTests.test_producerRegistrationN)r:r;r<r=r rr$r>r>r>r?r s  rc@sHeZdZdZddZddZddZdd Zd d Zd d Z ddZ dS)TransportProxyProducerTestszn Tests for L{TransportProxyProducer} which proxies the L{IPushProducer} interface of a transport. cCs|tttddS)zO L{TransportProxyProducer} instances provide L{IPushProducer}. N)rrr r%rjr>r>r?r  sz*TransportProxyProducerTests.test_interfacecCs6t}t|}||j||||jddS)z~ L{TransportProxyProducer.stopProxying} drops the reference to the wrapped L{IPushProducer} provider. N)rr%rr stopProxyingrOrcproxyr>r>r?%test_stopProxyingUnreferencesProducer s zATransportProxyProducerTests.test_stopProxyingUnreferencesProducercCsdt}|t|}||jd|||jd|||||jddS)z L{TransportProxyProducer.resumeProducing} calls the wrapped transport's C{resumeProducing} method unless told to stop proxying. rrN)rrr%rHrrr&r'r>r>r?test_resumeProducing sz0TransportProxyProducerTests.test_resumeProducingcCs\t}t|}||jd|||jd|||||jddS)z L{TransportProxyProducer.pauseProducing} calls the wrapped transport's C{pauseProducing} method unless told to stop proxying. rrN)rr%rHrrrr&r'r>r>r?test_pauseProducing, sz/TransportProxyProducerTests.test_pauseProducingcCsbt}t|}||jd|||jdt}t|}||||jddS)z L{TransportProxyProducer.stopProducing} calls the wrapped transport's C{stopProducing} method unless told to stop proxying. rr9N)rr%rHrrr&r'r>r>r?test_stopProducingA sz.TransportProxyProducerTests.test_stopProducingcCsdt}t}||||_t|}||j||jd| ||jd| |jdS)zs L{TransportProxyProducer.loseConnection} calls the wrapped transport's C{loseConnection}. rN) rrrrr%r connectedrHrloseConnectionrrOrcrr(r>r>r? test_loseConnectionWhileProxyingU s  zr>r?test_loseConnectionNotProxyingj s  z:TransportProxyProducerTests.test_loseConnectionNotProxyingN) r:r;r<r=r r)r*r+r,r0r1r>r>r>r?r% s  r%c@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZddZd S)! ResponseTestsz Tests for L{Response}. cCstt}|tt|dS)z= L{Response} instances provide L{IResponse}. N)rdrrrr4rOrr>r>r?test_verifyInterface s z"ResponseTests.test_verifyInterfacecslgt}Gfdddt}|}t|}||\}|||jd|||jddS)z The L{IProtocol} provider passed to L{Response.deliverBody} has its C{makeConnection} method called with an L{IPushProducer} provider hooked up to the response as an argument. ceZdZfddZdS)z7ResponseTests.test_makeConnection..SomeProtocolc|dSrir)rOr producersr>r?r zFResponseTests.test_makeConnection..SomeProtocol.makeConnectionNr:r;r<rr>r7r>r? SomeProtocol r;rrN)rr rdrrrrHrr)rOrcr;rr theProducerr>r7r?test_makeConnection s z!ResponseTests.test_makeConnectioncsNgGfdddt}|}tt}|||d|dgdS)z The L{IProtocol} provider passed to L{Response.deliverBody} has its C{dataReceived} method called with bytes received as part of the response body. cr5)z5ResponseTests.test_dataReceived..ListConsumercr6rirrOrrr>r?r r9zBResponseTests.test_dataReceived..ListConsumer.dataReceivedNr:r;r<rr>r@r>r? ListConsumer r<rBrN)r rdrrrrrHrOrBrrr>r@r?test_dataReceived s   zResponseTests.test_dataReceivedcsjgGfdddt}|}tt}|||dt|td| |j ddS)z The L{IProtocol} provider passed to L{Response.deliverBody} has its C{connectionLost} method called with a L{Failure} wrapping L{ResponseDone} when the response's C{_bodyDataFinished} method is called. cr5)z7ResponseTests.test_connectionLost..ListConsumercr6rirrlostr>r?r  r9zFResponseTests.test_connectionLost..ListConsumer.connectionLostN)r:r;r<r r>rEr>r?rB r<rBrr_N) r rdrrrrrGr.rHrIr _bodyProtocolrCr>rEr?test_connectionLost s  z!ResponseTests.test_connectionLostcsrgGfdddt}|}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. cr5)z8ResponseTests.test_bufferEarlyData..ListConsumercr6rirr?r@r>r?r r9zEResponseTests.test_bufferEarlyData..ListConsumer.dataReceivedNrAr>r@r>r?rB r<rBrrr)rrrN)r rdrrrrrHr _bodyBuffer)rOrBrrr>r@r?test_bufferEarlyData s     z"ResponseTests.test_bufferEarlyDatacCs,tt}|t|t|jtdS)zb L{Response.deliverBody} raises L{RuntimeError} if called more than once. N)rdrrrr rwrxr3r>r>r? test_multipleStartProducingFails s  z.ResponseTests.test_multipleStartProducingFailscCs4tt}|t||t|jtdS)zw L{Response.deliverBody} raises L{RuntimeError} if called after L{Response._bodyDataFinished}. N)rdrrrr rrwrxr3r>r>r?%test_startProducingAfterFinishedFails s  z3ResponseTests.test_startProducingAfterFinishedFailscCs&tt}||t|jddS)z L{Response._bodyDataReceived} raises L{RuntimeError} if called after L{Response._bodyDataFinished} but before L{Response.deliverBody}. rN)rdrrrwrxrr3r>r>r?'test_bodyDataReceivedAfterFinishedFails s z5ResponseTests.test_bodyDataReceivedAfterFinishedFailscCs2tt}||t|t|jddS)z L{Response._bodyDataReceived} raises L{RuntimeError} if called after L{Response._bodyDataFinished} and after L{Response.deliverBody}. rN)rdrrrrr rwrxrr3r>r>r?'test_bodyDataReceivedAfterDeliveryFails s  z5ResponseTests.test_bodyDataReceivedAfterDeliveryFailscCs$tt}||t|jdS)zh L{Response._bodyDataFinished} raises L{RuntimeError} if called more than once. N)rdrrrwrxr3r>r>r?'test_bodyDataFinishedAfterFinishedFails s z5ResponseTests.test_bodyDataFinishedAfterFinishedFailscCs0tt}||t|t|jdS)z{ L{Response._bodyDataFinished} raises L{RuntimeError} if called after the body has been delivered. N)rdrrrrr rwrxr3r>r>r?'test_bodyDataFinishedAfterDeliveryFails s  z5ResponseTests.test_bodyDataFinishedAfterDeliveryFailscslgGfdddt}t}||}t|}||jd|||dg||jddS)z L{Response.deliverBody} resumes the HTTP connection's transport after passing it to the consumer's C{makeConnection} method. cr5)z9ResponseTests.test_transportResumed..ListConsumercs|jdSri)r~rr5transportStater>r?r# rzHResponseTests.test_transportResumed..ListConsumer.makeConnectionNr:r>rQr>r?rB" r<rBrrN)r rrrdrHrrr)rOrBrcrrr>rQr?test_transportResumed s z#ResponseTests.test_transportResumedcCsXt}t|}|d|d|t}||||jd|j t dS)z If the entire body is delivered to the L{Response} before the response's C{deliverBody} method is called, the protocol passed to C{deliverBody} is immediately given the body data and then disconnected. rrrwN) rrdrrrrrrHrrrGr.rOrcrrr>r>r?)test_bodyDataFinishedBeforeStartProducing/ s   z7ResponseTests.test_bodyDataFinishedBeforeStartProducingcCsLt}t|}t}||||jd|tt|j tdS)a  The L{Failure} passed to L{Response._bodyDataFinished} when the response is in the I{connected} state is passed to the C{connectionLost} method of the L{IProtocol} provider passed to the L{Response}'s C{deliverBody} method. CONNECTEDN) rrdrrrrHrsrrr8rrGrTr>r>r?#test_finishedWithErrorWhenConnectedA s z1ResponseTests.test_finishedWithErrorWhenConnectedcCsLt}t|}||jd|ttt}|||j tdS)a The L{Failure} passed to L{Response._bodyDataFinished} when the response is in the I{initial} state is passed to the C{connectionLost} method of the L{IProtocol} provider passed to the L{Response}'s C{deliverBody} method. INITIALN) rrdrHrsrrr8rrrrrGrTr>r>r?!test_finishedWithErrorWhenInitialT s z/ResponseTests.test_finishedWithErrorWhenInitialN)r:r;r<r=r4r>rDrHrJrKrLrMrNrOrPrSrUrWrYr>r>r>r?r2} s"       r2N)_r=typingrzope.interfacerzope.interface.verifyrtwisted.internet.deferrrrrtwisted.internet.errorr r twisted.internet.interfacesr r twisted.internet.protocolr twisted.loggerrtwisted.protocols.basicrtwisted.python.failurertwisted.test.proto_helpersrrrrtwisted.trial.unittestrtwisted.web._newclientrrrrrrrrrrr r!r"r#r$r%r&r'twisted.web.clientr(r)r*r+r,r-r.r/r0twisted.web.httpr1twisted.web.http_headersr2twisted.web.iwebr3r4twisted.web.test.requesthelperr5r6 Exceptionr8rArbrVrYr[r]rdrfr{rrrr4r>rArrrrr%r2r>r>r>r?sp        P, (   !`o#we,~