o ¯bÄbã@sšdZddlmZmZmZmZddlmZddlm Z ddl m Z m Z m Z mZddlmZddlmZGdd „d ƒZGd d „d eeƒZGd d „d eeƒZdS)z$ Test the memcache client protocol. é)ÚDeferredÚ DeferredListÚ TimeoutErrorÚ gatherResults)ÚConnectionDone)ÚClock)Ú ClientErrorÚMemCacheProtocolÚ NoSuchCommandÚ ServerError)Ú StringTransportWithDisconnection)Ú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. cCstƒ‚)zp Helper test method to test the resulting C{Deferred} of a L{MemCacheProtocol} command. )ÚNotImplementedError©ÚselfÚdÚsendÚrecvÚresult©rúFr;r"rrrÚtest_errorReplacer@zCommandMixin.test_errorReplacecCr)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_deletecCr)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}. rrBs NOT FOUND FrCr"rrrÚtest_errorDelete•sÿzCommandMixin.test_errorDeletecCr)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ŸózCommandMixin.test_incrementcCr)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"rrrÚtest_decrement§rLzCommandMixin.test_decrementcCr1)z‘ L{MemCacheProtocol.increment} takes an optional argument C{value} which replaces the default value of 1 when specified. rés incr foo 8 rGrHrIr"rrrÚtest_incrementVal¯óÿzCommandMixin.test_incrementValcCr1)z‘ L{MemCacheProtocol.decrement} takes an optional argument C{value} which replaces the default value of 1 when specified. rés decr foo 3 rMrNrOr"rrrÚtest_decrementVal¸rTzCommandMixin.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 rWrrXrYr[r"rrrÚtest_statsWithArgumentÎs  üz#CommandMixin.test_statsWithArgumentcCó| |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_versioncCr_)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"rrrÚ test_flushAllæszCommandMixin.test_flushAllN)Ú__name__Ú __module__Ú __qualname__Ú__doc__rr#r&r-r0r4r9r=r?rArErFrKrQrSrVr]r^rarcrrrrrs,              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 r rÚ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)rprkÚvalueÚ addCallbackr Ú dataReceived)rrrrrrsrrrrrÿ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)r r!Ú assertRaisesÚ RuntimeErrorrvr"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)r r,rwrxrvr"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)r r3rwrxrvr"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)rpÚstr)Úerrorr"rrÚ checkMessageJsz0MemCacheTests.test_timeOut..checkMessage) r r!rÚcallbackÚconnectionLostriÚadvanceÚpersistentTimeOutÚ assertFailurerrurr)rÚd1Úd2Úd3r~rr"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)rpÚlenriÚcalls)rr"rrÚcheckZs z0MemCacheTests.test_timeoutRemoved..check)r r!rirr‚rvru)rrrŠrr"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) r r!rrr€rvrirr‚rƒrrr©rr„r…rrrÚ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 ) r r\rrr€rvrirr‚rƒrrrrŒrrrÚ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/) rprˆrir‰Úranger r‚rrƒrru)rÚi©Ú checkTimer…rrrrŠs z3MemCacheTests.test_timeoutPipelining..checkcs"ˆ ˆj ¡dˆjjd¡dS)Nér/)rpriÚsecondsr r‚)Úignoredr"rrr’”s"z7MemCacheTests.test_timeoutPipelining..checkTime) r r!rrr€rirr‚rvrurƒr)rr„r†rŠrr‘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) r r!rrr€rirr‚rƒrrr)rr„r†r…rrrÚ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) r r!rirr‚rƒrrxrrŒrrrÚ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)Ú consumeErrorscs&|D]\}}ˆ |¡| t¡qdSro)Ú assertFalseÚtrapr)ÚresultsÚsuccessrr"rrÚ checkFailuresÆs   þz8MemCacheTests.test_connectionLost..checkFailures)r r!rkÚloseConnectionrru)rr„r…Údoneržrr"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) rƒr r3rrJr!ÚappendÚprependr,r)rr„r…r†Ú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}. rZrrrósegg foo 0 0 3 bar sERROR )r Ú_setrprkrtrƒr rv©rrrrrÚtest_invalidCommandÜs   z!MemCacheTests.test_invalidCommandcóVd}ˆ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 cóˆ t|ƒtdƒ¡dS)NsWe don't like egg and spam©rpr|Úrepr©Úerrr"rrrŠóóz-MemCacheTests.test_clientError..checks)CLIENT_ERROR We don't like egg and spam ) r r3rprkrtrƒrrurv©rÚarrŠrr"rÚtest_clientErrorèó    zMemCacheTests.test_clientErrorcr¬)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­rr®cr¯)Nszomgr°r²r"rrrŠr´z-MemCacheTests.test_serverError..checksSERVER_ERROR zomg ) r r3rprkrtrƒr rurvrµrr"rÚtest_serverErrorúr¸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. ÚfoorÚeggr/ÚbarrZ) rƒr r3rrJr!rDr¢r£r,r)rr„r…r†r¤r¥r¦Úd7rrrÚtest_unicodeKey szMemCacheTests.test_unicodeKeycCs| |j dd¡t¡S)z; Using a non-string value raises an error. rr¼)rƒr r3rr"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 spamspamspamTrZ)rrXs0get 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!rurpr3rkrtrvr)rr„r…r†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 )r r!rurprkrtrvrªrrrÚtest_getInChunks6s     zMemCacheTests.test_getInChunkscCr1)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 r2T)rr r¢r"rrrÚ test_appendDr@zMemCacheTests.test_appendcCr1)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 r2T)rr r£r"rrrÚ test_prependQr@zMemCacheTests.test_prependcCr1)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^r@zMemCacheTests.test_getscCr1)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_emptyGetskrTzMemCacheTests.test_emptyGetscCó$| |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 ©rs2345rX©rrÅrZ©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Î)rr r,Úiterr"rrrÚtest_getsMultipleIterableKeys€s üz+MemCacheTests.test_getsMultipleIterableKeyscCrÉ) 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_getsMultipleWithEmptycCó| |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Å©Úcasócas foo 0 0 3 1234 bar r2T©rr Ú checkAndSetr"rrrÚtest_checkAndSet™ó üzMemCacheTests.test_checkAndSetcCrÓ)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¥rÚzMemCacheTests.test_casUnknowKeyN)"rdrerfrgrnrryrzr{r‡r‹rrŽr–r—r˜r¡r§r«r·r¹r¾r¿rÀrÁrÂrÃrÆrÈrÏrÑrÒrÙrÛrrrrrhîs@             rhc@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 r rrirjr rkrlrmrŸr"rrrrn¸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. )rƒrxrrrrrÄs zCommandFailureTests._testN)rdrerfrgrnrrrrrrܲs rÜN)rgÚtwisted.internet.deferrrrrÚtwisted.internet.errorrÚtwisted.internet.taskrÚtwisted.protocols.memcacherr r r Útwisted.test.proto_helpersr Útwisted.trial.unittestr rrhrÜrrrrÚs    YG