U sÍ@gvã@sdZddlmZmZddlZddlZddlZddlZzddlmZm Z m Z Wn(e k rtddl mZm Z m Z YnXddl mZddlmZddlmZddlmZmZmZmZmZmZdd lmZdd lmZdd lmZdd l m!Z!dd l"m#Z#m$Z$m%Z%ddl&m'Z'm(Z(ddl&m)Z)ddl*m+Z+ddl,m-Z-ddl.m/Z/m0Z0ddl1m2Z2ddl3m4Z4m5Z5m6Z6ddl7m8Z8ddl9m:Z:ddlm;Z;mZ>Gdd„dee#j?ƒƒZ@dd„ZAGdd„de#jBƒZCeAeCƒZDGdd „d ej!ƒZEGd!d"„d"e#jBƒZFeAeFƒZGee%jHƒGd#d$„d$eFƒƒZIeAeIƒZJGd%d&„d&eFƒZKeAeKƒZLGd'd(„d(e#jMƒZNd)d*„ZOGd+d,„d,ePƒZQGd-d.„d.ej!eQƒZRGd/d0„d0eRƒZSGd1d2„d2eRƒZTGd3d4„d4eRƒZUGd5d6„d6ej!eQƒZVGd7d8„d8ej!ƒZWGd9d:„d:ej!ƒZXGd;d<„d„d>ej!ƒZZd?d@„Z[GdAdB„dBej!ƒZ\GdCdD„dDe!ƒZ]GdEdF„dFej!ƒZ^GdGdH„dHej!eQƒZ_GdIdJ„dJej!ƒZ`GdKdL„dLej!ƒZaGdMdN„dNe#jMƒZbGdOdP„dPej!ƒZcGdQdR„dRej!eQƒZdGdSdT„dTej!ƒZeGdUdV„dVej!eQƒZfdWdX„ZgGdYdZ„dZej!ƒZhGd[d\„d\ej!ƒZidS)]z Test HTTP support. é)Úabsolute_importÚdivisionN)ÚurlparseÚ urlunsplitÚ clear_cache)ÚBytesIO)Úprovider)Ú verifyObject)Ú_PY3Ú iterbytesÚlongÚ networkStringÚunicodeÚ intToBytes)ÚproxyForInterface)ÚFailure)Úunittest)ÚTestCase)ÚhttpÚ http_headersÚiweb)ÚPotentialDataLossÚ _DataLoss)Ú_IdentityTransferDecoder)Úaddress)ÚClock)ÚConnectionLostÚConnectionDone)Úloopback)ÚStringTransportÚNonStreamingProducerÚEventLoggingObserver)Ú DummyProducer)Ú DummyChannel©ÚdirectlyProvidesÚ providedBy)ÚglobalLogPublisherc@seZdZdZdS)Ú._IDeprecatedHTTPChannelToRequestInterfaceProxyz‰ Proxy L{_IDeprecatedHTTPChannelToRequestInterface}. Used to assert that the interface matches what L{HTTPChannel} expects. N)Ú__name__Ú __module__Ú __qualname__Ú__doc__©r-r-ú._makeRequestProxyr$)r4r5r-r3r.Ú_makeRequestProxyFactory5s r6c@seZdZdZdd„ZdS)ÚDummyPullProducerHandlerzš An HTTP request handler that registers a dummy pull producer to serve the body. The owner must call C{finish} to complete the response. cCs&t|ƒ|_| d¡| |jd¡dS)NéÈF)r Ú_actualProducerÚsetResponseCodeÚregisterProducer©Úselfr-r-r.ÚprocessTs  z DummyPullProducerHandler.processN©r)r*r+r,r>r-r-r-r.r7Msr7c@s eZdZdZdd„Zdd„ZdS)Ú DateTimeTestszTest date parsing functions.cCs>tdƒD]0}t dd¡}t |¡}t |¡}| ||¡qdS)Ni'ri”5w)ÚrangeÚrandomZrandintrZdatetimeToStringÚstringToDatetimeÚ assertEqual)r=ÚiÚtimeZtimestrZtime2r-r-r.Ú testRoundtripbs     zDateTimeTests.testRoundtripcCsVddddddddg}t d ¡}|D]}| t |¡|¡q"| t d ¡t d ¡¡dS) NsSun, 06 Nov 1994 08:49:37 GMTs06 Nov 1994 08:49:37 GMTsSunday, 06-Nov-94 08:49:37 GMTs06-Nov-94 08:49:37 GMTs Sunday, 06-Nov-1994 08:49:37 GMTs06-Nov-1994 08:49:37 GMTsSun Nov 6 08:49:37 1994sNov 6 08:49:37 1994) iÊé ééé1é%rIrIrs Thursday, 29-Sep-16 17:15:29 GMT) iàé ééérNéir)ÚcalendarZtimegmrDrrC)r=Z dateStringsZdateIntZ dateStringr-r-r.ÚtestStringToDatetimejs ø þz"DateTimeTests.testStringToDatetimeN)r)r*r+r,rGrSr-r-r-r.r@_sr@c@seZdZdd„ZdS)ÚDummyHTTPHandlercCs¨|j dd¡|j ¡}| d¡}|dkr6t|ƒ ¡}d|d|d}| d¡| d|j¡| d|j ¡| d|j ¡| d t t |ƒƒ¡|  |¡| ¡dS) Nrócontent-lengths''' ó r8sRequestsCommandsVersionóContent-Length)ÚcontentÚseekÚreadÚ getHeaderÚstrÚencoder:Ú setHeaderÚuriÚmethodÚ clientprotorÚlenÚwriteÚfinish)r=ÚdataÚlengthÚrequestr-r-r.r>€s     zDummyHTTPHandler.processN©r)r*r+r>r-r-r-r.rT~srTc@seZdZdZdd„ZdS)ÚDummyNewHTTPHandlerzÉ This is exactly like the DummyHTTPHandler but it takes only one argument in its constructor, with no default arguments. This exists to test an alternative code path in L{HTTPChannel}. cCst ||¡dSr/)rTÚ__init__)r=Úchannelr-r-r.rjšszDummyNewHTTPHandler.__init__N)r)r*r+r,rjr-r-r-r.ri“sric@s eZdZdZdd„Zdd„ZdS)ÚDelayedHTTPHandlerzD Like L{DummyHTTPHandler}, but doesn't respond immediately. cCsdSr/r-r<r-r-r.r>¥szDelayedHTTPHandler.processcCst |¡dSr/)rTr>r<r-r-r.ÚdelayedProcess©sz!DelayedHTTPHandler.delayedProcessN)r)r*r+r,r>rmr-r-r-r.rl¡srlc@seZdZdd„ZdS)ÚLoopbackHTTPClientcCs0| dd¡| dd¡| ¡|j d¡dS)NóGETó/foo/barrWé ó 0123456789)Z sendCommandZ sendHeaderZ endHeadersÚ transportrcr<r-r-r.ÚconnectionMade²s  z!LoopbackHTTPClient.connectionMadeN)r)r*r+rtr-r-r-r.rn°srncCs|j|j_|S)a  Parametrizes the L{TimeoutMixin} so that it works with whatever reactor is being used by the test. @param protocol: A L{_GenericHTTPChannel} or something implementing a similar interface. @type protocol: L{_GenericHTTPChannel} @param reactor: An L{IReactorTime} implementation. @type reactor: L{IReactorTime} @return: The C{channel}, with its C{callLater} method patched. )Ú callLaterÚ_channel)ÚprotocolÚreactorr-r-r.ÚparametrizeTimeoutMixinºs ryc@seZdZdZdd„ZdS)ÚResponseTestMixinz› A mixin that provides a simple means of comparing an actual response string to an expected response string by performing the minimal parsing. c Cs¦|D]œ}|dd…|d}}|d}|dd…}| dd¡\}}| ¡}| d¡} | || ¡| t|ƒt|ƒ¡|dt|ƒ…} |t|ƒd…}| | |¡qdS)a( Assert that the C{responses} matches the C{expected} responses. @type responses: C{bytes} @param responses: The bytes sent in response to one or more requests. @type expected: C{list} of C{tuple} of C{bytes} @param expected: The expected values for the responses. Each tuple element of the list represents one response. Each byte string element of the tuple is a full header line without delimiter, except for the last element which gives the full response body. Néÿÿÿÿréó )ÚsplitÚ splitlinesÚpoprDÚsetrb) r=Z responsesÚexpectedÚresponseÚexpectedHeadersZexpectedContentZexpectedStatusÚheadersÚrestÚstatusrXr-r-r.ÚassertResponseEqualsÖs    z&ResponseTestMixin.assertResponseEqualsN)r)r*r+r,rˆr-r-r-r.rzÐsrzc@s^eZdZdZdgZdd„Zdd„Zdd„Zd d „Zd d „Z d d„Z dd„Z dd„Z dd„Z dS)Ú HTTP1_0Testss7GET / HTTP/1.0 GET / HTTP/1.1 Accept: text/html )óHTTP/1.0 200 OKó Request: /ó Command: GETóVersion: HTTP/1.0óContent-Length: 13ó ''' None ''' cCs`tƒ}t ¡}t|_| |¡t|jƒD]}| |¡q(|  t dƒ¡|  ¡}|  ||j ¡dS)zZ Send requests over a channel and check responses match what is expected. zall oneN©rrÚ HTTPChannelÚDummyHTTPHandlerProxyÚrequestFactoryÚmakeConnectionr ÚrequestsÚ dataReceivedÚconnectionLostÚIOErrorÚvaluerˆÚexpected_response©r=ÚbÚaÚbyter™r-r-r.Ú test_buffers  zHTTP1_0Tests.test_buffercCsŒtƒ}tƒ}t ¡}d|_|j|_| |¡| d¡| d¡|  |j ¡| d¡| d¡|  |j ¡| d¡|  t |j ƒd¡dS)zq L{HTTPChannel} resets its timeout whenever data from a request body is delivered to it. édó&POST / HTTP/1.0 Content-Length: 2 écóxr|N)rrrr‘ÚtimeOutrur”r–ÚadvanceÚ assertFalseÚ disconnectingrDrbr•)r=Úclockrsrwr-r-r.Útest_requestBodyTimeouts        z$HTTP1_0Tests.test_requestBodyTimeoutcCsltƒ}tƒ}t ¡}| d¡}t||ƒ}| |¡| d¡| d¡|  |j ¡| d¡|  |j ¡dS)zA L{HTTPChannel}'s default timeout is 60 seconds. Nr¡é;r|) rrrÚ HTTPFactoryÚ buildProtocolryr”r–r¥r¦r§Ú assertTrue©r=r¨rsÚfactoryrwr-r-r.Útest_requestBodyDefaultTimeout*s       z+HTTP1_0Tests.test_requestBodyDefaultTimeoutcCst |t¡}tƒ}tƒ}t ¡}| d¡}t||ƒ}|  |¡|  d¡|  |j ¡|  |j ¡| d¡| |j ¡|  |j ¡| dt|ƒ¡|d}| d|d¡| d¡| |j ¡|  |j ¡| d¡| |j ¡| |j ¡| d t|ƒ¡|d}| d |d¡dS) ú} If a timed out transport doesn't close after 15 seconds, the L{HTTPChannel} will forcibly close it. Nr¡é<r|rzTiming out client: {peer}Ú log_formatééz"Forcibly timing out client: {peer})r!ÚcreateWithCleanupr'rrrr«r¬ryr”r–r¦r§Ú disconnectedr¥r­Ú assertEqualsrbÚassertIn)r=Ú logObserverr¨rsr¯rwÚeventr-r-r.Útest_transportForciblyClosed;s>þ               þz)HTTP1_0Tests.test_transportForciblyClosedcCs°tƒ}tƒ}t ¡}| d¡}t||ƒ}| |¡| d¡| |j ¡| |j ¡|  d¡|  |j ¡| |j ¡|  d¡|  d¡|  d¡|  |j ¡| |j ¡dS)z… If a timed out transport ends up calling C{connectionLost}, it prevents the force-closure of the transport. Nr¡r²r´r|)rrrr«r¬ryr”r–r¦r§r·r¥r­r—r®r-r-r.Ú+test_transportNotAbortedAfterConnectionLostes"             z8HTTP1_0Tests.test_transportNotAbortedAfterConnectionLostcCs¤tƒ}tƒ}t ¡}| d¡}d|j_t||ƒ}| |¡|  d¡|  |j ¡|  |j ¡|  d¡| |j ¡|  |j ¡|  d¡| |j ¡|  |j ¡dS)zh If the L{HTTPChannel} has its c{abortTimeout} set to L{None}, it never aborts. Nr¡r²l)rrrr«r¬rvZ abortTimeoutryr”r–r¦r§r·r¥r­r®r-r-r.Ú,test_transportNotAbortedWithZeroAbortTimeoutƒs            z9HTTP1_0Tests.test_transportNotAbortedWithZeroAbortTimeoutcCsŽtƒ}tƒ}t ¡}| d¡}t||ƒ}| |¡| d¡| |j ¡| |j ¡|  d¡|  d¡|  |j ¡|  |j ¡|  t¡dS)r±Nr¡r²rP)rrrr«r¬ryr”r–r¦r§r·r¥r­r—rr®r-r-r.Ú"test_connectionLostAfterForceClosežs          z/HTTP1_0Tests.test_connectionLostAfterForceClosecCs`tƒ}t ¡}t|_| |¡t|jƒD]}| |¡q(|  t dƒ¡|  ¡}|  ||j ¡dS)zf Test that a L{http.Request} subclass with no queued kwarg works as expected. úall doneNrr›r-r-r.Útest_noPipeliningApi¹s  z!HTTP1_0Tests.test_noPipeliningApicCs¦tƒ}t ¡}t|_| |¡t|jƒD]}| |¡q(|  ¡}|  |d¡|  dt |jƒ¡|jrŒ|  dt |jƒ¡|jdj }|  ¡q^|  ¡}| ||j¡dS)zW Test that pipelined requests get buffered, not processed in parallel. ór|rN)rrr‘ÚDelayedHTTPHandlerProxyr“r”r r•r–r™rDrbÚoriginalrmrˆrš)r=rœrržr™rgr-r-r.Útest_noPipeliningÊs     zHTTP1_0Tests.test_noPipeliningN)r)r*r+r•ršrŸr©r°r¼r½r¾r¿rÁrÅr-r-r-r.r‰õsÿÿ*r‰c@seZdZdZddddgZdS)Ú HTTP1_1TestssšGET / HTTP/1.1 Accept: text/html POST / HTTP/1.1 Content-Length: 10 0123456789POST / HTTP/1.1 Content-Length: 10 0123456789HEAD / HTTP/1.1 )óHTTP/1.1 200 OKr‹rŒóVersion: HTTP/1.1rŽr©rÇr‹ó Command: POSTrÈsContent-Length: 21ó''' 10 0123456789''' )rÇr‹s Command: HEADrÈrŽrÂN©r)r*r+r•ršr-r-r-r.rÆæsÿírÆc@seZdZdZdgZdS)ÚHTTP1_1_close_TestsóJGET / HTTP/1.1 Accept: text/html Connection: close GET / HTTP/1.0 )rÇsConnection: closer‹rŒrÈrŽrNrÌr-r-r-r.rÍsÿ ÿrÍc@s$eZdZdZdZdd„Zdd„ZdS)Ú HTTP0_9TestssGET / óHTTP/1.1 400 Bad Request cCs| ||¡dSr/)rD)r=rƒZexpectedResponser-r-r.rˆ.sz!HTTP0_9Tests.assertResponseEqualscCst d¡‚dS)NzHTTP/0.9 not supported)rZSkipTestr<r-r-r.rÅ2szHTTP0_9Tests.test_noPipeliningN)r)r*r+r•ršrˆrÅr-r-r-r.rÏ&s ÿrÏc@sLeZdZdZdZddgZdd„Zdd„Zd d „Zd d „Z d d„Z dd„Z dS)ÚPipeliningBodyTestszl Pipelined requests get buffered and executed in the order received, not processed in parallel. stPOST / HTTP/1.1 Content-Length: 10 0123456789POST / HTTP/1.1 Transfer-Encoding: chunked a 0123456789 0 rÉ)rÇr‹rÊrÈsContent-Length: 23s''' None 0123456789''' cCsžtƒ}t ¡}t|_| |¡t|jƒD]}| |¡q(|  |  ¡d¡|  dt |jƒ¡|jrˆ|  dt |jƒ¡|jdj }|  ¡qZ| |  ¡|j¡dS)zà Imitate a slow connection that delivers one byte at a time. The request handler (L{DelayedHTTPHandler}) is puppeted to step through the handling of each request. rÂr|rN)rrr‘rÃr“r”r r•r–rDr™rbrÄrmrˆÚexpectedResponses)r=rœrržrgr-r-r.Útest_stepwiseTinyTubeXs    z)PipeliningBodyTests.test_stepwiseTinyTubecCstƒ}t ¡}t|_| |¡| |j¡| |  ¡d¡| dt |jƒ¡|jrz| dt |jƒ¡|jdj }|  ¡qL|  |  ¡|j¡dS)zã Imitate a fast connection where several pipelined requests arrive in a single read. The request handler (L{DelayedHTTPHandler}) is puppeted to step through the handling of each request. rÂr|rN)rrr‘rÃr“r”r–r•rDr™rbrÄrmrˆrÒ)r=rœrrgr-r-r.Útest_stepwiseDumpTruckrs    z*PipeliningBodyTests.test_stepwiseDumpTruckcCs`tƒ}t ¡}t|_| |¡t|jƒD] }| |¡|  t |jƒd¡q(|  |  ¡|j ¡dS)zŸ Imitate a slow connection that delivers one byte at a time. (L{DummyHTTPHandler}) immediately responds, but no more than one r|N)rrr‘r’r“r”r r•r–ZassertLessEqualrbrˆr™rÒ)r=rœrržr-r-r.Útest_immediateTinyTubeŒs  z*PipeliningBodyTests.test_immediateTinyTubecCs@tƒ}t ¡}t|_| |¡| |j¡| |  ¡|j ¡dS)aR Imitate a fast connection where several pipelined requests arrive in a single read. The request handler (L{DummyHTTPHandler}) immediately responds. This doesn't check the at-most-one pending request invariant but exercises otherwise uncovered code paths. See GHSA-c8m8-j448-xjx7. N) rrr‘r’r“r”r–r•rˆr™rÒ)r=rœrr-r-r.Útest_immediateDumpTruck s   z+PipeliningBodyTests.test_immediateDumpTruckcCs\tƒ}t ¡}t|_| |¡|jt|jƒd}|  |j|¡|  |  ¡|j |¡dS)a¯ Imitate a fast connection where a so many pipelined requests arrive in a single read that backpressure is indicated. The request handler (L{DummyHTTPHandler}) immediately responds. This doesn't check the at-most-one pending request invariant but exercises otherwise uncovered code paths. See GHSA-c8m8-j448-xjx7. @see: L{http.HTTPChannel._optimisticEagerReadSize} rqN) rrr‘r’r“r”Ú_optimisticEagerReadSizerbr•r–rˆr™rÒ)r=rœrZoverLimitCountr-r-r.Útest_immediateABiggerTruck´s  z.PipeliningBodyTests.test_immediateABiggerTruckc Csˆtƒ}t ¡}t|_| |¡|jt|jƒ}t d|dƒD],}|  |j¡|  |j ddj |j |d¡q<|  |j¡| |j d¡dS)zÝ When pipelined requests are received, we will optimistically continue receiving data up to a specified limit, then pause the transport. @see: L{http.HTTPChannel._optimisticEagerReadSize} r|Ú producingz(state was {state!r} after {x} iterations)ÚstateÚxÚpausedN)rrr‘rÃr“r”r×rbr•rAr–rDÚ producerStateÚformatr¸)r=rœrZ underLimitrÛr-r-r.Útest_pipeliningReadLimitËs   ÿÿ z,PipeliningBodyTests.test_pipeliningReadLimitN) r)r*r+r,r•rÒrÓrÔrÕrÖrØrßr-r-r-r.rÑ7sÿùrÑc@s.eZdZdZGdd„dejƒZdZdd„ZdS)Ú ShutdownTestszM Tests that connections can be shut down by L{http.Request} objects. c@seZdZdZdd„ZdS)z!ShutdownTests.ShutdownHTTPHandlerzL A HTTP handler that just immediately calls loseConnection. cCs | ¡dSr/)ÚloseConnectionr<r-r-r.r>êsz)ShutdownTests.ShutdownHTTPHandler.processNr?r-r-r-r.ÚShutdownHTTPHandleræsrâs1POST / HTTP/1.1 Content-Length: 10 0123456789cCsTtƒ}t ¡}t|jƒ|_| |¡| |j¡|  |j ¡|  ¡}|  |d¡dS)zi Calling L{http.Request.loseConnection} causes the transport to be disconnected. rÂN) rrr‘r6râr“r”r–rgr­r§r™rD)r=rœrr™r-r-r.Útest_losingConnectionös    z#ShutdownTests.test_losingConnectionN) r)r*r+r,rÚRequestrârgrãr-r-r-r.ràás  ÿràc@s(eZdZdZdd„Zdd„Zdd„ZdS) Ú SecurityTestsz] Tests that L{http.Request.isSecure} correctly takes the transport into account. cCs6t ¡}t ¡}| |¡t |¡}| | ¡¡dS)z‚ Calling L{http.Request.isSecure} when the channel is backed with a secure transport will return L{True}. N)r#ÚSSLrr‘r”rär­ÚisSecure©r=rœrÚreqr-r-r.Ú test_isSecures   zSecurityTests.test_isSecurecCs6t ¡}t ¡}| |¡t |¡}| | ¡¡dS)z‡ Calling L{http.Request.isSecure} when the channel is not backed with a secure transport will return L{False}. N)r#ÚTCPrr‘r”rär¦rçrèr-r-r.Útest_notSecures   zSecurityTests.test_notSecurecCsTt ¡}t ¡}| |¡t |¡}|j |¡| d¡|  ¡|  |  ¡¡dS)zt After a request is finished, calling L{http.Request.isSecure} will always return L{False}. r8N) r#rærr‘r”rär•Úappendr:rdr¦rçrèr-r-r.Útest_notSecureAfterFinish's    z'SecurityTests.test_notSecureAfterFinishN)r)r*r+r,rêrìrîr-r-r-r.rå s  råc@sœeZdZdZdZdd„Zdd„Zdd„Zd d „Zd d „Z e j sDd e _ dd„Z e j rXde _ dd„Zdd„Zdd„Zdd„Ze j s„d e_ dd„Ze j s˜d e_ dS)ÚGenericHTTPChannelTestsz† Tests for L{http._genericHTTPChannelProtocol}, a L{HTTPChannel}-alike which can handle different HTTP protocol channels. rÎcCsHt d¡}t|_| |¡t|jƒD]}| |¡q$| t dƒ¡|j S)z{ Run a request using the specific instance of a transport. Returns the negotiated protocol string. rÂrÀ) rÚ"_genericHTTPChannelProtocolFactoryr’r“r”r r•r–r—r˜Z_negotiatedProtocol)r=Útrržr-r-r.Ú'_negotiatedProtocolForTransportInstanceFs   z?GenericHTTPChannelTests._negotiatedProtocolForTransportInstancecCs tƒ}| |¡}| |d¡dS)zŠ If the transport has no support for protocol negotiation (no negotiatedProtocol attribute), HTTP/1.1 is assumed. óhttp/1.1N)rròrD©r=rœÚnegotiatedProtocolr-r-r.Útest_protocolUnspecifiedUs z0GenericHTTPChannelTests.test_protocolUnspecifiedcCs&tƒ}d|_| |¡}| |d¡dS)zŽ If the transport has no support for protocol negotiation (returns None for negotiatedProtocol), HTTP/1.1 is assumed. Nró©rrõròrDrôr-r-r.Útest_protocolNone_s z)GenericHTTPChannelTests.test_protocolNonecCs&tƒ}d|_| |¡}| |d¡dS)zi If the transport reports that HTTP/1.1 is negotiated, that's what's negotiated. róNr÷rôr-r-r.Ú test_http11js z#GenericHTTPChannelTests.test_http11cCs&tƒ}d|_| |¡}| |d¡dS)z} If the transport reports that HTTP/2 is negotiated and HTTP/2 is present, that's what's negotiated. óh2Nr÷rôr-r-r.Útest_http2_presentus z*GenericHTTPChannelTests.test_http2_presentzHTTP/2 support not presentcCs tƒ}d|_| t|j|¡dS)z€ If the transport reports that HTTP/2 is negotiated and HTTP/2 is not present, an error is encountered. rúN)rrõÚ assertRaisesÚ ValueErrorrò©r=rœr-r-r.Útest_http2_absent‚sýz)GenericHTTPChannelTests.test_http2_absentzHTTP/2 support presentcCs tƒ}d|_| t|j|¡dS)z€ If the transport reports that a protocol other than HTTP/1.1 or HTTP/2 is negotiated, an error occurs. ssmtpN)rrõrüÚAssertionErrorròrþr-r-r.Útest_unknownProtocol’sýz,GenericHTTPChannelTests.test_unknownProtocolcCs$t d¡}d|j_| |jd¡dS)zK The C{factory} attribute is taken from the inner channel. rÂóFooN)rrðrvr¯rD)r=rr-r-r.Ú test_factory s z$GenericHTTPChannelTests.test_factorycCsBtƒ}tj|d}| d¡}| |j|j¡| |jj|j¡dS)zž If C{callLater} is patched onto the L{http._GenericHTTPChannelProtocol} then we need to propagate it through to the backing channel. ©rxN)rrr«r¬rDrurv)r=r¨r¯rwr-r-r.Ú*test_GenericHTTPChannelPropagatesCallLater©s   zBGenericHTTPChannelTests.test_GenericHTTPChannelPropagatesCallLatercCsŠtƒ}tj|d}| d¡}| |j|j¡| |jj|j¡tƒ}d|_t |_ |  |¡|  d¡| |j|j¡| |jj|j¡dS)z· If C{callLater} is patched onto the L{http._GenericHTTPChannelProtocol} then we need to propagate it across onto a new backing channel after upgrade. rNrúóP) rrr«r¬rDrurvrrõrTr“r”r–©r=r¨r¯rwrsr-r-r.Ú'test_genericHTTPChannelCallLaterUpgrade¶s    z?GenericHTTPChannelTests.test_genericHTTPChannelCallLaterUpgradecCsftƒ}d|_t d¡}t|_| |¡|j}| |j |¡|  d¡|  |j |¡| |j |j¡dS)z‹ The L{_GenericHTTPChannelProtocol} will unregister its proxy channel from the transport if upgrade is negotiated. rúrÂrN) rrõrrðr’r“r”rvÚassertIsÚproducerr–Z assertIsNot)r=rsZgenericProtocolZoriginalChannelr-r-r.Útest_unregistersProducerÓs   z0GenericHTTPChannelTests.test_unregistersProducerN)r)r*r+r,r•ròrörørùrûrZ H2_ENABLEDÚskiprÿrrrrr r-r-r-r.rï8s.ÿ        ÿrïc@sZeZdZdddddœZdZdZdZdZdd„Zd d „Z d d „Z d d„Z dd„Z dd„Z dS)ÚHTTPLoopbackTestsrproóHTTP/1.0s21)srequestscommandsversionrUrcCs"d|_| |d¡| |d¡dS)Nr|rs200)Ú gotStatusrD©r=Úversionr‡Úmessager-r-r.Ú _handleStatusÿs zHTTPLoopbackTests._handleStatuscCsd|_| |d¡dS)Nr|rË)Ú gotResponserD)r=rer-r-r.Ú_handleResponsesz!HTTPLoopbackTests._handleResponsecCs&|jd|_| |j| ¡|¡dS)Nr|)Ú numHeadersrDr„Úlower)r=Úkeyr™r-r-r.Ú _handleHeaders zHTTPLoopbackTests._handleHeadercCsd|_| |jd¡dS)Nr|é)Ú gotEndHeadersrDrr<r-r-r.Ú_handleEndHeaders sz#HTTPLoopbackTests._handleEndHeaderscCsPt ¡}t|_tƒ}|j|_|j|_|j |_ |j |_ t  ||¡}| |j¡|Sr/)rr‘r’r“rnrZhandleResponserÚ handleHeaderrÚhandleEndHeadersrÚ handleStatusrZ loopbackAsyncÚ addCallbackÚ_cbTestLoopback)r=ZserverÚclientÚdr-r-r.Ú testLoopbacks  zHTTPLoopbackTests.testLoopbackcCs>|jr|jr|js*td|j|j|jgƒ‚|`|`|`|`dS)Nzdidn't got all callbacks %s)rrrÚ RuntimeErrorr)r=Zignoredr-r-r.r!sÿÿz!HTTPLoopbackTests._cbTestLoopbackN)r)r*r+r„rrrrrrrrr$r!r-r-r-r.r ôsý r cKs6t tƒd¡}| ¡D]\}}|j t|ƒ|¡q|S)zR Make a request with the given request headers for the persistence tests. F)rrär#ÚitemsÚrequestHeadersÚ setRawHeadersr )r…rgZ headerNameÚvr-r-r.Ú _prequest(sr*c@s8eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd S) ÚPersistenceTestsz0 Tests for persistent HTTP connections. cCst ¡|_tƒ|_dSr/)rr‘rkr*rgr<r-r-r.ÚsetUp7s zPersistenceTests.setUpcCs6|j |jd¡}| |¡| gt|jj ¡ƒ¡dS)zl After being used for an I{HTTP/0.9} request, the L{HTTPChannel} is not persistent. sHTTP/0.9N©rkÚcheckPersistencergr¦rDÚlistÚresponseHeadersÚgetAllRawHeaders©r=Úpersistr-r-r.Ú test_http09<s  ÿzPersistenceTests.test_http09cCs6|j |jd¡}| |¡| gt|jj ¡ƒ¡dS)zl After being used for an I{HTTP/1.0} request, the L{HTTPChannel} is not persistent. rNr-r2r-r-r.Ú test_http10Gs  ÿzPersistenceTests.test_http10cCs6|j |jd¡}| |¡| gt|jj ¡ƒ¡dS)zh After being used for an I{HTTP/1.1} request, the L{HTTPChannel} is persistent. óHTTP/1.1N)rkr.rgr­rDr/r0r1r2r-r-r.rùRs  ÿzPersistenceTests.test_http11cCsFtdgd}|j |d¡}| |¡| ddgfgt|j ¡ƒ¡dS)z After being used for an I{HTTP/1.1} request with a I{Connection: Close} header, the L{HTTPChannel} is not persistent. sclose)Z connectionr6s ConnectionN)r*rkr.r¦rDr/r0r1)r=rgr3r-r-r.Útest_http11Close]s    þz!PersistenceTests.test_http11CloseN) r)r*r+r,r,r4r5rùr7r-r-r-r.r+3s    r+c@s`eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dS)ÚIdentityTransferEncodingTestsz0 Tests for L{_IdentityTransferDecoder}. cCs.g|_g|_d|_t|j|jj|jjƒ|_dS)z€ Create an L{_IdentityTransferDecoder} with callbacks hooked up so that calls to them can be inspected. rqN)rerdÚ contentLengthrríÚdecoderr<r-r-r.r,osÿz#IdentityTransferEncodingTests.setUpcCs<|j d|j¡| |jd|jg¡| |jdg¡dS)aC If L{_IdentityTransferDecoder.dataReceived} is called with a byte string with length equal to the content length passed to L{_IdentityTransferDecoder}'s initializer, the data callback is invoked with that string and the finish callback is invoked with a zero-length string. r£rÂN©r:r–r9rDrerdr<r-r-r.Útest_exactAmountReceived{sz6IdentityTransferEncodingTests.test_exactAmountReceivedcCsp|j d¡| |jdg¡| |jg¡|j d|jd¡| |jdd|jdg¡| |jdg¡dS)a3 If L{_IdentityTransferDecoder.dataReceived} is called multiple times with byte strings which, when concatenated, are as long as the content length provided, the data callback is invoked with each string and the finish callback is invoked only after the second call. r£óyr|rÂN)r:r–rDrerdr9r<r-r-r.Útest_shortStringsˆs  z/IdentityTransferEncodingTests.test_shortStringscCs@|j d|jd¡| |jd|jg¡| |jdg¡dS)a3 If L{_IdentityTransferDecoder.dataReceived} is called with a byte string with length greater than the provided content length, only the prefix of that string up to the content length is passed to the data callback and the remainder is passed to the finish callback. r£r=Nr;r<r-r-r.Útest_longString—sz-IdentityTransferEncodingTests.test_longStringcsjg‰‡‡fdd„}td|jj|ƒ‰ˆ d¡| ˆg¡ˆ d¡ˆd t¡| tˆdjƒd¡dS) zž If data is passed to L{_IdentityTransferDecoder.dataReceived} after the finish callback has been invoked, C{RuntimeError} is raised. cs,zˆ d¡Wnˆ tƒ¡YnXdS)Nófoo)r–rír©Úbytes©r:Zfailuresr-r.rd©szJIdentityTransferEncodingTests.test_rejectDataAfterFinished..finishésxxxxr=rz;_IdentityTransferDecoder cannot decode data after finishingN) rrerír–rDZtrapr%r\r™)r=rdr-rCr.Útest_rejectDataAfterFinished£s    þz:IdentityTransferEncodingTests.test_rejectDataAfterFinishedcCsZg}g}td|j|jƒ}| d¡| |dg¡| d¡| |ddg¡| |g¡dS)zµ If L{_IdentityTransferDecoder} is constructed with L{None} for the content length, it passes all data delivered to it through to the data callback. Nr£r=)rrír–rD)r=rerdr:r-r-r.Útest_unknownContentLength¸s  z7IdentityTransferEncodingTests.test_unknownContentLengthcCs | |jd¡| |jd¡dS)z Check the decoder's data and finish callbacks and make sure they are None in order to help avoid references cycles. N)ÚassertIdenticalZ dataCallbackZfinishCallback)r=r:r-r-r.Ú_verifyCallbacksUnreferencedÈsz:IdentityTransferEncodingTests._verifyCallbacksUnreferencedcCs6|j d|jd¡| t|jj¡| |j¡dS)z¶ L{_IdentityTransferDecoder.noMoreData} raises L{_DataLoss} if it is called and the content length is known but not enough bytes have been delivered. r£r|N)r:r–r9rürÚ noMoreDatarHr<r-r-r.Útest_earlyConnectionLoseÑsz6IdentityTransferEncodingTests.test_earlyConnectionLosecCsNg}g}td|j|jƒ}| t|j¡| |g¡| |dg¡| |¡dS)zµ L{_IdentityTransferDecoder.noMoreData} calls the finish callback and raises L{PotentialDataLoss} if it is called and the content length is unknown. NrÂ)rrírürrIrDrH)r=ÚbodyÚfinishedr:r-r-r.Ú'test_unknownContentLengthConnectionLoseÜs zEIdentityTransferEncodingTests.test_unknownContentLengthConnectionLosecCs,|j d|j¡|j ¡| |j¡dS)z¿ L{_IdentityTransferDecoder.noMoreData} does not raise any exception if it is called when the content length is known and that many bytes have been delivered. r£N)r:r–r9rIrHr<r-r-r.Útest_finishedConnectionLoseës z9IdentityTransferEncodingTests.test_finishedConnectionLoseN)r)r*r+r,r,r<r>r?rErFrHrJrMrNr-r-r-r.r8ks     r8c@s`eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dS)ÚChunkedTransferEncodingTestsz¨ Tests for L{_ChunkedTransferDecoder}, which turns a byte stream encoded using HTTP I{chunked} C{Transfer-Encoding} back into the original byte stream. cCs<g}t |jd¡}| d¡| d¡| |dddg¡dS)z L{_ChunkedTransferDecoder.dataReceived} decodes chunked-encoded data and passes the result to the specified callback. Ns3 abc 5 12345 sa 0123456789 óabcs12345rr©rÚ_ChunkedTransferDecoderrír–rD©r=ÚLÚpr-r-r.Ú test_decodingýs   z*ChunkedTransferEncodingTests.test_decodingc Cs^g}g}t |j|j¡}tdƒD]}| |¡q | |dddddddd g¡| |d g¡d S) z{ L{_ChunkedTransferDecoder.dataReceived} decodes chunks broken up and delivered in multiple calls. s3 abc 5 12345 0 óaóbócó1ó2ó3ó4ó5rÂN)rrRrír r–rD)r=rTrLrUÚsr-r-r.Ú test_short s  z'ChunkedTransferEncodingTests.test_shortcCs.g}t |jd¡}| d¡| |dg¡dS)z L{_ChunkedTransferDecoder.dataReceived} doesn't treat CR LF pairs embedded in chunk bodies specially. Ns2 ó rQrSr-r-r.Ú test_newliness z*ChunkedTransferEncodingTests.test_newlinescCs.g}t |jd¡}| d¡| |dg¡dS)zd L{_ChunkedTransferDecoder.dataReceived} disregards chunk-extension fields. Ns3; x-foo=bar abc rPrQrSr-r-r.Útest_extensions"s z,ChunkedTransferEncodingTests.test_extensionscCs.g}t d|j¡}| d¡| |dg¡dS)z± L{_ChunkedTransferDecoder.dataReceived} interprets a zero-length chunk as the end of the chunked data stream and calls the completion callback. Nó0 rÂrQ©r=rLrUr-r-r.Ú test_finish-s z(ChunkedTransferEncodingTests.test_finishcCs.g}t d|j¡}| d¡| |dg¡dS)z¡ L{_ChunkedTransferDecoder.dataReceived} passes any bytes which come after the terminating zero-length chunk to the completion callback. Ns 0 helloóhellorQrer-r-r.Ú test_extra9s z'ChunkedTransferEncodingTests.test_extracCs.t ddd„¡}| d¡| t|jd¡dS)zŠ L{_ChunkedTransferDecoder.dataReceived} raises C{RuntimeError} if it is called after it has seen the last chunk. NcSsdSr/r-rAr-r-r.ÚIrÂzAChunkedTransferEncodingTests.test_afterFinished..rdrg)rrRr–rür%)r=rUr-r-r.Útest_afterFinishedDs z/ChunkedTransferEncodingTests.test_afterFinishedcCs<t ddd„¡}| d¡| t|j¡}| t|ƒd¡dS)zž L{_ChunkedTransferDecoder.noMoreData} raises L{_DataLoss} if it is called and the end of the last trailer has not yet been received. NcSsdSr/r-rAr-r-r.riSrÂzGChunkedTransferEncodingTests.test_earlyConnectionLose..s0 zYChunked decoder in 'TRAILER' state, still expecting more data to get to 'FINISHED' state.)rrRr–rürrIrDr\)r=ÚparserÚexcr-r-r.rJNs þz5ChunkedTransferEncodingTests.test_earlyConnectionLosecCs&t ddd„¡}| d¡| ¡dS)zž L{_ChunkedTransferDecoder.noMoreData} does not raise any exception if it is called after the terminal zero length chunk is received. NcSsdSr/r-rAr-r-r.riarÂzJChunkedTransferEncodingTests.test_finishedConnectionLose..rd)rrRr–rI)r=rkr-r-r.rN\s z8ChunkedTransferEncodingTests.test_finishedConnectionLosecsLg‰g‰‡‡‡fdd„}t d|¡‰ˆ d¡| ˆg¡| ˆdg¡dS)z† L{_ChunkedTransferDecoder.noMoreData} can be called from the finished callback without raising an exception. cs4z ˆ ¡Wnˆ tƒ¡Yn Xˆ d¡dS©NT)rIrír)Zextra©ÚerrorsrkZ successesr-r.rLms  zOChunkedTransferEncodingTests.test_reentrantFinishedNoMoreData..finishedNrdT)rrRr–rD)r=rLr-rnr.Ú test_reentrantFinishedNoMoreDatafs   z=ChunkedTransferEncodingTests.test_reentrantFinishedNoMoreDataN)r)r*r+r,rVr`rbrcrfrhrjrJrNrpr-r-r-r.rO÷s       rOc@s4eZdZddddddgZdd„Zd d „Zd d „Zd S)Ú ChunkingTestssabcvrÂsfdfsd423s Ffasfas s 523523 fsdfs4234cCsF|jD]*}d t |¡¡}| |dft |¡¡q| ttjd¡dS)NrÂs-5 malformed! )ÚstringsÚjoinrÚtoChunkrDÚ fromChunkrürý)r=r_Úchunkedr-r-r.Ú testChunks€s zChunkingTests.testChunksc Csxd dd„|jDƒ¡}g}d}t|ƒD]>}||}zt |¡\}}| |¡Wq&tk rbYq&Xq&| ||j¡dS)NrÂcSsg|]}d t |¡¡‘qS)rÂ)rsrrt)Ú.0rñr-r-r.Ú ‡sz8ChunkingTests.testConcatenatedChunks..)rsrrr rrurírýrD)r=rvÚresultÚbufferÚcrer-r-r.ÚtestConcatenatedChunks†s z$ChunkingTests.testConcatenatedChunkscCsntƒ}t ¡}| |¡t |d¡}| d¡d|_|j ddg¡|  d¡|  d¡|  |  ¡dg¡d S) zV Test that the L{HTTPChannel} correctly chunks responses when needed. Fr8r6ótestólemuróHelloóWorld!©rÇó Test: lemuróTransfer-Encoding: chunkeds5 Hello 6 World! N) rrr‘r”rär:rar0r(rcrˆr™)r=Útransrkrér-r-r.Útest_chunkedResponses“s     þz#ChunkingTests.test_chunkedResponsesN)r)r*r+rrrwr}r†r-r-r-r.rq{sÿ rqc@seZdZdZdd„ZdEdd„Zdd „Zd d „Zd d „Zdd„Z dd„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zer¨d(e_d)d*„Zd+d,„Zd-d.„Zd/d0„Zd1d2„Zd3d4„Zd5d6„Zd7d8„Zd9d:„Z d;d<„Z!d=d>„Z"d?d@„Z#dAdB„Z$dCdD„Z%dS)FÚ ParsingTestsz7 Tests for protocol parsing in L{HTTPChannel}. cCs d|_dS)NF©Ú didRequestr<r-r-r.r,°szParsingTests.setUpNTcCsŠ|s t ¡}|rt|ƒ|_| dd¡}tƒ}| |¡t|ƒD]}|jj rNqZ|  |¡q>|  t dƒ¡|rz|  |j¡n | |j¡|S)a› Execute a web request based on plain text content. @param httpRequest: Content for the request which is processed. Each L{" "} will be replaced with L{" "}. @type httpRequest: C{bytes} @param requestFactory: 2-argument callable returning a Request. @type requestFactory: C{callable} @param success: Value to compare against I{self.didRequest}. @type success: C{bool} @param channel: Channel instance over which the request is processed. @type channel: L{HTTPChannel} @return: Returns the channel used for processing the request. @rtype: L{HTTPChannel} rVrarÀ)rr‘r6r“Úreplacerr”r rsr§r–r—r˜r­r‰r¦)r=Ú httpRequestr“Úsuccessrkrsržr-r-r.Ú runRequest´s       zParsingTests.runRequestcsdd |¡}g‰G‡fdd„dtjƒ}|j||dd}| |j ¡d¡| |jj¡| ˆg¡dS)aJ Execute a HTTP request and assert that it is rejected with a 400 Bad Response and disconnection. @param requestLines: Plain text lines of the request. These lines will be joined with newlines to form the HTTP request that is processed. @type requestLines: C{list} of C{bytes} rVcseZdZ‡fdd„ZdS)z5ParsingTests.assertRequestRejected..MyRequestcsˆ |¡| ¡dSr/©rírdr<©Ú processedr-r.r>îs z=ParsingTests.assertRequestRejected..MyRequest.processNrhr-rr-r.Ú MyRequestísr‘F©rŒrÐN) rsrrärrDrsr™r­r§)r=Ú requestLinesr‹r‘rkr-rr.ÚassertRequestRejectedás þz"ParsingTests.assertRequestRejectedcs\g‰G‡fdd„dtjƒ}d}| ||d¡}| |j ¡d¡| |jj¡| ˆg¡dS)z When client sends invalid HTTP method containing non-ascii characters HTTP 400 'Bad Request' status will be returned. cseZdZ‡fdd„ZdS)z:ParsingTests.test_invalidNonAsciiMethod..MyRequestcsˆ |¡| ¡dSr/rŽr<rr-r.r>s zBParsingTests.test_invalidNonAsciiMethod..MyRequest.processNrhr-rr-r.r‘sr‘sGE© / HTTP/1.1 rrÐN)rrärrDrsr™r­r§)r=r‘ZbadRequestLinerkr-rr.Útest_invalidNonAsciiMethodûsþz'ParsingTests.test_invalidNonAsciiMethodcsxg‰G‡fdd„dtjƒ}dD]T\}}t d ||f¡¡ ¡}d|d}| ||d¡ˆ ¡}| ||f|j ¡qdS) zÜ L{HTTPChannel} provides username and password information supplied in an I{Authorization} header to the L{Request} which makes it available via its C{getUser} and C{getPassword} methods. cseZdZ‡fdd„ZdS)z,ParsingTests.test_basicAuth..Requestcs | ¡| ¡f|_ˆ |¡dSr/©ZgetUserZ getPasswordÚ credentialsrír<©r•r-r.r>sz4ParsingTests.test_basicAuth..Request.processNrhr-r˜r-r.räsrä))r@óbar)rgsthere:zó:ó$GET / HTTP/1.0 Authorization: Basic ó rN) rräÚbase64Ú encodestringrsÚstriprr€rDr—)r=räÚurUr_Úfrér-r˜r.Útest_basicAuths  zParsingTests.test_basicAuthcsvg‰G‡fdd„dtjƒ}ddddddg}| d |¡|d ¡ˆ\}| |j d ¡d g¡| |j d ¡d dg¡dS)zo Headers received by L{HTTPChannel} in a request are made available to the L{Request}. cseZdZ‡fdd„ZdS)z,ParsingTests.test_headers..MyRequestcsˆ |¡| ¡dSr/rŽr<rr-r.r>*s z4ParsingTests.test_headers..MyRequest.processNrhr-rr-r.r‘)sr‘óGET / HTTP/1.0óFoo: bars baz: Quuxs baz: quuxrÂrVrr@r™sbAzsQuuxóquuxN)rrärrsrDr'Ú getRawHeaders)r=r‘r“rgr-rr.Ú test_headers#s&ú ÿ ÿzParsingTests.test_headerscCsLdg}ttjjdƒD]}| td|fƒ¡q| ddg¡| |¡dS)z… C{HTTPChannel} enforces a limit of C{HTTPChannel.maxHeaders} on the number of headers received per request. r£rµz%s: foorÂN)rArr‘Ú maxHeadersrír Úextendr”)r=r“rEr-r-r.Útest_tooManyHeaders>s z ParsingTests.test_tooManyHeaderscCs| ddddg¡dS)z¶ If a I{Content-Length} header with a non-integer value is received, a 400 (Bad Request) response is sent to the client and the connection is closed. r£sContent-Length: xrÂN©r”r<r-r-r.Útest_invalidContentLengthHeaderKsz,ParsingTests.test_invalidContentLengthHeadercCs| ddddg¡dS)z If a header without colon is received a 400 (Bad Request) response is sent to the client and the connection is closed. r£s HeaderName rÂNr«r<r-r-r.Útest_invalidHeaderNoColonTsz&ParsingTests.test_invalidHeaderNoColoncs”g‰G‡fdd„dtjƒ}| tjdd¡ddddddddg}| d  |¡|d ¡}ˆ\}}| | d ¡d ¡| | d ¡d ¡| |j  ¡d¡dS)zÛ C{HTTPChannel} enforces the limit of C{HTTPChannel.maxHeaders} per request so that headers received in an earlier request do not count towards the limit when processing a later request. cseZdZ‡fdd„ZdS)z:ParsingTests.test_headerLimitPerRequest..MyRequestcsˆ |¡| ¡dSr/rŽr<rr-r.r>ds zBParsingTests.test_headerLimitPerRequest..MyRequest.processNrhr-rr-r.r‘csr‘r¨r|sGET / HTTP/1.1r¤rÂsBar: bazrVrr@r™óbazóhHTTP/1.1 200 OK Transfer-Encoding: chunked 0 HTTP/1.1 200 OK Transfer-Encoding: chunked 0 N) rräÚpatchr‘rrsrDr[rsr™)r=r‘r“rkÚfirstÚsecondr-rr.Útest_headerLimitPerRequest\s(ø þz'ParsingTests.test_headerLimitPerRequestcs`g‰G‡fdd„dtjƒ}t ¡}d|_d}|j|||dd}| ˆg¡| |j ¡d¡dS) z¥ Enforces a limit of C{HTTPChannel.totalHeadersSize} on the size of headers received per request starting from initial command line. cseZdZ‡fdd„ZdS)z@ParsingTests.test_headersTooBigInitialCommand..MyRequestcsˆ |¡| ¡dSr/rŽr<rr-r.r>s zHParsingTests.test_headersTooBigInitialCommand..MyRequest.processNrhr-rr-r.r‘Œsr‘rqs"GET /path/longer/than/10 HTTP/1.1 F©r‹r“rkrŒrÐN©rrär‘ÚtotalHeadersSizerrDrsr™©r=r‘rkr‹r-rr.Ú test_headersTooBigInitialCommand…s ü þz-ParsingTests.test_headersTooBigInitialCommandcs`g‰G‡fdd„dtjƒ}t ¡}d|_d}|j|||dd}| ˆg¡| |j ¡d¡dS) z¨ Enforces a limit of C{HTTPChannel.totalHeadersSize} on the size of headers received per request counting first line and total headers. cseZdZ‡fdd„ZdS)z>ParsingTests.test_headersTooBigOtherHeaders..MyRequestcsˆ |¡| ¡dSr/rŽr<rr-r.r>ªs zFParsingTests.test_headersTooBigOtherHeaders..MyRequest.processNrhr-rr-r.r‘©sr‘é(s5GET /less/than/40 HTTP/1.1 Some-Header: less-than-40 Fr´rÐNrµr·r-rr.Útest_headersTooBigOtherHeaders¢s"ÿý þz+ParsingTests.test_headersTooBigOtherHeaderscCsPGdd„dtjƒ}t ¡}d|_||_d}|j||dd}| |j ¡d¡dS) z€ Enforces total size of headers per individual request and counter is reset at the end of each request. c@seZdZdd„ZdS)z@ParsingTests.test_headersTooBigPerRequest..SimpleRequestcSs | ¡dSr/)rdr<r-r-r.r>ÇszHParsingTests.test_headersTooBigPerRequest..SimpleRequest.processNrhr-r-r-r.Ú SimpleRequestÆsr»r²sZGET / HTTP/1.1 Some-Header: total-less-than-60 GET / HTTP/1.1 Some-Header: less-than-60 F)r‹rkrŒr¯N) rrär‘r¶r“rrDrsr™)r=r»rkr‹r-r-r.Útest_headersTooBigPerRequestÁsÿ ÿþz)ParsingTests.test_headersTooBigPerRequestcsHd}i‰|‰G‡‡fdd„dtjƒ}| ||¡| ˆddddœ¡dS) z3 Test cookies parsing and reading. sKGET / HTTP/1.0 Cookie: rabbit="eat carrot"; ninja=secret; spam="hey 1=1!" cseZdZ‡‡fdd„ZdS)z+ParsingTests.testCookies..MyRequestcs*dD]}| |¡ˆ|<qdˆ_| ¡dS)N©srabbitsninjasspamT)Z getCookier‰rd)r=Úname©ÚcookiesÚtestcaser-r.r>ósz3ParsingTests.testCookies..MyRequest.processNrhr-r¿r-r.r‘òsr‘s "eat carrot"ssecrets "hey 1=1!"r½N©rrärrD©r=r‹r‘r-r¿r.Ú testCookiesçs ýÿzParsingTests.testCookiescsbd}g‰g‰|‰G‡‡‡fdd„dtjƒ}| ||¡| ˆdg¡| ˆdgdgddgg¡dS) NsJGET /?key=value&multiple=two+words&multiple=more%20words&empty= HTTP/1.0 cseZdZ‡‡‡fdd„ZdS)z'ParsingTests.testGET..MyRequestcs@ˆ |j¡ˆ |jd|jd|jdg¡dˆ_| ¡dS©NskeysemptysmultipleT)rír`r©r0r‰rdr<©r0r`rÁr-r.r> s ýz/ParsingTests.testGET..MyRequest.processNrhr-rÆr-r.r‘ sr‘roóvaluerÂó two wordsó more wordsrÂrÃr-rÆr.ÚtestGETs ÿzParsingTests.testGETcspd}g‰g‰g‰|‰G‡‡‡‡fdd„dtjƒ}| ||¡| ˆdg¡| ˆdg¡| ˆdgdgg¡dS) zÝ While only a single '?' is allowed in an URL, several other servers allow several and pass all after the first through as part of the query arguments. Test that we emulate this behavior. s"GET /foo?bar=?&baz=quux HTTP/1.0 cseZdZ‡‡‡‡fdd„ZdS)z6ParsingTests.test_extraQuestionMark..MyRequestcsDˆ |j¡ˆ |j¡ˆ |jd|jdg¡dˆ_| ¡dS)Nr™r®T)rír`Úpathr©r0r‰rdr<©r0r`rËrÁr-r.r>'s   z>ParsingTests.test_extraQuestionMark..MyRequest.processNrhr-rÌr-r.r‘&sr‘ros/fooó?r¥NrÂrÃr-rÌr.Útest_extraQuestionMarks z#ParsingTests.test_extraQuestionMarkcsŽd}tdt|ƒ|fƒ}g‰g‰g‰|‰G‡‡‡‡fdd„dtjƒ}| ||¡| ˆdg¡| ˆdgdgdd gg¡| ˆt|ƒg¡d S) a] The request body of a I{POST} request with a I{Content-Type} header of I{application/x-www-form-urlencoded} is parsed according to that content type and made available in the C{args} attribute of the request object. The original bytes of the request may still be read from the C{content} attribute. z9key=value&multiple=two+words&multiple=more%20words&empty=zVPOST / HTTP/1.0 Content-Length: %d Content-Type: application/x-www-form-urlencoded %scseZdZ‡‡‡‡fdd„ZdS)z4ParsingTests.test_formPOSTRequest..MyRequestcsPˆ |j¡ˆ |jd|jd|jdg¡ˆ |j ¡¡dˆ_| ¡dSrÅ)rír`r©r0rXrZr‰rdr<©r0rXr`rÁr-r.r>Is þz.MyRequest.processNrhr-rÏr-r.r‘Hsr‘sPOSTrÇrÂrÈrÉN)r rbrrärrD)r=Úqueryr‹r‘r-rÏr.Útest_formPOSTRequest4s  û ÿz!ParsingTests.test_formPOSTRequestcCs,d}|j|tjdd}| |j ¡d¡dS)zr If the C{Content-Disposition} header is missing, the request is denied as a bad request. sºPOST / HTTP/1.0 Content-Type: multipart/form-data; boundary=AaB03x Content-Length: 103 --AaB03x Content-Type: text/plain Content-Transfer-Encoding: quoted-printable abasdfg --AaB03x-- Fr’rÐN©rrrärDrsr™©r=rérkr-r-r.Útest_missingContentDisposition[s  þz+ParsingTests.test_missingContentDispositionz.MyRequestcs ˆ |¡| d¡| ¡dS©Nsdone©rírcrdr<rr-r.r>–s  zRParsingTests.test_multipartEmptyHeaderProcessingFailure..MyRequest.processNrhr-rr-r.r‘•sr‘srPOST / HTTP/1.0 Content-Type: multipart/form-data; boundary=AaBb1313 Content-Length: 14 --AaBb1313 --AaBb1313-- Fr’óHTTP/1.0 200 OK donerN)rrärrDrsr™r0©r=r‘rérkr-rr.Ú*test_multipartEmptyHeaderProcessingFailures  z7ParsingTests.test_multipartEmptyHeaderProcessingFailurecslg‰G‡fdd„dtjƒ}d}|j||dd}| |j ¡d¡| tˆƒd¡| ˆdjd d gi¡d S) z¶ If the request has a Content-Type of C{multipart/form-data}, and the form data is parseable, the form arguments will be added to the request's args. cseZdZ‡fdd„ZdS)z6ParsingTests.test_multipartFormData..MyRequestcs ˆ |¡| d¡| ¡dSrÖr×r<rr-r.r>²s  z>ParsingTests.test_multipartFormData..MyRequest.processNrhr-rr-r.r‘±sr‘sæPOST / HTTP/1.0 Content-Type: multipart/form-data; boundary=AaB03x Content-Length: 149 --AaB03x Content-Type: text/plain Content-Disposition: form-data; name="text" Content-Transfer-Encoding: quoted-printable abasdfg --AaB03x-- Fr’rØr|rstextóabasdfgN)rrärrDrsr™rbr0rÙr-rr.Útest_multipartFormDataªs  ÿz#ParsingTests.test_multipartFormDatacs’g‰G‡fdd„dtjƒ}d}dtt| dd¡ƒƒd}|j| d¡||d d }| |j  ¡d ¡| tˆƒd ¡| ˆd j ddgi¡dS)zÈ If the request has a Content-Type of C{multipart/form-data}, and the form data is parseable and contains files, the file portions will be added to the request's args. cseZdZ‡fdd„ZdS)z6ParsingTests.test_multipartFileData..MyRequestcs ˆ |¡| d¡| ¡dSrÖr×r<rr-r.r>Òs  z>ParsingTests.test_multipartFileData..MyRequest.processNrhr-rr-r.r‘Ñsr‘sé-----------------------------738837029596785559389649595 Content-Disposition: form-data; name="uploadedfile"; filename="test" Content-Type: application/octet-stream abasdfg -----------------------------738837029596785559389649595-- zƒPOST / HTTP/1.0 Content-Type: multipart/form-data; boundary=---------------------------738837029596785559389649595 Content-Length: rVraz ÚasciiFr’rØr|rs uploadedfilerÛN) rrär\rbrŠrr]rDrsr™r0)r=r‘rKrérkr-rr.Útest_multipartFileDataÊs ýýÿ ÿz#ParsingTests.test_multipartFileDatacsd}g‰g‰g‰g‰|‰G‡‡‡‡‡fdd„dtjƒ}| ||¡| ˆdt¡| ˆdd¡| ˆdg¡| ˆdg¡| ˆd g¡d S) z¡ If a request uses the I{chunked} transfer encoding, the request body is decoded accordingly before it is made available on the request. shGET / HTTP/1.0 Content-Type: text/plain Transfer-Encoding: chunked 6 Hello, 14 spam,eggs spam spam 0 cs eZdZ‡‡‡‡‡fdd„ZdS)z4ParsingTests.test_chunkedEncoding..MyRequestcsXˆ |j ¡¡ˆ |j ¡¡ˆ |j¡ˆ |j¡ˆ |jj¡dˆ_|  ¡dSrm) rírXÚfilenorZr`rËrkZ_transferDecoderr‰rdr<©rXr:r`rËrÁr-r.r>s  z.MyRequest.processNrhr-ràr-r.r‘sr‘rr|sHello, spam,eggs spam spamroó/N)rrärÚassertIsInstanceÚintrDrÃr-ràr.Útest_chunkedEncodingîs  z!ParsingTests.test_chunkedEncodingcs^d}g‰G‡fdd„dtjƒ}|j||dd}| ˆd¡| |j ¡d¡| |jj¡dS) z If a request uses the I{chunked} transfer encoding, but provides an invalid chunk length value, the request fails with a 400 error. sˆGET / HTTP/1.1 Content-Type: text/plain Transfer-Encoding: chunked MALFORMED_LINE_THIS_SHOULD_BE_'6' Hello, 14 spam,eggs spam spam 0 cseZdZ‡fdd„ZdS)z=ParsingTests.test_malformedChunkedEncoding..MyRequestcsˆ d¡dSrm©rír<rˆr-r.r>2szEParsingTests.test_malformedChunkedEncoding..MyRequest.processNrhr-rˆr-r.r‘0sr‘Fr’úRequest.process calledrÐN) rrärr¦rDrsr™r­r§)r=r‹r‘rkr-rˆr.Útest_malformedChunkedEncodings  þz*ParsingTests.test_malformedChunkedEncodingc sÄt |t¡}g‰G‡fdd„dtjƒ}d}d}t d ||f¡¡ ¡}d|d}|  tdd d „¡|  ||d ¡ˆ  ¡}|  d |j ¡| d t|ƒ¡|d }|d}| |jt¡| t¡dS)z• A L{Request} that throws an exception processing basic authorization logs an error and uses an empty username and password. cseZdZ‡fdd„ZdS)z5ParsingTests.test_basicAuthException..Requestcs | ¡| ¡f|_ˆ |¡dSr/r–r<r˜r-r.r>Isz=ParsingTests.test_basicAuthException..Request.processNrhr-r˜r-r.räHsrär@r™ršr›rœZ decodestringcSsgSr/r-)rÛr-r-r.riQrÂz6ParsingTests.test_basicAuthException..r)Úrèr|Ú log_failureN)r!r¶r'rrärržrsrŸr°rr€rDr—r¸rbrâr™ÚAttributeErrorÚflushLoggedErrors) r=rºrär rUr_r¡rér»r-r˜r.Útest_basicAuthException>s&þ z$ParsingTests.test_basicAuthExceptioncsXG‡fdd„dtjƒ‰|j|ˆdd}| ˆjd¡| |j ¡d¡| |jj ¡dS)zÉ Assert that the given request bytes fail with a 400 bad request without calling L{Request.process}. @param request: A raw HTTP request @type request: L{bytes} cseZdZdZ‡fdd„ZdS)zAParsingTests.assertDisconnectingBadRequest..FailedRequestFcs dˆ_dSrmrr<©Ú FailedRequestr-r.r>fszIParsingTests.assertDisconnectingBadRequest..FailedRequest.processN©r)r*r+rr>r-rír-r.rîdsrîFr’rærÐN) rrärr¦rrDrsr™r­r§)r=rgrkr-rír.ÚassertDisconnectingBadRequest\sþz*ParsingTests.assertDisconnectingBadRequestcCs| ddddddg¡dS)z“ A request which includes multiple C{content-length} headers fails with a 400 response without calling L{Request.process}. óGET /a HTTP/1.1óContent-Length: 56óContent-Length: 0óHost: host.invalidrÂNr«r<r-r-r.Útest_duplicateContentLengthsqsúz)ParsingTests.test_duplicateContentLengthsc Cs"| ddddddddddg ¡dS)z´ Two pipelined requests, the first of which includes multiple C{content-length} headers, trigger a 400 response without calling L{Request.process}. rñròrórôrÂNr«r<r-r-r.Ú1test_duplicateContentLengthsWithPipelinedRequests€söz>ParsingTests.test_duplicateContentLengthsWithPipelinedRequestscCs| ddddddg¡dS)z¯ A request that includes both C{content-length} and C{transfer-encoding} headers fails with a 400 response without calling L{Request.process}. rñr„rórôrÂNr«r<r-r-r.Ú%test_contentLengthAndTransferEncoding”súz2ParsingTests.test_contentLengthAndTransferEncodingc Cs"| ddddddddddg ¡dS)zÊ Two pipelined requests, the first of which includes both C{content-length} and C{transfer-encoding} headers, triggers a 400 response without calling L{Request.process}. rñr„rórôrÂNr«r<r-r-r.Ú:test_contentLengthAndTransferEncodingWithPipelinedRequests¤sözGParsingTests.test_contentLengthAndTransferEncodingWithPipelinedRequestscCs| dddddg¡dS)zÁ A request whose C{transfer-encoding} header includes a value other than C{chunked} or C{identity} fails with a 400 response without calling L{Request.process}. rñsTransfer-Encoding: unknownrôrÂNr«r<r-r-r.Útest_unknownTransferEncoding¸sûz)ParsingTests.test_unknownTransferEncodingcsPg‰G‡fdd„dtjƒ}d}| ||d¡}| ˆdg¡| |j ¡d¡dS)z‚ A request with a valid C{content-length} and a C{transfer-encoding} whose value is C{identity} succeeds. cseZdZdZ‡fdd„ZdS)zEParsingTests.test_transferEncodingIdentity..SuccessfulRequestFcs(ˆ |j ¡¡| dd¡| ¡dS)NrUó0)rírXrZr^rdr<©rKr-r.r>Ðs zMParsingTests.test_transferEncodingIdentity..SuccessfulRequest.processNrïr-rûr-r.ÚSuccessfulRequestÎsrüsTGET / HTTP/1.1 Host: host.invalid Content-Length: 2 Transfer-Encoding: identity ok Fsoks&HTTP/1.1 200 OK Content-Length: 0 N)rrärrDrsr™)r=rürgrkr-rûr.Útest_transferEncodingIdentityÇsþz*ParsingTests.test_transferEncodingIdentity)NTN)&r)r*r+r,r,rr”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ðrõrör÷rørùrýr-r-r-r.r‡¬sLÿ -  )&'ÿ $."r‡c@s$eZdZdd„Zdd„Zdd„ZdS)ÚQueryArgumentsTestscCsh| t d¡t d¡¡|jttjddd| tjdddtjddd¡| t d¡t d¡¡dS)Ns a=b&d=c;+=fsblahT)Zstrict_parsingsa=&b=cr|)Zkeep_blank_values)rDÚcgiZparse_qsrrürýr<r-r-r.Ú testParseqsçs$þÿ  þþzQueryArgumentsTests.testParseqscsdd„}‡fdd„}tƒ|ƒD]}||dƒ||dƒq tƒ|ƒD]}||dƒ||dƒqF|ƒD]$}tƒ||dƒtƒ||dƒqfdS)z— For a given URL, L{http.urlparse} should behave the same as L{urlparse}, except it should always return C{bytes}, never text. c ss\dD]R}dD]H}dD]>}dD]4}|dk r|dtt|ƒƒ}t|||ddfƒVqqq qdS)N)shttpshttps)ó example.com)Nr )rÂspathršrÂ)r r\r)ÚschemeZhostZportrËr-r-r.Úurlsúsz/QueryArgumentsTests.test_urlparse..urlsc sþ|}|r| d¡}t|ƒ}t|jtƒrh|j d¡|j d¡|j d¡|j d¡|j  d¡|j  d¡f}n|j|j|j|j|j |j f}t  |¡\}}}}} } ˆ  ||||| | f|¡ˆ  |t¡ˆ  |t¡ˆ  |t¡ˆ  |t¡ˆ  | t¡ˆ  | t¡dS)z‚ Verify that C{url} is parsed into the same objects by both L{http.urlparse} and L{urlparse}. rÝzutf-8N)ÚdecoderÚ isinstancerrr]ÚnetlocrËÚparamsrÐÚfragmentrrDrârB) ÚurlrZurlToStandardImplementationZstandardResultr‚rrrËrrÐrr<r-r.ÚassertSameParsing s<        ûûÿ     z.assertSameParsingTFN)r)r=rr r r-r<r.Ú test_urlparseõs )        z!QueryArgumentsTests.test_urlparsecCs| ttjd¡dS)zE L{http.urlparse} should reject unicode input early. zhttp://example.org/pathN)rüÚ TypeErrorrrr<r-r-r.Útest_urlparseRejectsUnicode@ sz/QueryArgumentsTests.test_urlparseRejectsUnicodeN)r)r*r+rr r r-r-r-r.rþæsKrþc@seZdZdd„ZdS)Ú ClientDrivercCs||_||_||_dSr/)rr‡rrr-r-r.rI szClientDriver.handleStatusN)r)r*r+rr-r-r-r.rH src@s$eZdZdd„Zdd„Zdd„ZdS)ÚClientStatusParsingTestscCs>tƒ}| d¡| |jd¡| |jd¡| |jd¡dS)NsHTTP/1.0 201 fooró201r@©rÚ lineReceivedrDrr‡r©r=r|r-r-r.Ú testBaselineO s  z%ClientStatusParsingTests.testBaselinecCs>tƒ}| d¡| |jd¡| |jd¡| |jd¡dS)Nó HTTP/1.0 201rrrÂrrr-r-r.Ú testNoMessageV s  z&ClientStatusParsingTests.testNoMessagecCs>tƒ}| d¡| |jd¡| |jd¡| |jd¡dS)Ns HTTP/1.0 201 rrrÂrrr-r-r.ÚtestNoMessage_trailingSpace] s  z4ClientStatusParsingTests.testNoMessage_trailingSpaceN)r)r*r+rrrr-r-r-r.rN src@sXeZdZdZdd„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%dFdG„Z&dHdI„Z'dJdK„Z(dLdM„Z)dNdO„Z*dPdQ„Z+dRdS„Z,dTdU„Z-dVdW„Z.dXdY„Z/dZd[„Z0d\d]„Z1d^d_„Z2d`da„Z3dbdc„Z4ddde„Z5dfdg„Z6dhdi„Z7djdk„Z8dldm„Z9dndo„Z:dpdq„Z;drds„Zdxdy„Z?dzd{„Z@d|d}„ZAd~d„ZBd€d„ZCd‚dƒ„ZDd„d…„ZEd†d‡„ZFdˆd‰„ZGdŠd‹„ZHdŒd„ZIdŽd„ZJdd‘„ZKd’d“„ZLd”S)•Ú RequestTestsz# Tests for L{http.Request} cCst tƒd¡}t||ƒ ddg¡| t||ƒdd¡t||ddiƒ| tt||ƒ ¡ƒddgfg¡t||t   ¡ƒ| t||ƒi¡dS)a0 Verify that each of two different attributes which are associated with the same state properly reflect changes made through the other. This is used to test that the C{headers}/C{responseHeaders} and C{received_headers}/C{requestHeaders} pairs interact properly. Fr~rr@r™rN) rrär#Úgetattrr(rDÚsetattrr/r1rZHeaders)r=ZoldNameZnewNamerér-r-r.Ú_compatHeadersTestj s þzRequestTests._compatHeadersTestcCs4t tƒd¡}|j ddg¡| | d¡d¡dS)zb L{http.Request.getHeader} returns the value of the named request header. Fr~rN©rrär#r'r(rDr[©r=rér-r-r.Útest_getHeader} szRequestTests.test_getHeadercCs6t tƒd¡}|j dddg¡| | d¡d¡dS)z‡ When there are multiple values for a single request header, L{http.Request.getHeader} returns the last value. Fr~rópandaNrrr-r-r.Útest_getHeaderReceivedMultiples‡ sz,RequestTests.test_getHeaderReceivedMultiplescCs$t tƒd¡}| | d¡d¡dS)z† L{http.Request.getHeader} returns L{None} when asked for the value of a request header which is not present. Fr~N)rrär#rDr[rr-r-r.Útest_getHeaderNotFound‘ sz#RequestTests.test_getHeaderNotFoundcCs6t tƒd¡}|j ddg¡| | ¡ddi¡dS)z‰ L{http.Request.getAllheaders} returns a C{dict} mapping all request header names to their corresponding values. Fr~rN©rrär#r'r(rDÚ getAllHeadersrr-r-r.Útest_getAllHeadersš szRequestTests.test_getAllHeaderscCs"t tƒd¡}| | ¡i¡dS)zq L{http.Request.getAllHeaders} returns an empty C{dict} if there are no request headers. FN)rrär#rDr#rr-r-r.Útest_getAllHeadersNoHeaders¤ sz(RequestTests.test_getAllHeadersNoHeaderscCs8t tƒd¡}|j dddg¡| | ¡ddi¡dS)z When there are multiple values for a single request header, L{http.Request.getAllHeaders} returns only the last value. Fr~rrNr"rr-r-r.Ú!test_getAllHeadersMultipleHeaders­ sz.RequestTests.test_getAllHeadersMultipleHeaderscCsFtƒ}t |d¡}| d¡| d¡| |jj ¡  ¡dd¡dS)z~ L{http.Request.setResponseCode} takes a status code and causes it to be used as the response status. FéÉrÂrs (no clientproto yet) 201 CreatedN© r#rrär:rcrDrsÚwrittenÚgetvaluer©r=rkrér-r-r.Útest_setResponseCode· s   þz!RequestTests.test_setResponseCodecCsHtƒ}t |d¡}| dd¡| d¡| |jj ¡  ¡dd¡dS)zŽ L{http.Request.setResponseCode} takes a status code and a message and causes them to be used as the response status. FéÊshappily acceptedrÂrs)(no clientproto yet) 202 happily acceptedNr(r+r-r-r.Útest_setResponseCodeAndMessageÅ s   þz+RequestTests.test_setResponseCodeAndMessagecCs(tƒ}t |d¡}| t|jdd¡dS)z• L{http.Request.setResponseCode} accepts C{bytes} for the message parameter and raises L{TypeError} if passed anything else. Fr-znot happily acceptedN)r#rrärür r:r+r-r-r.Ú&test_setResponseCodeAndMessageNotBytesÓ s   ÿz3RequestTests.test_setResponseCodeAndMessageNotBytescCs,t tƒd¡}| d¡| t|jd¡dS)z L{http.Request.setResponseCode} accepts C{int} for the code parameter and raises L{TypeError} if passed anything else. Fr|Ú1N)rrär#r:rür rr-r-r.Ú#test_setResponseCodeAcceptsIntegersÞ s z0RequestTests.test_setResponseCodeAcceptsIntegerscCs t tƒd¡}| tdƒ¡dS)za L{http.Request.setResponseCode} accepts C{long} for the code parameter. Fr|N)rrär#r:r rr-r-r.Ú'test_setResponseCodeAcceptsLongIntegersè sz4RequestTests.test_setResponseCodeAcceptsLongIntegerscCs*t tƒd¡}| d¡| |jd¡dS)zì When no previous value was set and no 'if-modified-since' value was requested, L{http.Request.setLastModified} takes a timestamp in seconds since the epoch and sets the request's lastModified attribute. Fé*N©rrär#ÚsetLastModifiedrDÚ lastModifiedrr-r-r.Útest_setLastModifiedNeverSetñ s z)RequestTests.test_setLastModifiedNeverSetcCs4t tƒd¡}| d¡| d¡| |jd¡dS)z° If the supplied timestamp is later than the lastModified attribute's value, L{http.Request.setLastModified} updates the lastModifed attribute. Frr|Nr4rr-r-r.Útest_setLastModifiedUpdateþ s  z'RequestTests.test_setLastModifiedUpdatecCs4t tƒd¡}| d¡| d¡| |jd¡dS)z— If the supplied timestamp occurs earlier than the current lastModified attribute, L{http.Request.setLastModified} ignores it. Fr|rNr4rr-r-r.Útest_setLastModifiedIgnore s  z'RequestTests.test_setLastModifiedIgnorecCs>t tƒd¡}|j tdƒdg¡| d¡}| |tj¡dS)z¡ If the resource is older than the if-modified-since date in the request header, L{http.Request.setLastModified} returns L{http.CACHED}. Fúif-modified-sinces02 Jan 1970 00:00:00 GMTr3N© rrär#r'r(r r5rDZCACHED©r=rérzr-r-r.Útest_setLastModifiedCached sþ z'RequestTests.test_setLastModifiedCachedcCs<t tƒd¡}|j tdƒdg¡| d¡}| |d¡dS)z– If the resource is newer than the if-modified-since date in the request header, L{http.Request.setLastModified} returns None Fr:s01 Jan 1970 00:00:00 GMTé@BN©rrär#r'r(r r5rDr<r-r-r.Útest_setLastModifiedNotCached) sþ z*RequestTests.test_setLastModifiedNotCachedcCsFt tƒd¡}|j tdƒdg¡| d¡| d¡}| |d¡dS)zï When L{http.Request.setLastModified} is called multiple times, the highest supplied value is honored. If that value is higher than the if-modified-since date in the request header, the method returns None. Fr:s01 Jan 1970 00:00:01 GMTr>rNr?r<r-r-r.Ú"test_setLastModifiedTwiceNotCached9 sþ  z/RequestTests.test_setLastModifiedTwiceNotCachedcCsHt tƒd¡}|j tdƒdg¡| d¡| d¡}| |tj¡dS)a When L{http.Request.setLastModified} is called multiple times, the highest supplied value is honored. If that value is lower than the if-modified-since date in the request header, the method returns L{http.CACHED}. Fr:s01 Jan 1999 00:00:01 GMTr|rNr;r<r-r-r.Útest_setLastModifiedTwiceCachedK sþ  z,RequestTests.test_setLastModifiedTwiceCachedcCs4t tƒd¡}| dd¡| |j d¡dg¡dS)ú” L{http.Request.setHost} sets the value of the host request header. The port should not be added because it is the default. FréPóhostN©rrär#ÚsetHostrDr'r¦rr-r-r.Ú test_setHost^ s   ÿzRequestTests.test_setHostcCsBtƒ}t ¡|_t |d¡}| dd¡| |j d¡dg¡dS)rCFri»rEN© r#rærsrrärGrDr'r¦©r=r#rér-r-r.Útest_setHostSSLi s    ÿzRequestTests.test_setHostSSLcCs4t tƒd¡}| dd¡| |j d¡dg¡dS©z” L{http.Request.setHost} sets the value of the host request header. The port should be added because it is not the default. FréQrEsexample.com:81NrFrr-r-r.Útest_setHostNonDefaultPortv s   ÿz'RequestTests.test_setHostNonDefaultPortcCsBtƒ}t ¡|_t |d¡}| dd¡| |j d¡dg¡dSrLrIrJr-r-r.Útest_setHostSSLNonDefaultPort s    ÿz*RequestTests.test_setHostSSLNonDefaultPortcCs4t tƒd¡}| dd¡| |j d¡dg¡dS)zX L{http.Request.setHeader} sets the value of the given response header. Fr~rN)rrär#r^rDr0r¦rr-r-r.Útest_setHeaderŽ s zRequestTests.test_setHeadercOs‚tƒ}t |d¡}|j||Ž| |jd|¡| d¡|jj  ¡  d¡}dd„|Dƒ}| t |ƒd¡| |dd|¡d S) z› Call L{http.Request.setCookie} with C{*args} and C{**kwargs}, and check that the cookie value is equal to C{expectedCookieValue}. FrrÂracSsg|]}| d¡r|‘qS)s Set-Cookie)Ú startswith)rxrÛr-r-r.ry¦ s ÿz-RequestTests._checkCookie..r|s Set-Cookie: N) r#rräZ addCookierDrÀrcrsr)r*r~rb)r=ÚexpectedCookieValuer0r1rkréZ writtenLinesZsetCookieLinesr-r-r.Ú _checkCookie— s    ÿzRequestTests._checkCookiecCsd}| |dd¡dS)zÈ L{http.Request.setCookie} adds a new cookie to be sent with the response, and can be called with just a key and a value. L{unicode} arguments are encoded using UTF-8. ófoo=barÚfooÚbarN©rS©r=rRr-r-r.Ú)test_addCookieWithMinimumArgumentsUnicode­ sz6RequestTests.test_addCookieWithMinimumArgumentsUnicodec Cs&d}|j|dddddddd d d d S) z‘ L{http.Request.setCookie} adds a new cookie to be sent with the response. L{unicode} arguments are encoded using UTF-8. ó}foo=bar; Expires=Fri, 31 Dec 9999 23:59:59 GMT; Domain=.example.com; Path=/; Max-Age=31536000; Comment=test; Secure; HttpOnlyrUrVzFri, 31 Dec 9999 23:59:59 GMTz .example.comú/Z31536000ZtestT©ZexpiresZdomainrËZmax_ageZcommentZsecureZhttpOnlyNrWrXr-r-r.Ú%test_addCookieWithAllArgumentsUnicode¸ sÿýz2RequestTests.test_addCookieWithAllArgumentsUnicodecCsd}| |dd¡dS)z¾ L{http.Request.setCookie} adds a new cookie to be sent with the response, and can be called with just a key and a value. L{bytes} arguments are not decoded. rTr@r™NrWrXr-r-r.Ú'test_addCookieWithMinimumArgumentsBytesÈ sz4RequestTests.test_addCookieWithMinimumArgumentsBytesc Cs&d}|j|dddddddd d d d S) z‡ L{http.Request.setCookie} adds a new cookie to be sent with the response. L{bytes} arguments are not decoded. rZr@r™sFri, 31 Dec 9999 23:59:59 GMTs .example.comrás31536000r~Tr\NrWrXr-r-r.Ú#test_addCookieWithAllArgumentsBytesÓ sÿýz0RequestTests.test_addCookieWithAllArgumentsBytescCs\d}| |dd¡| |jg¡}| dt|ƒ¡| |ddt¡| |ddd¡d S) z× L{http.Request.setCookie} will raise a L{DeprecationWarning} if non-string (not L{bytes} or L{unicode}) arguments are given, and will call C{str()} on it to preserve past behaviour. sfoo=10r@rqr|rÚcategoryrzSPassing non-bytes or non-unicode cookie arguments is deprecated since Twisted 16.1.N)rSÚ flushWarningsrDrbÚDeprecationWarning)r=rRÚwarningsr-r-r.Útest_addCookieNonStringArgumentã s þz,RequestTests.test_addCookieNonStringArgumentcCsR|jddddd|jddddd|jddddd|jt|jd ddd dd S) zL L{http.Request.setCookie} supports a C{sameSite} argument. sfoo=bar; SameSite=laxr@r™Zlax)ZsameSiteZLaxsfoo=bar; SameSite=strictÚstrictrÂz anything-elseN)rSrürýr<r-r-r.Útest_addCookieSameSiteö s4ÿÿÿýz#RequestTests.test_addCookieSameSitecCs^tƒ}t |d¡}tƒ}||_| d¡d|_|j ddg¡|  d¡|  |  ¡dg¡dS) z For an HTTP 1.0 request, L{http.Request.write} sends an HTTP 1.0 Response-Line and whatever response headers are set. Fr8rr~rr€)rŠrƒr€N© r#rrärrsr:rar0r(rcrˆr™©r=rkrér…r-r-r.Útest_firstWrite s   þzRequestTests.test_firstWritecCs¦tƒ}t |d¡}tƒ}||_| d¡d|_|j ddg¡|  d¡|  |  ¡dg¡|j |j gd}| d t|ƒ¡| |d d t¡| |d d d ¡dS)zd L{http.Request.write} casts non-bytes header value to bytes transparently. Fr8rr~rqr€)rŠsTest: 10r€©ZoffendingFunctionsr|rr`rzZPassing non-bytes header values is deprecated since Twisted 12.3. Pass only bytes instead.N)r#rrärrsr:rar0r(rcrˆr™raÚtest_nonByteHeaderValuerDrbrb)r=rkrér…rcr-r-r.rk s*   þÿ þz$RequestTests.test_nonByteHeaderValuecCshtƒ}t |d¡}tƒ}||_| d¡d|_|j ddg¡|  d¡|  d¡|  |  ¡dg¡d S) zÅ For an HTTP 1.1 request, L{http.Request.write} sends an HTTP 1.1 Response-Line, whatever response headers are set, and uses chunked encoding for the response body. Fr8r6r~rr€rr‚Nrgrhr-r-r.Útest_firstWriteHTTP11Chunked> s    þz)RequestTests.test_firstWriteHTTP11ChunkedcCsdtƒ}t |d¡}tƒ}||_| d¡d|_d|_|j  ddg¡|  d¡|  |  ¡dg¡d S) zê For an HTTP 1.0 request for a resource with a known last modified time, L{http.Request.write} sends an HTTP Response-Line, whatever response headers are set, and a last-modified header with that time. Fr8rrr~rr€)rŠrƒó,Last-Modified: Thu, 01 Jan 1970 00:00:00 GMTr€N) r#rrärrsr:rar6r0r(rcrˆr™rhr-r-r.Útest_firstWriteLastModifiedX s   þz(RequestTests.test_firstWriteLastModifiedcCs˜t |t¡}tƒ}t |d¡}tƒ}||_| d¡d|_ d|_ |j   ddg¡|  d¡| | ¡dg¡| d t|ƒ¡|d }| d |d ¡d S)z´ If the last-modified header already exists in the L{http.Request} response headers, the lastModified attribute is ignored and a message is logged. Fr8riÊš;s last-modifiedsThu, 01 Jan 1970 00:00:00 GMTr€)rŠrmr€r|rzPWarning: last-modified specified both in header list and lastModified attribute.r³N)r!r¶r'r#rrärrsr:rar6r0r(rcrˆr™r¸rb)r=rºrkrér…r»r-r-r.Útest_lastModifiedAlreadyWrittens s4þ  þ þýz,RequestTests.test_lastModifiedAlreadyWrittencCs t tƒd¡}| |ji¡dS)zP L{http.Request.received_cookies} defaults to an empty L{dict}. FN)rrär#rDÚreceived_cookiesrr-r-r.Útest_receivedCookiesDefaultš sz(RequestTests.test_receivedCookiesDefaultcCs>t tƒd¡}|j ddg¡| ¡| |jdddœ¡dS)z„ L{http.Request.parseCookies} extracts cookies from C{requestHeaders} and adds them to C{received_cookies}. Fócookiestest="lemur"; test2="panda"ó"lemur"ó"panda"©r~stest2N©rrär#r'r(Ú parseCookiesrDrprr-r-r.Útest_parseCookies¢ sÿÿzRequestTests.test_parseCookiescCs@t tƒd¡}|j dddg¡| ¡| |jdddœ¡dS) zh L{http.Request.parseCookies} can extract cookies from multiple Cookie headers. Frrs test="lemur"s test2="panda"rsrtruNrvrr-r-r.Ú test_parseCookiesMultipleHeaders¯ sÿÿz-RequestTests.test_parseCookiesMultipleHeaderscCs(t tƒd¡}| ¡| |ji¡dS)zj L{http.Request.parseCookies} can be called on a request without a cookie header. FN)rrär#rwrDrprr-r-r.Útest_parseCookiesNoCookie¼ sz&RequestTests.test_parseCookiesNoCookiecCs6t tƒd¡}|j dg¡| ¡| |ji¡dS)zn L{http.Request.parseCookies} can be called on a request with an empty cookie header. FrrNrvrr-r-r.Útest_parseCookiesEmptyCookieÆ sÿz)RequestTests.test_parseCookiesEmptyCookiecCs8t tƒd¡}|j ddg¡| ¡| |ji¡dS)z` L{http.Request.parseCookies} ignores cookies which don't have a value. Frrsfoo; bar; baz;Nrvrr-r-r.Ú test_parseCookiesIgnoreValuelessÒ sÿÿz-RequestTests.test_parseCookiesIgnoreValuelesscCs<t tƒd¡}|j ddg¡| ¡| |jddi¡dS)zR L{http.Request.parseCookies} parses cookies with an empty value. Frrsfoo=r@rÂNrvrr-r-r.Útest_parseCookiesEmptyValueß sÿÿz(RequestTests.test_parseCookiesEmptyValuecCs<t tƒd¡}|j ddg¡| ¡| |jddi¡dS)zf L{http.Request.parseCookies} leaves trailing whitespace in the cookie value. Frrsfoo=bar r@sbar Nrvrr-r-r.Ú!test_parseCookiesRetainRightSpaceë sÿÿz.RequestTests.test_parseCookiesRetainRightSpacecCs<t tƒd¡}|j ddg¡| ¡| |jddi¡dS)zc L{http.Request.parseCookies} strips leading whitespace in the cookie key. Frrs foo=barr@r™Nrvrr-r-r.Útest_parseCookiesStripLeftSpaceø sÿÿz,RequestTests.test_parseCookiesStripLeftSpacecCs>t tƒd¡}|j ddg¡| ¡| |jdddœ¡dS)zr L{http.Request.parseCookies} parses valid cookies set before or after malformed cookies. Frrs012345; test="lemur"; 12345; test2="panda"; 12345rsrtruNrvrr-r-r.Ú-test_parseCookiesContinueAfterMalformedCookie sÿÿz:RequestTests.test_parseCookiesContinueAfterMalformedCookiecCsXt tƒd¡}| d¡|j}| d¡| ttdƒƒ¡|  |j ¡|  |j d¡dS)z£ L{http.Request.connectionLost} closes L{Request.content} and drops the reference to the L{HTTPChannel} to assist with garbage collection. FrqrgZFinishedN) rrär#Ú gotLengthrXZhandleContentChunkr—rrr­ÚclosedrGrk)r=rérXr-r-r.Útest_connectionLost s   z RequestTests.test_connectionLostcCs4t tƒd¡}| tƒd¡| t|jtƒd¡dS)zv Calling L{Request.registerProducer} when a producer is already registered raises ValueError. FTN)rrär#r;r"rürýrr-r-r.Útest_registerProducerTwiceFails( sÿz,RequestTests.test_registerProducerTwiceFailscCs:t tƒd¡}tƒ}| |d¡| |dfg|jj¡dS)zÀ Calling L{Request.registerProducer} with an IPushProducer when the request is not queued registers the producer as a push producer on the request's transport. FTN©rrär#r"r;rDrsZ producers©r=rér r-r-r.Ú7test_registerProducerWhenNotQueuedRegistersPushProducer3 s zDRequestTests.test_registerProducerWhenNotQueuedRegistersPushProducercCs:t tƒd¡}tƒ}| |d¡| |dfg|jj¡dS)zÀ Calling L{Request.registerProducer} with an IPullProducer when the request is not queued registers the producer as a pull producer on the request's transport. FNr…r†r-r-r.Ú7test_registerProducerWhenNotQueuedRegistersPullProducer? s zDRequestTests.test_registerProducerWhenNotQueuedRegistersPullProducercCsFtƒ}t |d¡}| ¡}| ttdƒƒ¡| |jd¡|  |t¡S)z L{Request.connectionLost} triggers all finish notification Deferreds and cleans up per-request state. TzConnection doneN) r#rräÚ notifyFinishr—rrrGrkZ assertFailure)r=r#rgrLr-r-r.Útest_connectionLostNotificationK s  z,RequestTests.test_connectionLostNotificationcCs,t tƒd¡}| ¡}| d¡| ¡|S)zO L{Request.finish} triggers all finish notification Deferreds. Fr|)rrär#r‰rrd©r=rgrLr-r-r.Útest_finishNotificationX s  z$RequestTests.test_finishNotificationcCsFt tƒd¡}| ¡}| d¡| d¡| ¡| t|jd¡|S)z… Calling L{Request.write} after L{Request.finish} has been called results in a L{RuntimeError} being raised. Fr|sfoobar) rrär#r‰rrcrdrür%r‹r-r-r.Útest_writeAfterFinishe s  z"RequestTests.test_writeAfterFinishcCs6tƒ}t |d¡}| ttdƒƒ¡| t|j¡dS)zŽ Calling L{Request.finish} after L{Request.connectionLost} has been called results in a L{RuntimeError} being raised. FzThe end.N) r#rrär—rrrür%rdr+r-r-r.Útest_finishAfterConnectionLostu s z+RequestTests.test_finishAfterConnectionLostcCs,t tƒd¡}| t|ƒdt|ƒf¡dS)z¹ L{Request.__repr__} returns the class name, object address, and dummy-place holder values when used on a L{Request} which has not yet been initialized. FzZN©rrär#rDÚreprÚid©r=rgr-r-r.Útest_reprUninitialized€ sÿþz#RequestTests.test_reprUninitializedcCs>t tƒd¡}d|_d|_d|_| t|ƒdt|ƒf¡dS)a L{Request.__repr__} returns, as a L{str}, the class name, object address, and the method, uri, and client protocol of the HTTP request it represents. The string is in the form:: Frrorpz>N) rrär#rar`r_rDrr‘r’r-r-r.Útest_reprInitialized sÿþz!RequestTests.test_reprInitializedcCs<Gdd„dtjƒ}|tƒdƒ}| t|ƒdt|ƒf¡dS)zŸ Subclasses of L{Request} inherit a C{__repr__} implementation which includes the subclass's name in place of the string C{"Request"}. c@s eZdZdS)z1RequestTests.test_reprSubclass..OtherwiseN)r)r*r+r-r-r-r.Ú Otherwise¤ sr•Fz\Nr)r=r•rgr-r-r.Útest_reprSubclassŸ s ÿþzRequestTests.test_reprSubclasscCsFt tƒd¡}tƒ|_| tƒd¡| ¡| d|j |jj f¡dS)z• L{Request.unregisterProducer} unregisters a non-queued non-streaming producer from the request and the request's transport. F©NNN© rrär#rrsr;r"ÚunregisterProducerrDr rr-r-r.Ú,test_unregisterNonQueuedNonStreamingProducer® s z9RequestTests.test_unregisterNonQueuedNonStreamingProducercCsFt tƒd¡}tƒ|_| tƒd¡| ¡| d|j |jj f¡dS)z‘ L{Request.unregisterProducer} unregisters a non-queued streaming producer from the request and the request's transport. FTr—Nr˜rr-r-r.Ú)test_unregisterNonQueuedStreamingProducerº s z6RequestTests.test_unregisterNonQueuedStreamingProducercCs†t ¡}d|_d|_d|_| ¡tƒ|_| d¡}ddg}t ƒ}|  |¡|D]}|  |¡qP|j j d ¡| d|j ¡¡dS)zj L{http.Request.finish} will call the channel's factory to produce a log message. NÚsometimeTóGET /path HTTP/1.1 r}rssometime "GET /path HTTP/1.1")rr«r¤Ú _logDateTimeÚ_logDateTimeCallÚ startFactoryrÚlogFiler¬rr”r–rvr•rdr¹r*©r=r¯ÚprotoÚvalr…rÛr-r-r.Útest_finishProducesLogÆ s$ þ  ÿz#RequestTests.test_finishProducesLogcCsˆtƒ}tjd|d}| ¡| d¡}tƒ}t||ƒ}| |jd¡|  |¡|  d¡|  d¡|  |j ¡|  d¡| |j ¡dS)z¢ L{HTTPChannel} timeouts whenever data from a request body is not delivered to it in time, even when it gets built from a L{HTTPFactory}. r )ZtimeoutrxNr¡r¢rµ)rrr«r r¬rryrDr¤r”r–r¥r¦r§r­rr-r-r.Ú"test_requestBodyTimeoutFromFactoryå s       z/RequestTests.test_requestBodyTimeoutFromFactorycCs°t ¡}d|_d|_d|_| ¡tƒ|_| d¡}d|j _ ddg}t ƒ}|  |¡|  |jd¡|D]}| |¡qf| d¡|  |jd ¡|j jd ¡|  |jd¡dS) zÊ L{http.Request.finish} will notify the channel that it is finished, and will put the transport back in the producing state so that the reactor can close the connection. NrœTrrr}rÙsGET rÜ)rr«r¤ržrŸr rr¡r¬rvr×rr”rDrÝr–r•rdr¢r-r-r.Útest_finishCleansConnectionü s( þ   z(RequestTests.test_finishCleansConnectioncCst tƒd¡}ttj|ƒdS)z¦ L{http.Request} provides L{http._IDeprecatedHTTPChannelToRequestInterface}, which defines the interface used by L{http.HTTPChannel}. FN)rrär#r Ú)_IDeprecatedHTTPChannelToRequestInterfacerr-r-r.Ú6test_provides_IDeprecatedHTTPChannelToRequestInterface szCRequestTests.test_provides_IDeprecatedHTTPChannelToRequestInterfacecCst tƒd¡}| ||¡dS)z7 A L{http.Request} is equal to itself. FN)rrär#rDrr-r-r.Útest_eq) szRequestTests.test_eqcCs(t tƒd¡}| |t tƒd¡¡dS)zC A L{http.Request} is not equal to another object. FN)rrär#ÚassertNotEqualrr-r-r.Útest_ne1 szRequestTests.test_necCst tƒd¡}t|ƒdS)z0 A L{http.Request} is hashable. FN)rrär#Úhashrr-r-r.Ú test_hashable9 szRequestTests.test_hashablecsFg‰G‡fdd„dtƒ}t tƒd¡}| ||ƒ¡| ˆ|g¡dS)zÔ A L{http.Request} on the left hand side of an equality comparison to an instance that is not a L{http.Request} hands the comparison off to that object's C{__eq__} implementation. cseZdZ‡fdd„ZdS)z8RequestTests.test_eqWithNonRequest.._NotARequestcsˆ |¡dSrmrå©r=Úother©ZeqCallsr-r.Ú__eq__K s z?RequestTests.test_eqWithNonRequest.._NotARequest.__eq__N)r)r*r+r²r-r±r-r.Ú _NotARequestI sr³FN)Úobjectrrär#rD©r=r³rér-r±r.Útest_eqWithNonRequestA s z"RequestTests.test_eqWithNonRequestcsFg‰G‡fdd„dtƒ}t tƒd¡}| ||ƒ¡| ˆ|g¡dS)zÖ A L{http.Request} on the left hand side of an inequality comparison to an instance that is not a L{http.Request} hands the comparison off to that object's C{__ne__} implementation. cseZdZ‡fdd„ZdS)z8RequestTests.test_neWithNonRequest.._NotARequestcsˆ |¡dSrmrår¯r±r-r.Ú__ne___ s z?RequestTests.test_neWithNonRequest.._NotARequest.__ne__N)r)r*r+r·r-r±r-r.r³] sr³FN)r´rrär#r«rDrµr-r±r.Útest_neWithNonRequestU s z"RequestTests.test_neWithNonRequestcCslt |t¡}t tƒd¡}| tƒd¡| ¡|  dt |ƒ¡|d}|d}|  |j t ¡| t ¡dS)zy A RuntimeError is logged if a producer is still registered when an L{http.Request} is finished. FTr|rréN)r!r¶r'rrär#r;r"rdr¸rbrâr™r%rë)r=rºrgr»r¡r-r-r.Ú"test_finishProducerStillRegisteredi sþz/RequestTests.test_finishProducerStillRegisteredcCs.t tt ddd¡d¡}| | ¡d¡dS)z} L{http.Request.getClientIP} returns the host part of the client's address when connected over IPv4. rëú 127.0.0.1é80©ZpeerN©rrär#rÚ IPv6AddressrDÚ getClientIPr’r-r-r.Útest_getClientIPWithIPv4| sÿz%RequestTests.test_getClientIPWithIPv4cCs.t tt ddd¡d¡}| | ¡d¡dS)z} L{http.Request.getClientIP} returns the host part of the client's address when connected over IPv6. rëz::1r»r¼Nr½r’r-r-r.Útest_getClientIPWithIPv6† sÿz%RequestTests.test_getClientIPWithIPv6cCs*t tt d¡d¡}| | ¡d¡dS)zŠ L{http.Request.getClientIP} returns L{None} for the client's IP address when connected over a non-TCP transport. ú/path/to/socketr¼N)rrär#rÚ UNIXAddressrDr¿r’r-r-r.Útest_getClientIPWithNonTCPPeer sÿz+RequestTests.test_getClientIPWithNonTCPPeercCs.t d¡}t t|d¡}| | ¡|¡dS)zs L{http.Request.getClientAddress} returns the client's address as an L{IAddress} provider. rÂr¼N)rrÃrrär#r ZgetClientAddress)r=r"rgr-r-r.Útest_getClientAddressš s z"RequestTests.test_getClientAddressN)Mr)r*r+r,rrr r!r$r%r&r,r.r/r1r2r7r8r9r=r@rArBrHrKrNrOrPrSrYr]r^r_rdrfrirkrlrnrorqrxryrzr{r|r}r~rr€rƒr„r‡rˆrŠrŒrrŽr“r”r–ršr›r¥r¦r§r©rªr¬r®r¶r¸r¹rÀrÁrÄrÅr-r-r-r.rf s”                   '                  #    rc@sLeZdZdZdd„ZddddœZdd „Zd d „Zd d „Zdd„Z dd„Z dS)ÚMultilineHeadersTestsa Tests to exercise handling of multiline headers by L{HTTPClient}. RFCs 1945 (HTTP 1.0) and 2616 (HTTP 1.1) state that HTTP message header fields can span multiple lines if each extra line is preceded by at least one space or horizontal tab. cCsd|_d|_dS)zv Initialize variables used to verify that the header-processing functions are getting called. FN)ÚhandleHeaderCalledÚhandleEndHeadersCalledr<r-r-r.r,¬ szMultilineHeadersTests.setUps10s line-0 line-1s line-2 line-3)rWs X-Multilines X-Multiline2cCsd|_| ||j|¡dS)zE Dummy implementation of L{HTTPClient.handleHeader}. TN)rÇrDr„)r=rr¤r-r-r.ÚourHandleHeaderº sz%MultilineHeadersTests.ourHandleHeadercCs d|_dS)zI Dummy implementation of L{HTTPClient.handleEndHeaders}. TN)rÈr<r-r-r.ÚourHandleEndHeaders sz)MultilineHeadersTests.ourHandleEndHeaderscCs„tƒ}|j|_|j|_| d¡| d¡| |jd¡| |j ¡| |j ¡| d¡|  |j ¡|  |j ¡|  |jd¡dS)z» A header isn't processed by L{HTTPClient.extractHeader} until it is confirmed in L{HTTPClient.lineReceived} that the header has been received completely. róContent-Length: 10NrÂrq) rrÉrrÊrrrGrfr¦rÇrÈr­rDrr-r-r.Útest_extractHeaderÉ s       z(MultilineHeadersTests.test_extractHeadercCsbtƒ}|j|_|j|_| d¡| d¡| |j¡| |j ¡|  |j d¡|  |j d¡dS)zº An HTTP request with no headers will not cause any calls to L{handleHeader} but will cause L{handleEndHeaders} to be called on L{HTTPClient} subclasses. rrÂrrN) rrÉrrÊrrr¦rÇr­rÈrDrr‡rr-r-r.Útest_noHeadersá s    z$MultilineHeadersTests.test_noHeaderscCs®tƒ}|j|_|j|_| d¡| d¡| |j¡| d¡| d¡| |j¡| d¡| d¡| d¡| |j ¡|  |j d¡|  |j d ¡|  |j d ¡d S) zð L{HTTPClient} parses multiline headers by buffering header lines until an empty line or a line that does not start with whitespace hits lineReceived, confirming that the header has been received completely. rsX-Multiline: line-0s line-1sX-Multiline2: line-2s line-3rËrÂrrrqN)rrÉrrÊrrr¦rÇr­rÈrDrr‡rfrr-r-r.Útest_multilineHeadersõ s           z+MultilineHeadersTests.test_multilineHeadersN) r)r*r+r,r,r„rÉrÊrÌrÍrÎr-r-r-r.rÆ¥ s þrÆc@s eZdZdZdd„Zdd„ZdS)ÚExpect100ContinueServerTestsai Test that the HTTP server handles 'Expect: 100-continue' header correctly. The tests in this class all assume a simplistic behavior where user code cannot choose to deny a request. Once ticket #288 is implemented and user code can run before the body of a POST is processed this should be extended to support overriding this behavior. cCs€tƒ}t ¡}t|_| |¡| d¡| d¡| d¡| d¡| d¡| | ¡d¡| d¡|  | ¡dg¡d S) z‹ HTTP/1.0 requests do not get 100-continue returned, even if 'Expect: 100-continue' is included (RFC 2616 10.1.1). sGET / HTTP/1.0 óHost: www.example.com óContent-Length: 3 óExpect: 100-continue rarÂrP)rŠrŒrŽrr‹ó ''' 3 abc''' N) rrr‘r’r“r”r–rDr™rˆ)r=rsrkr-r-r.Ú test_HTTP10s       þz(Expect100ContinueServerTests.test_HTTP10cCs´tƒ}t ¡}t|_| |¡| d¡| d¡| d¡| d¡| | ¡d¡| d¡| | ¡d¡| d¡| ¡}|  |  d¡¡|t dƒd …}|  |d g¡d S) a! If a HTTP/1.1 client sends a 'Expect: 100-continue' header, the server responds with a 100 response code before handling the request body, if any. The normal resource rendering code will then be called, which will send an additional response code. sGET / HTTP/1.1 rÐrÒrÑrÂrasHTTP/1.1 100 Continue rPN)rÇrŒrŽrÈr‹rÓ) rrr‘r’r“r”r–rDr™r­rQrbrˆ)r=rsrkrƒr-r-r.Útest_expect100ContinueHeader9s*       ÿþz9Expect100ContinueServerTests.test_expect100ContinueHeaderN)r)r*r+r,rÔrÕr-r-r-r.rÏs rÏcst‡fdd„|DƒƒS)a Create a new dict containing only a subset of the items of an existing dict. @param keys: An iterable of the keys which will be added (with values from C{d}) to the result. @param d: The existing L{dict} from which to copy items. @return: The new L{dict} with keys given by C{keys} and values given by the corresponding values in C{d}. @rtype: L{dict} csg|]}|ˆ|f‘qSr-r-)rxÚk©r#r-r.rymszsub..)Údict)Úkeysr#r-r×r.Úsub_srÚc@s eZdZdZdd„Zdd„ZdS)Ú DeprecatedRequestAttributesTestszI Tests for deprecated attributes of L{twisted.web.http.Request}. cCs~t tt ddd¡d¡}| d¡| ddd¡| ¡|j|j gd }|  d t |ƒ¡|  t d d œt d dg|dƒ¡dS)zg L{Request.getClientIP} is deprecated in favor of L{Request.getClientAddress}. rërºi90r¼rrorár6rjr|zjtwisted.web.http.Request.getClientIP was deprecated in Twisted 18.4.0; please use getClientAddress instead©r`rr`rN)rrär#rr¾rZrequestReceivedr¿raÚtest_getClientIPrDrbrbrÚ)r=rgrcr-r-r.rÝvs ÿ ÿýûz1DeprecatedRequestAttributesTests.test_getClientIPcCs\tƒ}t |¡}| ¡|j|jgd}| dt|ƒ¡| tddœt ddg|dƒ¡dS) zs L{Request.noLongerQueued} is deprecated, as we no longer process requests simultaneously. rjr|zHtwisted.web.http.Request.noLongerQueued was deprecated in Twisted 16.3.0rÜr`rrN) r#rräZnoLongerQueuedraÚtest_noLongerQueuedrDrbrbrÚ)r=rkrgrcr-r-r.rÞs ÿýûz4DeprecatedRequestAttributesTests.test_noLongerQueuedN)r)r*r+r,rÝrÞr-r-r-r.rÛqsrÛc@s|eZdZdZdZdd„Zdd„Zdd„Zd d „Zd d „Z d d„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„ZdS)ÚChannelProductionTestsz= Tests for the way HTTPChannel manages backpressure. s#GET / HTTP/1.1 Host: localhost cCs(|}t ¡}t|ƒ|_| |¡||fS)a Setup a L{HTTPChannel} and a transport and associate them. @param transport: A transport to back the L{HTTPChannel} @param requestFactory: An object that can construct L{Request} objects. @return: A tuple of the channel and the transport. )rr‘r6r“r”)r=rsr“rkr-r-r.ÚbuildChannelAndTransport®s   z/ChannelProductionTests.buildChannelAndTransportcCs0| tƒt¡\}}| |j|¡| |j¡dS)zu L{HTTPChannel} registers itself as a producer with its transport when a connection is made. N)ràrrTrDr r­Ú streaming©r=rkrsr-r-r.Útest_HTTPChannelIsAProducer¾s ÿz2ChannelProductionTests.test_HTTPChannelIsAProducercCs:| tƒt¡\}}| ¡| |jd¡| |jd¡dS)zV L{HTTPChannel} unregisters itself when it has loseConnection called. N)ràrrTrár r rárâr-r-r.Ú8test_HTTPChannelUnregistersSelfWhenCallingLoseConnectionËsÿzOChannelProductionTests.test_HTTPChannelUnregistersSelfWhenCallingLoseConnectioncCs8| tƒt¡\}}| tƒd¡| t|jtƒd¡dS)z If two producers are registered on a L{HTTPChannel} without the first being unregistered, a L{RuntimeError} is thrown. TN)ràrrTr;r"rür%râr-r-r.Ú(test_HTTPChannelRejectsMultipleProducersØsÿÿz?ChannelProductionTests.test_HTTPChannelRejectsMultipleProducerscCs,| tƒt¡\}}| ¡| |jd¡dS)zr If there is no producer, the L{HTTPChannel} can still have C{unregisterProducer} called. N©ràrrTr™r Z_requestProducerrâr-r-r.Ú+test_HTTPChannelCanUnregisterWithNoProducerçs ÿzBChannelProductionTests.test_HTTPChannelCanUnregisterWithNoProducercCs,| tƒt¡\}}| ¡| |jd¡dS)zn If there is no request producer currently registered, C{stopProducing} does nothing. Nrærâr-r-r.Ú,test_HTTPChannelStopWithNoRequestOutstandingôs ÿzCChannelProductionTests.test_HTTPChannelStopWithNoRequestOutstandingcCsf| tƒt¡\}}| |j¡|jdj}tƒ}| |d¡|  |j g¡|  ¡|  |j dg¡dS)z If there is a request producer registered with L{HTTPChannel}, calling C{stopProducing} causes that producer to be stopped as well. rTÚstopN) ràrrlr–rgr•rÄr"r;rDÚeventsZ stopProducing©r=rkrsrgr r-r-r.Ú#test_HTTPChannelStopRequestProducersÿ   z:ChannelProductionTests.test_HTTPChannelStopRequestProducercCsP| tƒt¡\}}| |jd¡| ¡| |jd¡| ¡| |jd¡dS)zë When L{HTTPChannel} has C{pauseProducing} called on it by the transport it will call C{pauseProducing} on the transport. When unpaused, the L{HTTPChannel} will call C{resumeProducing} on its transport. rÙrÜN)ràrrTrDrÝÚpauseProducingÚresumeProducingrâr-r-r.Ú;test_HTTPChannelPropagatesProducingFromTransportToTransportsÿzRChannelProductionTests.test_HTTPChannelPropagatesProducingFromTransportToTransportcCsØ| tƒt¡\}}d|_| |j¡| d¡|jdj}tƒ}|  |d¡|  |j d¡|  |j g¡|  ¡|  |j d¡|  |j dg¡| ¡|  |j d¡|  |j ddg¡| ¡| ¡|  |j d¡dS) zÙ If a L{Request} object has registered itself as a producer with a L{HTTPChannel} object, and the L{HTTPChannel} object is paused, both the transport and L{Request} objects get paused. rs123TrÜÚpauseZresumerÙN)ràrrlr×r–rgr•rÄr"r;rDrÝrêrírîr™rmrër-r-r.Ú3test_HTTPChannelPropagatesPausedProductionToRequest0s*ÿ    zJChannelProductionTests.test_HTTPChannelPropagatesPausedProductionToRequestcCsÆ| tƒt¡\}}d|_| |j¡| d¡|jdj}tƒ}|  |d¡|  |j d¡|  |j g¡|  ¡|  |j d¡|  |j dg¡| ¡| ¡|  |j d¡| ¡|  |j d¡dS)z˜ If a L{Request} object completes its response while the transport is paused, the L{HTTPChannel} does not resume the transport. rsextraTrÜrðrÙN)ràrrlr×r–rgr•rÄr"r;rDrÝrêrír™rmrîrër-r-r.Ú/test_HTTPChannelStaysPausedWhenRequestCompletes]s(ÿ    zFChannelProductionTests.test_HTTPChannelStaysPausedWhenRequestCompletescCsªGdd„dtƒ}|ƒ}| ¡| t|j¡| |ƒt¡\}}| |jd¡| ¡| |jd¡| |j ¡| |jd¡|  |  ¡  d¡¡|  ¡| |jd¡dS)zŸ If the L{HTTPChannel} has paused the transport, it still tolerates receiving data, and does not attempt to pause the transport again. c@seZdZdZdd„ZdS)zgChannelProductionTests.test_HTTPChannelToleratesDataWhenTransportPaused..NoDoublePauseTransportz| A version of L{StringTransport} that fails tests if it is paused while already paused. cSs |jdkrtdƒ‚t |¡dS)NrÜzTransport was paused twice!)rÝr%rrír<r-r-r.rí’s zvChannelProductionTests.test_HTTPChannelToleratesDataWhenTransportPaused..NoDoublePauseTransport.pauseProducingN)r)r*r+r,rír-r-r-r.ÚNoDoublePauseTransportsrórÙrÜsHTTP/1.1 200 OK N)rrírür%ràrTrDrÝr–rgr­r™rQrî)r=rórsrkr-r-r.Ú0test_HTTPChannelToleratesDataWhenTransportPausedˆs  ÿ zGChannelProductionTests.test_HTTPChannelToleratesDataWhenTransportPausedcshˆ tƒt¡\}‰tƒ‰t ¡}t|_| ˆ¡| ˆj ¡|j dj }|j j }‡‡fdd„}| |¡S)zŽ If the L{HTTPChannel} has a L{IPullProducer} registered with it it can adapt that producer into an L{IPushProducer}. rcs(ˆ ¡ dd¡d}d}ˆ ||¡dS)Nr}r|s<1 0 1 1 1 2 1 3 1 4 1 5 1 6 1 7 1 8 1 9 )r™r~rD)ZignZ responseBodyZexpectedResponseBody©r=rsr-r.ÚvalidateÅsÿ zOChannelProductionTests.test_HTTPChannelToleratesPullProducers..validate)ràrr7rr‘ÚDummyPullProducerHandlerProxyr“r”r–rgr•rÄr9rzr )r=rkrgZresponseCompleterör-rõr.Ú&test_HTTPChannelToleratesPullProducers´sÿ   z=ChannelProductionTests.test_HTTPChannelToleratesPullProducerscCs|tƒ}tƒ}t ¡}d|_|j|_| |¡| d¡| |j |¡| |j d¡| d¡| |j d¡| |j d¡dS)zS L{HTTPChannel} unregisters itself when it times out a connection. r r¢Tr|N) rrrr‘r¤rur”r¥r r rá)r=r¨rsrkr-r-r.Ú,test_HTTPChannelUnregistersSelfWhenTimingOutØs   zCChannelProductionTests.test_HTTPChannelUnregistersSelfWhenTimingOutN)r)r*r+r,rgràrãrärårçrèrìrïrñròrôrørùr-r-r-r.rߣs ÿ    -+,$rß)jr,Z __future__rrrBrÿrrRrrrÚ ImportErrorZ urllib.parseÚiorZzope.interfacerZzope.interface.verifyr Ztwisted.python.compatr r r r rrZtwisted.python.componentsrZtwisted.python.failurerZ twisted.trialrZtwisted.trial.unittestrZ twisted.webrrrZtwisted.web.httprrrZtwisted.internetrZtwisted.internet.taskrZtwisted.internet.errorrrZtwisted.protocolsrZtwisted.test.proto_helpersrr r!Ztwisted.test.test_internetr"Ztwisted.web.test.requesthelperr#r%r&Ztwisted.loggerr'r¨r(r6rär7r÷r@rTr’ZINonQueuedRequestFactoryriZDummyNewHTTPHandlerProxyrlrÃZ HTTPClientrnryr´rzr‰rÆrÍrÏrÑràrårïr r*r+r8rOrqr‡rþrrrrÆrÏrÚrÛrßr-r-r-r.Ús°                 ÿ  ÿ   %r++).=4 8 1@bGpJ2