File: //proc/self/root/lib/python3/dist-packages/twisted/test/__pycache__/test_memcache.cpython-38.pyc
U
W[7b � @ s� d Z ddlmZmZ ddlmZ ddlmZmZ ddlm Z m
Z
ddl m Z ddl
mZ ddlmZ dd lmZmZmZ dd
lmZ G d d � d �ZG d
d� dee �ZG dd� dee �ZdS )z$
Test the memcache client protocol.
� )�absolute_import�division)�ConnectionDone)�MemCacheProtocol�
NoSuchCommand)� ClientError� ServerError)�TestCase)� StringTransportWithDisconnection)�Clock)�Deferred�
gatherResults� TimeoutError)� DeferredListc @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*S )+� CommandMixinzO
Setup and tests for basic invocation of L{MemCacheProtocol} commands.
c C s
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 �</usr/lib/python3/dist-packages/twisted/test/test_memcache.py�_test s zCommandMixin._testc C s | � | 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�r r r r �test_get$ s
�zCommandMixin.test_getc C s | � | j�d�ddd�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# r r r �
test_emptyGet/ s
�zCommandMixin.test_emptyGetc C s" | � | 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
s1 VALUE foo 0 3
bar
VALUE cow 0 7
chicken
END
)r s chickenr �r( r �r r! � getMultipler# r r r �test_getMultiple9 s �z CommandMixin.test_getMultiplec C s" | � | j�ddg�ddddd��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# r r r �test_getMultipleWithEmptyE s �z&CommandMixin.test_getMultipleWithEmptyc C s | � | j�dd�ddd�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# r r r �test_setQ s �zCommandMixin.test_setc C s | � | j�dd�ddd�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
r0 T�r r! �addr# r r r �test_add[ s �zCommandMixin.test_addc C s | � | j�dd�ddd�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
r0 T�r r! �replacer# r r r � test_replacee s �zCommandMixin.test_replacec C s | � | 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}.
r r r3 � NOT STORED
Fr4 r# r r r �
test_errorAddo s �zCommandMixin.test_errorAddc C s | � | 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}.
r r r7 r; Fr8 r# r r r �test_errorReplacez s �z CommandMixin.test_errorReplacec C s | � | 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�r r! �deleter# r r r � test_delete� s
�zCommandMixin.test_deletec C s | � | 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}.
r r> s NOT FOUND
Fr? r# r r r �test_errorDelete� s
�z CommandMixin.test_errorDeletec C s | � | 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.
r s incr foo 1
� 4
� �r r! � incrementr# r r r �test_increment� s
�zCommandMixin.test_incrementc C s | � | 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.
r s decr foo 1
� 5
� �r r! Z decrementr# r r r �test_decrement� s
�zCommandMixin.test_decrementc C s | � | 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
rC rD rE r# r r r �test_incrementVal� s �z CommandMixin.test_incrementValc C s | � | 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
rH rI rJ r# r r r �test_decrementVal� s �z CommandMixin.test_decrementValc C s | � | 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.
s stats
�" STAT foo bar
STAT egg spam
END
r � spam�r � egg�r r! �statsr# r r r �
test_stats� s �zCommandMixin.test_statsc C s | � | 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).
s blahs stats blah
rP r rQ rR rT r# r r r �test_statsWithArgument� s
�z#CommandMixin.test_statsWithArgumentc C s | � | 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
s 1.1)r r! �versionr# r r r � test_version� s �zCommandMixin.test_versionc C s | � | 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
s OK
T)r r! ZflushAllr# r r r �
test_flushAll� s �zCommandMixin.test_flushAllN)�__name__�
__module__� __qualname__�__doc__r r$ r' r- r/ r2 r6 r: r< r= rA rB rG rK rM rO rV rW rY rZ r r r r r s*
r c @ s e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Z d4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z!d>S )?�
MemCacheTestsz9
Test client protocol class L{MemCacheProtocol}.
c C s@ 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# r r r �setUp� s
zMemCacheTests.setUpc s: � �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}
c s �� | � � d S �N)� assertEqual)�res�r r r r �cb s z MemCacheTests._test.<locals>.cb)rg rb �value� addCallbackr! � dataReceived)r r r r r rj r ri r r � s
zMemCacheTests._testc C s" | j �d� | �t| j jd� 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}.
r s VALUE bar 0 7
spamegg
END
N)r! r" � assertRaises� RuntimeErrorrm r# r r r �test_invalidGetResponse s �z%MemCacheTests.test_invalidGetResponsec C s& | j �ddg� | �t| j jd� 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}.
r r s VALUE egg 0 7
spamegg
END
N)r! r, rn ro rm r# r r r � test_invalidMultipleGetResponse" s �z-MemCacheTests.test_invalidMultipleGetResponsec C s$ | j �dd� | �t| j jd� 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}.
s keys valuer% N)r! r1 rn ro rm r# r r r �test_invalidEndResponse. s �z%MemCacheTests.test_invalidEndResponsec s� � j �d�}� j �d�}t� }|j� j _� j�� j j� � �|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.
r r c s � � t| �d� d S )NzConnection timeout)rg �str)�errorr# r r � checkMessageI s z0MemCacheTests.test_timeOut.<locals>.checkMessage)
r! r" r �callback�connectionLostr` �advance�persistentTimeOut�
assertFailurer rl r r
)r �d1�d2�d3ru r r# r � test_timeOut: s
zMemCacheTests.test_timeOutc sF � j �d�}� j�� j jd � � j �d� � fdd�}|�|� |S )zY
When a request gets a response, no pending timeout call remains around.
r r. r c s$ � � | d� � � t� jj�d� d S )Nr r )rg �lenr` �calls)r r# r r �checkZ s z0MemCacheTests.test_timeoutRemoved.<locals>.check)r! r" r` rx ry rm rl )r r r� r r# r �test_timeoutRemovedQ s
z!MemCacheTests.test_timeoutRemovedc C s\ | j �d�}t� }|j| j _| j �d� | j�| j j� | � |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.
r s VALUE foo 0 10
12345)
r! r" r rv rw rm r` rx ry rz r r r
�r r{ r| r r r �test_timeOutRawa s
z MemCacheTests.test_timeOutRawc C sZ | j �� }t� }|j| j _| j �d� | j�| j j� | � |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.
s STAT foo bar
)
r! rU r rv rw rm r` rx ry rz r r r
r� r r r �test_timeOutStatr s
z MemCacheTests.test_timeOutStatc s~ �j �d�}�j �d��t� }|j�j _�j��j jd � �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.
r r r. r c sP �� | d� �� t�jj�d� t�jj�D ]}�j�d� q,���t ��
� �S )Nr r. ) rg r r` r� �ranger! ry rx rz r rl )r �i�� checkTimer| r r r r� � s
z3MemCacheTests.test_timeoutPipelining.<locals>.checkc s" � � � j�� d� jj d � d S )N� r. )rg r` Zsecondsr! ry )Zignoredr# r r r� � s �z7MemCacheTests.test_timeoutPipelining.<locals>.checkTime) r! r" r rv rw r` rx ry rm rl rz r )r r{ r} r� r r� r �test_timeoutPipelining� s
z$MemCacheTests.test_timeoutPipeliningc C sz | j �d�}t� }|j| j _| j�| j jd � | 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.
r r. r ) r! r" r rv rw r` rx ry rz r r r
)r r{ r} r| r r r �test_timeoutNotReset� s
z"MemCacheTests.test_timeoutNotResetc C sL | j �d�}| j�| j j� | �|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}.
r r ) r! r" r` rx ry rz r ro r
r� r r r �test_timeoutCleanDeferreds� s z(MemCacheTests.test_timeoutCleanDeferredsc sH � j �d�}� j �d�}� j�� t||gdd�}� fdd�}|�|�S )zl
When disconnection occurs while commands are still outstanding, the
commands fail.
r r T)Z
consumeErrorsc s& | D ] \}}� � |� |�t� qd S rf )Z assertFalseZtrapr )ZresultsZsuccessr r# r r �
checkFailures� s
z8MemCacheTests.test_connectionLost.<locals>.checkFailures)r! r" rb �loseConnectionr rl )r r{ r| Zdoner� r r# r �test_connectionLost� s
z!MemCacheTests.test_connectionLostc C s� | � | 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� aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaar r )
rz r! r1 r rF r" �append�prependr, r
)r r{ r| r} �d4�d5�d6r r r �test_tooLongKey� s& � � � �z MemCacheTests.test_tooLongKeyc C sD | 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}.
rS r r r � s egg foo 0 0 3
bar
s ERROR
)r! Z_setrg rb rk rz r rm �r r r r r �test_invalidCommand� s
z!MemCacheTests.test_invalidCommandc sV d}� 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 s � � t| �td�� d S )Ns We don't like egg and spam�rg rs �repr��errr# r r r� � s z-MemCacheTests.test_clientError.<locals>.checks) CLIENT_ERROR We don't like egg and spam
) r! r1 rg rb rk rz r rl rm �r �ar r� r r# r �test_clientError� s �
z MemCacheTests.test_clientErrorc sV d}� 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� r r� c s � � t| �td�� d S )Ns zomgr� r� r# r r r� s z-MemCacheTests.test_serverError.<locals>.checks SERVER_ERROR zomg
) r! r1 rg rb rk rz r rl rm r� r r# r �test_serverError s �
z MemCacheTests.test_serverErrorc C s� | � | 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.
Zfoor Zeggr. �barrS ) rz r! r1 r rF r" r@ r� r� r, r
)r r{ r| r} r� r� r� Zd7r r r �test_unicodeKey s � �z MemCacheTests.test_unicodeKeyc C s | � | j�dd�t�S )z;
Using a non-string value raises an error.
r r� )rz r! r1 r r# r r r �test_unicodeValue+ s z MemCacheTests.test_unicodeValuec C s| | 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.
r r r s spamspamspamTrS )r rQ 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" rl rg r1 rb rk rm r
)r r{ r| r} r r r �test_pipelining2 s � z MemCacheTests.test_pipeliningc C s` | 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 )r s
0123456789r s VALUE foo 0 10
0123456s 789s
ENDs
)r! r" rl rg rb rk rm r� r r r �test_getInChunksG s z MemCacheTests.test_getInChunksc C s | � | 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.
r r s append foo 0 0 3
bar
r0 T)r r! r� r# r r r � test_appendV s �zMemCacheTests.test_appendc C s | � | 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.
r r s prepend foo 0 0 3
bar
r0 T)r r! r� r# r r r � test_prependa s �zMemCacheTests.test_prependc C s | � | 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}.
r T�
gets foo
s VALUE foo 0 3 1234
bar
END
)r � 1234r r r# r r r � test_getsl s �zMemCacheTests.test_getsc C s | � | 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.
r Tr� r% �r r� Nr r# r r r �test_emptyGetsw s �z MemCacheTests.test_emptyGetsc C s$ | � | j�ddgd�ddddd��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 2345rQ �r r� rS �r r r+ r# r r r �test_getsMultiple� s �z MemCacheTests.test_getsMultiplec C s( | � | j�tddg�d�ddddd��S ) zO
L{MemCacheProtocol.getMultiple} accepts any iterable of keys.
r r Tr� r� r� r� r� )r r! r, �iterr# r r r � test_getsMultipleIterableKeys� s �z+MemCacheTests.test_getsMultipleIterableKeysc C s$ | � | 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.
r r Tr� s VALUE foo 0 3 1234
egg
END
r� r� r� r+ r# r r r �test_getsMultipleWithEmpty� s �z(MemCacheTests.test_getsMultipleWithEmptyc C s | � | jjdddd�ddd�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� �Zcas� cas foo 0 0 3 1234
bar
r0 T�r r! Z checkAndSetr# r r r �test_checkAndSet� s �z MemCacheTests.test_checkAndSetc C s | � | jjdddd�ddd�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# r r r �test_casUnknowKey� s �z MemCacheTests.test_casUnknowKeyN)"r[ r\ r] r^ re r rp rq rr 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_ � s>
r_ c @ s e Zd ZdZdd� Zdd� ZdS )�CommandFailureTestszZ
Tests for correct failure of commands on a disconnected
L{MemCacheProtocol}.
c C sJ t � | _t� | _| jj| j_t� | _| j| j_| j�| j� | j� � dS )zU
Create a disconnected memcache client, using a deterministic clock.
N)
r r! r r` ra r
rb rc rd r� r# r r r re � s
zCommandFailureTests.setUpc C s | � |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.
)rz ro r r r r r � s zCommandFailureTests._testN)r[ r\ r] r^ re r r r r r r� � s
r� N)r^ Z
__future__r r Ztwisted.internet.errorr Ztwisted.protocols.memcacher r r r Ztwisted.trial.unittestr Ztwisted.test.proto_helpersr
Ztwisted.internet.taskr Ztwisted.internet.deferr r
r r r r_ r� r r r r �<module> s V T