Ë
    ojÂb  ã                   ó¬   — d Z ddlmZmZmZ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mZ ddlmZ  G d„ d	«      Z G d
„ dee«      Z G d„ dee«      Zy)z$
Test the memcache client protocol.
é    )ÚDeferredÚDeferredListÚTimeoutErrorÚgatherResults)ÚConnectionDone)ÚClock)Ú StringTransportWithDisconnection)ÚClientErrorÚMemCacheProtocolÚNoSuchCommandÚServerError)ÚTestCasec                   óˆ   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zd
„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zy)ÚCommandMixinzO
    Setup and tests for basic invocation of L{MemCacheProtocol} commands.
    c                 ó   — t        «       ‚)zp
        Helper test method to test the resulting C{Deferred} of a
        L{MemCacheProtocol} command.
        )ÚNotImplementedError©ÚselfÚdÚsendÚrecvÚresults        ú</usr/lib/python3/dist-packages/twisted/test/test_memcache.pyÚ_testzCommandMixin._test   s   € ô
 "Ó#Ð#ó    c                 ó\   — | j                  | j                  j                  d«      ddd«      S )zÉ
        L{MemCacheProtocol.get} returns a L{Deferred} which is called back with
        the value and the flag associated with the given key if the server
        returns a successful result.
        ó   fooó	   get foo
ó   VALUE foo 0 3
bar
END
©r   ó   bar©r   ÚprotoÚget©r   s    r   Útest_getzCommandMixin.test_get"   s.   € ð �z‰zØ�J‰J�N‰N˜6Ó"ØØ.Øó	
ð 	
r   c                 ó\   — | j                  | j                  j                  d«      ddd«      S )zu
        Test getting a non-available key: it succeeds but return L{None} as
        value and C{0} as flag.
        r   r   ó   END
©r   Nr"   r%   s    r   Útest_emptyGetzCommandMixin.test_emptyGet/   s&   € ð
 �z‰z˜$Ÿ*™*Ÿ.™.¨Ó0°.À*ÈiÓXÐXr   c                 óf   — | j                  | j                  j                  ddg«      dddddœ«      S )z™
        L{MemCacheProtocol.getMultiple} returns a L{Deferred} which is called
        back with a dictionary of flag, value for each given key.
        r   ó   cowó   get foo cow
s1   VALUE foo 0 3
bar
VALUE cow 0 7
chicken
END
)r   s   chickenr    ©r,   r   ©r   r#   ÚgetMultipler%   s    r   Útest_getMultiplezCommandMixin.test_getMultiple6   s:   € ð
 �z‰zØ�J‰J×"Ñ" F¨FÐ#3Ó4ØØJØ$¨kÑ:ó	
ð 	
r   c                 óf   — | j                  | j                  j                  ddg«      dddddœ«      S )z‰
        When L{MemCacheProtocol.getMultiple} is called with non-available keys,
        the corresponding tuples are (0, None).
        r   r,   r-   s   VALUE cow 1 3
bar
END
)é   r!   r)   r.   r/   r%   s    r   Útest_getMultipleWithEmptyz&CommandMixin.test_getMultipleWithEmptyB   s:   € ð
 �z‰zØ�J‰J×"Ñ" F¨FÐ#3Ó4ØØ.Ø ¨)Ñ4ó	
ð 	
r   c                 ó^   — | j                  | j                  j                  dd«      ddd«      S )z†
        L{MemCacheProtocol.set} returns a L{Deferred} which is called back with
        C{True} when the operation succeeds.
        r   r!   s   set foo 0 0 3
bar
ó   STORED
T)r   r#   Úsetr%   s    r   Útest_setzCommandMixin.test_setN   ó0   € ð
 �z‰zØ�J‰J�N‰N˜6 6Ó*Ø'ØØó	
ð 	
r   c                 ó^   — | j                  | j                  j                  dd«      ddd«      S )z†
        L{MemCacheProtocol.add} returns a L{Deferred} which is called back with
        C{True} when the operation succeeds.
        r   r!   ó   add foo 0 0 3
bar
r6   T©r   r#   Úaddr%   s    r   Útest_addzCommandMixin.test_addZ   r9   r   c                 ó^   — | j                  | j                  j                  dd«      ddd«      S )zŠ
        L{MemCacheProtocol.replace} returns a L{Deferred} which is called back
        with C{True} when the operation succeeds.
        r   r!   ó   replace foo 0 0 3
bar
r6   T©r   r#   Úreplacer%   s    r   Útest_replacezCommandMixin.test_replacef   s2   € ð
 �z‰zØ�J‰J×Ñ˜v vÓ.Ø+ØØó	
ð 	
r   c                 ó^   — | j                  | j                  j                  dd«      ddd«      S )zæ
        Test an erroneous add: if a L{MemCacheProtocol.add} is called but the
        key already exists on the server, it returns a B{NOT STORED} answer,
        which calls back the resulting L{Deferred} with C{False}.
        r   r!   r;   ó   NOT STORED
