כhbSrSSKJrJrJrJr SSKJr SSKJ r SSK J r SSK J r JrJrJr SSKJr "SS 5r"S S \\5r"S S \\5rg)z$ Test the memcache client protocol. )Deferred DeferredList TimeoutError gatherResults)ConnectionDone)Clock) StringTransportWithDisconnection) ClientErrorMemCacheProtocol NoSuchCommand ServerError)TestCasec\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrSrSrSrSrg) CommandMixinzG Setup and tests for basic invocation of L{MemCacheProtocol} commands. c[5e)zX Helper test method to test the resulting C{Deferred} of a L{MemCacheProtocol} command. )NotImplementedErrorselfdsendrecvresults ^C:\Users\psant\Downloads\Noiseback\school\venv\Lib\site-packages\twisted/test/test_memcache.py_testCommandMixin._tests "##c\URURRS5SSS5$)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_getCommandMixin.test_get"s. zz JJNN6 "  .    rc\URURRS5SSS5$)z] Test getting a non-available key: it succeeds but return L{None} as value and C{0} as flag. rr END rNr$r's r test_emptyGetCommandMixin.test_emptyGet/s& zz$**..0.*iXXrcfURURRSS/5SSSSS.5$)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"r0rrr% getMultipler's rtest_getMultipleCommandMixin.test_getMultiple6s: zz JJ " "FF#3 4  J$k :   rcfURURRSS/5SSSSS.5$)zq When L{MemCacheProtocol.getMultiple} is called with non-available keys, the corresponding tuples are (0, None). rr0r1sVALUE cow 1 3 bar END )r#r,r2r3r's rtest_getMultipleWithEmpty&CommandMixin.test_getMultipleWithEmptyBs: zz JJ " "FF#3 4  . ) 4   rc^URURRSS5SSS5$)zn 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_setCommandMixin.test_setN0 zz JJNN66 * '     rc^URURRSS5SSS5$)zn 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 r<Trr%addr's rtest_addCommandMixin.test_addZr@rc^URURRSS5SSS5$)zr 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 r<Trr%replacer's r test_replaceCommandMixin.test_replacefs2 zz JJ  vv . +     rc^URURRSS5SSS5$)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#rB NOT STORED FrCr's r test_errorAddCommandMixin.test_errorAddrs0 zz JJNN66 * '     rc^URURRSS5SSS5$)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#rHrNFrIr's rtest_errorReplaceCommandMixin.test_errorReplaces2 zz JJ  vv . +     rc\URURRS5SSS5$)zx 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_deleteCommandMixin.test_deletes. zz JJ  f %'8.$  rc\URURRS5SSS5$)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#rUs NOT FOUND FrVr's rtest_errorDeleteCommandMixin.test_errorDeletes/ zz JJ  f %'8:JE  rc\URURRS5SSS5$)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_incrementCommandMixin.test_increment* zz$**..v68I8UVWWrc\URURRS5SSS5$)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_decrementCommandMixin.test_decrementrdrc^URURRSS5SSS5$)zy L{MemCacheProtocol.increment} takes an optional argument C{value} which replaces the default value of 1 when specified. rs incr foo 8 r^r_r`r's rtest_incrementValCommandMixin.test_incrementVal0 zz JJ  +->!  rc^URURRSS5SSS5$)zy L{MemCacheProtocol.decrement} takes an optional argument C{value} which replaces the default value of 1 when specified. rs decr foo 3 rfrgrhr's rtest_decrementValCommandMixin.test_decrementValrprc`URURR5SSSSS.5$)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_statsCommandMixin.test_statss3 zz JJ     7W -   rcbURURRS5SSSSS.5$)a 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 rvr#rwrxrzr's rtest_statsWithArgument#CommandMixin.test_statsWithArguments5zz JJ  W %  7W -   rcZURURR5SSS5$)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_versionCommandMixin.test_versions, zz JJ   .2Df  rcZURURR5SSS5$)zz 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_flushAllCommandMixin.test_flushAlls' zz$**--/1A9dSSrN)__name__ __module__ __qualname____firstlineno____doc__rr(r-r5r9r>rErKrOrRrXr[rbrjrnrsr|rrr__static_attributes__rrrrrso$  Y                XX       Trrc\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSr Sr!S r"S!r#g")# MemCacheTestsz1 Test client protocol class L{MemCacheProtocol}. c([5Ul[5UlURRURl[ 5UlURUR lURRUR 5 g)zc Create a memcache client, connect it to a string protocol, and make it use a deterministic clock. N) r r%rclock callLaterr transportprotocolmakeConnectionr's rsetUpMemCacheTests.setUps] &' W #zz33 9;"&** !!$..1rc^^UU4SjnTRTRR5U5 URU5 TRR U5 U$)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*>TRUT5 gN) assertEqual)resrrs rcbMemCacheTests._test..cbs   S& )r)rrvalue addCallbackr% dataReceived)rrrrrrs` ` rrMemCacheTests._testsJ$ * --/6 b %rcURRS5 UR[URRS5 g)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_invalidGetResponse%MemCacheTests.test_invalidGetResponses5 v   JJ # # 2 rcURRSS/5 UR[URRS5 g)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%r4rrrr's rtest_invalidMultipleGetResponse-MemCacheTests.test_invalidMultipleGetResponse%s< /0   JJ # # 2 rcURRSS5 UR[URRS5 g)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%r=rrrr's rtest_invalidEndResponse%MemCacheTests.test_invalidEndResponse2s2 vx( , (?(?Lrc^TRRS5nTRRS5n[5nURTRlTR R TRR5 TRU[5 TRU[5 U4SjnURU5 TRU[5 [XU/5$)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#c<>TR[U5S5 g)NzConnection timeout)rstr)errorrs r checkMessage0MemCacheTests.test_timeOut..checkMessageJs   SZ)= >r) r%r&rcallbackconnectionLostradvancepersistentTimeOut assertFailurerrrr)rd1d2d3rs` r test_timeOutMemCacheTests.test_timeOut;s ZZ^^F # ZZ^^F # Z$&KK ! 4::778 2|, 2|, ? |$ 2~.bb\**rc^TRRS5nTRRTRRS- 5 TRR S5 U4SjnUR U5 U$)zI When a request gets a response, no pending timeout call remains around. rr8r!c>TRUS5 TR[TRR5S5 g)Nr"r)rlenrcalls)rrs rcheck0MemCacheTests.test_timeoutRemoved..checkZs2   V[ 1   S!1!12A 6r)r%r&rrrrr)rrrs` rtest_timeoutRemoved!MemCacheTests.test_timeoutRemovedQsc JJNN6 " 4::77!;<  BC 7 ercURRS5n[5nURURlURR S5 UR RURR5 URU[5 URU[5 [X/5$)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&rrrrrrrrrrrrrrs rtest_timeOutRawMemCacheTests.test_timeOutRawas ZZ^^F # Z$&KK !  :; 4::778 2|, 2~.bX&&rcURR5n[5nURURlURR S5 UR RURR5 URU[5 URU[5 [X/5$)zn Test the timeout when stat command has started: the timeout is not reset until the final B{END} is received. sSTAT foo bar ) r%r{rrrrrrrrrrrrs rtest_timeOutStatMemCacheTests.test_timeOutStatqs ZZ    Z$&KK !  34 4::778 2|, 2~.bX&&rc^^^TRRS5nTRRS5m[5nURTRlTR R TRRS- 5 TRRS5 UUU4SjnU4SjmURU5 TRU[5 U$)zt When two requests are sent, a timeout call remains around for the second request, and its timeout time is correct. rr#r8r!cR>TRUS5 TR[TRR5S5 [ TR R 5HnTRRS5 M TRT[5RT5$)Nr"r8) rrrrranger%rrrrr)ri checkTimerrs rr3MemCacheTests.test_timeoutPipelining..checks{   V[ 1   S!1!12A 64::778 ""1%9%%b,7CCIN Nrc>TRTRR5STRR-S- 5 g)Nr8)rrsecondsr%r)ignoredrs rr7MemCacheTests.test_timeoutPipelining..checkTimes7   TZZ//11tzz7S7S3SVW3W Xr) r%r&rrrrrrrrrr)rrrrrrs` @@rtest_timeoutPipelining$MemCacheTests.test_timeoutPipelinings ZZ^^F # ZZ^^F # Z$&KK ! 4::77!;<  BC O Y u 2~. rcURRS5n[5nURURlUR R URRS- 5 URRS5nUR R S5 URU[5 URU[5 URU[5 [XU/5$)zu Check that timeout is not resetted for every command, but keep the timeout from the first command without response. rr8r#) r%r&rrrrrrrrrr)rrrrs rtest_timeoutNotReset"MemCacheTests.test_timeoutNotResets ZZ^^F # Z$&KK ! 4::77!;< ZZ^^F # 1 2|, 2|, 2~.bb\**rc<URRS5nURRURR5 UR U[ 5 URRS5nUR U[5 [X/5$)z 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&rrrrrrrrs rtest_timeoutCleanDeferreds(MemCacheTests.test_timeoutCleanDeferredssqZZ^^F # 4::778 2|, ZZ^^F # 2|,bX&&rc^TRRS5nTRRS5nTRR5 [ X/SS9nU4SjnUR U5$)zT When disconnection occurs while commands are still outstanding, the commands fail. rr#T) consumeErrorsch>UH+upTRU5 UR[5 M- gr) assertFalsetrapr)resultssuccessrrs r checkFailures8MemCacheTests.test_connectionLost..checkFailuress)#*  ) N+$+r)r%r&rloseConnectionrr)rrrdoners` rtest_connectionLost!MemCacheTests.test_connectionLosts_ ZZ^^F # ZZ^^F # %%'RHD9 ,  ..rc\URURRSS5[5nURURR S5[5nURURR S5[5nURURR SS5[5nURURRSS5[5nURURRSS/5[5n[XX4XV/5$)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%r=r rar&appendprependr4r)rrrrd4d5d6s rtest_tooLongKeyMemCacheTests.test_tooLongKeys    z6 BK P    4 4Z @+ N    z :K H    1 1*f E{ S    2 2:v F T    JJ " "FJ#7 8+ bbb566rcURRSSSSSS5nURURR 5S5 UR U[ 5 URRS5 U$)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}. ryrr#rrsegg foo 0 0 3 bar sERROR )r%_setrrrrr rrrs rtest_invalidCommand!MemCacheTests.test_invalidCommandse JJOOFFFAq# > --/1LM 1m,  -rc(^SnTRRSU5nTRTRR 5S5 TR U[ 5 U4SjnURU5 TRRS5 U$)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 cN>TR[U5[S55 g)NsWe don't like egg and spamrrreprerrrs rr-MemCacheTests.test_clientError..checks   SXt,I'J Krs)CLIENT_ERROR We don't like egg and spam ) r%r=rrrrr rrrarrs` rtest_clientErrorMemCacheTests.test_clientErrorsx  JJNN61 % --/1QR 1k* L e  NOrc(^SnTRRSU5nTRTRR 5S5 TR U[ 5 U4SjnURU5 TRRS5 U$)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. rrrcN>TR[U5[S55 g)Nszomgrrs rr-MemCacheTests.test_serverError..checks   SXtG} 5rsSERVER_ERROR zomg ) r%r=rrrrr rrrs` rtest_serverErrorMemCacheTests.test_serverErrorsw  JJNN61 % --/1QR 1k* 6 e  89rc URURRSS5[5nURURR S5[5nURURR S5[5nURURR S5[5nURURRSS5[5nURURRSS5[5nURURRSS/5[5n[XX4XVU/5$)zA Using a non-string key as argument to commands raises an error. foor#eggr8barry) rr%r=r rar&rWrrr4r)rrrrrrrd7s rtest_unicodeKeyMemCacheTests.test_unicodeKey s   uf ={ K    4 4U ;[ I    q 1; ?    1 1% 8+ F    1 1% @+ N    2 25& A; O    6 6{ C[ Qbbbb9::rcbURURRSS5[5$)z+ Using a non-string value raises an error. rr)rr%r=r r's rtest_unicodeValueMemCacheTests.test_unicodeValues&!!$**.."?MMrcURRS5nURURS5 URR SS5nURURS5 URRS5nURURS5 URUR R 5S5 URRS 5 [XU/5$) 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 spamspamspamTry)rrws0get 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&rrr=rrrr)rrrrs rtest_pipeliningMemCacheTests.test_pipelinings ZZ^^F # t''5 ZZ^^FO 4 t''. ZZ^^F # t''6  NN " G   0 bb\**rcURRS5nURURS5 URURR 5S5 URR S5 URR S5 URR S5 URR S5 U$)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 0123456789r sVALUE foo 0 10 0123456s789s ENDs )r%r&rrrrrrs rtest_getInChunksMemCacheTests.test_getInChunks6s JJNN6 " d&&(:; --/@  <= '  + (rc^URURRSS5SSS5$)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 r<T)rr%rr's r test_appendMemCacheTests.test_appendDs2 zz JJ  ff - *     rc^URURRSS5SSS5$)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 r<T)rr%rr's r test_prependMemCacheTests.test_prependQs2 zz JJ  vv . +     rc^URURRSS5SSS5$)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_getsMemCacheTests.test_gets^s0 zz JJNN64 (  3   rc^URURRSS5SSS5$)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. rTr&r+rrNr$r's rtest_emptyGetsMemCacheTests.test_emptyGetsks- zz JJNN64 (/:~  rchURURRSS/S5SSSSS.5$) zy 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 rs2345rwrr'ryr#rr3r's rtest_getsMultipleMemCacheTests.test_getsMultiplets= zz JJ " "FF#3T :  U*4H I   rczURURR[SS/5S5SSSSS.5$) z? L{MemCacheProtocol.getMultiple} accepts any iterable of keys. rr#Tr/r0r1r2r3)rr%r4iterr's rtest_getsMultipleIterableKeys+MemCacheTests.test_getsMultipleIterableKeyssBzz JJ " "4(8#94 @  U*4H I   rchURURRSS/S5SSSSS.5$) z 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#Tr/sVALUE foo 0 3 1234 egg END r+r2r3r3r's rtest_getsMultipleWithEmpty(MemCacheTests.test_getsMultipleWithEmptys=zz JJ " "FF#3T :  3#-A B   rc\URURRSSSS9SSS5$)z L{MemCacheProtocol.checkAndSet} passes an additional cas identifier that the server handles to check if the data has to be updated. rr#r'cascas foo 0 0 3 1234 bar r<Trr% checkAndSetr's rtest_checkAndSetMemCacheTests.test_checkAndSets7 zz JJ " "66w " ? ,     rc\URURRSSSS9SSS5$)zl When L{MemCacheProtocol.checkAndSet} response is C{EXISTS}, the resulting L{Deferred} fires with C{False}. rr#r'r>r@sEXISTS FrAr's rtest_casUnknowKeyMemCacheTests.test_casUnknowKeys7 zz JJ " "66w " ? ,     rrr%rN)$rrrrrrrrrrrrrrrrrrrrrr rrrrr r#r(r,r4r8r;rCrFrrrrrrs 24    M+, ' ':+" '/" 7 $$ ;N +.                  rrc$\rSrSrSrSrSrSrg)CommandFailureTestsizN Tests for correct failure of commands on a disconnected L{MemCacheProtocol}. c\[5Ul[5UlURRURl[ 5UlURUR lURRUR 5 UR R5 g)zE Create a disconnected memcache client, using a deterministic clock. N) r r%rrrr rrrrr's rrCommandFailureTests.setUpsm&' W #zz33 9;"&** !!$..1 %%'rc.URU[5$)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 rrCommandFailureTests._tests !!!\22rrHN)rrrrrrrrrrrrJrJs (3rrJN)rtwisted.internet.deferrrrrtwisted.internet.errorrtwisted.internet.taskrtwisted.internet.testingr twisted.protocols.memcacher r r r twisted.trial.unittestrrrrJrrrrUsY WV1'E ,UTUTpA L(A H3,3r