
    tfZ                        d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl	m
Z
mZmZ ddZ G d de          Z G d de          Z G d de          ZdS )z(
Tests for L{twisted.web.http_headers}.
    )annotations)Sequence)TestCase)Headers)bytesLinearWhitespaceComponentssanitizedBytestextLinearWhitespaceComponentstestCaser   
componentsSequence[bytes] | Sequence[str]expectedbytesreturnNonec                   |D ]}g }|                     t          ||gi                     t                      }|                    ||           |                     |           t                      }|                    ||g           |                     |           |D ]e}|                     t          |                                          ||gfg           |                     |                    |          |g           fdS )a  
    Assert that the components are sanitized to the expected value as
    both a header name and value, across all of L{Header}'s setters
    and getters.

    @param testCase: A test case.

    @param components: A sequence of values that contain linear
        whitespace to use as header names and values; see
        C{textLinearWhitespaceComponents} and
        C{bytesLinearWhitespaceComponents}

    @param expected: The expected sanitized form of the component for
        both headers names and their values.
    N)appendr   addRawHeadersetRawHeadersassertEquallistgetAllRawHeadersgetRawHeaders)r
   r   r   	componentheadersadded	setHeaderheaders           a/var/www/surfInsights/venv3-11/lib/python3.11/site-packages/twisted/web/test/test_http_headers.pyassertSanitizedr      s(   $   M M	w	I;788999		9i000uII		I;777y!!! 	M 	MF  V,,..//8hZ2H1I     !5!5h!?!?(LLLL		MM M    c                      e Zd ZdZddZddZddZddZddZdd	Z	dd
Z
ddZddZddZddZddZddZddZddZddZddZddZddZddZddZdS )BytesHeadersTestszE
    Tests for L{Headers}, using L{bytes} arguments for methods.
    r   r   c                <    t          | t          t                     dS zf
        Linear whitespace in header names or values is replaced with a
        single space.
        N)r   r   r   selfs    r   test_sanitizeLinearWhitespacez/BytesHeadersTests.test_sanitizeLinearWhitespace>   s    
 	=~NNNNNr    c                ~    t          ddgi          }|                     |                    d          dg           dS )zx
        The header values passed to L{Headers.__init__} can be retrieved via
        L{Headers.getRawHeaders}.
        s   Foo   bar   fooNr   r   r   r&   hs     r   test_initializerz"BytesHeadersTests.test_initializerE   sB    
 VfX&''006(;;;;;r    c                H   ddg}t                      }|                    d|           |                     |                    d                     |                     |                    d                     |                     |                    d          |           dS )z
        L{Headers.setRawHeaders} sets the header values for the given
        header name to the sequence of byte string values.
           value1   value2   test   TestNr   r   