Fr<   r%   s    r   Útest_errorAddzCommandMixin.test_errorAddr   s0   € ð �z‰zØ�J‰J�N‰N˜6 6Ó*Ø'ØØó	
ð 	
r   c                 ó^   — | j                  | j                  j                  dd«      ddd«      S )zí
        Test an erroneous replace: if a L{MemCacheProtocol.replace} is called
        but the key doesn't exist on the server, it returns a B{NOT STORED}
        answer, which calls back the resulting L{Deferred} with C{False}.
        r   r!   r@   rE   FrA   r%   s    r   Útest_errorReplacezCommandMixin.test_errorReplace   s2   € ð �z‰zØ�J‰J×Ñ˜v vÓ.Ø+ØØó	
ð 	
r   c                 ó\   — | j                  | j                  j                  d«      ddd«      S )z�
        L{MemCacheProtocol.delete} returns a L{Deferred} which is called back
        with C{True} when the server notifies a success.
        r!   ó   delete bar
s	   DELETED
T©r   r#   Údeleter%   s    r   Útest_deletezCommandMixin.test_deleteŒ   s.   € ð
 �z‰zØ�J‰J×Ñ˜fÓ%Ð'8¸.È$ó
ð 	
r   c                 ó\   — | j                  | j                  j                  d«      ddd«      S )z¿
        Test an error during a delete: if key doesn't exist on the server, it
        returns a B{NOT FOUND} answer which calls back the resulting
        L{Deferred} with C{False}.
        r!   rJ   s   NOT FOUND
FrK   r%   s    r   Útest_errorDeletezCommandMixin.test_errorDelete•   s/   € ð �z‰zØ�J‰J×Ñ˜fÓ%Ð'8Ð:JÈEó
ð 	
r   c                 ó\   — | j                  | j                  j                  d«      ddd«      S )zµ
        Test incrementing a variable: L{MemCacheProtocol.increment} returns a
        L{Deferred} which is called back with the incremented value of the
        given key.
        r   s   incr foo 1
ó   4
é   ©r   r#   Ú	incrementr%   s    r   Útest_incrementzCommandMixin.test_incrementŸ   ó*   € ð �z‰z˜$Ÿ*™*×.Ñ.¨vÓ6Ð8IÈ8ÐUVÓWÐWr   c                 ó\   — | j                  | j                  j                  d«      ddd«      S )zµ
        Test decrementing a variable: L{MemCacheProtocol.decrement} returns a
        L{Deferred} which is called back with the decremented value of the
        given key.
        r   s   decr foo 1
ó   5
é   ©r   r#   Ú	decrementr%   s    r   Útest_decrementzCommandMixin.test_decrement§   rV   r   c                 ó^   — | j                  | j                  j                  dd«      ddd«      S )z‘
        L{MemCacheProtocol.increment} takes an optional argument C{value} which
        replaces the default value of 1 when specified.
        r   é   s   incr foo 8
rQ   rR   rS   r%   s    r   Útest_incrementValzCommandMixin.test_incrementVal¯   ó0   € ð
 �z‰zØ�J‰J× Ñ  ¨Ó+Ð->ÀÈ!ó
ð 	
r   c                 ó^   — | j                  | j                  j                  dd«      ddd«      S )z‘
        L{MemCacheProtocol.decrement} takes an optional argument C{value} which
        replaces the default value of 1 when specified.
        r   é   s   decr foo 3
rX   rY   rZ   r%   s    r   Útest_decrementValzCommandMixin.test_decrementVal¸   r`   r   c                 ó`   — | j                  | j                  j                  «       dddddœ«      S )zë
        Test retrieving server statistics via the L{MemCacheProtocol.stats}
        command: it parses the data sent by the server and calls back the
        resulting L{Deferred} with a dictionary of the received statistics.
        s   stats
ó"   STAT foo bar
STAT egg spam
END
r!   ó   spam©r   ó   egg©r   r#   Ústatsr%   s    r   Ú
test_statszCommandMixin.test_statsÁ   s3   € ð �z‰zØ�J‰J×ÑÓØØ7Ø WÑ-ó	
ð 	
r   c                 ób   — | j                  | j                  j                  d«      dddddœ«      S )a9  
        L{MemCacheProtocol.stats} takes an optional C{bytes} argument which,
        if specified, is sent along with the I{STAT} command.  The I{STAT}
        responses from the server are parsed as key/value pairs and returned
        as a C{dict} (as in the case where the argument is not specified).
        s   blahs   stats blah
re   r!   rf   rg   ri   r%   s    r   Útest_statsWithArgumentz#CommandMixin.test_statsWithArgumentÎ   s5   € ð �z‰zØ�J‰J×Ñ˜WÓ%ØØ7Ø WÑ-ó	
ð 	
r   c                 óZ   — | j                  | j                  j                  «       ddd«      S )z¸
        Test version retrieval via the L{MemCacheProtocol.version} command: it
        returns a L{Deferred} which is called back with the version sent by the
        server.
        s	   version
s   VERSION 1.1
s   1.1)r   r#   Úversionr%   s    r   Útest_versionzCommandMixin.test_versionÜ   s,   € ð �z‰zØ�J‰J×ÑÓ  .Ð2DÀfó
ð 	
r   c                 óZ   — | j                  | j                  j                  «       ddd«      S )z’
        L{MemCacheProtocol.flushAll} returns a L{Deferred} which is called back
        with C{True} if the server acknowledges success.
        s   flush_all
