twisted.test.test_memcache.MemCacheTests

Test client protocol class MemCacheProtocol.

Method	setUp	Create a memcache client, connect it to a string protocol, and make it use a deterministic clock.
Method	test_invalidGetResponse	If the value returned doesn't match the expected key of the current `get` command, an error is raised in `MemCacheProtocol.dataReceived`.
Method	test_invalidMultipleGetResponse	If the value returned doesn't match one the expected keys of the current multiple `get` command, an error is raised error in `MemCacheProtocol.dataReceived`.
Method	test_invalidEndResponse	If an END is received in response to an operation that isn't `get`, `gets`, or `stats`, an error is raised in `MemCacheProtocol.dataReceived`.
Method	test_timeOut	Test the timeout on outgoing requests: when timeout is detected, all current commands fail with a `TimeoutError`, and the connection is closed.
Method	test_timeoutRemoved	When a request gets a response, no pending timeout call remains around.
Method	test_timeOutRaw	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 `TimeoutError` when waiting for raw data.
Method	test_timeOutStat	Test the timeout when stat command has started: the timeout is not reset until the final END is received.
Method	test_timeoutPipelining	When two requests are sent, a timeout call remains around for the second request, and its timeout time is correct.
Method	test_timeoutNotReset	Check that timeout is not resetted for every command, but keep the timeout from the first command without response.
Method	test_timeoutCleanDeferreds	No summary
Method	test_connectionLost	When disconnection occurs while commands are still outstanding, the commands fail.
Method	test_tooLongKey	An error is raised when trying to use a too long key: the called command returns a `Deferred` which fails with a `ClientError`.
Method	test_invalidCommand	When an unknown command is sent directly (not through public API), the server answers with an ERROR token, and the command fails with `NoSuchCommand`.
Method	test_clientError	Test the `ClientError` error: when the server sends a CLIENT_ERROR token, the originating command fails with `ClientError`, and the error contains the text sent by the server.
Method	test_serverError	Test the `ServerError` error: when the server sends a SERVER_ERROR token, the originating command fails with `ServerError`, and the error contains the text sent by the server.
Method	test_unicodeKey	Using a non-string key as argument to commands raises an error.
Method	test_unicodeValue	Using a non-string value raises an error.
Method	test_pipelining	Multiple requests can be sent subsequently to the server, and the protocol orders the responses correctly and dispatch to the corresponding client command.
Method	test_getInChunks	If the value retrieved by a `get` arrive in chunks, the protocol is able to reconstruct it and to produce the good value.
Method	test_append	`MemCacheProtocol.append` behaves like a `MemCacheProtocol.set` method: it returns a `Deferred` which is called back with `True` when the operation succeeds.
Method	test_prepend	`MemCacheProtocol.prepend` behaves like a `MemCacheProtocol.set` method: it returns a `Deferred` which is called back with `True` when the operation succeeds.
Method	test_gets	`MemCacheProtocol.get` handles an additional cas result when `withIdentifier` is `True` and forward it in the resulting `Deferred`.
Method	test_emptyGets	Test getting a non-available key with gets: it succeeds but return `None` as value, `0` as flag and an empty cas value.
Method	test_getsMultiple	`MemCacheProtocol.getMultiple` handles an additional cas field in the returned tuples if `withIdentifier` is `True`.
Method	test_getsMultipleIterableKeys	`MemCacheProtocol.getMultiple` accepts any iterable of keys.
Method	test_getsMultipleWithEmpty	No summary
Method	test_checkAndSet	`MemCacheProtocol.checkAndSet` passes an additional cas identifier that the server handles to check if the data has to be updated.
Method	test_casUnknowKey	When `MemCacheProtocol.checkAndSet` response is `EXISTS`, the resulting `Deferred` fires with `False`.
Method	_test	Implementation of `_test` which checks that the command sends `send` data, and that upon reception of `recv` the result is `result`.

Inherited from CommandMixin:

Method	test_get	`MemCacheProtocol.get` returns a `Deferred` which is called back with the value and the flag associated with the given key if the server returns a successful result.
Method	test_emptyGet	Test getting a non-available key: it succeeds but return `None` as value and `0` as flag.
Method	test_getMultiple	`MemCacheProtocol.getMultiple` returns a `Deferred` which is called back with a dictionary of flag, value for each given key.
Method	test_getMultipleWithEmpty	When `MemCacheProtocol.getMultiple` is called with non-available keys, the corresponding tuples are (0, None).
Method	test_set	`MemCacheProtocol.set` returns a `Deferred` which is called back with `True` when the operation succeeds.
Method	test_add	`MemCacheProtocol.add` returns a `Deferred` which is called back with `True` when the operation succeeds.
Method	test_replace	`MemCacheProtocol.replace` returns a `Deferred` which is called back with `True` when the operation succeeds.
Method	test_errorAdd	Test an erroneous add: if a `MemCacheProtocol.add` is called but the key already exists on the server, it returns a NOT STORED answer, which calls back the resulting `Deferred` with `False`.
Method	test_errorReplace	Test an erroneous replace: if a `MemCacheProtocol.replace` is called but the key doesn't exist on the server, it returns a NOT STORED answer, which calls back the resulting `Deferred` with `False`.
Method	test_delete	`MemCacheProtocol.delete` returns a `Deferred` which is called back with `True` when the server notifies a success.
Method	test_errorDelete	Test an error during a delete: if key doesn't exist on the server, it returns a NOT FOUND answer which calls back the resulting `Deferred` with `False`.
Method	test_increment	Test incrementing a variable: `MemCacheProtocol.increment` returns a `Deferred` which is called back with the incremented value of the given key.
Method	test_decrement	Test decrementing a variable: `MemCacheProtocol.decrement` returns a `Deferred` which is called back with the decremented value of the given key.
Method	test_incrementVal	`MemCacheProtocol.increment` takes an optional argument `value` which replaces the default value of 1 when specified.
Method	test_decrementVal	`MemCacheProtocol.decrement` takes an optional argument `value` which replaces the default value of 1 when specified.
Method	test_stats	Test retrieving server statistics via the `MemCacheProtocol.stats` command: it parses the data sent by the server and calls back the resulting `Deferred` with a dictionary of the received statistics.
Method	test_statsWithArgument	No summary
Method	test_version	Test version retrieval via the `MemCacheProtocol.version` command: it returns a `Deferred` which is called back with the version sent by the server.
Method	test_flushAll	`MemCacheProtocol.flushAll` returns a `Deferred` which is called back with `True` if the server acknowledges success.

Inherited from TestCase:

Instance Variable	timeout	A real number of seconds. If set, the test will raise an error if it takes longer than `timeout` seconds. If not set, util.DEFAULT_TIMEOUT_DURATION is used.
Method	__init__	Construct an asynchronous test case for `methodName`.
Method	assertFailure	Fail if `deferred` does not errback with one of `expectedFailures`. Returns the original Deferred with callbacks added. You will need to return this Deferred from your test case.
Method	__call__	Run the test. Should always do exactly the same thing as run().
Method	deferSetUp	Undocumented
Method	deferTestMethod	Undocumented
Method	deferTearDown	Undocumented
Method	deferRunCleanups	Run any scheduled cleanups and report errors (if any to the result object.
Method	addCleanup	Extend the base cleanup feature with support for cleanup functions which return Deferreds.
Method	getSuppress	Undocumented
Method	getTimeout	No summary
Method	_run	Run a single method, either a test method or fixture.
Method	_ebDeferSetUp	Undocumented
Method	_cbDeferTestMethod	Undocumented
Method	_ebDeferTestMethod	Undocumented
Method	_ebDeferTearDown	Undocumented
Method	_cbDeferRunCleanups	Undocumented
Method	_cleanUp	Undocumented
Method	_classCleanUp	Undocumented
Method	_makeReactorMethod	Create a method which wraps the reactor method `name`. The new method issues a deprecation warning and calls the original.
Method	_deprecateReactor	Deprecate `iterate`, `crash` and `stop` on `reactor`. That is, each method is wrapped in a function that issues a deprecation warning, then calls the original.
Method	_undeprecateReactor	Restore the deprecated reactor methods. Undoes what `_deprecateReactor` did.
Method	_runCleanups	Run the cleanups added with `addCleanup` in order.
Method	_runFixturesAndTest	Really run `setUp`, the test method, and `tearDown`. Any of these may return `defer.Deferred`s. After they complete, do some reactor cleanup.
Method	_wait	Take a Deferred that only ever callbacks. Block until it happens.

Inherited from SynchronousTestCase (via TestCase):

Instance Variable	failureException	An exception class, defaulting to `FailTest`. If the test method raises this exception, it will be reported as a failure, rather than an exception. All of the assertion methods raise this if the assertion fails.
Instance Variable	skip	`None` or a string explaining why this test is to be skipped. If defined, the test will not be run. Instead, it will be reported to the result object as 'skipped' (if the `TestResult` supports skipping).
Instance Variable	todo	`None`, a string or a tuple of `(errors, reason)` where `errors` is either an exception class or an iterable of exception classes, and `reason` is a string. See `Todo` or `makeTodo` for more information.
Instance Variable	suppress	`None` or a list of tuples of `(args, kwargs)` to be passed to `warnings.filterwarnings`. Use these to suppress warnings raised in a test. Useful for testing deprecated code. See also `util.suppress`.
Method	__eq__	No summary
Method	__ne__	Undocumented
Method	__hash__	Undocumented
Method	shortDescription	Undocumented
Method	getSkip	No summary
Method	getTodo	No summary
Method	runTest	If no `methodName` argument is passed to the constructor, `run` will treat this method as the thing with the actual test inside.
Method	run	Run the test case, storing the results in `result`.
Method	patch	Monkey patch an object for the duration of the test.
Method	flushLoggedErrors	Remove stored errors received from the log.
Method	flushWarnings	Remove stored warnings from the list of captured warnings and return them.
Method	callDeprecated	Call a function that should have been deprecated at a specific version and in favor of a specific alternative, and assert that it was thusly deprecated.
Method	mktemp	Create a new path name which can be used for a new file or directory.
Method	_getSuppress	No summary
Method	_getSkipReason	Return the reason to use for skipping a test method.
Method	_installObserver	Undocumented
Method	_removeObserver	Undocumented

Inherited from _Assertions (via TestCase, SynchronousTestCase):

Method	fail	Absolutely fail the test. Do not pass go, do not collect $200.
Method	assertFalse	Fail the test if `condition` evaluates to True.
Method	assertTrue	Fail the test if `condition` evaluates to False.
Method	assertRaises	Fail the test unless calling the function `f` with the given `args` and `kwargs` raises `exception`. The failure will report the traceback and call stack of the unexpected exception.
Method	assertEqual	Fail the test if `first` and `second` are not equal.
Method	assertIs	Fail the test if `first` is not `second`. This is an obect-identity-equality test, not an object equality (i.e. `__eq__`) test.
Method	assertIsNot	Fail the test if `first` is `second`. This is an obect-identity-equality test, not an object equality (i.e. `__eq__`) test.
Method	assertNotEqual	Fail the test if `first` == `second`.
Method	assertIn	Fail the test if `containee` is not found in `container`.
Method	assertNotIn	Fail the test if `containee` is found in `container`.
Method	assertNotAlmostEqual	Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero.
Method	assertAlmostEqual	Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero.
Method	assertApproximates	Fail if `first` - `second` > `tolerance`
Method	assertSubstring	Fail if `substring` does not exist within `astring`.
Method	assertNotSubstring	Fail if `astring` contains `substring`.
Method	assertWarns	Fail if the given function doesn't generate the specified warning when called. It calls the function, checks the warning, and forwards the result of the function if everything is fine.
Method	assertIsInstance	Fail if `instance` is not an instance of the given class or of one of the given classes.
Method	assertNotIsInstance	Fail if `instance` is an instance of the given class or of one of the given classes.
Method	successResultOf	Return the current success result of `deferred` or raise `self.failureException`.
Method	failureResultOf	Return the current failure result of `deferred` or raise `self.failureException`.
Method	assertNoResult	Assert that `deferred` does not have a result at this point.
Method	assertRegex	Fail the test if a `regexp` search of `text` fails.

def setUp(self):

Create a memcache client, connect it to a string protocol, and make it use a deterministic clock.

def _test(self, d, send, recv, result):

overrides twisted.test.test_memcache.CommandMixin._test

Implementation of _test which checks that the command sends send data, and that upon reception of recv the result is result.

Parameters	d	the resulting deferred from the memcache command. (type: `Deferred`)
	send	the expected data to be sent. (type: `bytes`)
	recv	the data to simulate as reception. (type: `bytes`)
	result	the expected result. (type: `any`)

def test_invalidGetResponse(self):

If the value returned doesn't match the expected key of the current get command, an error is raised in MemCacheProtocol.dataReceived.

def test_invalidMultipleGetResponse(self):

If the value returned doesn't match one the expected keys of the current multiple get command, an error is raised error in MemCacheProtocol.dataReceived.

def test_invalidEndResponse(self):

If an END is received in response to an operation that isn't get, gets, or stats, an error is raised in MemCacheProtocol.dataReceived.

def test_timeOut(self):

Test the timeout on outgoing requests: when timeout is detected, all current commands fail with a TimeoutError, and the connection is closed.

def test_timeoutRemoved(self):

When a request gets a response, no pending timeout call remains around.

def test_timeOutRaw(self):

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 TimeoutError when waiting for raw data.

def test_timeOutStat(self):

Test the timeout when stat command has started: the timeout is not reset until the final END is received.

def test_timeoutPipelining(self):

When two requests are sent, a timeout call remains around for the second request, and its timeout time is correct.

def test_timeoutNotReset(self):

Check that timeout is not resetted for every command, but keep the timeout from the first command without response.

def test_timeoutCleanDeferreds(self):

timeoutConnection cleans the list of commands that it fires with TimeoutError: connectionLost doesn't try to fire them again, but sets the disconnected state so that future commands fail with a RuntimeError.

def test_connectionLost(self):

When disconnection occurs while commands are still outstanding, the commands fail.

def test_tooLongKey(self):

An error is raised when trying to use a too long key: the called command returns a Deferred which fails with a ClientError.

def test_invalidCommand(self):

When an unknown command is sent directly (not through public API), the server answers with an ERROR token, and the command fails with NoSuchCommand.

def test_clientError(self):

Test the ClientError error: when the server sends a CLIENT_ERROR token, the originating command fails with ClientError, and the error contains the text sent by the server.

def test_serverError(self):

Test the ServerError error: when the server sends a SERVER_ERROR token, the originating command fails with ServerError, and the error contains the text sent by the server.

def test_unicodeKey(self):

Using a non-string key as argument to commands raises an error.

def test_unicodeValue(self):

Using a non-string value raises an error.

def test_pipelining(self):

Multiple requests can be sent subsequently to the server, and the protocol orders the responses correctly and dispatch to the corresponding client command.

def test_getInChunks(self):

If the value retrieved by a get arrive in chunks, the protocol is able to reconstruct it and to produce the good value.

def test_append(self):

MemCacheProtocol.append behaves like a MemCacheProtocol.set method: it returns a Deferred which is called back with True when the operation succeeds.

def test_prepend(self):

MemCacheProtocol.prepend behaves like a MemCacheProtocol.set method: it returns a Deferred which is called back with True when the operation succeeds.

def test_gets(self):

MemCacheProtocol.get handles an additional cas result when withIdentifier is True and forward it in the resulting Deferred.

def test_emptyGets(self):

Test getting a non-available key with gets: it succeeds but return None as value, 0 as flag and an empty cas value.

def test_getsMultiple(self):

MemCacheProtocol.getMultiple handles an additional cas field in the returned tuples if withIdentifier is True.

def test_getsMultipleIterableKeys(self):

MemCacheProtocol.getMultiple accepts any iterable of keys.

def test_getsMultipleWithEmpty(self):

When getting a non-available key with MemCacheProtocol.getMultiple when withIdentifier is True, the other keys are retrieved correctly, and the non-available key gets a tuple of 0 as flag, None as value, and an empty cas value.

def test_checkAndSet(self):

MemCacheProtocol.checkAndSet passes an additional cas identifier that the server handles to check if the data has to be updated.

def test_casUnknowKey(self):

When MemCacheProtocol.checkAndSet response is EXISTS, the resulting Deferred fires with False.

API Documentation for twisted, generated by pydoctor at 2020-03-25 17:34:30.

twisted.test.test_memcache.MemCacheTests(CommandMixin, TestCase) class documentation

`twisted.test.test_memcache.MemCacheTests(CommandMixin, TestCase)` class documentation