assertTrue	hasHeaderr   r   )r&   rawValuer-   s      r   test_setRawHeadersz$BytesHeadersTests.test_setRawHeadersM   s    
 y)II	***G,,---G,,---118<<<<<r    c                $   t                      }|                    dd           |                     |                    d          dg           |                    dd           |                     |                    d          ddg           dS )N
        L{Headers.addRawHeader} adds a new value for a given header.
        r2      lemur   pandaNr   r   r   r   r,   s     r   test_addRawHeaderz#BytesHeadersTests.test_addRawHeaderY   s     II	w)))11H:>>>	w)))11Hh3GHHHHHr    c                n    |                      t                                          d                     dS )z
        L{Headers.getRawHeaders} returns L{None} if the header is not found and
        no default is specified.
        r2   NassertIsNoner   r   r%   s    r   test_getRawHeadersNoDefaultz-BytesHeadersTests.test_getRawHeadersNoDefaultc   s0    
 	'))11'::;;;;;r    c                    t                      }t                      }|                     |                    d|          |           dS )o
        L{Headers.getRawHeaders} returns the specified default value when no
        header is found.
        r2   N)r   objectassertIdenticalr   r&   r-   defaults      r   test_getRawHeadersDefaultValuez0BytesHeadersTests.test_getRawHeadersDefaultValuej   s@    
 II((Q__Wg>>HHHHHr    c                   t                      }dg}|                    d|           |                     |                    d|          d         t                     |                     |                    d|          dg           dS )z
        If the object passed as the value list to L{Headers.setRawHeaders}
        is later passed as a default to L{Headers.getRawHeaders}, the
        result nevertheless contains encoded values.
        value   keyr      valueN)r   r   assertIsInstancer   r   r   rH   s      r   *test_getRawHeadersWithDefaultMatchingValuez<BytesHeadersTests.test_getRawHeadersWithDefaultMatchingValues   s}     II)	(((aoofg>>qA5III99H:FFFFFr    c                    t                      }|                    ddg           |                     |                    d          dg           |                     |                    d          dg           dS )m
        L{Headers.getRawHeaders} returns the values which have been set for a
        given header.
        r2   r;   r3   Nr   r   r   r   r,   s     r   test_getRawHeadersz$BytesHeadersTests.test_getRawHeaders   sq    
 II	(,,,11H:>>>11H:>>>>>r    c                    t                      }|                    ddg           |                     |                    d                     |                     |                    d                     dS )i
        Check that L{Headers.hasHeader} returns C{True} when the given header
        is found.
        r2   r;   r3   Nr   r   r5   r6   r,   s     r   test_hasHeaderTruez$BytesHeadersTests.test_hasHeaderTrue   se    
 II	(,,,G,,---G,,-----r    c                n    |                      t                                          d                     dS )c
        L{Headers.hasHeader} returns C{False} when the given header is not
        found.
        r2   NassertFalser   r6   r%   s    r   test_hasHeaderFalsez%BytesHeadersTests.test_hasHeaderFalse   s0    
 	,,W5566666r    c                   t                      }|                    ddg           |                     |                    d                     |                    d           |                     |                    d                     |                    ddg           |                     |                    d                     |                    d           |                     |                    d                     dS )N
        Check that L{Headers.removeHeader} removes the given header.
        r*   r;   r)   r<   s   BarNr   r   r5   r6   removeHeaderr\   r,   s     r   test_removeHeaderz#BytesHeadersTests.test_removeHeader   s     II	
+++F++,,,	vV,,---	
+++F++,,,	vV,,-----r    c                    t                      }|                    d           |                     t          |                                          g            dS )k
        L{Headers.removeHeader} is a no-operation when the specified header is
        not found.
        r2   Nr   ra   r   r   r   r,   s     r   test_removeHeaderDoesntExistz.BytesHeadersTests.test_removeHeaderDoesntExist   sO    
 II	wa002233R88888r    c                   t                      }|                     |                    d          d           |                     |                    d          d           |                     |                    d          d           |                     |                    d          d           |                     |                    d	          d
           |                     |                    d          d           |                     |                    d          d           |                     |                    d          d           |                     |                    d          d           |                     |                    d          d           |                     |                    d          d           dS )zk
        L{Headers._encodeName} returns the canonical capitalization for
        the given header.
        r2   r3   s
   test-stuffs
   Test-Stuffs   content-md5   Content-MD5s   dnts   DNTs   etags   ETags   p3ps   P3Ps   tes   TE   www-authenticate   WWW-Authenticates   WWW-authenticates   Www-Authenticates   x-xss-protections   X-XSS-ProtectionN)r   r   _encodeNamer,   s     r   test_encodeNamez!BytesHeadersTests.test_encodeName   s   
 IIw//999}55}EEE~66GGGv..777w//999v..777u--u555':;;=PQQQ':;;=PQQQ':;;=PQQQ':;;=PQQQQQr    c                    t                      }|                    ddg           |                    ddg           d |                                D             }|                     |ddh           dS )	
        L{Headers.getAllRawHeaders} returns an iterable of (k, v) pairs, where
        C{k} is the canonicalized representation of the header name, and C{v}
        is a sequence of values.
        r2      lemursri      basic aksljdlk=c                6    h | ]\  }}|t          |          fS  tuple.0kvs      r   	<setcomp>z:BytesHeadersTests.test_getAllRawHeaders.<locals>.<setcomp>   &    EEE1q%((mEEEr    rj   )rp   )r3   ro   Nr   r   r   r   r&   r-   