s   OK
T)r   r#   ÚflushAllr%   s    r   Útest_flushAllzCommandMixin.test_flushAllæ   s'   € ð
 �z‰z˜$Ÿ*™*×-Ñ-Ó/Ð1AÀ9ÈdÓSÐSr   N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r&   r*   r1   r4   r8   r>   rC   rF   rH   rM   rO   rU   r\   r_   rc   rk   rm   rp   rs   © r   r   r   r      so   „ ñò$ò
òYò

ò

ò

ò

ò

ò
ò
ò
ò
òXòXò
ò
ò
ò
ò
óTr   r   c                   óÄ   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zd
„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z d„ Z!y )!ÚMemCacheTestsz9
    Test client protocol class L{MemCacheProtocol}.
    c                 ó(  — t        «       | _        t        «       | _        | j                  j                  | j                  _        t        «       | _        | j                  | j                  _        | j                  j                  | j                  «       y)z{
        Create a memcache client, connect it to a string protocol, and make it
        use a deterministic clock.
        N)	r   r#   r   ÚclockÚ	callLaterr	   Ú	transportÚprotocolÚmakeConnectionr%   s    r   ÚsetUpzMemCacheTests.setUpó   s]   € ô
 &Ó'ˆŒ
Ü“WˆŒ
Ø#Ÿz™z×3Ñ3ˆ�
‰
ÔÜ9Ó;ˆŒØ"&§*¡*ˆ�‰ÔØ�
‰
×!Ñ! $§.¡.Õ1r   c                 óÂ   ‡ ‡— ˆˆ fd„}‰ j                  ‰ j                  j                  «       |«       |j                  |«       ‰ j                  j                  |«       |S )aõ  
        Implementation of C{_test} which checks that the command sends C{send}
        data, and that upon reception of C{recv} the result is C{result}.

        @param d: the resulting deferred from the memcache command.
        @type d: C{Deferred}

        @param send: the expected data to be sent.
        @type send: C{bytes}

        @param recv: the data to simulate as reception.
        @type recv: C{bytes}

        @param result: the expected result.
        @type result: C{any}
        c                 ó*   •— ‰j                  | ‰«       y ©N)ÚassertEqual)Úresr   r   s    €€r   ÚcbzMemCacheTests._test.<locals>.cb  s   ø€ Ø×Ñ˜S &Õ)r   )r…   r~   ÚvalueÚaddCallbackr#   ÚdataReceived)r   r   r   r   r   r‡   s   `   ` r   r   zMemCacheTests._testÿ   sJ   ù€ õ$	*ð 	×Ñ˜Ÿ™×-Ñ-Ó/°Ô6Ø	�‰�bÔØ�
‰
×Ñ Ô%Øˆr   c                 ó�   — | j                   j                  d«       | j                  t        | j                   j                  d«       y)z¥
        If the value returned doesn't match the expected key of the current
        C{get} command, an error is raised in L{MemCacheProtocol.dataReceived}.
        r   s   VALUE bar 0 7
spamegg
END
N)r#   r$   ÚassertRaisesÚRuntimeErrorrŠ   r%   s    r   Útest_invalidGetResponsez%MemCacheTests.test_invalidGetResponse  s5   € ð
 	�
‰
�‰�vÔØ×ÑÜØ�J‰J×#Ñ#Ø2õ	
r   c                 ó”   — | j                   j                  ddg«       | j                  t        | j                   j                  d«       y)zÁ
        If the value returned doesn't match one the expected keys of the
        current multiple C{get} command, an error is raised error in
        L{MemCacheProtocol.dataReceived}.
        r   r!   s   VALUE egg 0 7
spamegg
END
N)r#   r0   rŒ   r�   rŠ   r%   s    r   Útest_invalidMultipleGetResponsez-MemCacheTests.test_invalidMultipleGetResponse%  s<   € ð 	�
‰
×Ñ ¨Ð/Ô0Ø×ÑÜØ�J‰J×#Ñ#Ø2õ	
r   c                 ó’   — | j                   j                  dd«       | j                  t        | j                   j                  d«       y)z´
        If an END is received in response to an operation that isn't C{get},
        C{gets}, or C{stats}, an error is raised in
        L{MemCacheProtocol.dataReceived}.
        s   keys   valuer(   N)r#   r7   rŒ   r�   rŠ   r%   s    r   Útest_invalidEndResponsez%MemCacheTests.test_invalidEndResponse2  s2   € ð 	�
‰
�‰�v˜xÔ(Ø×Ñœ,¨¯
©
×(?Ñ(?ÀÕLr   c                 óä  ‡ — ‰ j                   j                  d«      }‰ j                   j                  d«      }t        «       }|j                  ‰ j                   _        ‰ j
                  j                  ‰ j                   j                  «       ‰ j                  |t        «       ‰ j                  |t        «       ˆ fd„}|j                  |«       ‰ j                  |t        «       t        |||g«      S )z²
        Test the timeout on outgoing requests: when timeout is detected, all
        current commands fail with a L{TimeoutError}, and the connection is
        closed.
        r   r!   c                 ó<   •— ‰j                  t        | «      d«       y )NzConnection timeout)r…   Ústr)Úerrorr   s    €r   ÚcheckMessagez0MemCacheTests.test_timeOut.<locals>.checkMessageJ  s   ø€ Ø×ÑœS ›ZÐ)=Õ>r   )r#   r$   r   ÚcallbackÚconnectionLostr|   ÚadvanceÚpersistentTimeOutÚassertFailurer   r‰   r   r   )r   Úd1Úd2Úd3r—   s   `    r   Útest_timeOutzMemCacheTests.test_timeOut;  s°   ø€ ð �Z‰Z�^‰^˜FÓ#ˆØ�Z‰Z�^‰^˜FÓ#ˆÜ‹ZˆØ$&§K¡Kˆ�
‰
Ô!à�
‰
×Ñ˜4Ÿ:™:×7Ñ7Ô8Ø×Ñ˜2œ|Ô,Ø×Ñ˜2œ|Ô,ô	?ð 	�‰�|Ô$Ø×Ñ˜2œ~Ô.Ü˜b " b˜\Ó*Ð*r   c                 ó  ‡ — ‰ j                   j                  d«      }‰ j                  j                  ‰ j                   j                  dz
  «       ‰ j                   j                  d«       ˆ fd„}|j                  |«       |S )zY
        When a request gets a response, no pending timeout call remains around.
        r   r3   r   c                 óˆ   •— ‰j                  | d«       ‰j                  t        ‰j                  j                  «      d«       y )Nr    r   )r…   Úlenr|   Úcalls)r   r   s    €r   Úcheckz0MemCacheTests.test_timeoutRemoved.<locals>.checkZ  s2   ø€ Ø×Ñ˜V [Ô1Ø×ÑœS §¡×!1Ñ!1Ó2°AÕ6r   )r#   r$   r|   rš   r›   rŠ   r‰   )r   r   r¥   s   `  r   Útest_timeoutRemovedz!MemCacheTests.test_timeoutRemovedQ  sc   ø€ ð �J‰J�N‰N˜6Ó"ˆà�
‰
×Ñ˜4Ÿ:™:×7Ñ7¸!Ñ;Ô<Ø�
‰
×ÑÐ BÔCô	7ð 	
�‰�eÔØˆr   c                 óˆ  — | j                   j                  d«      }t        «       }|j                  | j                   _        | j                   j                  d«       | j                  j                  | j                   j                  «       | j                  |t        «       | j                  |t        «       t        ||g«      S )zÈ
        Test the timeout when raw mode was started: the timeout is not reset
        until all the data has been received, so we can have a L{TimeoutError}
        when waiting for raw data.
        r   s   VALUE foo 0 10
12345)r#   r$   r   r˜   r™   rŠ   r|   rš   r›   rœ   r   r   r   ©r   r�   rž   s      r   Útest_timeOutRawzMemCacheTests.test_timeOutRawa  s‹   € ð �Z‰Z�^‰^˜FÓ#ˆÜ‹ZˆØ$&§K¡Kˆ�
‰
Ô!à�
‰
×ÑÐ :Ô;Ø�
‰
×Ñ˜4Ÿ:™:×7Ñ7Ô8Ø×Ñ˜2œ|Ô,Ø×Ñ˜2œ~Ô.Ü˜b "˜XÓ&Ð&r   c                 ó†  — | j                   j                  «       }t        «       }|j                  | j                   _        | j                   j                  d«       | j                  j                  | j                   j                  «       | j                  |t        «       | j                  |t        «       t        ||g«      S )z†
        Test the timeout when stat command has started: the timeout is not
        reset until the final B{END} is received.
        s   STAT foo bar
)r#   rj   r   r˜   r™   rŠ   r|   rš   r›   rœ   r   r   r   r¨   s      r   Útest_timeOutStatzMemCacheTests.test_timeOutStatq  s‹   € ð
 �Z‰Z×ÑÓˆÜ‹ZˆØ$&§K¡Kˆ�
‰
Ô!à�
‰
×ÑÐ 3Ô4Ø�
‰
×Ñ˜4Ÿ:™:×7Ñ7Ô8Ø×Ñ˜2œ|Ô,Ø×Ñ˜2œ~Ô.Ü˜b "˜XÓ&Ð&r   c                 óÂ  ‡ ‡‡— ‰ j                   j                  d«      }‰ j                   j                  d«      Št        «       }|j                  ‰ j                   _        ‰ j
                  j                  ‰ j                   j                  dz
  «       ‰ j                   j                  d«       ˆˆˆ fd„}ˆ fd„Š|j                  |«       ‰ j                  |t        «       |S )zŒ
        When two requests are sent, a timeout call remains around for the
        second request, and its timeout time is correct.
        r   r!   r3   r   c                 óN  •— ‰j                  | d«       ‰j                  t        ‰j                  j                  «      d«       t	        ‰j
                  j                  «      D ]  }‰j                  j                  d«       Œ ‰j                  ‰t        «      j                  ‰«      S )Nr    r3   )r…   r£   r|   r¤   Úranger#   r›   rš   rœ   r   r‰   )r   ÚiÚ	checkTimerž   r   s     €€€r   r¥   z3MemCacheTests.test_timeoutPipelining.<locals>.check�  s€   ø€ Ø×Ñ˜V [Ô1Ø×ÑœS §¡×!1Ñ!1Ó2°AÔ6Ü˜4Ÿ:™:×7Ñ7Ó8ò &�Ø—
