U AcjÂbã@sšdZddlmZmZmZmZddlmZddlm Z ddl m Z ddl m Z mZmZmZddlmZGdd „d ƒZGd d „d eeƒZGd d „d eeƒZdS)z$ Test the memcache client protocol. é)ÚDeferredÚ DeferredListÚ TimeoutErrorÚ gatherResults)ÚConnectionDone)ÚClock)Ú StringTransportWithDisconnection)Ú ClientErrorÚMemCacheProtocolÚ NoSuchCommandÚ ServerError)ÚTestCasec@s°eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd(d)„Zd*S)+Ú CommandMixinzO Setup and tests for basic invocation of L{MemCacheProtocol} commands. cCs tƒ‚dS)zp Helper test method to test the resulting C{Deferred} of a L{MemCacheProtocol} command. N)ÚNotImplementedError©ÚselfÚdÚsendÚrecvÚresult©rú>/tmp/pip-unpacked-wheel-nrvc_22y/twisted/test/test_memcache.pyÚ_testszCommandMixin._testcCs| |j d¡ddd¡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©rrrrÚtest_get"s  üzCommandMixin.test_getcCs| |j d¡ddd¡S)zu Test getting a non-available key: it succeeds but return L{None} as value and C{0} as flag. rróEND ©rNrr!rrrÚ test_emptyGet/szCommandMixin.test_emptyGetcCs"| |j ddg¡dddddœ¡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 s1VALUE foo 0 3 bar VALUE cow 0 7 chicken END )rschickenr©r&r©rrÚ getMultipler!rrrÚtest_getMultiple6s üzCommandMixin.test_getMultiplecCs"| |j ddg¡dddddœ¡S)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 )érr$r(r)r!rrrÚtest_getMultipleWithEmptyBs üz&CommandMixin.test_getMultipleWithEmptycCs| |j dd¡ddd¡S)z† L{MemCacheProtocol.set} returns a L{Deferred} which is called back with C{True} when the operation succeeds. rrsset foo 0 0 3 bar óSTORED T)rrÚsetr!rrrÚtest_setNs  üzCommandMixin.test_setcCs| |j dd¡ddd¡S)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 r.T©rrÚaddr!rrrÚtest_addZs  üzCommandMixin.test_addcCs| |j dd¡ddd¡S)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 r.T©rrÚreplacer!rrrÚ test_replacefs  üzCommandMixin.test_replacecCs| |j dd¡ddd¡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}. rrr1ó NOT STORED Fr2r!rrrÚ test_errorAddrs  üzCommandMixin.test_errorAddcCs| |j dd¡ddd¡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}. rrr5r9Fr6r!rrrÚtest_errorReplaces  üzCommandMixin.test_errorReplacecCs| |j d¡ddd¡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©rrÚdeleter!rrrÚ test_deleteŒs  ÿzCommandMixin.test_deletecCs| |j d¡ddd¡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}. rr<s NOT FOUND Fr=r!rrrÚtest_errorDelete•s  ÿzCommandMixin.test_errorDeletecCs| |j d¡ddd¡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. rs incr foo 1 ó4 é©rrÚ incrementr!rrrÚtest_incrementŸszCommandMixin.test_incrementcCs| |j d¡ddd¡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. rs decr foo 1 ó5 é©rrZ decrementr!rrrÚtest_decrement§szCommandMixin.test_decrementcCs| |j dd¡ddd¡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 rArBrCr!rrrÚtest_incrementVal¯s  ÿzCommandMixin.test_incrementValcCs| |j dd¡ddd¡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 rFrGrHr!rrrÚtest_decrementVal¸s  ÿzCommandMixin.test_decrementValcCs| |j ¡dddddœ¡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. sstats ó"STAT foo bar STAT egg spam END róspam©róegg©rrÚstatsr!rrrÚ test_statsÁs üzCommandMixin.test_statscCs| |j d¡dddddœ¡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). sblahs stats blah rNrrOrPrRr!rrrÚtest_statsWithArgumentÎs  üz#CommandMixin.test_statsWithArgumentcCs| |j ¡ddd¡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 s1.1)rrÚversionr!rrrÚ test_versionÜs ÿzCommandMixin.test_versioncCs| |j ¡ddd¡S)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)rrZflushAllr!rrrÚ test_flushAllæszCommandMixin.test_flushAllN)Ú__name__Ú __module__Ú __qualname__Ú__doc__rr"r%r+r-r0r4r8r:r;r?r@rErIrKrMrTrUrWrXrrrrrs*              rc@seZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd(d)„Zd*d+„Zd,d-„Zd.d/„Zd0d1„Zd2d3„Zd4d5„Zd6d7„Zd8d9„Zd:d;„Z dS)?Ú MemCacheTestsz9 Test client protocol class L{MemCacheProtocol}. cCs@tƒ|_tƒ|_|jj|j_tƒ|_|j|j_|j |j¡dS)z{ Create a memcache client, connect it to a string protocol, and make it use a deterministic clock. N) r rrÚclockÚ callLaterrÚ transportÚprotocolÚmakeConnectionr!rrrÚsetUpós   zMemCacheTests.setUpcs:‡‡fdd„}ˆ ˆ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} csˆ |ˆ¡dS©N)Ú assertEqual)Úres©rrrrÚcbszMemCacheTests._test..cb)rer`ÚvalueÚ addCallbackrÚ dataReceived)rrrrrrhrrgrrÿs   zMemCacheTests._testcCs"|j d¡| t|jjd¡dS)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)rr Ú assertRaisesÚ RuntimeErrorrkr!rrrÚtest_invalidGetResponses  ýz%MemCacheTests.test_invalidGetResponsecCs&|j ddg¡| t|jjd¡dS)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}. rrsVALUE egg 0 7 spamegg END N)rr*rlrmrkr!rrrÚtest_invalidMultipleGetResponse%s ýz-MemCacheTests.test_invalidMultipleGetResponsecCs$|j dd¡| t|jjd¡dS)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)rr/rlrmrkr!rrrÚtest_invalidEndResponse2sz%MemCacheTests.test_invalidEndResponsecs€ˆj d¡}ˆj d¡}tƒ}|jˆj_ˆj ˆjj¡ˆ |t ¡ˆ |t ¡‡fdd„}|  |¡ˆ |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. rrcsˆ t|ƒd¡dS)NzConnection timeout)reÚstr)Úerrorr!rrÚ checkMessageJsz0MemCacheTests.test_timeOut..checkMessage) rr rÚcallbackÚconnectionLostr^ÚadvanceÚpersistentTimeOutÚ assertFailurerrjrr)rÚd1Úd2Úd3rsrr!rÚ test_timeOut;s        zMemCacheTests.test_timeOutcsFˆj d¡}ˆj ˆjjd¡ˆj d¡‡fdd„}| |¡|S)zY When a request gets a response, no pending timeout call remains around. rr,rcs$ˆ |d¡ˆ tˆjjƒd¡dS)Nrr)reÚlenr^Úcalls)rr!rrÚcheckZs z0MemCacheTests.test_timeoutRemoved..check)rr r^rvrwrkrj)rrrrr!rÚtest_timeoutRemovedQs     z!MemCacheTests.test_timeoutRemovedcCs\|j d¡}tƒ}|j|j_|j d¡|j |jj¡|  |t ¡|  |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. rsVALUE foo 0 10 12345) rr rrtrurkr^rvrwrxrrr©rryrzrrrÚtest_timeOutRawas     zMemCacheTests.test_timeOutRawcCsZ|j ¡}tƒ}|j|j_|j d¡|j |jj¡|  |t ¡|  |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. sSTAT foo bar ) rrSrrtrurkr^rvrwrxrrrrrrrÚtest_timeOutStatqs     zMemCacheTests.test_timeOutStatcs~ˆj d¡}ˆj d¡‰tƒ}|jˆj_ˆj ˆjjd¡ˆj d¡‡‡‡fdd„}‡fdd„‰|  |¡ˆ  |t ¡|S) zŒ When two requests are sent, a timeout call remains around for the second request, and its timeout time is correct. rrr,rcsPˆ |d¡ˆ tˆjjƒd¡tˆjjƒD]}ˆj d¡q,ˆ ˆt ¡  ˆ¡S)Nrr,) rer}r^r~Úrangerrwrvrxrrj)rÚi©Ú checkTimerzrrrrs  z3MemCacheTests.test_timeoutPipelining..checkcs"ˆ ˆj ¡dˆjjd¡dS)Nér,)rer^Úsecondsrrw)Zignoredr!rrr‡”sz7MemCacheTests.test_timeoutPipelining..checkTime) rr rrtrur^rvrwrkrjrxr)rryr{rrr†rÚtest_timeoutPipelining€s       z$MemCacheTests.test_timeoutPipeliningcCsz|j d¡}tƒ}|j|j_|j |jjd¡|j d¡}|j d¡| |t ¡| |t ¡| |t ¡t |||gƒS)z Check that timeout is not resetted for every command, but keep the timeout from the first command without response. rr,r) rr rrtrur^rvrwrxrrr)rryr{rzrrrÚtest_timeoutNotResets       z"MemCacheTests.test_timeoutNotResetcCsL|j d¡}|j |jj¡| |t¡|j d¡}| |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}. rr) rr r^rvrwrxrrmrrrrrÚtest_timeoutCleanDeferreds®s     z(MemCacheTests.test_timeoutCleanDeferredscsHˆj d¡}ˆj d¡}ˆj ¡t||gdd}‡fdd„}| |¡S)zl When disconnection occurs while commands are still outstanding, the commands fail. rrT)Z consumeErrorscs&|D]\}}ˆ |¡| t¡qdSrd)Z assertFalseZtrapr)ÚresultsÚsuccessrr!rrÚ checkFailuresÆs  z8MemCacheTests.test_connectionLost..checkFailures)rr r`ÚloseConnectionrrj)rryrzÚdonerrr!rÚtest_connectionLost¼s     z!MemCacheTests.test_connectionLostcCs–| |j dd¡t¡}| |j d¡t¡}| |j d¡t¡}| |j dd¡t¡}| |j dd¡t¡}| |j ddg¡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ôaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarr) rxrr/r rDr ÚappendÚprependr*r)rryrzr{Úd4Úd5Úd6rrrÚtest_tooLongKeyÍsÿzMemCacheTests.test_tooLongKeycCsD|j dddddd¡}| |j ¡d¡| |t¡|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}. rQrrrósegg foo 0 0 3 bar sERROR )rZ_setrer`rirxr rk©rrrrrÚtest_invalidCommandÜs   z!MemCacheTests.test_invalidCommandcsVd}ˆj d|¡}ˆ ˆj ¡d¡ˆ |t¡‡fdd„}| |¡ˆ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 csˆ t|ƒtdƒ¡dS)NsWe don't like egg and spam©rerqÚrepr©Úerrr!rrrósz-MemCacheTests.test_clientError..checks)CLIENT_ERROR We don't like egg and spam ) rr/rer`rirxr rjrk©rÚarrrr!rÚtest_clientErrorès    zMemCacheTests.test_clientErrorcsVd}ˆj d|¡}ˆ ˆj ¡d¡ˆ |t¡‡fdd„}| |¡ˆ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œrrcsˆ t|ƒtdƒ¡dS)Nszomgržr r!rrrsz-MemCacheTests.test_serverError..checksSERVER_ERROR zomg ) rr/rer`rirxr rjrkr¢rr!rÚtest_serverErrorús    zMemCacheTests.test_serverErrorcCs¬| |j dd¡t¡}| |j d¡t¡}| |j d¡t¡}| |j d¡t¡}| |j dd¡t¡}| |j dd¡t¡}| |j  ddg¡t¡}t |||||||gƒS)zQ Using a non-string key as argument to commands raises an error. ZfoorZeggr,ÚbarrQ) rxrr/r rDr r>r“r”r*r)rryrzr{r•r–r—Zd7rrrÚtest_unicodeKey szMemCacheTests.test_unicodeKeycCs| |j dd¡t¡S)z; Using a non-string value raises an error. rr¦)rxrr/r r!rrrÚtest_unicodeValueszMemCacheTests.test_unicodeValuecCs||j d¡}| |jd¡|j dd¡}| |jd¡|j d¡}| |jd¡| |j ¡d¡|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. rrrs spamspamspamTrQ)rrOs0get foo set bar 0 0 12 spamspamspam get egg s;VALUE foo 0 3 bar END STORED VALUE egg 0 4 spam END ) rr rjrer/r`rirkr)rryrzr{rrrÚtest_pipelinings  þÿzMemCacheTests.test_pipeliningcCs`|j d¡}| |jd¡| |j ¡d¡|j d¡|j d¡|j d¡|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)rs 0123456789rsVALUE foo 0 10 0123456s789s ENDs )rr rjrer`rirkršrrrÚtest_getInChunks6s     zMemCacheTests.test_getInChunkscCs| |j dd¡ddd¡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. rrsappend foo 0 0 3 bar r.T)rrr“r!rrrÚ test_appendDs  üzMemCacheTests.test_appendcCs| |j dd¡ddd¡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. rrsprepend foo 0 0 3 bar r.T)rrr”r!rrrÚ test_prependQs  üzMemCacheTests.test_prependcCs| |j dd¡ddd¡S)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 )ró1234rrr!rrrÚ test_gets^s  üzMemCacheTests.test_getscCs| |j dd¡ddd¡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. rTr­r#©rr™Nrr!rrrÚtest_emptyGetsks  ÿzMemCacheTests.test_emptyGetscCs$| |j ddgd¡dddddœ¡S) z‘ L{MemCacheProtocol.getMultiple} handles an additional cas field in the returned tuples if C{withIdentifier} is C{True}. rrTógets foo bar ó8VALUE foo 0 3 1234 egg VALUE bar 0 4 2345 spam END ©rs2345rO©rr®rQ©rrr)r!rrrÚtest_getsMultiplets üzMemCacheTests.test_getsMultiplecCs(| |j tddgƒd¡dddddœ¡S) zO L{MemCacheProtocol.getMultiple} accepts any iterable of keys. rrTr²r³r´rµr¶)rrr*Úiterr!rrrÚtest_getsMultipleIterableKeys€s üz+MemCacheTests.test_getsMultipleIterableKeyscCs$| |j ddgd¡dddddœ¡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. rrTr²sVALUE foo 0 3 1234 egg END r°rµr¶r)r!rrrÚtest_getsMultipleWithEmpty‹s üz(MemCacheTests.test_getsMultipleWithEmptycCs| |jjddddddd¡S)z L{MemCacheProtocol.checkAndSet} passes an additional cas identifier that the server handles to check if the data has to be updated. rrr®©Zcasócas foo 0 0 3 1234 bar r.T©rrZ checkAndSetr!rrrÚtest_checkAndSet™s üzMemCacheTests.test_checkAndSetcCs| |jjddddddd¡S)z„ When L{MemCacheProtocol.checkAndSet} response is C{EXISTS}, the resulting L{Deferred} fires with C{False}. rrr®r»r¼sEXISTS Fr½r!rrrÚtest_casUnknowKey¥s üzMemCacheTests.test_casUnknowKeyN)"rYrZr[r\rcrrnrorpr|r€r‚rƒrŠr‹rŒr’r˜r›r¤r¥r§r¨r©rªr«r¬r¯r±r·r¹rºr¾r¿rrrrr]îs>             r]c@s eZdZdZdd„Zdd„ZdS)ÚCommandFailureTestszZ Tests for correct failure of commands on a disconnected L{MemCacheProtocol}. cCsJtƒ|_tƒ|_|jj|j_tƒ|_|j|j_|j |j¡|j  ¡dS)zU Create a disconnected memcache client, using a deterministic clock. N) r rrr^r_rr`rarbrr!rrrrc¸s  zCommandFailureTests.setUpcCs | |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. )rxrmrrrrrÄszCommandFailureTests._testN)rYrZr[r\rcrrrrrrÀ²s rÀN)r\Ztwisted.internet.deferrrrrZtwisted.internet.errorrZtwisted.internet.taskrZtwisted.internet.testingrZtwisted.protocols.memcacher r r r Ztwisted.trial.unittestr rr]rÀrrrrÚs    YG