o Óó·iˆ·ã@s¦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@mAZAddlBmCZCmDZDddlEmFZFmGZGGdd„deHƒZIGdd„deHƒZJeAddgiƒZKdd„ZLdd„ZMdd„ZNd 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/ƒZVGd0d1„d1ƒZWGd2d3„d3e ƒZXeeCƒGd4d5„d5ƒƒZYGd6d7„d7e ƒZZGd8d9„d9e ƒZ[Gd:d;„d;e ƒZ\Gdd?„d?e ƒZ^d@S)Az& Tests for L{twisted.web._newclient}. é)ÚOptional)Ú implementer)Ú verifyObject)ÚCancelledErrorÚDeferredÚfailÚsucceed)ÚConnectionDoneÚConnectionLost)Ú IConsumerÚ IPushProducer)ÚProtocol)ÚAccumulatingProtocolÚEventLoggingObserverÚStringTransportÚ StringTransportWithDisconnection)ÚglobalLogPublisher)Ú LineReceiver)ÚFailure)ÚTestCase)ÚBODYÚDONEÚHEADERÚSTATUSÚUNKNOWN_LENGTHÚ BadHeadersÚBadResponseVersionÚChunkedEncoderÚConnectionAbortedÚ ExcessWriteÚHTTPClientParserÚ HTTPParserÚLengthEnforcingConsumerÚ ParseErrorÚRequestNotSentÚTransportProxyProducerÚWrongBodyLengthÚmakeStatefulDispatcher) ÚHTTP11ClientProtocolÚPotentialDataLossÚRequestÚRequestGenerationFailedÚRequestTransmissionFailedÚResponseÚ ResponseDoneÚResponseFailedÚResponseNeverReceived)Ú _DataLoss)ÚHeaders)Ú IBodyProducerÚ IResponse)ÚbytesLinearWhitespaceComponentsÚsanitizedBytesc@óeZdZdZdS)ÚArbitraryExceptionze A unique, arbitrary exception type which L{twisted.web._newclient} knows nothing about. N©Ú__name__Ú __module__Ú __qualname__Ú__doc__©r>r>úeC:\Users\psant\Downloads\PAF backend\school\venv\Lib\site-packages\twisted/web/test/test_newclient.pyr8Cór8c@r7)ÚAnotherArbitraryExceptionzI Similar to L{ArbitraryException} but with a different identity. Nr9r>r>r>r?rAJr@rAóhostó example.comcs(‡‡fdd„}ˆ ||¡}| |¡|S)a• Assert that the given L{Deferred} fails with the exception given by C{mainType} and that the exceptions wrapped by the instance of C{mainType} it fails with match the list of exception types given by C{reasonTypes}. This is a helper for testing failures of exceptions which subclass L{_newclient._WrapperException}. @param self: A L{TestCase} instance which will be used to make the assertions. @param deferred: The L{Deferred} which is expected to fail with C{mainType}. @param mainType: A L{_newclient._WrapperException} subclass which will be trapped on C{deferred}. @param reasonTypes: A sequence of exception types which will be trapped on the resulting C{mainType} exception instance's C{reasons} sequence. @return: A L{Deferred} which fires with the C{mainType} instance C{deferred} fails with, or which fails somehow. c sLt|jˆƒD] \}}| |¡qˆ t|jƒtˆƒd|j›dˆ›d¡|S)Nzlen(z ) != len(ú))ÚzipÚreasonsÚtrapÚ assertEqualÚlen)ÚerrÚreasonÚtype©Ú reasonTypesÚselfr>r?ÚcbFailedns ýz-assertWrapperExceptionTypes..cbFailedN)Ú assertFailureÚ addCallback)rOÚdeferredZmainTyperNrPÚdr>rMr?ÚassertWrapperExceptionTypesUs rUcCót||t|ƒS)zo A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{ResponseFailed}. N)rUr/©rOrSrNr>r>r?ÚassertResponseFailed}órXcCrV)zx A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{RequestGenerationFailed}. N)rUr+rWr>r>r?ÚassertRequestGenerationFailed…óÿrZcCrV)zz A simple helper to invoke L{assertWrapperExceptionTypes} with a C{mainType} of L{RequestTransmissionFailed}. N)rUr,rWr>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. ©sHTTPér^éÈóOKN)r-Ú_boringHeaders)Ú transportr>r>r?ÚjustTransportResponse™srcc@óeZdZdZdd„ZdS)ÚMakeStatefulDispatcherTestsz. Tests for L{makeStatefulDispatcher}. cCsRGdd„dƒ}|ƒ}| | ¡d¡d|_| | ¡d¡d|_| t|j¡dS)z‹ A method defined with L{makeStatefulDispatcher} invokes a second method based on the current state of the object. c@s2eZdZdZdd„ZedeƒZdd„Zdd„Zd S) zCMakeStatefulDispatcherTests.test_functionCalledByState..FooÚAcSódS©Nr>©rOr>r>r?Úbar±ózGMakeStatefulDispatcherTests.test_functionCalledByState..Foo.barZquuxcSódS)NÚar>rir>r>r?Ú_quux_A¶rkzKMakeStatefulDispatcherTests.test_functionCalledByState..Foo._quux_AcSrl)NÚbr>rir>r>r?Ú_quux_B¹rkzKMakeStatefulDispatcherTests.test_functionCalledByState..Foo._quux_BN)r:r;r<Ú_staterjr'rnrpr>r>r>r?ÚFoo®s   rrrmÚBroÚCN)rHrjrqÚ assertRaisesÚ RuntimeError)rOrrZstatefulr>r>r?Útest_functionCalledByState¨sz6MakeStatefulDispatcherTests.test_functionCalledByStateN)r:r;r<r=rwr>r>r>r?re£s rec@sreZdZUdZdZeeed<dd„Zdd„Z dd „Z d d „Z d d „Z dd„Z dd„Zdd„Zdd„Zdd„ZdS)Ú_HTTPParserTestszt Base test class for L{HTTPParser} which is responsible for the bulk of the task of parsing HTTP bytes. NÚsepcCs\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!ÚappendÚstatusReceivedÚmakeConnectionrrHÚstaterÚ dataReceivedryr)rOÚstatusÚprotocolr>r>r?Útest_statusCallbackÌs z$_HTTPParserTests.test_statusCallbackcCs6i}tƒ}|j|_| tƒ¡| d|j¡||fS)Nrz)r!Ú __setitem__ÚheaderReceivedr}rrry©rOÚheaderrr>r>r?Ú_headerTestSetupÚs  z!_HTTPParserTests._headerTestSetupcCsJ| ¡\}}| d|j¡| |j¡| |ddi¡| |jt¡dS)ze L{HTTPParser} calls its C{headerReceived} method when it receives a header. s X-Foo:baróX-FooóbarN©r‡rryrHr~rr…r>r>r?Útest_headerCallbackâs  z$_HTTPParserTests.test_headerCallbackcCsj| ¡\}}| d|j¡| d|j¡| d|j¡| |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 quuxrˆs bar baz quuxNrŠr…r>r>r?Útest_continuedHeaderCallbackïs  z-_HTTPParserTests.test_continuedHeaderCallbackcCsZ| ¡\}}|j gd¢¡}| d|¡| d|¡| |j¡| |dddœ¡dS)zŒ Leading and trailing linear whitespace is stripped from the header value passed to the C{headerReceived} callback. )s s bar s ósX-Bar:sX-Foo:r‰)rˆsX-BarN)r‡ryÚjoinrrH)rOr†rÚvaluer>r>r?Útest_fieldContentWhitespaceüs  z,_HTTPParserTests.test_fieldContentWhitespacecsPg‰| ¡\}‰‡‡fdd„}|ˆ_ˆ |j¡| ˆtg¡| ˆjt¡dS)zg After the last header is received, L{HTTPParser} calls C{allHeadersReceived}. csˆ ˆj¡tˆ_dSrh)r{r~rr>©Úcalledrr>r?ÚallHeadersReceiveds  zD_HTTPParserTests.test_allHeadersCallback..allHeadersReceivedN)r‡r”rryrHrr~r)rOr†r”r>r’r?Útest_allHeadersCallbacks  z(_HTTPParserTests.test_allHeadersCallbackcCs6| ¡\}}| |j¡| |i¡| |jt¡dS)zp If there are no headers in the message, L{HTTPParser} does not call C{headerReceived}. NrŠr…r>r>r?Útest_noHeaderCallbacks   z&_HTTPParserTests.test_noHeaderCallbackcCsvtƒ}| tƒ¡| d|j¡| d|j¡| d|j¡| |j¡dddgfg}| |t|j ¡ƒ¡dS)zc All headers received by L{HTTPParser} are added to L{HTTPParser.headers}. rzrŒó X-Foo: bazrˆr‰óbazN) r!r}rrryrHÚlistÚheadersÚgetAllRawHeaders)rOrÚexpectedr>r>r?Útest_headersSavedOnResponse#s  z,_HTTPParserTests.test_headersSavedOnResponsecCsFtƒ}gd¢}|D]}| | |¡d|f¡q | | d¡d¡dS)zð L{HTTPParser.isConnectionControlHeader} returns C{True} for headers which are always connection control headers (similar to "hop-by-hop" headers from RFC 2616 section 13.5.1) and C{False} for other headers. )ócontent-lengthó connections keep-alivestestrailersstransfer-encodingsupgradesproxy-connectionz:Expecting %r to be a connection control header, but wasn'tsdatez`Expecting the arbitrarily selected 'date' header to not be a connection control header, but was.N)r!Ú assertTrueZisConnectionControlHeaderÚ assertFalse)rOrZconnHeaderNamesr†r>r>r?Útest_connectionControlHeaders1s ÿþþz._HTTPParserTests.test_connectionControlHeaderscCs4tƒ}| tƒ¡| tƒ¡| t|jtƒ¡dS)zi L{HTTPParser.switchToBodyMode} raises L{RuntimeError} if called more than once. N)r!r}rZswitchToBodyModeÚobjectrurv©rOrr>r>r?Útest_switchToBodyModeOs  z&_HTTPParserTests.test_switchToBodyMode)r:r;r<r=ryrÚbytesÚ__annotations__r‚r‡r‹rr‘r•r–rr¢r¥r>r>r>r?rxÄs      rxc@óeZdZdZdZdS)Ú$HTTPParserRFCComplaintDelimeterTestsz< L{_HTTPParserTests} using standard CR LF newlines. ó N©r:r;r<r=ryr>r>r>r?r©Zór©c@r¨)Ú'HTTPParserNonRFCComplaintDelimeterTestsz5 L{_HTTPParserTests} using bare LF newlines. ó Nr«r>r>r>r?r­br¬r­c@s eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd(d)„Zd*d+„Zd,d-„Zd.d/„Zd0d1„Zd2d3„Zd4d5„Zd6d7„Zd8d9„Zd:d;„Z dd?„Z"d@dA„Z#dBdC„Z$dDdE„Z%dFS)GÚHTTPClientParserTestszd Tests for L{HTTPClientParser} which is responsible for parsing HTTP response messages. cCs tddƒ}| | d¡d¡dS)zj L{HTTPClientParser.parseVersion} parses a status line into its three components. Ns CANDY/7.2)sCANDYéé)r rHÚ parseVersionr¤r>r>r?Útest_parseVersionps z'HTTPClientParserTests.test_parseVersioncsXtddƒ}t‰|j‰‡‡‡fdd„}|dƒ|dƒ|dƒ|dƒ|dƒ|d ƒdS) zr L{HTTPClientParser.parseVersion} raises L{ValueError} when passed an unparsable version. Ncs ˆ ˆˆ|¡}ˆ |j|¡dSrh)rurHÚdata©ÚsÚexc©ÚeÚfrOr>r?Ú checkParsingsz@HTTPClientParserTests.test_parseBadVersion..checkParsingófoos foo/bar/bazsfoo/sfoo/..sfoo/a.bs foo/-1.-1)r rr²)rOrr»r>r¸r?Útest_parseBadVersionxs  z*HTTPClientParserTests.test_parseBadVersioncCóbtddtdƒ}t|dƒ}| tƒ¡| d¡| |jjd¡| |jj d¡| |jj d¡dS)zž L{HTTPClientParser.statusReceived} parses the version, code, and phrase from the status line and stores them on the response object. óGETó/NóHTTP/1.1 200 OK r]r_r`© r*rar r}rrrHÚresponseÚversionÚcodeÚphrase©rOÚrequestrr>r>r?Útest_responseStatusParsingŽs   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). r¿rÀNsHTTP/1.1 200 r]r_rŽrÂrÇr>r>r?Ú test_responseStatusWithoutPhrase›s   z6HTTPClientParserTests.test_responseStatusWithoutPhrasecs,tddƒ‰‡‡fdd„}|dƒ|dƒdS)zŒ L{HTTPClientParser.statusReceived} raises L{ParseError} if it is called with a status line which cannot be parsed. Ncs"ˆ tˆj|¡}ˆ |j|¡dSrh)rur#r|rHr´rµ©rrOr>r?r»°ózBHTTPClientParserTests.test_badResponseStatus..checkParsingr¼sHTTP/1.1 bar OK)r )rOr»r>rËr?Útest_badResponseStatus©s  z,HTTPClientParserTests.test_badResponseStatusc sºi}g}g}g‰t||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ó ˆ d¡S©NT©r{r>©ZbodyDataFinishedr>r?ÚÖó z3HTTPClientParserTests._noBodyTest..Ú producingrŽTrN)r r{rƒr„rr}rrÃÚ_bodyDataReceivedÚ_bodyDataFinishedrHÚ producerStater~rÚlength) rOrÈr€rÃr†ÚfinishedÚbodyrrbr>rÑr?Ú _noBodyTest¼s&      z!HTTPClientParserTests._noBodyTestcCs8tddtdƒ}d}d}| |||¡}| |ddi¡dS)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. óHEADrÀNrÁsContent-Length: 10 sContent-Lengths10)r*rarÛrH)rOrÈr€rÃr†r>r>r?Útest_headResponseàs 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. r¿rÀNsHTTP/1.1 204 NO CONTENT rª©r*rarÛ©rOrÈr€rÃr>r>r?Útest_noContentResponseìóz,HTTPClientParserTests.test_noContentResponsecCrÞ)z‚ If the response code is I{NOT MODIFIED} (304), no body is expected and the body callback is not invoked. r¿rÀNsHTTP/1.1 304 NOT MODIFIED rªrßràr>r>r?Útest_notModifiedResponseörâz.HTTPClientParserTests.test_notModifiedResponsecCs‚ttddtdƒdd„ƒ}| 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. r¿rÀNcSrgrhr>©Úrestr>r>r?rÒóz.rÁs X-Foo: bar rªóx-foor‰©r r*rar}rrrHÚ connHeadersr2rÃršÚassertIdenticalrØrr¤r>r>r?Útest_responseHeaderssÿ    z*HTTPClientParserTests.test_responseHeaderscCsŒttddtdƒdd„ƒ}| 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. r¿rÀNcSrgrhr>rär>r>r?rÒræzEHTTPClientParserTests.test_responseHeadersMultiline..rÁsX-Multiline: a s b rªs x-multilinesa brèr¤r>r>r?Útest_responseHeadersMultilinesÿ     ÿz3HTTPClientParserTests.test_responseHeadersMultilinecCsttddtdƒdd„ƒ}| 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. r¿rÀNcSrgrhr>rär>r>r?rÒ)ræz>HTTPClientParserTests.test_connectionHeaders..rÁóContent-Length: 123 sConnection: close rªó123sclose)ržrŸé{© r r*rar}rrrHrÃršr2rérØr¤r>r>r?Útest_connectionHeaders#sÿ     þz,HTTPClientParserTests.test_connectionHeaderscCs‚ttddtdƒdd„ƒ}| 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. rÜrÀNcSrgrhr>rär>r>r?rÒ=ræzRHTTPClientParserTests.test_headResponseContentLengthEntityHeader..rÁrírªržrîrrðr¤r>r>r?Ú*test_headResponseContentLengthEntityHeader7sÿ    ÿz@HTTPClientParserTests.test_headResponseContentLengthEntityHeadercCsÒg}ttddtdƒ|jƒ}tƒ}| |¡| d¡g}|j|j_| d¡| d¡|  |j d¡|  |j t ¡| d¡|  |dg¡|  |j t ¡| d ¡|  |dd g¡|  |j t ¡|  |d g¡dS) 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}. r¿rÀNrÁsContent-Length: 10 rªÚpausedsxxxxxxsyyyyrŽ)r r*rar{rr}rrÃrÕrHr×r~rr©rOrÙrrbrÚr>r>r?Útest_contentLengthIs(ÿ       z(HTTPClientParserTests.test_contentLengthcCsŽg}ttddtdƒ|jƒ}| tƒ¡| d¡g}|j|j_| d¡| d¡|  |j t ¡|  |g¡|  |dg¡|  |jj d¡dS) 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}. r¿rÀNrÁóContent-Length: 0 rªrŽr) r r*rar{r}rrrÃrÕrHr~rrØ©rOrÙrrÚr>r>r?Útest_zeroContentLengthhsÿ      z,HTTPClientParserTests.test_zeroContentLengthcCó4ttddtdƒdƒ}| tƒ¡| t|jd¡dS)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. r¿rÀNs9HTTP/1.1 200 OK Content-Length: 1 Content-Length: 2 ©r r*rar}rruÚ ValueErrorrr¤r>r>r?Ú)test_multipleDistinctContentLengthHeadersó ýz?HTTPClientParserTests.test_multipleDistinctContentLengthHeaderscCóLttddtdƒdƒ}| tƒ¡| d¡| |jjd¡| |j t ¡dS)zË If a response includes multiple, yet equal, I{Content-Length} headers, L{HTTPClientParser.dataReceived} successfully handles and passes single length for body processing r¿rÀNs9HTTP/1.1 200 OK Content-Length: 1 Content-Length: 1 r^© r r*rar}rrrHrÃrØr~rr¤r>r>r?Ú&test_multipleEqualContentLengthHeaders“s ÿzr>r?Ú3test_multipleDistinctContentLengthHeaderFieldValues¥rýzIHTTPClientParserTests.test_multipleDistinctContentLengthHeaderFieldValuescCrþ)a% If a response includes multiple, equal I{Content-Length} header field-values, L{HTTPClientParser.dataReceived} successfully handles and passes single content-length header for body processing. Field-values are considered equal by parsed decimal value. r¿rÀNs+HTTP/1.1 200 OK Content-Length: 1, 001 r^rÿr¤r>r>r?Ú0test_multipleEqualContentLengthHeaderFieldValues´s ÿzFHTTPClientParserTests.test_multipleEqualContentLengthHeaderFieldValuescCrù)zç If the I{Content-Length} header contains anything other than digits L{HTTPClientParser.dataReceived} raises L{ValueError} to indicate that the response is invalid and the transport is now unusable. r¿rÀNs'HTTP/1.1 200 OK Content-Length: +1 rúr¤r>r>r?Útest_contentLengthTooPositiveÄrýz3HTTPClientParserTests.test_contentLengthTooPositivecCrù)zØ If the I{Content-Length} header has a negative value L{HTTPClientParser.dataReceived} raises L{ValueError} to indicate that the response is invalid and the transport is now unusable. r¿rÀNs'HTTP/1.1 200 OK Content-Length: -1 rúr¤r>r>r?Útest_contentLengthNegativeÓrýz0HTTPClientParserTests.test_contentLengthNegativecCódg}ttddtdƒ|jƒ}| tƒ¡| d¡| d¡| d¡| |jt ¡| |dg¡dS)zy If extra bytes are received past the end of a response, they are passed to the finish callback. r¿rÀNrÁröó Here is another thing!óHere is another thing!© r r*rar{r}rrrHr~r©rOrÙrr>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. rÜrÀNrÁsContent-Length: 12 rrrr r>r>r?Útest_extraBytesPassedBackHEADór z3HTTPClientParserTests.test_extraBytesPassedBackHEADcCs¼g}ttddtdƒ|jƒ}| tƒ¡| d¡g}|j|j_| d¡| d¡|  |g¡|  |jj t ¡| d¡|  |dg¡| d ¡|  |dd g¡| d ¡|  |d g¡dS) 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}. r¿rÀNrÁsTransfer-Encoding: chunked rªs3 aóasbc sbcs 0 extrasextra) r r*rar{r}rrrÃrÕrHrêrØrr÷r>r>r?Útest_chunkedResponseBodys$ÿ         z.HTTPClientParserTests.test_chunkedResponseBodycCsg}ttddtdƒ|jƒ}tƒ}| |¡| d¡g}|j|j_| d¡| d¡| d¡|  |ddg¡|  t dƒ¡|  |d g¡dS) 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. r¿rÀNrÁrªr¼r‰zsimulated end of connectionrŽ) r r*rar{rr}rrÃrÕrHÚconnectionLostr rôr>r>r?Útest_unknownContentLength)sÿ      z/HTTPClientParserTests.test_unknownContentLengthcCslg}ttddtdƒ|jƒ}tƒ}| |¡| d¡g}|j|j_| d¡|  |dg¡|  |dg¡dS)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 r¿rÀNrÁs@Content-Length: 102 Transfer-Encoding: chunked 3 abc 0 óabcrŽ) r r*rar{rr}rrÃrÕrHrôr>r>r?Ú%test_contentLengthAndTransferEncodingAsÿ   ÿ z;HTTPClientParserTests.test_contentLengthAndTransferEncodingcCsHtƒ}ttddtdƒdƒ}| |¡|j}| ttƒƒ¡t ||tgƒS)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}. r¿rÀN) rr r*rar}Ú_responseDeferredrrr8rX)rOrbrZresponseDeferredr>r>r?Útest_connectionLostBeforeBody_s  z3HTTPClientParserTests.test_connectionLostBeforeBodycCsªt |t¡}tƒ}ttddtdƒdƒ}| |¡g}|j  |j ¡|  d¡|d}d dd„}||_ |  d¡| dt|ƒ¡|d}|d }| |jt¡| t¡dS) z° If one of the L{Response} methods called by L{HTTPClientParser.connectionLost} raises an exception, the exception is logged and not re-raised. r¿rÀNó&HTTP/1.1 200 OK Content-Length: 1 rcSótƒ‚rh©r8)rJr>r>r?ÚfakeBodyDataFinishedózPHTTPClientParserTests.test_connectionLostWithError..fakeBodyDataFinishedr^Ú log_failurerh)rÚcreateWithCleanuprrr r*rar}rrRr{rrÖrÚ assertEqualsrIÚassertIsInstancerr8ÚflushLoggedErrors)rOÚ logObserverrbrrÃrÚeventrºr>r>r?Útest_connectionLostWithErrorns     z2HTTPClientParserTests.test_connectionLostWithErrorcCsBttddtdƒdd„ƒ}|j}| tƒ¡| tƒ¡| |t ¡S)z‰ If no response at all was received and the connection is lost, the resulting error is L{ResponseNeverReceived}. rÜrÀNcSrgrhr>©Zignr>r>r?rÒ‘ræz.) r r*rarr}rrr rQr0©rOrrTr>r>r?Útest_noResponseAtAll‹sÿ   z*HTTPClientParserTests.test_noResponseAtAllcCsVttddtdƒdd„ƒ}|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}. rÜrÀNcSrgrhr>r"r>r>r?rÒ ræzBHTTPClientParserTests.test_someResponseButNotAll..ó2) r r*rarr}rrrr rQr/rRrr#r>r>r?Útest_someResponseButNotAll™sÿ    ÿz0HTTPClientParserTests.test_someResponseButNotAllcCsšd}ttddtdƒdd„ƒ}| tƒ¡| |¡| t|ddƒdu¡| |j t ¡| t t |j  ¡ƒƒd¡| t t |j ¡ƒƒd¡| |j¡dS) 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 r¿rÀNcSrgrhr>r"r>r>r?rÒ¹ræzCHTTPClientParserTests.test_1XXResponseIsSwallowed..rÃr)r r*rar}rrr ÚgetattrrHr~rrIr™ršr›réZ_everReceivedData)rOÚsample103Responserr>r>r?Útest_1XXResponseIsSwallowed«sÿÿ  z1HTTPClientParserTests.test_1XXResponseIsSwallowedcCsŠd}d}ttddtdƒdd„ƒ}| 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 r¿rÀNcSrgrhr>r"r>r>r?rÒÔræzUHTTPClientParserTests.test_1XXFollowedByFinalResponseOnlyEmitsFinal..r_ržrîrï© r r*rar}rrrHrÃrÅršr2rérØ©rOr)Zfollowing200Responserr>r>r?Ú-test_1XXFollowedByFinalResponseOnlyEmitsFinalÅsÿÿ zCHTTPClientParserTests.test_1XXFollowedByFinalResponseOnlyEmitsFinalcCs’d}d}ttddtdƒdd„ƒ}| 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+r¿rÀNcSrgrhr>r"r>r>r?rÒíræzKHTTPClientParserTests.test_multiple1XXResponsesAreIgnored..r_ržrîrïr,r-r>r>r?Ú#test_multiple1XXResponsesAreIgnoredÞs(ÿÿ ÿþýÿz9HTTPClientParserTests.test_multiple1XXResponsesAreIgnoredcCszt |t¡}d}ttddtdƒdd„ƒ}| tƒ¡| |¡|  dt |ƒ¡|d}|  |d d ¡|  |d d ¡dS) zF When a 1XX response is ignored, Twisted emits a log. r'r¿rÀNcSrgrhr>r"r>r>r?rÒ ræzHHTTPClientParserTests.test_ignored1XXResponseCausesLog..r^rÚ log_formatz#Ignoring unexpected {code} responserÅég) rrrr r*rar}rrrrI)rOrr)rr r>r>r?Ú test_ignored1XXResponseCausesLogüs ÿÿ  z6HTTPClientParserTests.test_ignored1XXResponseCausesLogN)&r:r;r<r=r³r½rÉrÊrÍrÛrÝrárãrërìrñròrõrørürrrrrr r rrrrr!r$r&r*r.r/r2r>r>r>r?r¯jsH $   % r¯c@s,eZdZdZdZdZdZdd„Zdd„ZdS) Ú 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}. r¿FcCstƒ|_|jSrh)rrÙ©rOrbr>r>r?ÚwriteTo%szSlowRequest.writeTocCó d|_dSrÏ©Ústoppedrir>r>r?Ú stopWriting)ó zSlowRequest.stopWritingN) r:r;r<r=Úmethodr8Ú persistentr5r9r>r>r>r?r3s  r3c@seZdZdZdZdd„ZdS)Ú 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| d¡tdƒS)Nó SOME BYTES)Úwriterr4r>r>r?r57s zSimpleRequest.writeToN)r:r;r<r=r<r5r>r>r>r?r=-s r=c@s*eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dIdd„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd „Zd!d"„Zd#d$„Zd%d&„Zd'd(„Zd)d*„Zd+d,„Zd-d.„Zd/d0„Zd1d2„Zd3d4„Zd5d6„Zd7d8„Zd9d:„Zd;d<„Z d=d>„Z!d?d@„Z"dAdB„Z#dCdD„Z$dEdF„Z%dGdH„Z&dS)JÚHTTP11ClientProtocolTestsz] Tests for the HTTP 1.1 client protocol implementation, L{HTTP11ClientProtocol}. cCs"tƒ|_tƒ|_|j |j¡dS)zR Create an L{HTTP11ClientProtocol} connected to a fake transport. N)rrbr(rr}rir>r>r?ÚsetUpBszHTTP11ClientProtocolTests.setUpcCs$|j tƒ¡| |j ¡d¡dS)z† L{HTTP11ClientProtocol.request} accepts a L{Request} and calls its C{writeTo} method with its own transport. r>N)rrÈr=rHrbrrir>r>r?Ú test_requestJsz&HTTP11ClientProtocolTests.test_requestcs>ˆj tƒ¡‡fdd„}ˆ ˆj tƒ¡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. cóˆ ˆj ¡d¡dS©NrŽ©rHrbr©Zignoredrir>r?Ú cbNotSentZóz?HTTP11ClientProtocolTests.test_secondRequest..cbNotSentN)rrÈr3rQr=r$rR©rOrGrTr>rir?Útest_secondRequestRs   z,HTTP11ClientProtocolTests.test_secondRequestcsDˆj ttdƒƒ¡‡fdd„}ˆ ˆj tƒ¡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 transportcrCrDrErFrir>r?rGirHzLHTTP11ClientProtocolTests.test_requestAfterConnectionLost..cbNotSentN) rrrr rQrÈr=r$rRrIr>rir?Útest_requestAfterConnectionLostas   z9HTTP11ClientProtocolTests.test_requestAfterConnectionLostcsDGdd„dƒ}ˆ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@rd)zCHTTP11ClientProtocolTests.test_failedWriteTo..BrokenRequestFcSs ttƒƒSrh)rr8r4r>r>r?r5{r:zKHTTP11ClientProtocolTests.test_failedWriteTo..BrokenRequest.writeToN©r:r;r<r<r5r>r>r>r?Ú BrokenRequestxó rMcs&ˆ ˆjj¡ˆj ttdƒƒ¡dS)Nzyou asked for it)r rbÚ disconnectingrrrr rFrir>r?rP€sz>HTTP11ClientProtocolTests.test_failedWriteTo..cbFailedN)rrÈrZr8rR)rOrMrTrPr>rir?Útest_failedWriteTops   z,HTTP11ClientProtocolTests.test_failedWriteTocCs*Gdd„dƒ}|j |ƒ¡}t||tgƒS)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@rd)zMHTTP11ClientProtocolTests.test_synchronousWriteToError..BrokenRequestFcSrrhrr4r>r>r?r5”rzUHTTP11ClientProtocolTests.test_synchronousWriteToError..BrokenRequest.writeToNrLr>r>r>r?rM‘rNrMN)rrÈrZr8)rOrMrTr>r>r?Útest_synchronousWriteToErrorŠsz6HTTP11ClientProtocolTests.test_synchronousWriteToErrorNcCs tƒ}|j |¡}t||tgƒ}| |j¡|j ttƒƒ¡|  |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. ÚcallbackNÚerrbackr^)r3rrÈr\r8r¡r8rrr rÙrRrSrArrHrI)rOÚmoderÈrTÚerrorsr>r>r?Ú*test_connectionLostDuringRequestGenerationšs     ù ÿzDHTTP11ClientProtocolTests.test_connectionLostDuringRequestGenerationcCó | d¡S)z If the request passed to L{HTTP11ClientProtocol} finishes generation successfully after the L{HTTP11ClientProtocol}'s connection has been lost, nothing happens. rRN©rVrir>r>r?Ú+test_connectionLostBeforeGenerationFinishedºó zEHTTP11ClientProtocolTests.test_connectionLostBeforeGenerationFinishedcCrW)zà If the request passed to L{HTTP11ClientProtocol} finished generation with an error after the L{HTTP11ClientProtocol}'s connection has been lost, nothing happens. rSNrXrir>r>r?Ú)test_connectionLostBeforeGenerationFailedÂrZzCHTTP11ClientProtocolTests.test_connectionLostBeforeGenerationFailedcs*t ˆt¡‰‡‡fdd„}ˆ 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. csHˆ dtˆƒ¡ˆd}ˆ d|¡ˆ |dd¡ˆ |dd¡dS)Nr^rrr0zJError writing request, but not in valid state to finalize request: {state}r~ÚCONNECTION_LOST)rrIÚassertInrH)Úignorer ©rrOr>r?ÚcheckÓs þznHTTP11ClientProtocolTests.test_errorMessageOnConnectionLostBeforeGenerationFailedDoesNotConfuse..checkrSN)rrrrVrR)rOr`r>r_r?ÚEtest_errorMessageOnConnectionLostBeforeGenerationFailedDoesNotConfuseÊs  ÿz_HTTP11ClientProtocolTests.test_errorMessageOnConnectionLostBeforeGenerationFailedDoesNotConfusecó<ˆj tddtdƒ¡}‡fdd„}| |¡ˆj d¡|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. r¿rÀNcs@ˆ |jd¡ˆ |jtƒ¡ˆ ˆjj¡ˆ ˆjjd¡dS)Nr_Ú QUIESCENT) rHrÅršr2r rbrOrr~©rÃrir>r?Ú cbRequestêszIHTTP11ClientProtocolTests.test_receiveSimplestResponse..cbRequests9HTTP/1.1 200 OK Content-Length: 0 Connection: close ©rrÈr*rarRr©rOrTrer>rir?Útest_receiveSimplestResponseâs  ÿz6HTTP11ClientProtocolTests.test_receiveSimplestResponsecrb)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. r¿rÀNcs"tdddgiƒ}ˆ |j|¡dS)Nrçr‰r˜)r2rHrš)rÃrœrir>r?rerÌzHHTTP11ClientProtocolTests.test_receiveResponseHeaders..cbRequests+HTTP/1.1 200 OK X-Foo: bar X-Foo: baz rfrgr>rir?Útest_receiveResponseHeadersùs  ÿz5HTTP11ClientProtocolTests.test_receiveResponseHeaderscspg‰tƒ‰tˆjƒ‰ˆ ˆ¡tƒ‰ˆ ˆ¡}ˆ d¡‡‡‡‡fdd„}| |¡‡‡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 foobarcsVtƒ‰tƒ}ˆ_ˆ ˆ¡ˆ ˆjd¡ˆ ˆj¡ˆ ˆg¡| ‡‡fdd„¡S)NZ%TRANSMITTING_AFTER_RECEIVING_RESPONSEcó ˆˆjfSrh©r´r"©ÚprÃr>r?rÒ*rÓzoHTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone..cbResponse..) rrÚclosedDeferredÚ deliverBodyrHr~r rOrR©rÃÚ whenFinished)rÚquiescentResultrOrbrlr?Ú cbResponse#s    z]HTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone..cbResponsecsf|\}}ˆ |jd¡ˆ |jd¡ˆ |jd¡ˆ |jtddgiƒ¡ˆ |d¡ˆj d¡dS)Nr]r_r`rçr‰ófoobar)rHrÄrÅrÆršr2rÙrR)ÚresultrÃrÚ©rÈrOr>r?Ú cbAllResponse.s z`HTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDone..cbAllResponseN)rr(r{r}r3rÈrrR©rOrTrsrwr>)rrrrÈrOrbr?Ú/test_receiveResponseBeforeRequestGenerationDone s    ÿ  zIHTTP11ClientProtocolTests.test_receiveResponseBeforeRequestGenerationDonecCsZtƒ}tƒ}||_| |¡dtj}| tddtdƒ¡}|  d|d¡t ||t gƒS)zy The connection is closed when the server respond with a header which is above the maximum line. r r¿rÀNsHTTP/1.1 200 OK X-Foo: s X-Ignored: ignored ) rr(rr}rZ MAX_LENGTHrÈr*rarrXr )rOrbrZlongLinerTr>r>r?Ú"test_receiveResponseHeadersTooLong=s  ÿÿÿ zr?rÒjrÓz„HTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDone..cbResponse..)rrrnrorRrpr>rlr?rsfs  zrHTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDone..cbResponsecs2ˆj d¡ˆj ttƒƒ¡ˆ ˆjjd¡dS)Nr\)rÙrRrrrr8rHrq)r^rvr>r?rwns zuHTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDone..cbAllResponseN)r3rrÈrrRrxr>rvr?ÚDtest_connectionLostAfterReceivingResponseBeforeRequestGenerationDoneWs ÿ  z^HTTP11ClientProtocolTests.test_connectionLostAfterReceivingResponseBeforeRequestGenerationDonecs¢tƒ‰tƒ}ˆ_ˆj tddtdƒ¡}ˆj d¡g}| |j ¡ˆ  |g¡ˆj d¡|d}|  ˆ¡ˆj d¡ˆj d¡‡‡fd 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. r¿rÀNs%HTTP/1.1 200 OK Content-Length: 6 r®rr¼r‰csˆ ˆjd¡ˆj t¡dS)Nrt)rHr´Ú closedReasonrGr.rFrËr>r?rw™szIHTTP11ClientProtocolTests.test_receiveResponseBody..cbAllResponse) rrrnrrÈr*rarrRr{rHro)rOrqÚrequestDeferredrurÃrwr>rËr?Útest_receiveResponseBodyws&  ÿÿ       z2HTTP11ClientProtocolTests.test_receiveResponseBodycCs”|j tddtdƒ¡}|j d¡g}| |j¡|d}tƒ}| |¡|j d¡|j d¡|  |j d¡|j  t t d ƒƒ¡|j t¡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. r¿rÀNsHTTP/1.1 200 OK rr¼r‰rtz low-level transport disconnected)rrÈr*rarrRr{rrorHr´rrr r|rGr)©rOr}rurÃrr>r>r?ÚEtest_responseBodyFinishedWhenConnectionLostWhenContentLengthIsUnknown s  ÿ      ÿz_HTTP11ClientProtocolTests.test_responseBodyFinishedWhenConnectionLostWhenContentLengthIsUnknowncCs˜|j tddtdƒ¡}|j d¡g}| |j¡|d}tƒ}| |¡|j d¡|j d¡|  |j d¡|j  t t ƒƒ¡t|t|jƒt tgƒS) 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. r¿rÀNs/HTTP/1.1 200 OK Transfer-Encoding: chunked ró3 foo s3 bar rt)rrÈr*rarrRr{rrorHr´rrr8rXrr|r1rr>r>r?Ú4test_chunkedResponseBodyUnfinishedWhenConnectionLost½s$ ÿÿ    ÿzNHTTP11ClientProtocolTests.test_chunkedResponseBodyUnfinishedWhenConnectionLostcsJˆj tddtdƒ¡}ˆj d¡tˆ|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. r¿rÀNsunparseable garbage goes here cs<ˆ ˆjj¡ˆ |jdjjd¡ˆj t t dƒƒ¡dS)Nrsunparseable garbage goes herez it is done) r rbrOrHrFrr´rrrr ©r·rir>r?rPês ÿzLHTTP11ClientProtocolTests.test_parserDataReceivedException..cbFailed)rrÈr*rarrXr#rR)rOr}rTrPr>rir?Ú test_parserDataReceivedExceptionÝs ÿ   z:HTTP11ClientProtocolTests.test_parserDataReceivedExceptioncCs`|j tddtdƒ¡}|jjj}| |j|j¡|j t t dƒƒ¡| |jd¡t ||t gƒS)z£ When the HTTP response parser is disconnected, the L{TransportProxyProducer} which was connected to it as a transport is stopped. r¿rÀNzconnection done) rrÈr*raÚ_parserrbrêÚ _producerZ_disconnectParserrr rX)rOr}rbr>r>r?Útest_proxyStoppedùs ÿ z+HTTP11ClientProtocolTests.test_proxyStoppedcCsŽtƒ}tƒ}| |¡g}g}| ¡ |j¡| ¡ |j¡| ||fggf¡| |j¡|  t t ƒƒ¡| |dg¡| |dg¡dS)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(r}ÚabortrRr{rHr rOrrr )rOrbrZr1Zr2r>r>r?Útest_abortClosesConnections  z4HTTP11ClientProtocolTests.test_abortClosesConnectioncCsZtƒ}tƒ}| |¡| ttƒƒ¡g}| ¡ |j¡|  |dg¡|  |j d¡dS)z‰ L{HTTP11ClientProtocol.abort} called after the connection is lost returns a C{Deferred} that fires immediately. Nr\) rr(r}rrr rˆrRr{rHrq©rOrbrrur>r>r?Útest_abortAfterConnectionLosts z7HTTP11ClientProtocolTests.test_abortAfterConnectionLostcCs\tƒ}tƒ}| |¡| tddtdƒ¡}| ¡| |j¡|  t t ƒƒ¡t ||t gƒS)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. r¿rÀN)rr(r}rÈr*rarˆr rOrrr rXrrŠr>r>r?Útest_abortBeforeResponseBody,s  z6HTTP11ClientProtocolTests.test_abortBeforeResponseBodycs–tdd‰tƒ‰ˆ ˆ¡ˆ tddtdƒ¡}ˆ d¡tƒ‰G‡‡fdd„dtƒ‰‡‡‡‡fd 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)Úlenientr¿rÀNrcs(eZdZdZ‡fdd„Z‡fdd„ZdS)zQHTTP11ClientProtocolTests.test_abortAfterResponseHeaders..BodyDestinationzl A body response protocol which immediately aborts the HTTP connection. cs ˆ ¡dS)z< Abort the HTTP connection. N)rˆri)rr>r?ÚconnectionMadeVs 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)rS©rOrK)Ú testResultr>r?r\rYz`HTTP11ClientProtocolTests.test_abortAfterResponseHeaders..BodyDestination.connectionLostN)r:r;r<r=rŽrr>)rrr>r?ÚBodyDestinationPs r‘cs,| ˆƒ¡ˆ ˆj¡ˆ ttƒƒ¡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)ror rOrrr rd)r‘rrOrbr>r?rocs  zMHTTP11ClientProtocolTests.test_abortAfterResponseHeaders..deliverBodycsˆ |jt¡dSrh)rrÃr-)Úerrorrir>r?Ú checkErrormózLHTTP11ClientProtocolTests.test_abortAfterResponseHeaders..checkError) rr(r}rÈr*rarrr rRrXrr1)rOruror“rSr>)r‘rrOrrbr?Útest_abortAfterResponseHeaders<s     ÿ z8HTTP11ClientProtocolTests.test_abortAfterResponseHeadersc sg‰‡‡‡fdd„}tƒ}t|ƒ‰ˆ |¡ˆ tddtddd¡}ˆ d¡ˆ ˆg¡g}| |j ¡|d }t ƒ}t ƒ|_ |j  ‡fd d „¡|  |¡ˆ d ¡|j t¡ˆ ˆˆd g¡ˆ ˆjd¡ˆ ˆjd¡ˆ ˆjd¡ˆ ˆjd¡ˆ ˆjd¡dS)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¡ˆ |¡dS©Nrc©rHr~r{©rm©rrrrOr>r?rR„ó zHHTTP11ClientProtocolTests.test_quiescentCallbackCalled..callbackr¿rÀNT©r<s&HTTP/1.1 200 OK Content-length: 3 rcrÎ)Nú response donerÐr")rrr>r?rÒžrÓzHHTTP11ClientProtocolTests.test_quiescentCallbackCalled..rr)rr(r}rÈr*rarrHrRr{rrrnror|rGr.r…Z_finishedRequestZ_currentRequestZ_transportProxyr)rOrRrbr}rurÃÚ bodyProtocolr>ršr?Útest_quiescentCallbackCalledvs6  ÿ    ÿ   z6HTTP11ClientProtocolTests.test_quiescentCallbackCalledc sˆg‰‡‡‡fdd„}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. cr–r—r˜r™ršr>r?rR¼r›z]HTTP11ClientProtocolTests.test_transportProducingWhenQuiescentAfterFullBody..callbackr¿rÀNTrœs)HTTP/1.1 200 OK Content-length: 3 BBBZDEFERRED_CLOSEr^rÔ) rr(r}rÈr*rarZsuccessResultOfrHrqrIr×)rOrRrbr}rÃr>ršr?Ú1test_transportProducingWhenQuiescentAfterFullBody¯s  ÿÿ zKHTTP11ClientProtocolTests.test_transportProducingWhenQuiescentAfterFullBodyc sŽg‰‡‡‡fdd„}tƒ}t|ƒ‰ˆ |¡ˆ tddtddd¡}| ˆj¡ˆ d¡ˆ  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. cr–r—r˜r™ršr>r?rRär›zUHTTP11ClientProtocolTests.test_quiescentCallbackCalledEmptyResponse..callbackr¿rÀNTrœó&HTTP/1.1 200 OK Content-length: 0 r±rr^)rr(r}rÈr*rarRr{rrHrIrêrr-)rOrRrbr}r>ršr?Ú)test_quiescentCallbackCalledEmptyResponseÝs ÿ  zCHTTP11ClientProtocolTests.test_quiescentCallbackCalledEmptyResponsec Cóg}tƒ}t|jƒ}| |¡| tddtddd¡}| d¡g}| |j¡|d}t ƒ}|  |¡|j   t ¡| |g¡| |j¡dS)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. r¿rÀNTrœs9HTTP/1.1 200 OK Content-length: 0 Connection: close r©rr(r{r}rÈr*rarrRrror|rGr.rHr rO©rOrrrbrr}rurÃržr>r>r?Útest_quiescentCallbackNotCalled÷s$  ÿÿ    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. r¿rÀNFrœr¡rr¤r¥r>r>r?Ú1test_quiescentCallbackNotCalledNonPersistentQuerys   ÿ     zKHTTP11ClientProtocolTests.test_quiescentCallbackNotCalledNonPersistentQueryc CsÊdd„}t |t¡}tƒ}t|ƒ}| |¡| tddtddd¡}|  d¡g}|  |j ¡|d }t ƒ}|  |¡|j t¡| d t|ƒ¡|d } | d } | | jt¡| t¡| |j¡dS) zx If C{quiescentCallback} throws an exception, the error is logged and protocol is disconnected. cSrrh)ÚZeroDivisionErrorr™r>r>r?rR5rzHHTTP11ClientProtocolTests.test_quiescentCallbackThrows..callbackr¿rÀNTrœr¡rr^r)rrrrr(r}rÈr*rarrRr{rror|rGr.rrIrrr¨rr rO) rOrRrrbrr}rurÃržr rºr>r>r?Útest_quiescentCallbackThrows/s*  ÿ     z6HTTP11ClientProtocolTests.test_quiescentCallbackThrowscCsNtƒ}tƒ}| |¡| tddtdƒ¡}| ¡| |j¡t ||t t gƒS)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. r¿rÀN) rr(r}rÈr*raÚcancelr Ú disconnectedrUr0rrŠr>r>r?Útest_cancelBeforeResponseRs   ÿz3HTTP11ClientProtocolTests.test_cancelBeforeResponsecCsVtƒ}tƒ}| |¡| tddtdƒ¡}| d¡| ¡| |j ¡t ||t gƒS)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. r¿rÀNrÁ) rr(r}rÈr*rarrªr r«rXrrŠr>r>r?Útest_cancelDuringResponsecs   z3HTTP11ClientProtocolTests.test_cancelDuringResponsecs–tƒ}tƒ}| |¡t|ƒ‰ddi‰‡fdd„‰‡‡fdd„}|ˆ_| tddtˆƒ¡}ˆj  d ¡|  ¡|  |j ¡|  ˆd¡t ||tgƒS) 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 dˆd<dS)NTr®r>r")ÚnonLocalr>r?rªó zJHTTP11ClientProtocolTests.assertCancelDuringBodyProduction..cancelcs|ˆ_tˆƒˆ_ˆjSrh©ÚconsumerrrÙ)r²)rªÚproducerr>r?ÚstartProducing„s zRHTTP11ClientProtocolTests.assertCancelDuringBodyProduction..startProducingóPOSTó/barsxxxxxN)rr(r}ÚStringProducerr´rÈr*rar²r?rªr r«rZr)rOZproducerLengthrbrr´rur>)rªr¯r³r?Ú assertCancelDuringBodyProductionss    z:HTTP11ClientProtocolTests.assertCancelDuringBodyProductioncCrW)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. é N)r¸rir>r>r?Útest_cancelDuringBodyProduction’ó z9HTTP11ClientProtocolTests.test_cancelDuringBodyProductioncCs | t¡S)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. N)r¸rrir>r>r?Ú&test_cancelDuringChunkedBodyProduction›r»z@HTTP11ClientProtocolTests.test_cancelDuringChunkedBodyProductionrh)'r:r;r<r=rArBrJrKrPrQrVrYr[rarhriryrzr{r~r€r‚r„r‡r‰r‹rŒr•rŸr r¢r¦r§r©r¬r­r¸rºr¼r>r>r>r?r@<sJ  2 ) :9.# r@c@s<eZdZdZdZdd„Zdd„Zdd„Zd d „Zd d „Z d S)r·a» 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 ||_dSrh)rØ)rOrØr>r>r?Ú__init__µr:zStringProducer.__init__cCs||_tƒ|_|jSrhr±)rOr²r>r>r?r´¸szStringProducer.startProducingcCr6rÏr7rir>r>r?Ú stopProducing½r:zStringProducer.stopProducingcCrgrhr>rir>r>r?ÚpauseProducingÀózStringProducer.pauseProducingcCrgrhr>rir>r>r?ÚresumeProducingÄrÀzStringProducer.resumeProducingN) r:r;r<r=r8r½r´r¾r¿rÁr>r>r>r?r·¥s  r·c@sÚeZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd5d)d*„Zd+d,„Zd-d.„Zd/d0„Zd1d2„Zd3d4„Zd(S)6Ú RequestTestsz Tests for L{Request}. cCs tƒ|_dSrh)rrbrir>r>r?rAÎr°zRequestTests.setUpcCs,tddtdƒ |j¡| |j ¡d¡dS)zk L{Request.writeTo} formats the request data and writes it to the given transport. r¿rÀNs8GET / HTTP/1.1 Connection: close Host: example.com ©r*rar5rbrHrrir>r>r?Útest_sendSimplestRequestÑs þz%RequestTests.test_sendSimplestRequestcCs4tddtddd}| |j¡| |j ¡d¡dS)zO A pesistent request does not send 'Connection: close' header. r¿rÀNTrœs%GET / HTTP/1.1 Host: example.com rÃ)rOÚreqr>r>r?Ú"test_sendSimplestPersistentRequestßs  þz/RequestTests.test_sendSimplestPersistentRequestcCsŽtddgdgdœƒ}tdd|dƒ |j¡|j ¡ d¡}| |d d ¡| |d d…d d g¡|d =|d d…=| ¡| |gd ¢¡dS)zf L{Request.writeTo} formats header data and writes it to the given transport. r‰r˜rC©rçrBr¿ó/fooNrªróGET /foo HTTP/1.1éþÿÿÿrŽ)óConnection: closesHost: example.comrŒr—)r2r*r5rbrÚsplitrHÚsort)rOršÚlinesr>r>r?Útest_sendRequestHeadersêsþz$RequestTests.test_sendRequestHeaderscCs¦tD]N}t|gdgdœƒ}tƒ}tdd|dƒ |¡| ¡ d¡}| |dd¡| |d d…d d g¡|d=|d d…=| d ¡| d ¡| |d t g¡qdS)ze Linear whitespace in request header values is replaced with a single space. sexample.invalidrÇr¿rÈNrªrrÉrÊrŽrËsHost: example.invalidsX-Foo: ) r5r2rr*r5rrÌrHÚremover6)rOÚ componentršrbrÎr>r>r?Ú-test_sanitizeLinearWhitespaceInRequestHeadersûs  öz:RequestTests.test_sanitizeLinearWhitespaceInRequestHeaderscCs´ttƒ}tddt|ƒ}| |j¡| |jd¡| |jj |¡|  |jj ¡|  |j  ¡d¡|j ¡|j d¡|j d¡|j d¡| |jj d¡|  |j  ¡d¡dS)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. rµr¶NsXPOST /bar HTTP/1.1 Connection: close Transfer-Encoding: chunked Host: example.com sxxxsyyyyyyyyyyyyyyys!3 xxx f yyyyyyyyyyyyyyy 0 )r·rr*rar5rbÚassertNotIdenticalr²rêr³r Ú streamingrHrÚclearr?rÙrR©rOr³rÈr>r>r?Útest_sendChunkedRequestBody s& þ    þz(RequestTests.test_sendChunkedRequestBodycs`ttƒ}tddt|ƒ}| ˆj¡}ˆj ¡|j t ƒ¡‡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. rµr¶cs&ˆ ˆj ¡d¡ˆ ˆjjd¡dSrD)rHrbrrêr³rFrir>r?rP<szCRequestTests.test_sendChunkedRequestBodyWithError..cbFailedN) r·rr*rar5rbrÕrÙrSr8rQrR)rOr³rÈÚ writeDeferredrPrTr>rir?Ú$test_sendChunkedRequestBodyWithError-s      z1RequestTests.test_sendChunkedRequestBodyWithErrorcCs¨tdƒ}tddt|ƒ}| |j¡| |jd¡| |jj|¡|  |jj ¡|  |j  ¡d¡|j  ¡|j d¡|j d¡| |jjd¡|  |j  ¡d¡dS)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. érµr¶NsOPOST /bar HTTP/1.1 Connection: close Content-Length: 3 Host: example.com r)r·r*rar5rbrÓr²rêr³r rÔrHrrÕr?rÙrRrÖr>r>r?Útest_sendRequestBodyWithLengthDs þ   z+RequestTests.test_sendRequestBodyWithLengthcCs4t|dtdƒ}| |j¡| |j ¡|d¡dS)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} rÈNsK /foo HTTP/1.1 Connection: close Content-Length: 0 Host: example.com rÃ)rOr;rÈr>r>r?Ú_sendRequestEmptyBodyWithLengthas  þz,RequestTests._sendRequestEmptyBodyWithLengthcCó| d¡dS)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. sPUTN©rÜrir>r>r?Útest_sendPUTRequestEmptyBodyvó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. rµNrÞrir>r>r?Útest_sendPOSTRequestEmptyBody~ràz*RequestTests.test_sendPOSTRequestEmptyBodycCsVtdƒ}tddt|ƒ}| |j¡}|j d¡|j d¡|  |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. rÚrµr¶óabN) r·r*rar5rbr²r?rÙrRrêr³rQr&©rOr³rÈrØr>r>r?Ú#test_sendRequestBodyWithTooFewBytes†s    z0RequestTests.test_sendRequestBodyWithTooFewBytescsŒtdƒ‰tddtˆƒ}| ˆj¡}ˆj d¡ˆ ˆj¡ˆj d¡ˆ  ˆj¡ˆ  ˆjj d¡‡‡‡fdd„}ˆ  |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. rÚrµr¶râócdNcsLˆ ˆj ¡d¡ˆj ¡ˆ tˆjjd¡ˆˆƒˆ ˆj ¡d¡dS)NsQPOST /bar HTTP/1.1 Connection: close Content-Length: 3 Host: example.com absefrŽ)rHrbrrÕrurr²r?rƒ©Úfinisherr³rOr>r?rPµsþ zCRequestTests._sendRequestBodyWithTooManyBytesTest..cbFailed)r·r*rar5rbr²r?r¡r8r rêr³rQr&rR)rOrçrÈrØrPrTr>rær?Ú$_sendRequestBodyWithTooManyBytesTest•s        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ó|j d¡dSrh©rÙrR©r³r>r>r?rçÞózCRequestTests.test_sendRequestBodyWithTooManyBytes..finisherN)rè©rOrçr>r>r?Ú$test_sendRequestBodyWithTooManyBytesÖs z1RequestTests.test_sendRequestBodyWithTooManyBytescs$t ˆt¡‰‡‡fdd„}ˆ |¡S)récsV|j tƒ¡ˆd}ˆ d|¡|d}ˆ |jt¡ˆ t¡}ˆ t|ƒd¡dS)Nrrr^) rÙrSr8r]rrrrHrI)r³r rºrUr_r>r?rçìs  zHRequestTests.test_sendRequestBodyErrorWithTooManyBytes..finisherN)rrrrèrîr>r_r?Ú)test_sendRequestBodyErrorWithTooManyBytesãs  z6RequestTests.test_sendRequestBodyErrorWithTooManyBytescCsžt |t¡}tdƒ}tddt|ƒ}| |j¡|jj }|j  d¡|j   d¡|  tƒ¡|d}| d|¡|d}| |jt¡| t| t¡ƒd¡dS) 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. rÚrµr¶rNrrr^)rrrr·r*rar5rbr²Ú _finishedr?rÙrRrSr8r]rrrHrIr)rOrr³rÈZfinishedConsumingr rºr>r>r?Ú*test_sendRequestBodyErrorWithConsumerError÷s      z7RequestTests.test_sendRequestBodyErrorWithConsumerErrorcCsxtdƒ}tddt|ƒ}| |j¡}|j d¡||ƒ| |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. rÚrµr¶râNrårŽ)r·r*rar5rbr²r?rêr³rÕrurrHr)rOrçr³rÈrØr>r>r?Ú-_sendRequestBodyFinishedEarlyThenTooManyBytes s   z:RequestTests._sendRequestBodyFinishedEarlyThenTooManyBytescCódd„}| | |¡t¡S)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}. cSrêrhrërìr>r>r?rç- rízPRequestTests.test_sendRequestBodyFinishedEarlyThenTooManyBytes..finisherN)rQrór&rîr>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|j tƒ¡dSrh)rÙrSr8rìr>r>r?rç= r”zORequestTests.test_sendRequestBodyErroredEarlyThenTooManyBytes..finisherN)rQrór8rîr>r>r?Ú0test_sendRequestBodyErroredEarlyThenTooManyBytes5 röz=RequestTests.test_sendRequestBodyErroredEarlyThenTooManyBytesNcCs`ttƒ}tddt|ƒ}| |j¡}|j |¡|j ¡|  t |j j d¡|  |j ¡d¡|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. rµr¶r¼rŽN)r·rr*rar5rbrÙrRrÕrurr²r?rHr)rOZ_withr³rÈrØr>r>r?Ú0test_sendChunkedRequestBodyFinishedThenWriteMoreE s   z=RequestTests.test_sendChunkedRequestBodyFinishedThenWriteMorecCs| ttƒƒ¡}| |t¡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 with a L{Failure}, the C{write} call raises an exception and does not write anything to the underlying transport. N)rørr8rQ)rOrTr>r>r?Ú9test_sendChunkedRequestBodyFinishedWithErrorThenWriteMoreV sÿ zFRequestTests.test_sendChunkedRequestBodyFinishedWithErrorThenWriteMorecCs¨tdƒ}tddt|ƒ}| |j¡}| |jj|¡| |jj¡|j   d¡|  |j  ¡d¡|  |jj¡|j ttƒƒ¡|  |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}. érµr¶râsQPOST /bar HTTP/1.1 Connection: close Content-Length: 5 Host: example.com abN)r·r*rar5rbrêr³r rÔr²r?rHrr¡rOrÙrSrr8rQrãr>r>r?Útest_sendRequestBodyWithErrorb s  þ  z*RequestTests.test_sendRequestBodyWithErrorcCsxtddtiƒdƒ}| t|j|j¡| |j ¡d¡tddtdddgiƒdƒ}| t|j|j¡| |j ¡d¡dS)z— L{Request.writeTo} raises L{BadHeaders} if there is not exactly one I{Host} header and writes nothing to the given transport. r¿rÀNrŽsHostrCs example.org)r*r2rurr5rbrHr)rOrÈr>r>r?Útest_hostHeaderRequired‰ sÿz$RequestTests.test_hostHeaderRequiredcCsFtdƒ}tddt|ƒ}| |j¡| |j¡| ¡| |j¡dS)zc L{Request.stopWriting} calls its body producer's C{stopProducing} method. rÚr¿rÀN) r·r*rar5rbr¡r8r9r rÖr>r>r?Útest_stopWriting˜ s   zRequestTests.test_stopWritingcCs˜t |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. rÚcSstdƒ‚©NzstopProducing is bustedrr>r>r>r?ÚbrokenStopProducing¬ szBRequestTests.test_brokenStopProducing..brokenStopProducingr¿rÀr^rrN)rrrr·r¾r*rar5rbr9rHrIrr8rr]rr)rOrr³rÿrÈr rºr>r>r?Útest_brokenStopProducing¤ s   z%RequestTests.test_brokenStopProducingrh)r:r;r<r=rArÄrÆrÏrÒr×rÙrÛrÜrßrárärèrïrðròrórõr÷rørùrûrürýrr>r>r>r?rÂÉs6 !A   ' rÂc@sReZdZdZdd„Zdd„Zdd„Zdd d „Zd d „Zd d„Z dd„Z dd„Z dS)ÚLengthEnforcingConsumerTestsz/ Tests for L{LengthEnforcingConsumer}. cCs2tƒ|_tdƒ|_tƒ|_t|j|j|jƒ|_dS)Nr¹)rrur·r³rrbr"Úenforcerrir>r>r?rAÁ s    ÿz"LengthEnforcingConsumerTests.setUpcCsJ|j d¡| |j ¡d¡|j ¡|j d¡| |j ¡d¡dS)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?rHrbrrÕrir>r>r?Ú test_writeÉ s   z'LengthEnforcingConsumerTests.test_writecCs |j d¡| t|jj¡dS)z´ L{LengthEnforcingConsumer._noMoreWritesExpected} raises L{WrongBodyLength} if it is called before the indicated number of bytes have been written. s xxxxxxxxxN)rr?rur&Ú_noMoreWritesExpectedrir>r>r?Útest_finishedEarlyÕ s z/LengthEnforcingConsumerTests.test_finishedEarlyFcCsP|j d¡| |jj¡|j d¡| |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. ó xxxxxxxxxxóxN) rr?r¡r³r8r rrQrur&)rOZ_unregisterAfterr>r>r?Útest_writeTooManyÞ s   z.LengthEnforcingConsumerTests.test_writeTooManycCsH|j d¡|j ¡| |jj¡| t|jjd¡| |jj¡dS)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?rr¡r³r8rurr rir>r>r?Útest_writeAfterNoMoreExpectedî s  z:LengthEnforcingConsumerTests.test_writeAfterNoMoreExpectedcCrW)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}. TN)rrir>r>r?Útest_finishedLateú rZz.LengthEnforcingConsumerTests.test_finishedLatecCs"|j d¡| |j ¡d¡dS)zŸ If L{LengthEnforcingConsumer._noMoreWritesExpected} is called after the correct number of bytes have been written it returns L{None}. rN)rr?rêrrir>r>r?Ú test_finished s z*LengthEnforcingConsumerTests.test_finishedcs6‡fdd„}|ˆ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}. cst ˆj¡tdƒ‚rþ)r·r¾r³r8r>rir>r?rÿ s zRLengthEnforcingConsumerTests.test_stopProducingRaises..brokenStopProducingcsˆ tˆ t¡ƒd¡dS)Nr^)rHrIrr8rFrir>r?Ú cbFinished szILengthEnforcingConsumerTests.test_stopProducingRaises..cbFinishedN)r³r¾rrR)rOrÿr rTr>rir?Útest_stopProducingRaises s   z5LengthEnforcingConsumerTests.test_stopProducingRaisesN)F) r:r;r<r=rArrrr r r r r>r>r>r?r¼ s   rc@s(eZdZdZdd„Zdd„Zdd„ZdS) Ú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| ttttƒƒƒ¡dS)zC L{ChunkedEncoder} instances provide L{IConsumer}. N)r rr rrrir>r>r?Útest_interface( sz'RequestBodyConsumerTests.test_interfacecCsNtƒ}t|ƒ}| d¡| | ¡d¡| ¡| d¡| | ¡d¡dS)z} L{ChunkedEncoder.write} writes to the transport the chunked encoded form of the bytes passed to it. r¼rsxxxxxxxxxxxxxxxxs10 xxxxxxxxxxxxxxxx N)rrr?rHrrÕ)rOrbÚencoderr>r>r?r. s  z#RequestBodyConsumerTests.test_writecCsdtƒ}tƒ}t|ƒ}| |d¡| |j|¡| |j¡| ¡| |jd¡|  |  ¡d¡dS)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 ) rr£rZregisterProducerrêr³r rÔZunregisterProducerrHr)rOrbr³rr>r>r?Útest_producerRegistration; s  z2RequestBodyConsumerTests.test_producerRegistrationN)r:r;r<r=rrrr>r>r>r?r! s  rc@sHeZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dS)ÚTransportProxyProducerTestszn Tests for L{TransportProxyProducer} which proxies the L{IPushProducer} interface of a transport. cCs| tttdƒƒ¡dS)zO L{TransportProxyProducer} instances provide L{IPushProducer}. N)r rr r%rir>r>r?rS sz*TransportProxyProducerTests.test_interfacecCs6tƒ}t|ƒ}| |j|¡| ¡| |jd¡dS)z~ L{TransportProxyProducer.stopProxying} drops the reference to the wrapped L{IPushProducer} provider. N)rr%rêr†Ú stopProxying©rOrbÚproxyr>r>r?Ú%test_stopProxyingUnreferencesProducerY s zATransportProxyProducerTests.test_stopProxyingUnreferencesProducercCsdtƒ}| ¡t|ƒ}| |jd¡| ¡| |jd¡| ¡| ¡| ¡| |jd¡dS)z™ L{TransportProxyProducer.resumeProducing} calls the wrapped transport's C{resumeProducing} method unless told to stop proxying. rórÔN)rr¿r%rHr×rÁrrr>r>r?Útest_resumeProducingd sz0TransportProxyProducerTests.test_resumeProducingcCs\tƒ}t|ƒ}| |jd¡| ¡| |jd¡| ¡| ¡| ¡| |jd¡dS)z— L{TransportProxyProducer.pauseProducing} calls the wrapped transport's C{pauseProducing} method unless told to stop proxying. rÔróN)rr%rHr×r¿rÁrrr>r>r?Útest_pauseProducingz sz/TransportProxyProducerTests.test_pauseProducingcCsbtƒ}t|ƒ}| |jd¡| ¡| |jd¡tƒ}t|ƒ}| ¡| ¡| |jd¡dS)z• L{TransportProxyProducer.stopProducing} calls the wrapped transport's C{stopProducing} method unless told to stop proxying. rÔr8N)rr%rHr×r¾rrr>r>r?Útest_stopProducing sz.TransportProxyProducerTests.test_stopProducingcCsdtƒ}tƒ}| |¡||_t|ƒ}| |j¡| |jd¡|  ¡| |jd¡|  |j¡dS)zs L{TransportProxyProducer.loseConnection} calls the wrapped transport's C{loseConnection}. rÔN) rrr}rr%r Ú connectedrHr×ÚloseConnectionr¡©rOrbrrr>r>r?Ú test_loseConnectionWhileProxying£ s  zr>r?Útest_loseConnectionNotProxying¸ s  z:TransportProxyProducerTests.test_loseConnectionNotProxyingN) r:r;r<r=rrrrrrrr>r>r>r?rM s  rc@sˆeZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd„Zd S)!Ú ResponseTestsz Tests for L{Response}. cCsttƒƒ}| tt|ƒ¡dS)z= L{Response} instances provide L{IResponse}. N)rcrr rr4©rOrÃr>r>r?Útest_verifyInterfaceÐ s z"ResponseTests.test_verifyInterfacecslg‰tƒ}G‡fdd„dtƒ}|ƒ}t|ƒ}| |¡ˆ\}| ¡| |jd¡| ¡| |jd¡dS)zÑ The L{IProtocol} provider passed to L{Response.deliverBody} has its C{makeConnection} method called with an L{IPushProducer} provider hooked up to the response as an argument. cóeZdZ‡fdd„ZdS)z7ResponseTests.test_makeConnection..SomeProtocolcóˆ |¡dSrhrÐ)rOr³©Z producersr>r?r}á ózFResponseTests.test_makeConnection..SomeProtocol.makeConnectionN©r:r;r<r}r>r$r>r?Ú SomeProtocolà ór'rórÔN)rr rcror¿rHr×rÁ)rOrbr'r²rÃZ theProducerr>r$r?Útest_makeConnection× s z!ResponseTests.test_makeConnectioncsNg‰G‡fdd„dtƒ}|ƒ}ttƒƒ}| |¡| d¡| ˆdg¡dS)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. cr")z5ResponseTests.test_dataReceived..ListConsumercr#rhrЩrOr´©r¦r>r?rö r%zBResponseTests.test_dataReceived..ListConsumer.dataReceivedN©r:r;r<rr>r+r>r?Ú ListConsumerõ r(r-r¼N)r rcrrorÕrH©rOr-r²rÃr>r+r?Útest_dataReceivedí s   zResponseTests.test_dataReceivedcsjg‰G‡fdd„dtƒ}|ƒ}ttƒƒ}| |¡| ¡ˆd t¡| tˆƒd¡|  |j d¡dS)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. cr")z7ResponseTests.test_connectionLost..ListConsumercr#rhrÐr©Zlostr>r?r r%zFResponseTests.test_connectionLost..ListConsumer.connectionLostN)r:r;r<rr>r0r>r?r- r(r-rr^N) r rcrrorÖrGr.rHrIrêZ _bodyProtocolr.r>r0r?Útest_connectionLost s  z!ResponseTests.test_connectionLostcsrg‰G‡fdd„dtƒ}|ƒ}ttƒƒ}| d¡| d¡| |¡| d¡| ˆgd¢¡| |jd¡dS)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. cr")z8ResponseTests.test_bufferEarlyData..ListConsumercr#rhrÐr*r+r>r?r" r%zEResponseTests.test_bufferEarlyData..ListConsumer.dataReceivedNr,r>r+r>r?r-! r(r-r¼r‰r˜)r¼r‰r˜N)r rcrrÕrorHrêZ _bodyBuffer)rOr-rrÃr>r+r?Útest_bufferEarlyData s     z"ResponseTests.test_bufferEarlyDatacCs,ttƒƒ}| tƒ¡| t|jtƒ¡dS)zb L{Response.deliverBody} raises L{RuntimeError} if called more than once. N)rcrror rurvr r>r>r?Ú test_multipleStartProducingFails0 s  z.ResponseTests.test_multipleStartProducingFailscCs4ttƒƒ}| tƒ¡| ¡| t|jtƒ¡dS)zw L{Response.deliverBody} raises L{RuntimeError} if called after L{Response._bodyDataFinished}. N)rcrror rÖrurvr r>r>r?Ú%test_startProducingAfterFinishedFails9 s  z3ResponseTests.test_startProducingAfterFinishedFailscCs&ttƒƒ}| ¡| t|jd¡dS)z  L{Response._bodyDataReceived} raises L{RuntimeError} if called after L{Response._bodyDataFinished} but before L{Response.deliverBody}. r¼N)rcrrÖrurvrÕr r>r>r?Ú'test_bodyDataReceivedAfterFinishedFailsC s z5ResponseTests.test_bodyDataReceivedAfterFinishedFailscCs2ttƒƒ}| ¡| tƒ¡| t|jd¡dS)zŸ L{Response._bodyDataReceived} raises L{RuntimeError} if called after L{Response._bodyDataFinished} and after L{Response.deliverBody}. r¼N)rcrrÖror rurvrÕr r>r>r?Ú'test_bodyDataReceivedAfterDeliveryFailsL s  z5ResponseTests.test_bodyDataReceivedAfterDeliveryFailscCs$ttƒƒ}| ¡| t|j¡dS)zh L{Response._bodyDataFinished} raises L{RuntimeError} if called more than once. N)rcrrÖrurvr r>r>r?Ú'test_bodyDataFinishedAfterFinishedFailsV s z5ResponseTests.test_bodyDataFinishedAfterFinishedFailscCs0ttƒƒ}| ¡| tƒ¡| t|j¡dS)z{ L{Response._bodyDataFinished} raises L{RuntimeError} if called after the body has been delivered. N)rcrrÖror rurvr r>r>r?Ú'test_bodyDataFinishedAfterDeliveryFails_ s  z5ResponseTests.test_bodyDataFinishedAfterDeliveryFailscslg‰G‡fdd„dtƒ}tƒ}| ¡|ƒ}t|ƒ}| |jd¡| |¡| ˆdg¡| |jd¡dS)z– L{Response.deliverBody} resumes the HTTP connection's transport after passing it to the consumer's C{makeConnection} method. cr")z9ResponseTests.test_transportResumed..ListConsumercsˆ |j¡dSrh)r{r×r4©ZtransportStater>r?r}q rízHResponseTests.test_transportResumed..ListConsumer.makeConnectionNr&r>r9r>r?r-p r(r-rórÔN)r rr¿rcrHr×ro)rOr-rbrrÃr>r9r?Útest_transportResumedi s z#ResponseTests.test_transportResumedcCsXtƒ}t|ƒ}| d¡| d¡| ¡tƒ}| |¡| |jd¡|j  t ¡dS)zó If the entire body is delivered to the L{Response} before the response's C{deliverBody} method is called, the protocol passed to C{deliverBody} is immediately given the body data and then disconnected. r¼r‰rtN) rrcrÕrÖrrorHr´r|rGr.©rOrbrÃrr>r>r?Ú)test_bodyDataFinishedBeforeStartProducing} s   z7ResponseTests.test_bodyDataFinishedBeforeStartProducingcCsLtƒ}t|ƒ}tƒ}| |¡| |jd¡| ttƒƒ¡|j   t¡dS)a  The L{Failure} passed to L{Response._bodyDataFinished} when the response is in the I{connected} state is passed to the C{connectionLost} method of the L{IProtocol} provider passed to the L{Response}'s C{deliverBody} method. Z CONNECTEDN) rrcrrorHrqrÖrr8r|rGr;r>r>r?Ú#test_finishedWithErrorWhenConnected s z1ResponseTests.test_finishedWithErrorWhenConnectedcCsLtƒ}t|ƒ}| |jd¡| ttƒƒ¡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. ZINITIALN) rrcrHrqrÖrr8rror|rGr;r>r>r?Ú!test_finishedWithErrorWhenInitial¢ s z/ResponseTests.test_finishedWithErrorWhenInitialN)r:r;r<r=r!r)r/r1r2r3r4r5r6r7r8r:r<r=r>r>r>r>r?rË s"       rN)_r=ÚtypingrZzope.interfacerZzope.interface.verifyrZtwisted.internet.deferrrrrZtwisted.internet.errorr r Ztwisted.internet.interfacesr r Ztwisted.internet.protocolr Ztwisted.internet.testingrrrrZtwisted.loggerrZtwisted.protocols.basicrZtwisted.python.failurerZtwisted.trial.unittestrZtwisted.web._newclientrrrrrrrrrrr r!r"r#r$r%r&r'Ztwisted.web.clientr(r)r*r+r,r-r.r/r0Ztwisted.web.httpr1Ztwisted.web.http_headersr2Ztwisted.web.iwebr3r4Ztwisted.web.test.requesthelperr5r6Ú Exceptionr8rArarUrXrZr\rcrerxr©r­r¯r3r=r@r·rÂrrrrr>r>r>r?Úsr        P, (   !0o#ve,~