‘
×"Ñ" 1Õ%ð&à×%Ñ% b¬,Ó7×CÑCÀIÓNÐNr   c                 óŽ   •— ‰j                  ‰j                  j                  «       d‰j                  j                  z  dz
  «       y )Né   r3   )r…   r|   Úsecondsr#   r›   )Úignoredr   s    €r   r°   z7MemCacheTests.test_timeoutPipelining.<locals>.checkTime”  s7   ø€ ð ×Ñ˜TŸZ™Z×/Ñ/Ó1°1°t·z±z×7SÑ7SÑ3SÐVWÑ3WÕXr   )r#   r$   r   r˜   r™   r|   rš   r›   rŠ   r‰   rœ   r   )r   r�   rŸ   r¥   r°   rž   s   `   @@r   Útest_timeoutPipeliningz$MemCacheTests.test_timeoutPipelining€  s£   ú€ ð
 �Z‰Z�^‰^˜FÓ#ˆØ�Z‰Z�^‰^˜FÓ#ˆÜ‹ZˆØ$&§K¡Kˆ�
‰
Ô!à�
‰
×Ñ˜4Ÿ:™:×7Ñ7¸!Ñ;Ô<Ø�
‰
×ÑÐ BÔCö	Oô	Yð
 	�‰�uÔØ×Ñ˜2œ~Ô.Øˆ	r   c                 óò  — | j                   j                  d«      }t        «       }|j                  | j                   _        | j
                  j                  | j                   j                  dz
  «       | j                   j                  d«      }| j
                  j                  d«       | j                  |t        «       | j                  |t        «       | j                  |t        «       t        |||g«      S )z�
        Check that timeout is not resetted for every command, but keep the
        timeout from the first command without response.
        r   r3   r!   )r#   r$   r   r˜   r™   r|   rš   r›   rœ   r   r   r   )r   r�   rŸ   rž   s       r   Útest_timeoutNotResetz"MemCacheTests.test_timeoutNotReset�  s³   € ð
 �Z‰Z�^‰^˜FÓ#ˆÜ‹ZˆØ$&§K¡Kˆ�
‰
Ô!à�
‰
×Ñ˜4Ÿ:™:×7Ñ7¸!Ñ;Ô<Ø�Z‰Z�^‰^˜FÓ#ˆØ�
‰
×Ñ˜1ÔØ×Ñ˜2œ|Ô,Ø×Ñ˜2œ|Ô,Ø×Ñ˜2œ~Ô.Ü˜b " b˜\Ó*Ð*r   c                 ó>  — | j                   j                  d«      }| j                  j                  | j                   j                  «       | j                  |t        «       | j                   j                  d«      }| j                  |t        «       t        ||g«      S )a  
        C{timeoutConnection} cleans the list of commands that it fires with
        C{TimeoutError}: C{connectionLost} doesn't try to fire them again, but
        sets the disconnected state so that future commands fail with a
        C{RuntimeError}.
        r   r!   )	r#   r$   r|   rš   r›   rœ   r   r�   r   r¨   s      r   Útest_timeoutCleanDeferredsz(MemCacheTests.test_timeoutCleanDeferreds®  ss   € ð �Z‰Z�^‰^˜FÓ#ˆØ�
‰
×Ñ˜4Ÿ:™:×7Ñ7Ô8Ø×Ñ˜2œ|Ô,Ø�Z‰Z�^‰^˜FÓ#ˆØ×Ñ˜2œ|Ô,Ü˜b "˜XÓ&Ð&r   c                 óî   ‡ — ‰ j                   j                  d«      }‰ j                   j                  d«      }‰ j                  j                  «        t	        ||gd¬«      }ˆ fd„}|j                  |«      S )zl
        When disconnection occurs while commands are still outstanding, the
        commands fail.
        r   r!   T)ÚconsumeErrorsc                 óf   •— | D ]+  \  }}‰j                  |«       |j                  t        «       Œ- y r„   )ÚassertFalseÚtrapr   )ÚresultsÚsuccessr   r   s      €r   ÚcheckFailuresz8MemCacheTests.test_connectionLost.<locals>.checkFailuresÆ  s0   ø€ Ø#*ò ,‘�˜Ø× Ñ  Ô)Ø—‘œNÕ+ñ,r   )r#   r$   r~   ÚloseConnectionr   r‰   )r   r�   rž   ÚdonerÁ   s   `    r   Útest_connectionLostz!MemCacheTests.test_connectionLost¼  sa   ø€ ð
 �Z‰Z�^‰^˜FÓ#ˆØ�Z‰Z�^‰^˜FÓ#ˆØ�‰×%Ñ%Ô'Ü˜R ˜H°DÔ9ˆô	,ð
 ×Ñ Ó.Ð.r   c                 ób  — | j                  | j                  j                  dd«      t        «      }| j                  | j                  j	                  d«      t        «      }| j                  | j                  j                  d«      t        «      }| j                  | j                  j                  dd«      t        «      }| j                  | j                  j                  dd«      t        «      }| j                  | j                  j                  ddg«      t        «      }t        ||||||g«      S )z›
        An error is raised when trying to use a too long key: the called
        command returns a L{Deferred} which fails with a L{ClientError}.
        sô  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaar!   r   )
rœ   r#   r7   r
   rT   r$   ÚappendÚprependr0   r   )r   r�   rž   rŸ   Úd4Úd5Úd6s          r   Útest_tooLongKeyzMemCacheTests.test_tooLongKeyÍ  sî   € ð
 ×Ñ §