allHeaderss      r   test_getAllRawHeadersz'BytesHeadersTests.test_getAllRawHeaders   s     II	)---	+.@-ABBBEE0B0B0D0DEEE
9;RS	
 	
 	
 	
 	
r    c                j   t                      }|                    ddg           t                      }|                    ddg           t                      }|                    dddg           |                     ||           |                     ||           |                     ||           dS )
        A L{Headers} instance compares equal to itself and to another
        L{Headers} instance with the same values.
        r*   r<   r;   Nr   r   r   assertNotEqual)r&   firstsecondthirds       r   test_headersComparisonz(BytesHeadersTests.test_headersComparison   s    
 		FXJ///VhZ000		FXx$8999&&&'''E5)))))r    c                    t                      }|                     |d           |                     |t                                 |                     |d           dS )f
        An instance of L{Headers} does not compare equal to other unrelated
        objects.
        rr   r*   Nr   r   rF   r,   s     r   test_otherComparisonz&BytesHeadersTests.test_otherComparison   sY    
 IIAr"""Avxx(((Av&&&&&r    c           
         d}d}d}|                      t          t          |||gi                    d|                                d|d|d           dS )	zy
        The L{repr} of a L{Headers} instance shows the names and values of all
        the headers it contains.
        r*   r)      baz	Headers({: [, ]})Nr   reprr   
capitalizer&   foobarbazs       r   	test_reprzBytesHeadersTests.test_repr   sy    
 #Sz*++,,D))DDDDDDD	
 	
 	
 	
 	
r    c           
         d}d}d}|                      t          t          |||gi                    d|                                d|d|d           dS )	z
        The L{repr} of a L{Headers} instance shows the names and values of all
        the headers it contains, not attempting to decode any raw bytes.
        r*   s   bars   bazr   r   r   r   Nr   r   s       r   test_reprWithRawBytesz'BytesHeadersTests.test_reprWithRawBytes   s{      #Sz*++,,D))DDDDDDD	
 	
 	
 	
 	
r    c           
         d}d}d} G d dt                     }|                     t           ||||gi                    d|                                d|d|d	           d
S )
        The L{repr} of an instance of a subclass of L{Headers} uses the name
        of the subclass instead of the string C{"Headers"}.
        r*   r)   r   c                      e Zd ZdS )9BytesHeadersTests.test_subclassRepr.<locals>.FunnyHeadersN__name__
__module____qualname__rr   r    r   FunnyHeadersr             Dr    r   FunnyHeaders({r   r   r   N)r   r   r   r   )r&   r   r   r   r   s        r   test_subclassReprz#BytesHeadersTests.test_subclassRepr  s    
 	 	 	 	 	7 	 	 	 	sS#J/0011Icnn..IISIIcIII	
 	
 	
 	
 	
r    c                   t                      }|                    ddg           |                                }|                     |                    d          dg           |                    dd           |                     |                    d          dg           |                    dd           |                     |                    d          ddg           dS )
        L{Headers.copy} creates a new independent copy of an existing
        L{Headers} instance, allowing future modifications without impacts
        between the copies.
        r2   r*   r)   r   Nr   r   copyr   r   r   r&   r-   is      r   	test_copyzBytesHeadersTests.test_copy  s     II	&***FFHH11F8<<<	w'''11F8<<<	w'''11FF3CDDDDDr    c                    t                      }t          t           j        dz             D ]}|                    d| d           |                     t          t           j                  t           j                   dS )zH
        Only a limited number of HTTP header names get cached.
           zhello-rL   N)r   range_MAX_CACHED_HEADERSr   r   len_canonicalHeaderCache)r&   r   r   s      r   test_max_cached_headersz)BytesHeadersTests.test_max_cached_headers-  s     ))w2S899 	8 	8A  !w7777-..0K	
 	
 	
 	
 	
r    Nr   r   )r   r   r   __doc__r'   r.   r8   r>   rC   rJ   rP   rT   rX   r]   rb   rf   rl   r   r   r   r   r   r   r   r   rr   r    r   r"   r"   9   s        O O O O< < < <
= 
= 
= 
=I I I I< < < <I I I I
G 
G 
G 
G? ? ? ?. . . .7 7 7 7. . . . 9 9 9 9R R R R$
 
 
 
"* * * *' ' ' '
 
 
 

 
 
 
"
 
 
 
"E E E E	
 	
 	
 	
 	
 	
r    r"   c                      e Zd ZdZddZddZddZddZddZdd	Z	dd
Z
ddZddZddZddZddZddZddZddZddZddZddZddZddZddZdS )UnicodeHeadersTestszC
    Tests for L{Headers}, using L{str} arguments for methods.
    r   r   c                <    t          | t          t                     dS r$   )r   r	   r   r%   s    r   r'   z1UnicodeHeadersTests.test_sanitizeLinearWhitespace>  s    
 	<nMMMMMr    c                    t          ddgi          }|                     |                    d          dg           |                     |                    d          dg           dS )aC  
        The header values passed to L{Headers.__init__} can be retrieved via
        L{Headers.getRawHeaders}. If a L{bytes} argument is given, it returns
        L{bytes} values, and if a L{str} argument is given, it returns
        L{str} values. Both are the same header value, just encoded or
        decoded.
        Foor   r*   r)   r   Nr+   r,   s     r   r.   z$UnicodeHeadersTests.test_initializerE  sf     UUG$%%006(;;;//%99999r    c                B   ddg}ddg}t                      }|                    d|           |                     |                    d                     |                     |                    d                     |                     |                    d                     |                     |                    d                     |                     |                    d          |           |                     |                    d          |           d	S )
z
        L{Headers.setRawHeaders} sets the header values for the given
        header name to the sequence of strings, encoded.
        value1value2r0   r1   testr2   r3   TestNr4   )r&   r7   rawEncodedValuer-   s       r   r8   z&UnicodeHeadersTests.test_setRawHeadersQ  s    
 h'$i0II	)))G,,---G,,---F++,,,F++,,,00(;;;11?CCCCCr    c                D   t                      }|                     t                    5  |                    ddg           ddd           n# 1 swxY w Y   |                     t                    5  |                    d           ddd           dS # 1 swxY w Y   dS )z
        Passing L{str} to any function that takes a header name will encode
        said header name as ISO-8859-1, and if it cannot be encoded, it will
        raise a L{UnicodeDecodeError}.
           ☃valN)r   assertRaisesUnicodeEncodeErrorr   r6   r,   s     r   test_nameNotEncodablez)UnicodeHeadersTests.test_nameNotEncodablea  s    II 122 	/ 	/OOHug...	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 	/ 122 	" 	"KK!!!	" 	" 	" 	" 	" 	" 	" 	" 	" 	" 	" 	" 	" 	" 	" 	" 	" 	"s#   AAA2BBBc                D   t                      }|                    ddg           |                     |                    d                     |                     |                    d          dg           |                     |                    d                     dS )z}
        Passing L{str} to any function that takes a header name will encode
        said header name as ISO-8859-1.
           ár*      Nr4   r,   s     r   test_nameEncodingz%UnicodeHeadersTests.test_nameEncodingp  s    
 II 	
6(+++ 	G,,---11F8<<< 	H--.....r    c                    t                      }|                    dddg           |                     |                    d                     |                     |                    d          ddg           dS )z|
        Passing L{str} to L{Headers.setRawHeaders} will encode the name as
        ISO-8859-1 and values as UTF-8.
        r   r   r*   r   s   ☃Nr4   r,   s     r   test_rawHeadersValueEncodingz0UnicodeHeadersTests.test_rawHeadersValueEncoding  sq    
 II	8V"4555G,,---11OV3LMMMMMr    c                z   t                      }|                    dd           |                     |                    d          dg           |                    dd           |                     |                    d          ddg           |                     |                    d          ddg           dS )r:   r   lemurpandar2   r;   r<   Nr=   r,   s     r   r>   z%UnicodeHeadersTests.test_addRawHeader  s     II	vw'''007)<<<	vw'''007G2DEEE11Hh3GHHHHHr    c                n    |                      t                                          d                     dS )r@   r   NrA   r%   s    r   rC   z/UnicodeHeadersTests.test_getRawHeadersNoDefault  s0    
 	'))11&99:::::r    c                   t                      }t                      }|                     |                    d|          |           |                     |                    dd          d           |                     |                    ddg          dg           |                     |                    ddg          dg           dS )rE   r   Nr   )r   rF   rG   r   r   rH   s      r   rJ   z2UnicodeHeadersTests.test_getRawHeadersDefaultValue  s    
 II((Q__VW==wGGGQ__VT::DAAA$884&AAAOOF]O44O	
 	
 	
 	
 	
r    c                   t                      }dg}|                    d|           |                     |                    d|          d         t                     |                     |                    d|          dg           dS )z
        If the object passed as the value list to L{Headers.setRawHeaders}
        is later passed as a default to L{Headers.getRawHeaders}, the
        result nevertheless contains decoded values.
        rN   rM   keyr   rL   N)r   r   rO   r   strr   rH   s      r   rP   z>UnicodeHeadersTests.test_getRawHeadersWithDefaultMatchingValue  s}     II*	(((aooeW==a@#FFF887)DDDDDr    c                   t                      }|                    ddg           |                     |                    d          dg           |                     |                    d          dg           |                     |                    d          dg           |                     |                    d          dg           dS )rR      testár      Testá   testr;      TestNrS   r,   s     r   rT   z&UnicodeHeadersTests.test_getRawHeaders  s    
 II	wi00066	BBB66	BBB55zBBB55zBBBBBr    c                   t                      }|                    ddg           |                     |                    d                     |                     |                    d                     |                     |                    d                     |                     |                    d                     dS )rV   r   r   r   r   r   NrW   r,   s     r   rX   z&UnicodeHeadersTests.test_hasHeaderTrue  s    
 II	wi000L11222L11222K00111K0011111r    c                n    |                      t                                          d                     dS )rZ   r   Nr[   r%   s    r   r]   z'UnicodeHeadersTests.test_hasHeaderFalse  s0    
 	,,\::;;;;;r    c                   t                      }|                    ddg           |                     |                    d                     |                    d           |                     |                    d                     |                     |                    d                     |                    ddg           |                     |                    d                     |                    d           |                     |                    d                     |                     |                    d                     dS )	r_   r   r   r*   r   r   Barr)   Nr`   r,   s     r   rb   z%UnicodeHeadersTests.test_removeHeader  s    II	y)))E**+++	uU++,,,V,,---	y)))E**+++	uU++,,,V,,-----r    c                    t                      }|                    d           |                     t          |                                          g            dS )rd   r   Nre   r,   s     r   rf   z0UnicodeHeadersTests.test_removeHeaderDoesntExist  sO    
 II	va002233R88888r    c                   t                      }|                    ddg           |                    ddg           |                    ddg           d |                                D             }|                     |h d           d	S )
rn   r   lemurszwww-authenticatezbasic aksljdlk=zcontent-md5kjdfdfgdfgnsdc                6    h | ]\  }}|t          |          fS rr   rs   ru   s      r   ry   z<UnicodeHeadersTests.test_getAllRawHeaders.<locals>.<setcomp>  rz   r    >   r   r|   rh   )s   kjdfdfgdfgnsdr{   Nr}   r~   s      r   r   z)UnicodeHeadersTests.test_getAllRawHeaders  s     II	xj111	*->,?@@@	'8999EE0B0B0D0DEEE
  	
 	
 	
 	
 	
r    c                   t                      }|                    ddg           t                      }|                    ddg           t                      }|                    dddg           |                     ||           |                     ||           |                     ||           t                      }|                    ddg           t                      }|                    ddg           t                      }|                    dddg           |                     ||           |                     ||           |                     ||           dS )r      fooár   r   s   foor<   r;   Nr   )r&   r   r   r   
firstBytessecondBytes
thirdBytess          r   r   z*UnicodeHeadersTests.test_headersComparison  s\   
 		K'333[7)444		K'7);<<<&&&'''E5))) YY
  hZ888ii!!*xj999YY
  h-@AAA
+++---
+++++r    c                    t                      }|                     |d           |                     |t                                 |                     |d           dS )r   rr   r   Nr   r,   s     r   r   z(UnicodeHeadersTests.test_otherComparison$  sY    
 IIAr"""Avxx(((Au%%%%%r    c           
         d}d}d}d}d}d|z   }d|z   }|                      t          t          |||gi                    d                    |||                    d                               d	S )
