0x1949 Team - FAZEMRX - MANAGER
Edit File: 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