¡
§¡¨z¸6Ó BÄKÓPˆØ×Ñ §
¡
× 4Ñ 4°ZÓ @Ä+ÓNˆØ×Ñ §
¡
§¡¨zÓ :¼KÓHˆØ×Ñ §
¡
× 1Ñ 1°*¸fÓ EÄ{ÓSˆØ×Ñ §
¡
× 2Ñ 2°:¸vÓ FÌÓTˆØ×ÑØ�J‰J×"Ñ" F¨JÐ#7Ó8¼+ó
ˆô ˜b " b¨"¨b°"Ð5Ó6Ð6r   c                 óü   — | j                   j                  dddddd«      }| j                  | j                  j	                  «       d«       | j                  |t        «       | j                   j                  d«       |S )z¼
        When an unknown command is sent directly (not through public API), the
        server answers with an B{ERROR} token, and the command fails with
        L{NoSuchCommand}.
        rh   r   r!   r   r   s   egg foo 0 0 3
bar
s   ERROR
)r#   Ú_setr…   r~   rˆ   rœ   r   rŠ   ©r   r   s     r   Útest_invalidCommandz!MemCacheTests.test_invalidCommandÜ  se   € ð �J‰J�O‰O˜F F¨F°A°q¸#Ó>ˆØ×Ñ˜Ÿ™×-Ñ-Ó/Ð1LÔMØ×Ñ˜1œmÔ,Ø�
‰
×Ñ Ô-Øˆr   c                 ó&  ‡ — d}‰ j                   j                  d|«      }‰ j                  ‰ j                  j	                  «       d«       ‰ j                  |t        «       ˆ fd„}|j                  |«       ‰ j                   j                  d«       |S )zÖ
        Test the L{ClientError} error: when the server sends a B{CLIENT_ERROR}
        token, the originating command fails with L{ClientError}, and the error
        contains the text sent by the server.
        ó   eggspammr   ó   set foo 0 0 8
eggspamm
c                 óN   •— ‰j                  t        | «      t        d«      «       y )Ns   We don't like egg and spam©r…   r•   Úrepr©Úerrr   s    €r   r¥   z-MemCacheTests.test_clientError.<locals>.checkó  s   ø€ Ø×ÑœS ›X¤tÐ,IÓ'JÕKr   s)   CLIENT_ERROR We don't like egg and spam
)	r#   r7   r…   r~   rˆ   rœ   r
   r‰   rŠ   ©r   Úar   r¥   s   `   r   Útest_clientErrorzMemCacheTests.test_clientErrorè  sx   ø€ ð ˆØ�J‰J�N‰N˜6 1Ó%ˆØ×Ñ˜Ÿ™×-Ñ-Ó/Ð1QÔRØ×Ñ˜1œkÔ*ô	Lð 	
�‰�eÔØ�
‰
×ÑÐ NÔOØˆr   c                 ó&  ‡ — d}‰ j                   j                  d|«      }‰ j                  ‰ j                  j	                  «       d«       ‰ j                  |t        «       ˆ fd„}|j                  |«       ‰ j                   j                  d«       |S )zÖ
        Test the L{ServerError} error: when the server sends a B{SERVER_ERROR}
        token, the originating command fails with L{ServerError}, and the error
        contains the text sent by the server.
        rÑ   r   rÒ   c                 óN   •— ‰j                  t        | «      t        d«      «       y )Ns   zomgrÔ   rÖ   s    €r   r¥   z-MemCacheTests.test_serverError.<locals>.check  s   ø€ Ø×ÑœS ›X¤t¨G£}Õ5r   s   SERVER_ERROR zomg
)	r#   r7   r…   r~   rˆ   rœ   r   r‰   rŠ   rØ   s   `   r   Útest_serverErrorzMemCacheTests.test_serverErrorú  sw   ø€ ð ˆØ�J‰J�N‰N˜6 1Ó%ˆØ×Ñ˜Ÿ™×-Ñ-Ó/Ð1QÔRØ×Ñ˜1œkÔ*ô	6ð 	
�‰�eÔØ�
‰
×ÑÐ 8Ô9Øˆr   c           	      óÂ  — | j                  | j                  j                  dd«      t        «      }| j                  | j                  j	                  d«      t        «      }| j                  | j                  j                  d«      t        «      }| j                  | j                  j                  d«      t        «      }| j                  | j                  j                  dd«      t        «      }| j                  | j                  j                  dd«      t        «      }| j                  | j                  j                  ddg«      t        «      }t        |||||||g«      S )zQ
        Using a non-string key as argument to commands raises an error.
        Úfoor!   Úeggr3   Úbarrh   )rœ   r#   r7   r
   rT   r$   rL   rÆ   rÇ   r0   r   )r   r�   rž   rŸ   rÈ   rÉ   rÊ   Úd7s           r   Útest_unicodeKeyzMemCacheTests.test_unicodeKey  s  € ð ×Ñ §
