diff --git a/.gitignore b/.gitignore index c1979df..7cfa1dd 100644 --- a/.gitignore +++ b/.gitignore @@ -7,8 +7,7 @@ .*.sw[po] dist/ *.egg-info -*.egg -*.egg/ +*.egg* doc/__build/* docs/_build/ build/ diff --git a/mocket/mocket.py b/mocket/mocket.py index a442b5f..e918674 100644 --- a/mocket/mocket.py +++ b/mocket/mocket.py @@ -472,7 +472,6 @@ def enable(namespace=None, truesocket_recording_dir=None): (2, 1, 6, "", (host, port)) ] ssl.wrap_socket = ssl.__dict__["wrap_socket"] = FakeSSLContext.wrap_socket - # ssl.SSLSocket = ssl.__dict__["SSLSocket"] = MocketSocket ssl.SSLContext = ssl.__dict__["SSLContext"] = FakeSSLContext socket.inet_pton = socket.__dict__["inet_pton"] = lambda family, ip: byte_type( "\x7f\x00\x00\x01", "utf-8" @@ -502,7 +501,6 @@ def disable(): socket.gethostbyname = socket.__dict__["gethostbyname"] = true_gethostbyname socket.getaddrinfo = socket.__dict__["getaddrinfo"] = true_getaddrinfo ssl.wrap_socket = ssl.__dict__["wrap_socket"] = true_ssl_wrap_socket - # ssl.SSLSocket = ssl.__dict__["SSLSocket"] = true_ssl_socket ssl.SSLContext = ssl.__dict__["SSLContext"] = true_ssl_context socket.inet_pton = socket.__dict__["inet_pton"] = true_inet_pton urllib3.util.ssl_.wrap_socket = urllib3.util.ssl_.__dict__[ @@ -548,7 +546,9 @@ def __init__(self, location, responses): lresponses = [] for r in responses: - if not getattr(r, "data", False): + if isinstance(r, BaseException): + pass + elif not getattr(r, "data", False): if isinstance(r, text_type): r = encode_to_bytes(r) r = self.response_cls(r) @@ -569,6 +569,10 @@ def get_response(self): response = self.responses[self.response_index] if self.response_index < len(self.responses) - 1: self.response_index += 1 + + if isinstance(response, BaseException): + raise response + return response.data @@ -600,9 +604,15 @@ def check_and_call(self, method): def wrap(test=None, truesocket_recording_dir=None): def wrapper(t, *args, **kw): instance = args[0] if args else None - namespace = ".".join( - (instance.__class__.__module__, instance.__class__.__name__, t.__name__) - ) + namespace = None + if truesocket_recording_dir: + namespace = ".".join( + ( + instance.__class__.__module__, + instance.__class__.__name__, + t.__name__, + ) + ) with Mocketizer( instance, namespace=namespace, diff --git a/mocket/mockhttp.py b/mocket/mockhttp.py index dfa8c03..b07ddab 100644 --- a/mocket/mockhttp.py +++ b/mocket/mockhttp.py @@ -231,11 +231,22 @@ def register(cls, method, uri, *responses, **config): @classmethod def single_register( - cls, method, uri, body="", status=200, headers=None, match_querystring=True + cls, + method, + uri, + body="", + status=200, + headers=None, + match_querystring=True, + exception=None, ): + + response = ( + exception + if exception + else cls.response_cls(body=body, status=status, headers=headers) + ) + cls.register( - method, - uri, - cls.response_cls(body=body, status=status, headers=headers), - match_querystring=match_querystring, + method, uri, response, match_querystring=match_querystring, ) diff --git a/mocket/mockredis.py b/mocket/mockredis.py index 47db090..2599dfa 100644 --- a/mocket/mockredis.py +++ b/mocket/mockredis.py @@ -2,8 +2,7 @@ from itertools import chain -from .compat import (byte_type, decode_from_bytes, encode_to_bytes, shsplit, - text_type) +from .compat import byte_type, decode_from_bytes, encode_to_bytes, shsplit, text_type from .mocket import Mocket, MocketEntry @@ -21,38 +20,45 @@ class Redisizer(byte_type): @staticmethod def tokens(iterable): iterable = [encode_to_bytes(x) for x in iterable] - return [ - '*{0}'.format(len(iterable)).encode('utf-8') - ] + list( - chain(*zip(['${0}'.format(len(x)).encode('utf-8') for x in iterable], iterable)) + return ["*{0}".format(len(iterable)).encode("utf-8")] + list( + chain( + *zip( + ["${0}".format(len(x)).encode("utf-8") for x in iterable], iterable + ) + ) ) @staticmethod def redisize(data): def get_conversion(t): return { - dict: lambda x: b'\r\n'.join(Redisizer.tokens(list(chain(*tuple(x.items()))))), - int: lambda x: ':{0}'.format(x).encode('utf-8'), - text_type: lambda x: '${0}\r\n{1}'.format(len(x.encode('utf-8')), x).encode('utf-8'), - list: lambda x: b'\r\n'.join(Redisizer.tokens(x)), + dict: lambda x: b"\r\n".join( + Redisizer.tokens(list(chain(*tuple(x.items())))) + ), + int: lambda x: ":{0}".format(x).encode("utf-8"), + text_type: lambda x: "${0}\r\n{1}".format( + len(x.encode("utf-8")), x + ).encode("utf-8"), + list: lambda x: b"\r\n".join(Redisizer.tokens(x)), }[t] + if isinstance(data, Redisizer): return data if isinstance(data, byte_type): data = decode_from_bytes(data) - return Redisizer(get_conversion(data.__class__)(data) + b'\r\n') + return Redisizer(get_conversion(data.__class__)(data) + b"\r\n") @staticmethod - def command(description, _type='+'): - return Redisizer('{0}{1}{2}'.format(_type, description, '\r\n').encode('utf-8')) + def command(description, _type="+"): + return Redisizer("{0}{1}{2}".format(_type, description, "\r\n").encode("utf-8")) @staticmethod def error(description): - return Redisizer.command(description, _type='-') + return Redisizer.command(description, _type="-") -OK = Redisizer.command('OK') -QUEUED = Redisizer.command('QUEUED') +OK = Redisizer.command("OK") +QUEUED = Redisizer.command("QUEUED") ERROR = Redisizer.error @@ -61,7 +67,7 @@ class Entry(MocketEntry): response_cls = Response def __init__(self, addr, command, responses): - super(Entry, self).__init__(addr or ('localhost', 6379), responses) + super(Entry, self).__init__(addr or ("localhost", 6379), responses) d = shsplit(command) d[0] = d[0].upper() self.command = Redisizer.tokens(d) @@ -71,7 +77,10 @@ def can_handle(self, data): @classmethod def register(cls, addr, command, *responses): - responses = [cls.response_cls(r) for r in responses] + responses = [ + r if isinstance(r, BaseException) else cls.response_cls(r) + for r in responses + ] Mocket.register(cls(addr, command, responses)) @classmethod diff --git a/tests/main/test_http.py b/tests/main/test_http.py index 3a1aef9..6786568 100644 --- a/tests/main/test_http.py +++ b/tests/main/test_http.py @@ -323,6 +323,13 @@ def test_post_file_object(self): r = requests.post(url, files=files, data={}, verify=False) self.assertEqual(r.status_code, 201) + @mocketize + def test_raise_exception(self): + url = "http://github.com/fluidicon.png" + Entry.single_register(Entry.GET, url, exception=socket.error()) + with self.assertRaises(requests.exceptions.ConnectionError): + requests.get(url) + @mocketize def test_sockets(self): """ @@ -355,5 +362,4 @@ def test_sockets(self): sock.close() # Proof that worked. - print(Mocket.last_request().__dict__) - assert Mocket.last_request().body == '{"hello": "world"}' + self.assertEqual(Mocket.last_request().body, '{"hello": "world"}') diff --git a/tests/main/test_https.py b/tests/main/test_https.py index a360272..10f0762 100644 --- a/tests/main/test_https.py +++ b/tests/main/test_https.py @@ -5,10 +5,10 @@ import pytest import requests -from tests import urlopen -from mocket import Mocket, mocketize, Mocketizer +from mocket import Mocket, Mocketizer, mocketize from mocket.mockhttp import Entry +from tests import urlopen @pytest.fixture @@ -22,18 +22,19 @@ def response(): @mocketize def test_json(response): - url_to_mock = 'https://testme.org/json' + url_to_mock = "https://testme.org/json" Entry.single_register( Entry.GET, url_to_mock, body=json.dumps(response), - headers={'content-type': 'application/json'}) + headers={"content-type": "application/json"}, + ) mocked_response = requests.get(url_to_mock).json() assert response == mocked_response - mocked_response = json.loads(urlopen(url_to_mock).read().decode('utf-8')) + mocked_response = json.loads(urlopen(url_to_mock).read().decode("utf-8")) assert response == mocked_response @@ -43,21 +44,19 @@ def test_json(response): @pytest.mark.skipif('os.getenv("SKIP_TRUE_HTTP", False)') @mocketize(truesocket_recording_dir=recording_directory) def test_truesendall_with_recording_https(): - url = 'https://httpbin.org/ip' + url = "https://httpbin.org/ip" requests.get(url, headers={"Accept": "application/json"}) resp = requests.get(url, headers={"Accept": "application/json"}) - print(resp.content) assert resp.status_code == 200 dump_filename = os.path.join( - Mocket.get_truesocket_recording_dir(), - Mocket.get_namespace() + '.json', + Mocket.get_truesocket_recording_dir(), Mocket.get_namespace() + ".json", ) with io.open(dump_filename) as f: responses = json.load(f) - assert len(responses['httpbin.org']['443'].keys()) == 1 + assert len(responses["httpbin.org"]["443"].keys()) == 1 @pytest.mark.skipif('os.getenv("SKIP_TRUE_HTTP", False)') @@ -65,7 +64,7 @@ def test_truesendall_after_mocket_session(): Mocket.enable() Mocket.disable() - url = 'https://httpbin.org/ip' + url = "https://httpbin.org/ip" resp = requests.get(url) assert resp.status_code == 200 @@ -74,8 +73,8 @@ def test_truesendall_after_mocket_session(): def test_real_request_session(): session = requests.Session() - url1 = 'https://httpbin.org/ip' - url2 = 'http://httpbin.org/headers' + url1 = "https://httpbin.org/ip" + url2 = "http://httpbin.org/headers" with Mocketizer(): assert len(session.get(url1).content) < len(session.get(url2).content) diff --git a/tests/main/test_mocket.py b/tests/main/test_mocket.py index d54a5c7..e3c244a 100644 --- a/tests/main/test_mocket.py +++ b/tests/main/test_mocket.py @@ -34,29 +34,29 @@ def test_has_requests(self): def test_gethostname(self): hostname = socket.gethostname() Mocket.enable() - self.assertEqual(socket.gethostname(), 'localhost') + self.assertEqual(socket.gethostname(), "localhost") Mocket.disable() self.assertEqual(socket.gethostname(), hostname) def test_gethostbyname(self): - host = socket.gethostbyname('localhost') + host = socket.gethostbyname("localhost") Mocket.enable() - self.assertEqual(socket.gethostbyname('localhost'), '127.0.0.1') + self.assertEqual(socket.gethostbyname("localhost"), "127.0.0.1") Mocket.disable() - self.assertEqual(socket.gethostbyname('localhost'), host) + self.assertEqual(socket.gethostbyname("localhost"), host) def test_register(self): - entry_1 = MocketEntry(('localhost', 80), True) - entry_2 = MocketEntry(('localhost', 80), True) - entry_3 = MocketEntry(('localhost', 8080), True) + entry_1 = MocketEntry(("localhost", 80), True) + entry_2 = MocketEntry(("localhost", 80), True) + entry_3 = MocketEntry(("localhost", 8080), True) Mocket.register(entry_1, entry_2, entry_3) - self.assertEqual(Mocket._entries, { - ('localhost', 80): [entry_1, entry_2], - ('localhost', 8080): [entry_3], - }) + self.assertEqual( + Mocket._entries, + {("localhost", 80): [entry_1, entry_2], ("localhost", 8080): [entry_3],}, + ) def test_collect(self): - request = 'GET /get/p/?b=2&a=1 HTTP/1.1\r\nAccept-Encoding: identity\r\nHost: testme.org\r\nConnection: close\r\nUser-Agent: Python-urllib/2.6\r\n\r\n' + request = "GET /get/p/?b=2&a=1 HTTP/1.1\r\nAccept-Encoding: identity\r\nHost: testme.org\r\nConnection: close\r\nUser-Agent: Python-urllib/2.6\r\n\r\n" Mocket.collect(request) self.assertEqual(Mocket.last_request(), request) self.assertEqual(Mocket._requests, [request]) @@ -71,58 +71,48 @@ def test_remove_last_empty(self): self.assertEqual(Mocket._requests, []) def test_getentry(self): - entry = MocketEntry(('localhost', 80), True) + entry = MocketEntry(("localhost", 80), True) Mocket.register(entry) - self.assertEqual(Mocket.get_entry('localhost', 80, True), entry) + self.assertEqual(Mocket.get_entry("localhost", 80, True), entry) def test_getresponse(self): - entry = MocketEntry(('localhost', 8080), ['Show me.\r\n']) - self.assertEqual(entry.get_response(), encode_to_bytes('Show me.\r\n')) + entry = MocketEntry(("localhost", 8080), ["Show me.\r\n"]) + self.assertEqual(entry.get_response(), encode_to_bytes("Show me.\r\n")) def test_empty_getresponse(self): - entry = MocketEntry(('localhost', 8080), []) - self.assertEqual(entry.get_response(), encode_to_bytes('')) + entry = MocketEntry(("localhost", 8080), []) + self.assertEqual(entry.get_response(), encode_to_bytes("")) + + def test_raise_exception(self): + entry = MocketEntry(("localhost", 8080), [IOError()]) + + with self.assertRaises(IOError): + entry.get_response() def test_subsequent_recv_requests_have_correct_length(self): - Mocket.register( - MocketEntry( - ('localhost', 80), - [ - b'Long payload', - b'Short' - ] - ) - ) + Mocket.register(MocketEntry(("localhost", 80), [b"Long payload", b"Short"])) with Mocketizer(): _so = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - _so.connect(('localhost', 80)) - _so.sendall(b'first\r\n') - assert _so.recv(4096) == b'Long payload' - _so.sendall(b'second\r\n') - assert _so.recv(4096) == b'Short' + _so.connect(("localhost", 80)) + _so.sendall(b"first\r\n") + self.assertEqual(_so.recv(4096), b"Long payload") + _so.sendall(b"second\r\n") + self.assertEqual(_so.recv(4096), b"Short") _so.close() def test_recv_into(self): - Mocket.register( - MocketEntry( - ('localhost', 80), - [ - b'Long payload', - b'Short' - ] - ) - ) + Mocket.register(MocketEntry(("localhost", 80), [b"Long payload", b"Short"])) buffer = io.BytesIO() with Mocketizer(): _so = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - _so.connect(('localhost', 80)) - _so.sendall(b'first\r\n') - assert _so.recv_into(buffer, 4096) == 12 - _so.sendall(b'second\r\n') - assert _so.recv_into(buffer) == 5 + _so.connect(("localhost", 80)) + _so.sendall(b"first\r\n") + self.assertEqual(_so.recv_into(buffer, 4096), 12) + _so.sendall(b"second\r\n") + self.assertEqual(_so.recv_into(buffer), 5) _so.close() buffer.seek(0) - assert buffer.read() == b'Long payloadShort' + assert buffer.read() == b"Long payloadShort" class MocketizeTestCase(TestCase): @@ -134,7 +124,7 @@ def mocketize_teardown(self): @mocketize def test_gethostname(self): - self.assertEqual(socket.gethostname(), 'localhost') + self.assertEqual(socket.gethostname(), "localhost") @mocketize diff --git a/tests/main/test_redis.py b/tests/main/test_redis.py index f48fcb0..cda5d9f 100644 --- a/tests/main/test_redis.py +++ b/tests/main/test_redis.py @@ -2,6 +2,7 @@ from __future__ import unicode_literals +import socket from unittest import TestCase import pytest @@ -14,51 +15,41 @@ class RedisizerTestCase(TestCase): def test_token(self): self.assertEqual( - Redisizer.tokens(['SET', 'snowman', 'is ☃!']), - [b'*3', b'$3', b'SET', b'$7', b'snowman', b'$7', b'is \xe2\x98\x83!'] + Redisizer.tokens(["SET", "snowman", "is ☃!"]), + [b"*3", b"$3", b"SET", b"$7", b"snowman", b"$7", b"is \xe2\x98\x83!"], ) def test_command(self): - self.assertEqual(Redisizer.command('OK'), b'+OK\r\n') + self.assertEqual(Redisizer.command("OK"), b"+OK\r\n") def test_error(self): self.assertEqual( - Redisizer.error('ERR: ☃ summer'), - b'-ERR: \xe2\x98\x83 summer\r\n' + Redisizer.error("ERR: ☃ summer"), b"-ERR: \xe2\x98\x83 summer\r\n" ) def test_redisize_int(self): - self.assertEqual(Redisizer.redisize(10), b':10\r\n') + self.assertEqual(Redisizer.redisize(10), b":10\r\n") def test_redisize_list(self): self.assertEqual( - Redisizer.redisize(['snowman', '☃']), - b'*2\r\n$7\r\nsnowman\r\n$3\r\n\xe2\x98\x83\r\n' + Redisizer.redisize(["snowman", "☃"]), + b"*2\r\n$7\r\nsnowman\r\n$3\r\n\xe2\x98\x83\r\n", ) def test_redisize_dict(self): self.assertEqual( - Redisizer.redisize({'snowman': '☃'}), - b'*2\r\n$7\r\nsnowman\r\n$3\r\n\xe2\x98\x83\r\n' + Redisizer.redisize({"snowman": "☃"}), + b"*2\r\n$7\r\nsnowman\r\n$3\r\n\xe2\x98\x83\r\n", ) def test_redisize_text(self): - self.assertEqual( - Redisizer.redisize('☃'), - b'$3\r\n\xe2\x98\x83\r\n' - ) + self.assertEqual(Redisizer.redisize("☃"), b"$3\r\n\xe2\x98\x83\r\n") def test_redisize_byte(self): - self.assertEqual( - Redisizer.redisize(b'\xe2\x98\x83'), - b'$3\r\n\xe2\x98\x83\r\n' - ) + self.assertEqual(Redisizer.redisize(b"\xe2\x98\x83"), b"$3\r\n\xe2\x98\x83\r\n") def test_redisize_command(self): - self.assertEqual( - Redisizer.redisize(Redisizer.command('OK')), - b'+OK\r\n' - ) + self.assertEqual(Redisizer.redisize(Redisizer.command("OK")), b"+OK\r\n") class RedisEntryTestCase(TestCase): @@ -66,33 +57,38 @@ def test_init_text(self): entry = Entry(addr=None, command='SET snowman "is ☃!"', responses=[]) self.assertEqual( entry.command, - [b'*3', b'$3', b'SET', b'$7', b'snowman', b'$7', b'is \xe2\x98\x83!'] + [b"*3", b"$3", b"SET", b"$7", b"snowman", b"$7", b"is \xe2\x98\x83!"], ) def test_init_byte(self): - entry = Entry(addr=None, command=b'SET snowman "is \xe2\x98\x83!"', responses=[]) + entry = Entry( + addr=None, command=b'SET snowman "is \xe2\x98\x83!"', responses=[] + ) self.assertEqual( entry.command, - [b'*3', b'$3', b'SET', b'$7', b'snowman', b'$7', b'is \xe2\x98\x83!'] + [b"*3", b"$3", b"SET", b"$7", b"snowman", b"$7", b"is \xe2\x98\x83!"], ) def test_can_handle(self): entry = Entry(addr=None, command='SET snowman "is ☃!"', responses=[]) - self.assertTrue(entry.can_handle(b'*3\r\n$3\r\nSET\r\n$7\r\nsnowman\r\n$7\r\nis \xe2\x98\x83!')) + self.assertTrue( + entry.can_handle( + b"*3\r\n$3\r\nSET\r\n$7\r\nsnowman\r\n$7\r\nis \xe2\x98\x83!" + ) + ) def test_register(self): - Entry.register(('localhost', 6379), 'SET snowman "is ☃!"', OK) + Entry.register(("localhost", 6379), 'SET snowman "is ☃!"', OK) self.assertEqual( - Mocket._entries[('localhost', 6379)][0].command, - [b'*3', b'$3', b'SET', b'$7', b'snowman', b'$7', b'is \xe2\x98\x83!'] + Mocket._entries[("localhost", 6379)][0].command, + [b"*3", b"$3", b"SET", b"$7", b"snowman", b"$7", b"is \xe2\x98\x83!"], ) self.assertEqual( - Mocket._entries[('localhost', 6379)][0].responses[0].data, - b'+OK\r\n' + Mocket._entries[("localhost", 6379)][0].responses[0].data, b"+OK\r\n" ) def test_register_response(self): - Entry.register_response(command='SET snowman "is ☃!"', response='') + Entry.register_response(command='SET snowman "is ☃!"', response="") @pytest.mark.skipif('os.getenv("SKIP_TRUE_REDIS", False)') @@ -107,59 +103,59 @@ def mocketize_teardown(self): @mocketize def test_set(self): - self.assertTrue(self.rclient.set('mocket', 'is awesome!')) + self.assertTrue(self.rclient.set("mocket", "is awesome!")) @mocketize def test_incr(self): - self.assertEqual(self.rclient.incr('counter'), 1) - self.assertEqual(self.rclient.incr('counter'), 2) - self.assertEqual(self.rclient.incr('counter'), 3) + self.assertEqual(self.rclient.incr("counter"), 1) + self.assertEqual(self.rclient.incr("counter"), 2) + self.assertEqual(self.rclient.incr("counter"), 3) @mocketize def test_get(self): - self.rclient.set('mocket', 'is awesome!') - self.assertEqual(self.rclient.get('mocket'), b'is awesome!') + self.rclient.set("mocket", "is awesome!") + self.assertEqual(self.rclient.get("mocket"), b"is awesome!") @mocketize def test_get_utf8(self): - self.rclient.set('snowman', '☃') - self.assertEqual(self.rclient.get('snowman'), b'\xe2\x98\x83') + self.rclient.set("snowman", "☃") + self.assertEqual(self.rclient.get("snowman"), b"\xe2\x98\x83") @mocketize def test_get_unicode(self): - self.rclient.set('snowman', u'\u2603') - self.assertEqual(self.rclient.get('snowman'), b'\xe2\x98\x83') + self.rclient.set("snowman", "\u2603") + self.assertEqual(self.rclient.get("snowman"), b"\xe2\x98\x83") @mocketize def test_hm(self): - h = {b'f1': b'one', b'f2': b'two'} - self.assertTrue(self.rclient.hmset('hash', h)) - self.assertEqual(self.rclient.hgetall('hash'), h) + h = {b"f1": b"one", b"f2": b"two"} + self.assertTrue(self.rclient.hmset("hash", h)) + self.assertEqual(self.rclient.hgetall("hash"), h) @mocketize def test_lrange(self): - l = [b'one', b'two', b'three'] - self.rclient.rpush('list', *l) - self.assertEqual(self.rclient.lrange('list', 0, -1), l) + l = [b"one", b"two", b"three"] + self.rclient.rpush("list", *l) + self.assertEqual(self.rclient.lrange("list", 0, -1), l) @mocketize def test_err(self): - self.assertRaises(redis.ResponseError, self.rclient.incr, 'counter', 'one') + self.assertRaises(redis.ResponseError, self.rclient.incr, "counter", "one") @mocketize def test_shutdown(self): - rc = redis.StrictRedis(host='127.1.1.1') + rc = redis.StrictRedis(host="127.1.1.1") try: - rc.get('foo') + rc.get("foo") except redis.ConnectionError: pass @mocketize def test_select_db(self): r = redis.StrictRedis(db=1) - r.set('foo', 10) - foo = r.get('foo') - self.assertEqual(foo, b'10') + r.set("foo", 10) + foo = r.get("foo") + self.assertEqual(foo, b"10") class RedisTestCase(TestCase): @@ -167,7 +163,7 @@ def setUp(self): self.rclient = redis.StrictRedis() def mocketize_setup(self): - Entry.register_response('FLUSHDB', OK) + Entry.register_response("FLUSHDB", OK) self.rclient.flushdb() self.assertEqual(len(Mocket._requests), 1) Mocket.reset() @@ -175,61 +171,96 @@ def mocketize_setup(self): @mocketize def test_set(self): Entry.register_response('SET mocket "is awesome!"', OK) - self.assertTrue(self.rclient.set('mocket', 'is awesome!')) + self.assertTrue(self.rclient.set("mocket", "is awesome!")) self.assertEqual(len(Mocket._requests), 1) - self.assertEqual(Mocket.last_request().data, b'*3\r\n$3\r\nSET\r\n$6\r\nmocket\r\n$11\r\nis awesome!\r\n') + self.assertEqual( + Mocket.last_request().data, + b"*3\r\n$3\r\nSET\r\n$6\r\nmocket\r\n$11\r\nis awesome!\r\n", + ) @mocketize def test_incr(self): - Entry.register_responses('INCRBY counter 1', (1, 2, 3)) - self.assertEqual(self.rclient.incr('counter'), 1) - self.assertEqual(self.rclient.incr('counter'), 2) - self.assertEqual(self.rclient.incr('counter'), 3) + Entry.register_responses("INCRBY counter 1", (1, 2, 3)) + self.assertEqual(self.rclient.incr("counter"), 1) + self.assertEqual(self.rclient.incr("counter"), 2) + self.assertEqual(self.rclient.incr("counter"), 3) self.assertEqual(len(Mocket._requests), 3) - self.assertEqual(Mocket._requests[0].data, b'*3\r\n$6\r\nINCRBY\r\n$7\r\ncounter\r\n$1\r\n1\r\n') - self.assertEqual(Mocket._requests[1].data, b'*3\r\n$6\r\nINCRBY\r\n$7\r\ncounter\r\n$1\r\n1\r\n') - self.assertEqual(Mocket._requests[2].data, b'*3\r\n$6\r\nINCRBY\r\n$7\r\ncounter\r\n$1\r\n1\r\n') + self.assertEqual( + Mocket._requests[0].data, + b"*3\r\n$6\r\nINCRBY\r\n$7\r\ncounter\r\n$1\r\n1\r\n", + ) + self.assertEqual( + Mocket._requests[1].data, + b"*3\r\n$6\r\nINCRBY\r\n$7\r\ncounter\r\n$1\r\n1\r\n", + ) + self.assertEqual( + Mocket._requests[2].data, + b"*3\r\n$6\r\nINCRBY\r\n$7\r\ncounter\r\n$1\r\n1\r\n", + ) @mocketize def test_hgetall(self): - h = {b'f1': b'one', b'f2': b'two'} - Entry.register_response('HGETALL hash', h) - self.assertEqual(self.rclient.hgetall('hash'), h) + h = {b"f1": b"one", b"f2": b"two"} + Entry.register_response("HGETALL hash", h) + self.assertEqual(self.rclient.hgetall("hash"), h) self.assertEqual(len(Mocket._requests), 1) - self.assertEqual(Mocket._requests[0].data, b'*2\r\n$7\r\nHGETALL\r\n$4\r\nhash\r\n') + self.assertEqual( + Mocket._requests[0].data, b"*2\r\n$7\r\nHGETALL\r\n$4\r\nhash\r\n" + ) @mocketize def test_get(self): - Entry.register_response('GET mocket', 'is awesome!') - self.assertEqual(self.rclient.get('mocket'), b'is awesome!') + Entry.register_response("GET mocket", "is awesome!") + self.assertEqual(self.rclient.get("mocket"), b"is awesome!") self.assertEqual(len(Mocket._requests), 1) - self.assertEqual(Mocket._requests[0].data, b'*2\r\n$3\r\nGET\r\n$6\r\nmocket\r\n') + self.assertEqual( + Mocket._requests[0].data, b"*2\r\n$3\r\nGET\r\n$6\r\nmocket\r\n" + ) @mocketize def test_get_utf8(self): - Entry.register_response('GET snowman', '☃') - self.assertEqual(self.rclient.get('snowman'), b'\xe2\x98\x83') + Entry.register_response("GET snowman", "☃") + self.assertEqual(self.rclient.get("snowman"), b"\xe2\x98\x83") self.assertEqual(len(Mocket._requests), 1) - self.assertEqual(Mocket._requests[0].data, b'*2\r\n$3\r\nGET\r\n$7\r\nsnowman\r\n') + self.assertEqual( + Mocket._requests[0].data, b"*2\r\n$3\r\nGET\r\n$7\r\nsnowman\r\n" + ) @mocketize def test_get_unicode(self): - Entry.register_response('GET snowman', '\u2603') - self.assertEqual(self.rclient.get('snowman'), b'\xe2\x98\x83') + Entry.register_response("GET snowman", "\u2603") + self.assertEqual(self.rclient.get("snowman"), b"\xe2\x98\x83") self.assertEqual(len(Mocket._requests), 1) - self.assertEqual(Mocket.last_request().data, b'*2\r\n$3\r\nGET\r\n$7\r\nsnowman\r\n') + self.assertEqual( + Mocket.last_request().data, b"*2\r\n$3\r\nGET\r\n$7\r\nsnowman\r\n" + ) @mocketize def test_lrange(self): - l = [b'one', b'two', b'three'] - Entry.register_response('LRANGE list 0 -1', l) - self.assertEqual(self.rclient.lrange('list', 0, -1), l) + l = [b"one", b"two", b"three"] + Entry.register_response("LRANGE list 0 -1", l) + self.assertEqual(self.rclient.lrange("list", 0, -1), l) self.assertEqual(len(Mocket._requests), 1) - self.assertEqual(Mocket.last_request().data, b'*4\r\n$6\r\nLRANGE\r\n$4\r\nlist\r\n$1\r\n0\r\n$2\r\n-1\r\n') + self.assertEqual( + Mocket.last_request().data, + b"*4\r\n$6\r\nLRANGE\r\n$4\r\nlist\r\n$1\r\n0\r\n$2\r\n-1\r\n", + ) @mocketize def test_err(self): - Entry.register_response('INCRBY counter one', ERROR('ERR value is not an integer or out of range')) - self.assertRaises(redis.ResponseError, self.rclient.incr, 'counter', 'one') + Entry.register_response( + "INCRBY counter one", ERROR("ERR value is not an integer or out of range") + ) + self.assertRaises(redis.ResponseError, self.rclient.incr, "counter", "one") self.assertEqual(len(Mocket._requests), 1) - self.assertEqual(Mocket.last_request().data, b'*3\r\n$6\r\nINCRBY\r\n$7\r\ncounter\r\n$3\r\none\r\n') + self.assertEqual( + Mocket.last_request().data, + b"*3\r\n$6\r\nINCRBY\r\n$7\r\ncounter\r\n$3\r\none\r\n", + ) + + @mocketize + def test_raise_exception(self): + Entry.register_response("INCRBY counter one", socket.error("Mocket rulez!")) + self.assertRaises( + redis.exceptions.ConnectionError, self.rclient.incr, "counter", "one" + )