z
        The L{repr} of a L{Headers} instance shows the names and values of all
        the headers it contains. This shows only reprs of bytes values, as
        undecodable headers may cause an exception.
        r      bar☃r   z	'Foo\xe1'z'bar\xe2\x98\x83'bzHeaders({{{}: [{}, {!r}]}})utf8N)r   r   r   formatencode)r&   r   r   r   
fooEncoded
barEncodeds         r   r   zUnicodeHeadersTests.test_repr.  s     !
+
:%
:%
#Sz*++,,)00J

6(:(: 	
 	
 	
 	
 	
r    c                    d}d}d}d}d} G d dt                     }|                     t           ||||gi                    d|d	|d
|                    d          d           dS )r   r   r   r   z
b'Foo\xe1'zb'bar\xe2\x98\x83'c                      e Zd ZdS );UnicodeHeadersTests.test_subclassRepr.<locals>.FunnyHeadersNr   rr   r    r   r   r   M  r   r    r   r   r   r   r   r   N)r   r   r   r   )r&   r   r   r   r   r   r   s          r   r   z%UnicodeHeadersTests.test_subclassReprB  s    
 "
,
	 	 	 	 	7 	 	 	 	sS#J/00111zz:::szz&'9'9'9'9;	
 	
 	
 	
 	