¡
§¡¨u°fÓ =¼{ÓKˆØ×Ñ §
¡
× 4Ñ 4°UÓ ;¼[ÓIˆØ×Ñ §
¡
§¡¨qÓ 1´;Ó?ˆØ×Ñ §
¡
× 1Ñ 1°%Ó 8¼+ÓFˆØ×Ñ §
¡
× 1Ñ 1°%¸Ó @Ä+ÓNˆØ×Ñ §
¡
× 2Ñ 2°5¸&Ó AÄ;ÓOˆØ×Ñ §
¡
× 6Ñ 6¸À°{Ó CÄ[ÓQˆÜ˜b " b¨"¨b°"°bÐ9Ó:Ð:r   c                 ób   — | j                  | j                  j                  dd«      t        «      S )z;
        Using a non-string value raises an error.
        r   rá   )rœ   r#   r7   r
   r%   s    r   Útest_unicodeValuezMemCacheTests.test_unicodeValue  s&   € ð ×!Ñ! $§*¡*§.¡.°¸Ó"?ÄÓMÐMr   c                 óô  — | j                   j                  d«      }|j                  | j                  d«       | j                   j	                  dd«      }|j                  | j                  d«       | j                   j                  d«      }|j                  | j                  d«       | j                  | j
                  j                  «       d«       | j                   j                  d	«       t        |||g«      S )
z½
        Multiple requests can be sent subsequently to the server, and the
        protocol orders the responses correctly and dispatch to the
        corresponding client command.
        r   r    r!   s   spamspamspamTrh   )r   rf   s0   get foo
set bar 0 0 12
spamspamspam
get egg
s;   VALUE foo 0 3
bar
END
STORED
VALUE egg 0 4
spam
END
)	r#   r$   r‰   r…   r7   r~   rˆ   rŠ   r   )r   r�   rž   rŸ   s       r   Útest_pipeliningzMemCacheTests.test_pipelining  sÅ   € ð �Z‰Z�^‰^˜FÓ#ˆØ
�‰�t×'Ñ'¨Ô5Ø�Z‰Z�^‰^˜F OÓ4ˆØ
�‰�t×'Ñ'¨Ô.Ø�Z‰Z�^‰^˜FÓ#ˆØ
�‰�t×'Ñ'¨Ô6Ø×ÑØ�N‰N× Ñ Ó"ØGô	
ð 	�
‰
×Ñð0ô	
ô
 ˜b " b˜\Ó*Ð*r   c                 ó   — | j                   j                  d«      }|j                  | j                  d«       | j                  | j                  j                  «       d«       | j                   j                  d«       | j                   j                  d«       | j                   j                  d«       | j                   j                  d«       |S )z”
        If the value retrieved by a C{get} arrive in chunks, the protocol
        is able to reconstruct it and to produce the good value.
        r   )r   s
   0123456789r   s   VALUE foo 0 10
0123456s   789s   
ENDs   
)r#   r$   r‰   r…   r~   rˆ   rŠ   rÎ   s     r   Útest_getInChunkszMemCacheTests.test_getInChunks6  s–   € ð
 �J‰J�N‰N˜6Ó"ˆØ	�‰�d×&Ñ&Ð(:Ô;Ø×Ñ˜Ÿ™×-Ñ-Ó/°Ô@Ø�
‰
×ÑÐ <Ô=Ø�
‰
×Ñ Ô'Ø�
‰
×Ñ 
Ô+Ø�
‰
×Ñ Ô(Øˆr   c                 ó^   — | j                  | j                  j                  dd«      ddd«      S )zÃ
        L{MemCacheProtocol.append} behaves like a L{MemCacheProtocol.set}
        method: it returns a L{Deferred} which is called back with C{True} when
        the operation succeeds.
        r   r!   s   append foo 0 0 3
bar
r6   T)r   r#   rÆ   r%   s    r   Útest_appendzMemCacheTests.test_appendD  s2   € ð �z‰zØ�J‰J×Ñ˜f fÓ-Ø*ØØó	
ð 	
r   c                 ó^   — | j                  | j                  j                  dd«      ddd«      S )zÄ
        L{MemCacheProtocol.prepend} behaves like a L{MemCacheProtocol.set}
        method: it returns a L{Deferred} which is called back with C{True} when
        the operation succeeds.
        r   r!   s   prepend foo 0 0 3
bar
r6   T)r   r#   rÇ   r%   s    r   Útest_prependzMemCacheTests.test_prependQ  s2   € ð �z‰zØ�J‰J×Ñ˜v vÓ.Ø+ØØó	
ð 	
r   c                 ó^   — | j                  | j                  j                  dd«      ddd«      S )z©
        L{MemCacheProtocol.get} handles an additional cas result when
        C{withIdentifier} is C{True} and forward it in the resulting
        L{Deferred}.
        r   Tó
   gets foo
