← Back
Editing: 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
Save File
Cancel