\dbdZddlmZmZmZmZddlmZddlm Z ddl m Z m Z m Z mZddlmZddlmZGdd ZGd d eeZGd d eeZdS)z$ Test the memcache client protocol. )Deferred DeferredList TimeoutError gatherResults)ConnectionDone)Clock) ClientErrorMemCacheProtocol NoSuchCommand ServerError) StringTransportWithDisconnection)TestCaseceZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdZdZdS) CommandMixinzO Setup and tests for basic invocation of L{MemCacheProtocol} commands. ct)zp Helper test method to test the resulting C{Deferred} of a L{MemCacheProtocol} command. )NotImplementedErrorselfdsendrecvresults :lib/python3.11/site-packages/twisted/test/test_memcache.py_testzCommandMixin._tests "###cb||jddddS)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 rbarrprotogetrs rtest_getzCommandMixin.test_get"s4 zz JNN6 " "  .     rcb||jddddS)zu Test getting a non-available key: it succeeds but return L{None} as value and C{0} as flag. rrEND rNr"r%s r test_emptyGetzCommandMixin.test_emptyGet/s* zz$*..00.*iXXXrcl||jddgdddddS)z L{MemCacheProtocol.getMultiple} returns a L{Deferred} which is called back with a dictionary of flag, value for each given key. rcow get foo cow s1VALUE foo 0 3 bar VALUE cow 0 7 chicken END )rschickenr r,rrr# getMultipler%s rtest_getMultiplezCommandMixin.test_getMultiple6sC zz J " "FF#3 4 4  J$k : :    rcl||jddgdddddS)z When L{MemCacheProtocol.getMultiple} is called with non-available keys, the corresponding tuples are (0, None). rr,r-sVALUE cow 1 3 bar END )r!r)r.r/r%s rtest_getMultipleWithEmptyz&CommandMixin.test_getMultipleWithEmptyBsC zz J " "FF#3 4 4  . ) 4 4    rcd||jdddddS)z L{MemCacheProtocol.set} returns a L{Deferred} which is called back with C{True} when the operation succeeds. rr!sset foo 0 0 3 bar STORED T)rr#setr%s rtest_setzCommandMixin.test_setN6 zz JNN66 * * '      rcd||jdddddS)z L{MemCacheProtocol.add} returns a L{Deferred} which is called back with C{True} when the operation succeeds. rr!add foo 0 0 3 bar r6Trr#addr%s rtest_addzCommandMixin.test_addZr9rcd||jdddddS)z L{MemCacheProtocol.replace} returns a L{Deferred} which is called back with C{True} when the operation succeeds. rr!replace foo 0 0 3 bar r6Trr#replacer%s r test_replacezCommandMixin.test_replacefs8 zz J  vv . . +      rcd||jdddddS)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}. rr!r; NOT STORED Fr<r%s r test_errorAddzCommandMixin.test_errorAddrs6 zz JNN66 * * '      rcd||jdddddS)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}. rr!r@rEFrAr%s rtest_errorReplacezCommandMixin.test_errorReplaces8 zz J  vv . . +      rcb||jddddS)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 Trr#deleter%s r test_deletezCommandMixin.test_deletes4 zz J  f % %'8.$   rcb||jddddS)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!rJs NOT FOUND FrKr%s rtest_errorDeletezCommandMixin.test_errorDeletes5 zz J  f % %'8:JE   rcb||jddddS)z Test incrementing a variable: L{MemCacheProtocol.increment} returns a L{Deferred} which is called back with the incremented value of the given key. rs incr foo 1 4 rr# incrementr%s rtest_incrementzCommandMixin.test_increment. zz$*..v668I8UVWWWrcb||jddddS)z Test decrementing a variable: L{MemCacheProtocol.decrement} returns a L{Deferred} which is called back with the decremented value of the given key. rs decr foo 1 5 rr# decrementr%s rtest_decrementzCommandMixin.test_decrementrVrcd||jdddddS)z L{MemCacheProtocol.increment} takes an optional argument C{value} which replaces the default value of 1 when specified. rs incr foo 8 rQrRrSr%s rtest_incrementValzCommandMixin.test_incrementVal6 zz J  + +->!   rcd||jdddddS)z L{MemCacheProtocol.decrement} takes an optional argument C{value} which replaces the default value of 1 when specified. rs decr foo 3 rXrYrZr%s rtest_decrementValzCommandMixin.test_decrementValr`rcf||jdddddS)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. sstats "STAT foo bar STAT egg spam END r!spamreggrr#statsr%s r test_statszCommandMixin.test_statss< zz J      7W - -    rch||jddddddS)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). sblahs stats blah rer!rfrgrir%s rtest_statsWithArgumentz#CommandMixin.test_statsWithArguments>zz J  W % %  7W - -    rc`||jdddS)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 s1.1)rr#versionr%s r test_versionzCommandMixin.test_versions2 zz J   .2Df   rc`||jdddS)z L{MemCacheProtocol.flushAll} returns a L{Deferred} which is called back with C{True} if the server acknowledges success. s flush_all sOK T)rr#flushAllr%s r test_flushAllzCommandMixin.test_flushAlls+ zz$*--//1A9dSSSrN)__name__ __module__ __qualname____doc__rr&r*r1r4r8r>rCrFrHrMrOrUr\r_rcrkrmrprsrrrrsX$$$    YYY                                  XXXXXX                 TTTTTrrceZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!d S)! MemCacheTestsz9 Test client protocol class L{MemCacheProtocol}. ct|_t|_|jj|j_t |_|j|j_|j|jdS)z{ Create a memcache client, connect it to a string protocol, and make it use a deterministic clock. N) r r#rclock callLaterr transportprotocolmakeConnectionr%s rsetUpzMemCacheTests.setUpsb &'' WW #z3 9;;"&* !!$.11111rcfd}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} c4|dSN) assertEqual)resrrs rcbzMemCacheTests._test..cbs   S& ) ) ) ) )r)rr~value addCallbackr# dataReceived)rrrrrrs` ` rrzMemCacheTests._testsu$ * * * * * * --//666 b %%%rc|jd|t|jjddS)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}. rsVALUE bar 0 7 spamegg END N)r#r$ assertRaises RuntimeErrorrr%s rtest_invalidGetResponsez%MemCacheTests.test_invalidGetResponsesH v   J # 2     rc|jddg|t|jjddS)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}. rr!sVALUE egg 0 7 spamegg END N)r#r0rrrr%s rtest_invalidMultipleGetResponsez-MemCacheTests.test_invalidMultipleGetResponse%sO /000   J # 2     rc|jdd|t|jjddS)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}. skeysvaluer(N)r#r7rrrr%s rtest_invalidEndResponsez%MemCacheTests.test_invalidEndResponse2s= vx((( , (?LLLLLrcjd}jd}t}|jj_jjj|t|tfd}| ||tt|||gS)z Test the timeout on outgoing requests: when timeout is detected, all current commands fail with a L{TimeoutError}, and the connection is closed. rr!cNt|ddS)NzConnection timeout)rstr)errorrs r checkMessagez0MemCacheTests.test_timeOut..checkMessageJs&   SZZ)= > > > > >r) r#r$rcallbackconnectionLostr|advancepersistentTimeOut assertFailurerrrr)rd1d2d3rs` r test_timeOutzMemCacheTests.test_timeOut;s Z^^F # # Z^^F # # ZZ$&K ! 4:7888 2|,,, 2|,,, ? ? ? ? ? |$$$ 2~...b"b\***rcjd}jjjdz jdfd}|||S)zY When a request gets a response, no pending timeout call remains around. rr3rc|dtjjddS)Nr r)rlenr|calls)rrs rcheckz0MemCacheTests.test_timeoutRemoved..checkZsB   V[ 1 1 1   S!122A 6 6 6 6 6r)r#r$r|rrrr)rrrs` rtest_timeoutRemovedz!MemCacheTests.test_timeoutRemovedQs JNN6 " " 4:7!;<<<  BCCC 7 7 7 7 7 erc~|jd}t}|j|j_|jd|j|jj| |t| |tt||gS)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. rsVALUE foo 0 10 12345) r#r$rrrrr|rrrrrrrrrs rtest_timeOutRawzMemCacheTests.test_timeOutRawas Z^^F # # ZZ$&K !  :;;; 4:7888 2|,,, 2~...b"X&&&rc||j}t}|j|j_|jd|j|jj| |t| |tt||gS)z Test the timeout when stat command has started: the timeout is not reset until the final B{END} is received. sSTAT foo bar ) r#rjrrrrr|rrrrrrrs rtest_timeOutStatzMemCacheTests.test_timeOutStatqs Z     ZZ$&K !  3444 4:7888 2|,,, 2~...b"X&&&rcjd}jdt}|jj_jjjdz jdfd}fd| | |t|S)z When two requests are sent, a timeout call remains around for the second request, and its timeout time is correct. rr!r3rcR|dtjjdt jjD]}jdt S)Nr r3) rrr|rranger#rrrrr)ri checkTimerrs rrz3MemCacheTests.test_timeoutPipelining..checks   V[ 1 1 1   S!122A 6 6 64:788 & & ""1%%%%%%b,77CCINN Nrcjdjjzdz dS)Nr3)rr|secondsr#r)ignoredrs rrz7MemCacheTests.test_timeoutPipelining..checkTimes?   TZ//111tz7S3SVW3W X X X X Xr) r#r$rrrr|rrrrrr)rrrrrrs` @@rtest_timeoutPipeliningz$MemCacheTests.test_timeoutPipelinings Z^^F # # Z^^F # # ZZ$&K ! 4:7!;<<<  BCCC O O O O O O O Y Y Y Y Y u 2~... rc|jd}t}|j|j_|j|jjdz |jd}|jd||t||t||tt|||gS)z Check that timeout is not resetted for every command, but keep the timeout from the first command without response. rr3r!) r#r$rrrr|rrrrrr)rrrrs rtest_timeoutNotResetz"MemCacheTests.test_timeoutNotResets Z^^F # # ZZ$&K ! 4:7!;<<< Z^^F # # 1 2|,,, 2|,,, 2~...b"b\***rc@|jd}|j|jj||t |jd}||tt||gS)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}. rr!) r#r$r|rrrrrrrs rtest_timeoutCleanDeferredsz(MemCacheTests.test_timeoutCleanDeferredssZ^^F # # 4:7888 2|,,, Z^^F # # 2|,,,b"X&&&rcjd}jd}jt ||gd}fd}||S)zl When disconnection occurs while commands are still outstanding, the commands fail. rr!T) consumeErrorscv|D]4\}}||t5dSr) assertFalsetrapr)resultssuccessrrs r checkFailuresz8MemCacheTests.test_connectionLost..checkFailuressI#* , ,  ))) N++++ , ,r)r#r$r~loseConnectionrr)rrrdoners` rtest_connectionLostz!MemCacheTests.test_connectionLosts Z^^F # # Z^^F # # %%'''RHD999 , , , , ,  ...rc||jddt}||jdt}||jdt}||jddt}||jddt}||jddgt}t||||||gS)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}. saaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaar!r) rr#r7r rTr$appendprependr0r)rrrrd4d5d6s rtest_tooLongKeyzMemCacheTests.test_tooLongKeys     z6 B BK P P    4 4Z @ @+ N N    z : :K H H    1 1*f E E{ S S    2 2:v F F T T    J " "FJ#7 8 8+  b"b"b"5666rc|jdddddd}||jd||t |jd|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}. rhrr!rrsegg foo 0 0 3 bar sERROR )r#_setrr~rrr rrrs rtest_invalidCommandz!MemCacheTests.test_invalidCommandsw JOOFFFAq# > > --//1LMMM 1m,,,  ---rc:d}jd|}jd|t fd}||jd|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. eggspammrset foo 0 0 8 eggspamm cht|tddS)NsWe don't like egg and spamrrreprerrrs rrz-MemCacheTests.test_clientError..checks.   SXXt,I'J'J K K K K Krs)CLIENT_ERROR We don't like egg and spam ) r#r7rr~rrr rrrarrs` rtest_clientErrorzMemCacheTests.test_clientErrors  JNN61 % % --//1QRRR 1k*** L L L L L e  NOOOrc:d}jd|}jd|t fd}||jd|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. rrrcht|tddS)Nszomgrrs rrz-MemCacheTests.test_serverError..checks+   SXXtG}} 5 5 5 5 5rsSERVER_ERROR zomg ) r#r7rr~rrr rrrs` rtest_serverErrorzMemCacheTests.test_serverErrors  JNN61 % % --//1QRRR 1k*** 6 6 6 6 6 e  8999rc ||jddt}||jdt}||jdt}||jdt}||jddt}||jddt}||j ddgt}t|||||||gS)zQ Using a non-string key as argument to commands raises an error. foor!eggr3barrh) rr#r7r rTr$rLrrr0r)rrrrrrrd7s rtest_unicodeKeyzMemCacheTests.test_unicodeKey s*   uf = ={ K K    4 4U ; ;[ I I    q 1 1; ? ?    1 1% 8 8+ F F    1 1% @ @+ N N    2 25& A A; O O    6 6{ C C[ Q Qb"b"b"b9:::rcj||jddtS)z; Using a non-string value raises an error. rr)rr#r7r r%s rtest_unicodeValuezMemCacheTests.test_unicodeValues*!!$*.."?"?MMMrc|jd}||jd|jdd}||jd|jd}||jd||jd|jd t|||gS) z Multiple requests can be sent subsequently to the server, and the protocol orders the responses correctly and dispatch to the corresponding client command. rr r!s spamspamspamTrh)rrfs0get 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$rrr7r~rrr)rrrrs rtest_pipeliningzMemCacheTests.test_pipelinings Z^^F # # t'555 Z^^FO 4 4 t'... Z^^F # # t'666  N " " G     0   b"b\***rc|jd}||jd||jd|jd|jd|jd|jd|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)rs 0123456789rsVALUE foo 0 10 0123456s789s ENDs )r#r$rrr~rrrs rtest_getInChunkszMemCacheTests.test_getInChunks6s JNN6 " " d&(:;;; --//@@@  <=== '''  +++ (((rcd||jdddddS)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. rr!sappend foo 0 0 3 bar r6T)rr#rr%s r test_appendzMemCacheTests.test_appendDs8 zz J  ff - - *      rcd||jdddddS)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. rr!sprepend foo 0 0 3 bar r6T)rr#rr%s r test_prependzMemCacheTests.test_prependQs8 zz J  vv . . +      rcd||jdddddS)z L{MemCacheProtocol.get} handles an additional cas result when C{withIdentifier} is C{True} and forward it in the resulting L{Deferred}. rT gets foo sVALUE foo 0 3 1234 bar END )r1234r!r"r%s r test_getszMemCacheTests.test_gets^s6 zz JNN64 ( (  3    rcd||jdddddS)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. rTrr(rrNr"r%s rtest_emptyGetszMemCacheTests.test_emptyGetsks3 zz JNN64 ( (/:~   rcn||jddgddddddS) z L{MemCacheProtocol.getMultiple} handles an additional cas field in the returned tuples if C{withIdentifier} is C{True}. rr!Tgets foo bar 8VALUE foo 0 3 1234 egg VALUE bar 0 4 2345 spam END rs2345rfrrrhr!rr/r%s rtest_getsMultiplezMemCacheTests.test_getsMultipletsF zz J " "FF#3T : :  U*4H I I    rc||jtddgddddddS) zO L{MemCacheProtocol.getMultiple} accepts any iterable of keys. rr!Trrrrr)rr#r0iterr%s rtest_getsMultipleIterableKeysz+MemCacheTests.test_getsMultipleIterableKeyssNzz J " "4(8#9#94 @ @  U*4H I I    rcn||jddgddddddS) 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. rr!TrsVALUE foo 0 3 1234 egg END rrrr/r%s rtest_getsMultipleWithEmptyz(MemCacheTests.test_getsMultipleWithEmptysFzz J " "FF#3T : :  3#-A B B    rch||jddddddS)z L{MemCacheProtocol.checkAndSet} passes an additional cas identifier that the server handles to check if the data has to be updated. rr!rcascas foo 0 0 3 1234 bar r6Trr# checkAndSetr%s rtest_checkAndSetzMemCacheTests.test_checkAndSets= zz J " "66w " ? ? ,      rch||jddddddS)z When L{MemCacheProtocol.checkAndSet} response is C{EXISTS}, the resulting L{Deferred} fires with C{False}. rr!rrrsEXISTS Frr%s rtest_casUnknowKeyzMemCacheTests.test_casUnknowKeys= zz J " "66w " ? ? ,      rN)"rtrurvrwrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rxrrrzrzs 2 2 24        MMM+++, ''' ' ' ':+++" ' ' '///" 7 7 7   $$ ; ; ;NNN +++.                                        rrzceZdZdZdZdZdS)CommandFailureTestszZ Tests for correct failure of commands on a disconnected L{MemCacheProtocol}. c6t|_t|_|jj|j_t |_|j|j_|j|j|j dS)zU Create a disconnected memcache client, using a deterministic clock. N) r r#rr|r}r r~rrrr%s rrzCommandFailureTests.setUpsv&'' WW #z3 9;;"&* !!$.111 %%'''''rc8||tS)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. )rrrs rrzCommandFailureTests._tests !!!\222rN)rtrurvrwrrrxrrr r s< ( ( (33333rr N)rwtwisted.internet.deferrrrrtwisted.internet.errorrtwisted.internet.taskrtwisted.protocols.memcacher r r r twisted.test.proto_helpersr twisted.trial.unittestrrrzr rxrrrsa WVVVVVVVVVVV111111'''''' HGGGGG++++++UTUTUTUTUTUTUTUTpA A A A A L(A A A H33333,33333r