s   VALUE foo 0 3 1234
bar
END
)r   ó   1234r!   r"   r%   s    r   Ú	test_getszMemCacheTests.test_gets^  s0   € ð �z‰zØ�J‰J�N‰N˜6 4Ó(ØØ3Ø ó	
ð 	
r   c                 ó^   — | j                  | j                  j                  dd«      ddd«      S )z“
        Test getting a non-available key with gets: it succeeds but return
        L{None} as value, C{0} as flag and an empty cas value.
        r   Trï   r(   ©r   r   Nr"   r%   s    r   Útest_emptyGetszMemCacheTests.test_emptyGetsk  s-   € ð
 �z‰zØ�J‰J�N‰N˜6 4Ó(¨/¸:À~ó
ð 	
r   c                 óh   — | j                  | j                  j                  ddgd«      dddddœ«      S )	z‘
        L{MemCacheProtocol.getMultiple} handles an additional cas field in the
        returned tuples if C{withIdentifier} is C{True}.
        r   r!   Tó   gets foo bar
ó8   VALUE foo 0 3 1234
egg
VALUE bar 0 4 2345
spam
END
©r   s   2345rf   ©r   rð   rh   ©r!   r   r/   r%   s    r   Útest_getsMultiplezMemCacheTests.test_getsMultiplet  s=   € ð
 �z‰zØ�J‰J×"Ñ" F¨FÐ#3°TÓ:ØØUØ*Ð4HÑIó	
ð 	
r   c                 óz   — | j                  | j                  j                  t        ddg«      d«      dddddœ«      S )	zO
        L{MemCacheProtocol.getMultiple} accepts any iterable of keys.
        r   r!   Trö   r÷   rø   rù   rú   )r   r#   r0   Úiterr%   s    r   Útest_getsMultipleIterableKeysz+MemCacheTests.test_getsMultipleIterableKeys€  sB   € ð �z‰zØ�J‰J×"Ñ"¤4¨°Ð(8Ó#9¸4Ó@ØØUØ*Ð4HÑIó	
ð 	
r   c                 óh   — | j                  | j                  j                  ddgd«      dddddœ«      S )	a  
        When getting a non-available key with L{MemCacheProtocol.getMultiple}
        when C{withIdentifier} is C{True}, the other keys are retrieved
        correctly, and the non-available key gets a tuple of C{0} as flag,
        L{None} as value, and an empty cas value.
        r   r!   Trö   s   VALUE foo 0 3 1234
egg
END
ró   rù   rú   r/   r%   s    r   Útest_getsMultipleWithEmptyz(MemCacheTests.test_getsMultipleWithEmpty‹  s=   € ð �z‰zØ�J‰J×"Ñ" F¨FÐ#3°TÓ:ØØ3Ø#Ð-AÑBó	
ð 	
r   c                 ób   — | j                  | j                  j                  ddd¬«      ddd«      S )z�
        L{MemCacheProtocol.checkAndSet} passes an additional cas identifier
        that the server handles to check if the data has to be updated.
        r   r!   rð   ©Úcasó   cas foo 0 0 3 1234
bar
r6   T©r   r#   ÚcheckAndSetr%   s    r   Útest_checkAndSetzMemCacheTests.test_checkAndSet™  s7   € ð
 �z‰zØ�J‰J×"Ñ" 6¨6°wÐ"Ó?Ø,ØØó	
ð 	
r   c                 ób   — | j                  | j                  j                  ddd¬«      ddd«      S )z„
        When L{MemCacheProtocol.checkAndSet} response is C{EXISTS}, the
        resulting L{Deferred} fires with C{False}.
        r   r!   rð   r  r  s   EXISTS
Fr  r%   s    r   Útest_casUnknowKeyzMemCacheTests.test_casUnknowKey¥  s7   € ð
 �z‰zØ�J‰J×"Ñ" 6¨6°wÐ"Ó?Ø,ØØó	
ð 	
r   N)"rt   ru   rv   rw   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	  rx   r   r   rz   rz   î   sŸ   „ ñò
2òò4

ò
òMò+ò,ò 'ò 'òò:+ò"'ò/ò"7ò
òò$ò$;òNò+ò.ò
ò
ò
ò
ò

ò	
ò
ò

ó

r   rz   c                   ó   — e Zd ZdZd„ Zd„ Zy)ÚCommandFailureTestszZ
    Tests for correct failure of commands on a disconnected
    L{MemCacheProtocol}.
    c                 ó\  — t        «       | _        t        «       | _        | j                  j                  | j                  _        t        «       | _        | j                  | j                  _        | j                  j                  | j                  «       | j                  j                  «        y)zU
        Create a disconnected memcache client, using a deterministic clock.
        N)
r   r#   r   r|   r}   r	   r~   r   r€   rÂ   r%   s    r   r�   zCommandFailureTests.setUp¸  sm   € ô &Ó'ˆŒ
Ü“WˆŒ
Ø#Ÿz™z×3Ñ3ˆ�
‰
ÔÜ9Ó;ˆŒØ"&§*¡*ˆ�‰ÔØ�
‰
×!Ñ! $§.¡.Ô1Ø�‰×%Ñ%Õ'r   c                 ó.   — | j                  |t        «      S )zÈ
        Implementation of C{_test} which checks that the command fails with
        C{RuntimeError} because the transport is disconnected. All the
        parameters except C{d} are ignored.
        )rœ   r�   r   s        r   r   zCommandFailureTests._testÄ  s   € ð ×!Ñ! !¤\Ó2Ð2r   N)rt   ru   rv   rw   r�   r   rx   r   r   r  r  ²  s   „ ñò

(ó3r   r  N)rw   Útwisted.internet.deferr   r   r   r   Útwisted.internet.errorr   Útwisted.internet.taskr   Útwisted.internet.testingr	   Útwisted.protocols.memcacher
   r   r   r   Útwisted.trial.unittestr   r   rz   r  rx   r   r   ú<module>r     sY   ðñ÷
 WÓ VÝ 1Ý 'Ý E÷ó õ ,÷UTñ UTôpA
�L (ô A
ôH3˜,¨õ 3r   