r    c                   t                      }|                    ddg           |                                }|                     |                    d          dg           |                     |                    d          dg           |                    dd           |                     |                    d          dg           |                     |                    d          dg           |                    dd           |                     |                    d          ddg           |                     |                    d          ddg           dS )	r   r   u   foo☃r   s   foo☃r   r   r)   Nr   r   s      r   r   zUnicodeHeadersTests.test_copyV  sK    II	{m444FFHH 	66FFF558J7KLLL 	
|U+++ 	66FFF558J7KLLL 	
|V,,, 	66e8LMMM558JF7STTTTTr    Nr   )r   r   r   r   r'   r.   r8   r   r   r   r>   rC   rJ   rP   rT   rX   r]   rb   rf   r   r   r   r   r   r   rr   r    r   r   r   9  s        N N N N
: 
: 
: 
:D D D D " " " "/ / / /"N N N N	I 	I 	I 	I; ; ; ;
 
 
 

E 
E 
E 
E
C 
C 
C 
C
2 
2 
2 
2< < < <. . . .$9 9 9 9
 
 
 
,, , , ,8& & & &
 
 
 
(
 
 
 
(U U U U U Ur    r   c                  "    e Zd ZdZddZddZdS )MixedHeadersTestszm
    Tests for L{Headers}, mixing L{bytes} and L{str} arguments for methods
    where that is permitted.
    r   r   c                "   t                      }|                    dd           |                    dd           |                     |                    d          dg           |                     |                    d          dg           dS )zL
        L{Headers.addRawHeader} accepts mixed L{str} and L{bytes}.
           bytesr      Bytes   strStrr   Nr=   r,   s     r   r>   z#MixedHeadersTests.test_addRawHeadery  s     II	x'''	uh'''22VH===//';;;;;r    c                2   t                      }|                    ddg           |                    ddg           |                    dddg           |                    dddg           |                     |                    d          dg           |                     |                    d          dg           |                     |                    d          ddg           |                     |                    d	          d
dg           dS )zM
        L{Headers.setRawHeaders} accepts mixed L{str} and L{bytes}.
        r   r   z	mixed-strs   mixed-bytesr   r   z	Mixed-Strr   s   Mixed-Bytesr   NrS   r,   s     r   r8   z$MixedHeadersTests.test_setRawHeaders  s    II	8*---	w'''	h%6777	(9:::22XJ???//%999557GHHH8868:LMMMMMr    Nr   )r   r   r   r   r>   r8   rr   r    r   r   r   s  sL         
	< 	< 	< 	<N N N N N Nr    r   N)r
   r   r   r   r   r   r   r   )r   
__future__r   typingr   twisted.trial.unittestr   twisted.web.http_headersr   twisted.web.test.requesthelperr   r   r	   r   r"   r   r   rr   r    r   <module>r     sP    # " " " " "       + + + + + + , , , , , ,         "M "M "M "MJ}
 }
 }
 }
 }
 }
 }
 }
@wU wU wU wU wU( wU wU wUt	N N N N N N N N N Nr    