File: //lib/python3/dist-packages/twisted/test/__pycache__/test_memcache.cpython-310.pyc
o
�b�b � @ s� d Z ddlmZmZmZmZ ddlmZ ddlm Z ddl
m Z m Z m
Z
mZ ddlmZ ddlmZ G dd � d �ZG d
d � d ee�ZG d d
� d
ee�ZdS )z$
Test the memcache client protocol.
� )�Deferred� DeferredList� TimeoutError�
gatherResults)�ConnectionDone)�Clock)� ClientError�MemCacheProtocol�
NoSuchCommand� ServerError)� StringTransportWithDisconnection)�TestCasec @ 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 � �)zp
Helper test method to test the resulting C{Deferred} of a
L{MemCacheProtocol} command.
)�NotImplementedError��self�d�send�recv�result� r �</usr/lib/python3/dist-packages/twisted/test/test_memcache.py�_test s zCommandMixin._testc C � | � | 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 r )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 �" | � | 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_getMultiple6 � �z CommandMixin.test_getMultiplec C r' )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_getMultipleWithEmptyB r. z&CommandMixin.test_getMultipleWithEmptyc C � | � | 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_setN � �zCommandMixin.test_setc C r1 )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
r2 T�r r �addr" r r r �test_addZ r5 zCommandMixin.test_addc C r1 )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
r2 T�r r �replacer" r r r � test_replacef r5 zCommandMixin.test_replacec C r1 )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 r6 � NOT STORED
Fr7 r" r r r �
test_errorAddr � �zCommandMixin.test_errorAddc C r1 )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 r: r> Fr; r" r r r �test_errorReplace r@ z CommandMixin.test_errorReplacec C r )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 r )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 rB s NOT FOUND
FrC r" r r r �test_errorDelete� s �z CommandMixin.test_errorDeletec C r )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� � zCommandMixin.test_incrementc C r )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 � decrementr" r r r �test_decrement� rL zCommandMixin.test_decrementc C r1 )z�
L{MemCacheProtocol.increment} takes an optional argument C{value} which
replaces the default value of 1 when specified.
r � s incr foo 8
rG rH rI r" r r r �test_incrementVal� � �z CommandMixin.test_incrementValc C r1 )z�
L{MemCacheProtocol.decrement} takes an optional argument C{value} which
replaces the default value of 1 when specified.
r � s decr foo 3
rM rN rO r" r r r �test_decrementVal� rT 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
rW r rX rY r[ r" r r r �test_statsWithArgument� s
�z#CommandMixin.test_statsWithArgumentc C � | � | 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 r_ )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 �flushAllr" r r r �
test_flushAll� s zCommandMixin.test_flushAllN)�__name__�
__module__� __qualname__�__doc__r r# r& r- r0 r4 r9 r= r? rA rE rF rK rQ rS rV r] r^ ra rc 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)rp rk �value� addCallbackr � dataReceived)r r r r r rs r rr 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� RuntimeErrorrv 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, rw rx rv 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 r3 rw rx rv r" r r r �test_invalidEndResponse2 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)rp �str)�errorr" r r � checkMessageJ s z0MemCacheTests.test_timeOut.<locals>.checkMessage)
r r! r �callback�connectionLostri �advance�persistentTimeOut�
assertFailurer ru r r )r �d1�d2�d3r~ 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 )rp �lenri �calls)r r" r r �checkZ s z0MemCacheTests.test_timeoutRemoved.<locals>.check)r r! ri r� r� rv ru )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 r r� rv ri r� r� r� 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 r\ r r r� rv ri r� r� r� r r r r� r r r �test_timeOutStatq 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/ ) rp r� ri r� �ranger r� r� r� r ru )r �i�� checkTimer� r r r r� � s
z3MemCacheTests.test_timeoutPipelining.<locals>.checkc s" � � � j�� d� jj d � d S )N� r/ )rp ri �secondsr r� )�ignoredr" r r r� � s "z7MemCacheTests.test_timeoutPipelining.<locals>.checkTime) r r! r r r� ri r� r� rv ru r� 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 r r� ri r� r� r� 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! ri r� r� r� r rx 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)�
consumeErrorsc s& | D ]\}}� � |� |�t� qd S ro )� assertFalse�trapr )�results�successr r" r r �
checkFailures� s
�z8MemCacheTests.test_connectionLost.<locals>.checkFailures)r r! rk �loseConnectionr ru )r r� r� �doner� 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 )
r� r r3 r rJ 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}.
rZ r r r � s egg foo 0 0 3
bar
s ERROR
)r �_setrp rk rt r� r
rv �r r r r r �test_invalidCommand� s
z!MemCacheTests.test_invalidCommandc �V 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 � � � t| �td�� d S )Ns We don't like egg and spam�rp r| �repr��errr" r r r� � � z-MemCacheTests.test_clientError.<locals>.checks) CLIENT_ERROR We don't like egg and spam
) r r3 rp rk rt r� r ru rv �r �ar r� r r" r �test_clientError� �
z MemCacheTests.test_clientErrorc r� )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 r� )Ns zomgr� r� r" r r r� r� z-MemCacheTests.test_serverError.<locals>.checks SERVER_ERROR zomg
) r r3 rp rk rt r� r ru rv r� r r" r �test_serverError� r� 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.
�foor �eggr/ �barrZ ) r� r r3 r rJ r! rD r� r� r, r )r r� r� r� r� r� r� �d7r 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� )r� r r3 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 spamspamspamTrZ )r rX 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! ru rp r3 rk rt rv r )r r� r� r� r r r �test_pipelining 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! ru rp rk rt rv r� r r r �test_getInChunks6 s z MemCacheTests.test_getInChunksc C r1 )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
r2 T)r r r� r" r r r � test_appendD r@ zMemCacheTests.test_appendc C r1 )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
r2 T)r r r� r" r r r � test_prependQ r@ zMemCacheTests.test_prependc C r1 )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_gets^ r@ zMemCacheTests.test_getsc C r1 )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_emptyGetsk rT z MemCacheTests.test_emptyGetsc C �$ | � | 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 2345rX �r r� rZ �r r r+ r" r r r �test_getsMultiplet 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 r� ) 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 � | � | 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� ��cas� cas foo 0 0 3 1234
bar
r2 T�r r � checkAndSetr" r r r �test_checkAndSet� � �z MemCacheTests.test_checkAndSetc C r� )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� r� z MemCacheTests.test_casUnknowKeyN)"rd re rf rg rn r ry rz 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 rh � s@
rh 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 ri rj r rk rl rm r� r" r r r rn � 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.
)r� rx r r r r r � s zCommandFailureTests._testN)rd re rf rg rn r r r r r r� � s r� N)rg �twisted.internet.deferr r r r �twisted.internet.errorr �twisted.internet.taskr �twisted.protocols.memcacher r r
r �twisted.test.proto_helpersr �twisted.trial.unittestr
r rh r� r r r r �<module> s Y G