From c18c96beb34fac11a11ca2191637d5efd8b66b93 Mon Sep 17 00:00:00 2001 From: Alexey Popravka Date: Mon, 18 Nov 2019 22:35:22 +0200 Subject: [PATCH] remove run_loop tests marker --- setup.cfg | 2 +- tests/conftest.py | 27 ++++++++++-------------- tests/connection_commands_test.py | 9 -------- tests/connection_test.py | 29 ------------------------- tests/generic_commands_test.py | 34 ++---------------------------- tests/geo_commands_test.py | 11 ---------- tests/hash_commands_test.py | 18 ---------------- tests/hyperloglog_commands_test.py | 5 ----- tests/integration_test.py | 1 - tests/list_commands_test.py | 20 ------------------ tests/locks_test.py | 2 -- tests/pool_test.py | 31 --------------------------- tests/pubsub_commands_test.py | 17 --------------- tests/pubsub_receiver_test.py | 12 +---------- tests/scripting_commands_test.py | 6 ------ tests/sentinel_commands_test.py | 24 ++++----------------- tests/sentinel_failover_test.py | 8 ++----- tests/server_commands_test.py | 23 -------------------- tests/set_commands_test.py | 17 --------------- tests/sorted_set_commands_test.py | 27 ------------------------ tests/ssl_test.py | 5 ----- tests/stream_commands_test.py | 29 ------------------------- tests/stream_test.py | 3 --- tests/string_commands_test.py | 33 ----------------------------- tests/task_cancellation_test.py | 1 - tests/transaction_commands_test.py | 15 ------------- 26 files changed, 21 insertions(+), 388 deletions(-) diff --git a/setup.cfg b/setup.cfg index 7fd6e801d..1c043463e 100644 --- a/setup.cfg +++ b/setup.cfg @@ -3,7 +3,7 @@ minversion = 2.9.1 addopts = -r a --cov-report=term --cov-report=html restpaths = tests markers = - run_loop: Mark coroutine to be run with asyncio loop. + timeout: Set coroutine execution timeout (default is 15 seconds). redis_version(*version, reason): Mark test expecting minimum Redis version skip(reason): Skip test python_files = diff --git a/tests/conftest.py b/tests/conftest.py index 516eb1c4f..e64e37b97 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -9,6 +9,7 @@ import time import tempfile import atexit +import inspect from collections import namedtuple from urllib.parse import urlencode, urlunparse @@ -529,25 +530,19 @@ def run(*commandline, _clear_tmp_files=(), **kwargs): pass -@pytest.mark.tryfirst -def pytest_pycollect_makeitem(collector, name, obj): - if collector.funcnamefilter(name): - if not callable(obj): - return - item = pytest.Function(name, parent=collector) - if item.get_closest_marker('run_loop') is not None: - # TODO: re-wrap with asyncio.coroutine if not native coroutine - return list(collector._genfunctions(name, obj)) - - @pytest.mark.tryfirst def pytest_pyfunc_call(pyfuncitem): """ Run asyncio marked test functions in an event loop instead of a normal function call. """ - marker = pyfuncitem.get_closest_marker('run_loop') - if marker is not None: + if inspect.iscoroutinefunction(pyfuncitem.obj): + marker = pyfuncitem.get_closest_marker('timeout') + if marker is not None and marker.args: + timeout = marker.args[0] + else: + timeout = 15 + funcargs = pyfuncitem.funcargs loop = funcargs['loop'] testargs = {arg: funcargs[arg] @@ -555,7 +550,7 @@ def pytest_pyfunc_call(pyfuncitem): loop.run_until_complete( _wait_coro(pyfuncitem.obj, testargs, - timeout=marker.kwargs.get('timeout', 15), + timeout=timeout, loop=loop)) return True @@ -566,8 +561,8 @@ async def _wait_coro(corofunc, kwargs, timeout, loop): def pytest_runtest_setup(item): - run_loop = item.get_closest_marker('run_loop') - if run_loop and 'loop' not in item.fixturenames: + is_coro = inspect.iscoroutinefunction(item.obj) + if is_coro and 'loop' not in item.fixturenames: # inject an event loop fixture for all async tests item.fixturenames.append('loop') diff --git a/tests/connection_commands_test.py b/tests/connection_commands_test.py index 38e94d649..652edd64e 100644 --- a/tests/connection_commands_test.py +++ b/tests/connection_commands_test.py @@ -7,7 +7,6 @@ from _testutils import redis_version -@pytest.mark.run_loop async def test_repr(create_redis, loop, server): redis = await create_redis( server.tcp_address, db=1, loop=loop) @@ -24,14 +23,12 @@ async def test_repr(create_redis, loop, server): } -@pytest.mark.run_loop async def test_auth(redis): expected_message = "ERR Client sent AUTH, but no password is set" with pytest.raises(ReplyError, match=expected_message): await redis.auth('') -@pytest.mark.run_loop async def test_echo(redis): resp = await redis.echo('ECHO') assert resp == b'ECHO' @@ -40,12 +37,10 @@ async def test_echo(redis): await redis.echo(None) -@pytest.mark.run_loop async def test_ping(redis): assert await redis.ping() == b'PONG' -@pytest.mark.run_loop async def test_quit(redis, loop): expected = (ConnectionClosedError, ConnectionError) try: @@ -70,7 +65,6 @@ async def test_quit(redis, loop): await redis.ping() -@pytest.mark.run_loop async def test_select(redis): assert redis.db == 0 @@ -80,7 +74,6 @@ async def test_select(redis): assert redis.connection.db == 1 -@pytest.mark.run_loop async def test_encoding(create_redis, loop, server): redis = await create_redis( server.tcp_address, @@ -89,7 +82,6 @@ async def test_encoding(create_redis, loop, server): assert redis.encoding == 'utf-8' -@pytest.mark.run_loop async def test_yield_from_backwards_compatibility(create_redis, server, loop): redis = await create_redis(server.tcp_address, loop=loop) @@ -103,7 +95,6 @@ async def test_yield_from_backwards_compatibility(create_redis, server, loop): @redis_version(4, 0, 0, reason="SWAPDB is available since redis>=4.0.0") -@pytest.mark.run_loop async def test_swapdb(create_redis, start_server, loop): server = start_server('swapdb_1') cli1 = await create_redis(server.tcp_address, db=0, loop=loop) diff --git a/tests/connection_test.py b/tests/connection_test.py index 5956ee3e0..58c0fcb45 100644 --- a/tests/connection_test.py +++ b/tests/connection_test.py @@ -17,7 +17,6 @@ from _testutils import redis_version -@pytest.mark.run_loop async def test_connect_tcp(request, create_connection, loop, server): conn = await create_connection( server.tcp_address, loop=loop) @@ -36,7 +35,6 @@ async def test_connect_tcp(request, create_connection, loop, server): assert str(conn) == '' -@pytest.mark.run_loop async def test_connect_inject_connection_cls( request, create_connection, @@ -52,7 +50,6 @@ class MyConnection(RedisConnection): assert isinstance(conn, MyConnection) -@pytest.mark.run_loop async def test_connect_inject_connection_cls_invalid( request, create_connection, @@ -64,7 +61,6 @@ async def test_connect_inject_connection_cls_invalid( server.tcp_address, loop=loop, connection_cls=type) -@pytest.mark.run_loop async def test_connect_tcp_timeout(request, create_connection, loop, server): with patch.object(loop, 'create_connection') as\ open_conn_mock: @@ -74,7 +70,6 @@ async def test_connect_tcp_timeout(request, create_connection, loop, server): server.tcp_address, loop=loop, timeout=0.1) -@pytest.mark.run_loop async def test_connect_tcp_invalid_timeout( request, create_connection, loop, server): with pytest.raises(ValueError): @@ -82,7 +77,6 @@ async def test_connect_tcp_invalid_timeout( server.tcp_address, loop=loop, timeout=0) -@pytest.mark.run_loop @pytest.mark.skipif(sys.platform == 'win32', reason="No unixsocket on Windows") async def test_connect_unixsocket(create_connection, loop, server): @@ -93,7 +87,6 @@ async def test_connect_unixsocket(create_connection, loop, server): assert str(conn) == '' -@pytest.mark.run_loop @pytest.mark.skipif(sys.platform == 'win32', reason="No unixsocket on Windows") async def test_connect_unixsocket_timeout(create_connection, loop, server): @@ -104,7 +97,6 @@ async def test_connect_unixsocket_timeout(create_connection, loop, server): server.unixsocket, db=0, loop=loop, timeout=0.1) -@pytest.mark.run_loop @redis_version(2, 8, 0, reason="maxclients config setting") async def test_connect_maxclients(create_connection, loop, start_server): server = start_server('server-maxclients') @@ -128,7 +120,6 @@ def test_global_loop(create_connection, loop, server): # assert conn._loop is loop -@pytest.mark.run_loop async def test_select_db(create_connection, loop, server): address = server.tcp_address conn = await create_connection(address, loop=loop) @@ -159,7 +150,6 @@ async def test_select_db(create_connection, loop, server): assert conn.db == 1 -@pytest.mark.run_loop async def test_protocol_error(create_connection, loop, server): conn = await create_connection( server.tcp_address, loop=loop) @@ -195,7 +185,6 @@ def test_close_connection__tcp(create_connection, loop, server): conn.execute_pubsub('subscribe', 'channel:1') -@pytest.mark.run_loop @pytest.mark.skipif(sys.platform == 'win32', reason="No unixsocket on Windows") async def test_close_connection__socket(create_connection, loop, server): @@ -212,7 +201,6 @@ async def test_close_connection__socket(create_connection, loop, server): await conn.execute_pubsub('subscribe', 'channel:1') -@pytest.mark.run_loop async def test_closed_connection_with_none_reader( create_connection, loop, server): address = server.tcp_address @@ -233,7 +221,6 @@ async def test_closed_connection_with_none_reader( conn.close() -@pytest.mark.run_loop async def test_wait_closed(create_connection, loop, server): address = server.tcp_address conn = await create_connection(address, loop=loop) @@ -244,7 +231,6 @@ async def test_wait_closed(create_connection, loop, server): assert reader_task.done() -@pytest.mark.run_loop async def test_cancel_wait_closed(create_connection, loop, server): # Regression test: Don't throw error if wait_closed() is cancelled. address = server.tcp_address @@ -261,7 +247,6 @@ async def test_cancel_wait_closed(create_connection, loop, server): assert reader_task.done() -@pytest.mark.run_loop async def test_auth(create_connection, loop, server): conn = await create_connection( server.tcp_address, loop=loop) @@ -290,7 +275,6 @@ async def test_auth(create_connection, loop, server): assert res == b'OK' -@pytest.mark.run_loop async def test_decoding(create_connection, loop, server): conn = await create_connection( server.tcp_address, encoding='utf-8', loop=loop) @@ -320,7 +304,6 @@ async def test_decoding(create_connection, loop, server): assert res == 'значение' -@pytest.mark.run_loop async def test_execute_exceptions(create_connection, loop, server): conn = await create_connection( server.tcp_address, loop=loop) @@ -333,7 +316,6 @@ async def test_execute_exceptions(create_connection, loop, server): assert len(conn._waiters) == 0 -@pytest.mark.run_loop async def test_subscribe_unsubscribe(create_connection, loop, server): conn = await create_connection( server.tcp_address, loop=loop) @@ -364,7 +346,6 @@ async def test_subscribe_unsubscribe(create_connection, loop, server): assert conn.in_pubsub == 1 -@pytest.mark.run_loop async def test_psubscribe_punsubscribe(create_connection, loop, server): conn = await create_connection( server.tcp_address, loop=loop) @@ -373,7 +354,6 @@ async def test_psubscribe_punsubscribe(create_connection, loop, server): assert conn.in_pubsub == 1 -@pytest.mark.run_loop async def test_bad_command_in_pubsub(create_connection, loop, server): conn = await create_connection( server.tcp_address, loop=loop) @@ -388,7 +368,6 @@ async def test_bad_command_in_pubsub(create_connection, loop, server): conn.execute('get') -@pytest.mark.run_loop async def test_pubsub_messages(create_connection, loop, server): sub = await create_connection( server.tcp_address, loop=loop) @@ -425,7 +404,6 @@ async def test_pubsub_messages(create_connection, loop, server): assert msg == b'Hello!' -@pytest.mark.run_loop async def test_multiple_subscribe_unsubscribe(create_connection, loop, server): sub = await create_connection(server.tcp_address, loop=loop) @@ -455,7 +433,6 @@ async def test_multiple_subscribe_unsubscribe(create_connection, loop, server): assert res == [[b'punsubscribe', b'chan:*', 0]] -@pytest.mark.run_loop async def test_execute_pubsub_errors(create_connection, loop, server): sub = await create_connection( server.tcp_address, loop=loop) @@ -482,7 +459,6 @@ async def test_execute_pubsub_errors(create_connection, loop, server): Channel('chan:1', is_pattern=False, loop=loop)) -@pytest.mark.run_loop async def test_multi_exec(create_connection, loop, server): conn = await create_connection(server.tcp_address, loop=loop) @@ -504,7 +480,6 @@ async def test_multi_exec(create_connection, loop, server): assert res == b'OK' -@pytest.mark.run_loop async def test_multi_exec__enc(create_connection, loop, server): conn = await create_connection( server.tcp_address, loop=loop, encoding='utf-8') @@ -527,7 +502,6 @@ async def test_multi_exec__enc(create_connection, loop, server): assert res == 'OK' -@pytest.mark.run_loop async def test_connection_parser_argument(create_connection, server, loop): klass = mock.MagicMock() klass.return_value = reader = mock.Mock() @@ -548,7 +522,6 @@ def feed_gets(data, **kwargs): assert b'+PONG\r\n' == await conn.execute('ping') -@pytest.mark.run_loop async def test_connection_idle_close(create_connection, start_server, loop): server = start_server('idle') conn = await create_connection(server.tcp_address, loop=loop) @@ -566,7 +539,6 @@ async def test_connection_idle_close(create_connection, start_server, loop): {'db': 1}, {'encoding': 'utf-8'}, ], ids=repr) -@pytest.mark.run_loop async def test_create_connection__tcp_url( create_connection, server_tcp_url, loop, kwargs): url = server_tcp_url(**kwargs) @@ -586,7 +558,6 @@ async def test_create_connection__tcp_url( {'db': 1}, {'encoding': 'utf-8'}, ], ids=repr) -@pytest.mark.run_loop async def test_create_connection__unix_url( create_connection, server_unix_url, loop, kwargs): url = server_unix_url(**kwargs) diff --git a/tests/generic_commands_test.py b/tests/generic_commands_test.py index 42b7c9d2d..d4794727a 100644 --- a/tests/generic_commands_test.py +++ b/tests/generic_commands_test.py @@ -15,7 +15,6 @@ async def add(redis, key, value): assert ok == b'OK' -@pytest.mark.run_loop async def test_delete(redis): await add(redis, 'my-key', 123) await add(redis, 'other-key', 123) @@ -33,7 +32,6 @@ async def test_delete(redis): await redis.delete('my-key', 'my-key', None) -@pytest.mark.run_loop async def test_dump(redis): await add(redis, 'my-key', 123) @@ -49,7 +47,6 @@ async def test_dump(redis): await redis.dump(None) -@pytest.mark.run_loop async def test_exists(redis, server): await add(redis, 'my-key', 123) @@ -70,7 +67,6 @@ async def test_exists(redis, server): @redis_version( 3, 0, 3, reason='Multi-key EXISTS available since redis>=2.8.0') -@pytest.mark.run_loop async def test_exists_multiple(redis): await add(redis, 'my-key', 123) @@ -87,7 +83,6 @@ async def test_exists_multiple(redis): assert res == 0 -@pytest.mark.run_loop async def test_expire(redis): await add(redis, 'my-key', 132) @@ -116,7 +111,6 @@ async def test_expire(redis): await redis.expire('my-key', 'timeout') -@pytest.mark.run_loop async def test_expireat(redis): await add(redis, 'my-key', 123) now = math.ceil(time.time()) @@ -153,7 +147,6 @@ async def test_expireat(redis): await redis.expireat('my-key', 'timestamp') -@pytest.mark.run_loop async def test_keys(redis): res = await redis.keys('*pattern*') assert res == [] @@ -178,7 +171,6 @@ async def test_keys(redis): await redis.keys(None) -@pytest.mark.run_loop async def test_migrate(create_redis, loop, server, serverB): redisA = await create_redis(server.tcp_address) redisB = await create_redis(serverB.tcp_address, db=2) @@ -213,7 +205,6 @@ async def test_migrate(create_redis, loop, server, serverB): @redis_version( 3, 0, 0, reason="Copy/Replace flags available since Redis 3.0") -@pytest.mark.run_loop async def test_migrate_copy_replace(create_redis, loop, server, serverB): redisA = await create_redis(server.tcp_address) redisB = await create_redis(serverB.tcp_address, db=0) @@ -238,7 +229,6 @@ async def test_migrate_copy_replace(create_redis, loop, server, serverB): 3, 0, 6, reason="MIGRATE…KEYS available since Redis 3.0.6") @pytest.mark.skipif( sys.platform == 'win32', reason="Seems to be unavailable in win32 build") -@pytest.mark.run_loop async def test_migrate_keys(create_redis, loop, server, serverB): redisA = await create_redis(server.tcp_address) redisB = await create_redis(serverB.tcp_address, db=0) @@ -294,7 +284,6 @@ async def test_migrate_keys(create_redis, loop, server, serverB): assert (await redisA.get('key3')) is None -@pytest.mark.run_loop async def test_migrate__exceptions(redis, loop, server, unused_port): await add(redis, 'my-key', 123) @@ -310,7 +299,6 @@ async def test_migrate__exceptions(redis, loop, server, unused_port): 3, 0, 6, reason="MIGRATE…KEYS available since Redis 3.0.6") @pytest.mark.skipif( sys.platform == 'win32', reason="Seems to be unavailable in win32 build") -@pytest.mark.run_loop async def test_migrate_keys__errors(redis): with pytest.raises(TypeError, match="host .* str"): await redis.migrate_keys(None, 1234, 'key', 1, 23) @@ -330,7 +318,6 @@ async def test_migrate_keys__errors(redis): await redis.migrate_keys('host', '1234', (), 2, 123) -@pytest.mark.run_loop async def test_move(redis): await add(redis, 'my-key', 123) @@ -348,7 +335,6 @@ async def test_move(redis): await redis.move('my-key', 'not db') -@pytest.mark.run_loop async def test_object_refcount(redis): await add(redis, 'foo', 'bar') @@ -361,7 +347,6 @@ async def test_object_refcount(redis): await redis.object_refcount(None) -@pytest.mark.run_loop async def test_object_encoding(redis, server): await add(redis, 'foo', 'bar') @@ -385,7 +370,7 @@ async def test_object_encoding(redis, server): @redis_version( 3, 0, 0, reason="Older Redis version has lower idle time resolution") -@pytest.mark.run_loop(timeout=20) +@pytest.mark.timeout(20) async def test_object_idletime(redis, loop, server): await add(redis, 'foo', 'bar') @@ -406,7 +391,6 @@ async def test_object_idletime(redis, loop, server): await redis.object_idletime(None) -@pytest.mark.run_loop async def test_persist(redis): await add(redis, 'my-key', 123) res = await redis.expire('my-key', 10) @@ -422,7 +406,6 @@ async def test_persist(redis): await redis.persist(None) -@pytest.mark.run_loop async def test_pexpire(redis, loop): await add(redis, 'my-key', 123) res = await redis.pexpire('my-key', 100) @@ -449,7 +432,6 @@ async def test_pexpire(redis, loop): await redis.pexpire('my-key', 1.0) -@pytest.mark.run_loop async def test_pexpireat(redis): await add(redis, 'my-key', 123) now = int((await redis.time()) * 1000) @@ -468,7 +450,6 @@ async def test_pexpireat(redis): await redis.pexpireat('key', 1000.0) -@pytest.mark.run_loop async def test_pttl(redis, server): await add(redis, 'key', 'val') res = await redis.pttl('key') @@ -487,7 +468,6 @@ async def test_pttl(redis, server): await redis.pttl(None) -@pytest.mark.run_loop async def test_randomkey(redis): await add(redis, 'key:1', 123) await add(redis, 'key:2', 123) @@ -505,7 +485,6 @@ async def test_randomkey(redis): assert res is None -@pytest.mark.run_loop async def test_rename(redis, server): await add(redis, 'foo', 'bar') await redis.delete('bar') @@ -527,7 +506,6 @@ async def test_rename(redis, server): await redis.rename('bar', b'bar') -@pytest.mark.run_loop async def test_renamenx(redis, server): await redis.delete('foo', 'bar') await add(redis, 'foo', 123) @@ -553,7 +531,6 @@ async def test_renamenx(redis, server): await redis.renamenx('foo', b'foo') -@pytest.mark.run_loop async def test_restore(redis): ok = await redis.set('key', 'value') assert ok @@ -566,7 +543,6 @@ async def test_restore(redis): @redis_version(2, 8, 0, reason='SCAN is available since redis>=2.8.0') -@pytest.mark.run_loop async def test_scan(redis): for i in range(1, 11): foo_or_bar = 'bar' if i % 3 else 'foo' @@ -606,7 +582,6 @@ async def test_scan(redis): assert len(test_values) == 10 -@pytest.mark.run_loop async def test_sort(redis): async def _make_list(key, items): await redis.delete(key) @@ -664,7 +639,7 @@ async def _make_list(key, items): @redis_version(3, 2, 1, reason="TOUCH is available since redis>=3.2.1") -@pytest.mark.run_loop(timeout=20) +@pytest.mark.timeout(20) async def test_touch(redis, loop): await add(redis, 'key', 'val') res = 0 @@ -677,7 +652,6 @@ async def test_touch(redis, loop): assert 0 <= res2 < res -@pytest.mark.run_loop async def test_ttl(redis, server): await add(redis, 'key', 'val') res = await redis.ttl('key') @@ -696,7 +670,6 @@ async def test_ttl(redis, server): await redis.ttl(None) -@pytest.mark.run_loop async def test_type(redis): await add(redis, 'key', 'val') res = await redis.type('key') @@ -720,7 +693,6 @@ async def test_type(redis): @redis_version(2, 8, 0, reason='SCAN is available since redis>=2.8.0') -@pytest.mark.run_loop async def test_iscan(redis): full = set() foo = set() @@ -765,7 +737,6 @@ async def coro(cmd): @redis_version(4, 0, 0, reason="UNLINK is available since redis>=4.0.0") -@pytest.mark.run_loop async def test_unlink(redis): await add(redis, 'my-key', 123) await add(redis, 'other-key', 123) @@ -784,7 +755,6 @@ async def test_unlink(redis): @redis_version(3, 0, 0, reason="WAIT is available since redis>=3.0.0") -@pytest.mark.run_loop async def test_wait(redis, loop): await add(redis, 'key', 'val1') start = await redis.time() diff --git a/tests/geo_commands_test.py b/tests/geo_commands_test.py index 490ad735f..4e1307f6f 100644 --- a/tests/geo_commands_test.py +++ b/tests/geo_commands_test.py @@ -4,7 +4,6 @@ from _testutils import redis_version -@pytest.mark.run_loop @redis_version( 3, 2, 0, reason='GEOADD is available since redis >= 3.2.0') async def test_geoadd(redis): @@ -19,7 +18,6 @@ async def test_geoadd(redis): assert res == 2 -@pytest.mark.run_loop @redis_version( 3, 2, 0, reason='GEODIST is available since redis >= 3.2.0') async def test_geodist(redis): @@ -37,7 +35,6 @@ async def test_geodist(redis): assert res == 166.2742 -@pytest.mark.run_loop @redis_version( 3, 2, 0, reason='GEOHASH is available since redis >= 3.2.0') async def test_geohash(redis): @@ -59,7 +56,6 @@ async def test_geohash(redis): assert res == ['sqc8b49rny0', 'sqdtr74hyu0'] -@pytest.mark.run_loop @redis_version( 3, 2, 0, reason='GEOPOS is available since redis >= 3.2.0') async def test_geopos(redis): @@ -82,7 +78,6 @@ async def test_geopos(redis): ] -@pytest.mark.run_loop @redis_version( 3, 2, 0, reason='GEO* is available since redis >= 3.2.0') async def test_geo_not_exist_members(redis): @@ -117,7 +112,6 @@ async def test_geo_not_exist_members(redis): ] -@pytest.mark.run_loop @redis_version( 3, 2, 0, reason='GEORADIUS is available since redis >= 3.2.0') async def test_georadius_validation(redis): @@ -145,7 +139,6 @@ async def test_georadius_validation(redis): ) -@pytest.mark.run_loop @redis_version( 3, 2, 0, reason='GEORADIUS is available since redis >= 3.2.0') async def test_georadius(redis): @@ -264,7 +257,6 @@ async def test_georadius(redis): ] -@pytest.mark.run_loop @redis_version( 3, 2, 0, reason='GEORADIUSBYMEMBER is available since redis >= 3.2.0') async def test_georadiusbymember(redis): @@ -318,7 +310,6 @@ async def test_georadiusbymember(redis): ] -@pytest.mark.run_loop @redis_version( 3, 2, 0, reason='GEOHASH is available since redis >= 3.2.0') async def test_geohash_binary(redis): @@ -340,7 +331,6 @@ async def test_geohash_binary(redis): assert res == [b'sqc8b49rny0', b'sqdtr74hyu0'] -@pytest.mark.run_loop @redis_version( 3, 2, 0, reason='GEORADIUS is available since redis >= 3.2.0') async def test_georadius_binary(redis): @@ -459,7 +449,6 @@ async def test_georadius_binary(redis): ] -@pytest.mark.run_loop @redis_version( 3, 2, 0, reason='GEORADIUSBYMEMBER is available since redis >= 3.2.0') async def test_georadiusbymember_binary(redis): diff --git a/tests/hash_commands_test.py b/tests/hash_commands_test.py index a00438b2d..addc3cf28 100644 --- a/tests/hash_commands_test.py +++ b/tests/hash_commands_test.py @@ -10,7 +10,6 @@ async def add(redis, key, field, value): assert ok == 1 -@pytest.mark.run_loop async def test_hdel(redis): key, field, value = b'key:hdel', b'bar', b'zap' await add(redis, key, field, value) @@ -25,7 +24,6 @@ async def test_hdel(redis): await redis.hdel(None, field) -@pytest.mark.run_loop async def test_hexists(redis): key, field, value = b'key:hexists', b'bar', b'zap' await add(redis, key, field, value) @@ -43,7 +41,6 @@ async def test_hexists(redis): await redis.hexists(None, field) -@pytest.mark.run_loop async def test_hget(redis): key, field, value = b'key:hget', b'bar', b'zap' @@ -66,7 +63,6 @@ async def test_hget(redis): await redis.hget(None, field) -@pytest.mark.run_loop async def test_hgetall(redis): await add(redis, 'key:hgetall', 'foo', 'baz') await add(redis, 'key:hgetall', 'bar', 'zap') @@ -87,7 +83,6 @@ async def test_hgetall(redis): await redis.hgetall(None) -@pytest.mark.run_loop async def test_hincrby(redis): key, field, value = b'key:hincrby', b'bar', 1 await add(redis, key, field, value) @@ -122,7 +117,6 @@ async def test_hincrby(redis): await redis.hincrby(None, field, 2) -@pytest.mark.run_loop async def test_hincrbyfloat(redis): key, field, value = b'key:hincrbyfloat', b'bar', 2.71 await add(redis, key, field, value) @@ -147,7 +141,6 @@ async def test_hincrbyfloat(redis): await redis.hincrbyfloat(None, field, 2) -@pytest.mark.run_loop async def test_hkeys(redis): key = b'key:hkeys' field1, field2 = b'foo', b'bar' @@ -168,7 +161,6 @@ async def test_hkeys(redis): await redis.hkeys(None) -@pytest.mark.run_loop async def test_hlen(redis): key = b'key:hlen' field1, field2 = b'foo', b'bar' @@ -186,7 +178,6 @@ async def test_hlen(redis): await redis.hlen(None) -@pytest.mark.run_loop async def test_hmget(redis): key = b'key:hmget' field1, field2 = b'foo', b'bar' @@ -211,7 +202,6 @@ async def test_hmget(redis): await redis.hmget(None, field1, field2) -@pytest.mark.run_loop async def test_hmset(redis): key, field, value = b'key:hmset', b'bar', b'zap' await add(redis, key, field, value) @@ -249,7 +239,6 @@ async def test_hmset(redis): await redis.hmset(key) -@pytest.mark.run_loop async def test_hmset_dict(redis): key = 'key:hmset' @@ -301,7 +290,6 @@ async def test_hmset_dict(redis): await redis.hmset_dict(key, {'a': 1}, {'b': 2}, 'c', 3, d=4) -@pytest.mark.run_loop async def test_hset(redis): key, field, value = b'key:hset', b'bar', b'zap' test_value = await redis.hset(key, field, value) @@ -320,7 +308,6 @@ async def test_hset(redis): await redis.hset(None, field, value) -@pytest.mark.run_loop async def test_hsetnx(redis): key, field, value = b'key:hsetnx', b'bar', b'zap' # field does not exists, operation should be successful @@ -340,7 +327,6 @@ async def test_hsetnx(redis): await redis.hsetnx(None, field, value) -@pytest.mark.run_loop async def test_hvals(redis): key = b'key:hvals' field1, field2 = b'foo', b'bar' @@ -361,7 +347,6 @@ async def test_hvals(redis): @redis_version(2, 8, 0, reason='HSCAN is available since redis>=2.8.0') -@pytest.mark.run_loop async def test_hscan(redis): key = b'key:hscan' # setup initial values 3 "field:foo:*" items and 7 "field:bar:*" items @@ -405,7 +390,6 @@ async def test_hscan(redis): await redis.hscan(None) -@pytest.mark.run_loop async def test_hgetall_enc(create_redis, loop, server): redis = await create_redis( server.tcp_address, loop=loop, encoding='utf-8') @@ -418,7 +402,6 @@ async def test_hgetall_enc(create_redis, loop, server): assert res == [{'foo': 'bar', 'baz': 'bad'}] -@pytest.mark.run_loop @redis_version(3, 2, 0, reason="HSTRLEN new in redis 3.2.0") async def test_hstrlen(redis): ok = await redis.hset('myhash', 'str_field', 'some value') @@ -444,7 +427,6 @@ async def test_hstrlen(redis): @redis_version(2, 8, 0, reason='HSCAN is available since redis>=2.8.0') -@pytest.mark.run_loop async def test_ihscan(redis): key = b'key:hscan' # setup initial values 3 "field:foo:*" items and 7 "field:bar:*" items diff --git a/tests/hyperloglog_commands_test.py b/tests/hyperloglog_commands_test.py index 39402316b..5361c0613 100644 --- a/tests/hyperloglog_commands_test.py +++ b/tests/hyperloglog_commands_test.py @@ -6,7 +6,6 @@ 2, 8, 9, reason='HyperLogLog works only with redis>=2.8.9') -@pytest.mark.run_loop async def test_pfcount(redis): key = 'hll_pfcount' other_key = 'some-other-hll' @@ -43,7 +42,6 @@ async def test_pfcount(redis): await redis.pfcount(key, key, None) -@pytest.mark.run_loop async def test_pfadd(redis): key = 'hll_pfadd' values = ['a', 's', 'y', 'n', 'c', 'i', 'o'] @@ -55,13 +53,11 @@ async def test_pfadd(redis): assert is_changed == 0 -@pytest.mark.run_loop async def test_pfadd_wrong_input(redis): with pytest.raises(TypeError): await redis.pfadd(None, 'value') -@pytest.mark.run_loop async def test_pfmerge(redis): key = 'hll_asyncio' key_other = 'hll_aioredis' @@ -97,7 +93,6 @@ async def test_pfmerge(redis): await redis.pfmerge(key_dest, key, None) -@pytest.mark.run_loop async def test_pfmerge_wrong_input(redis): with pytest.raises(TypeError): await redis.pfmerge(None, 'value') diff --git a/tests/integration_test.py b/tests/integration_test.py index d660a4c78..47e4df826 100644 --- a/tests/integration_test.py +++ b/tests/integration_test.py @@ -65,7 +65,6 @@ async def blpop(): await asyncio.gather(blpop(), lpush()) -@pytest.mark.run_loop @pytest.mark.parametrize('test_case,pool_size', [ (simple_get_set, 1), (pipeline, 1), diff --git a/tests/list_commands_test.py b/tests/list_commands_test.py index 845d7d74f..92ceb9409 100644 --- a/tests/list_commands_test.py +++ b/tests/list_commands_test.py @@ -10,7 +10,6 @@ async def push_data_with_sleep(redis, loop, key, *values): return result -@pytest.mark.run_loop async def test_blpop(redis): key1, value1 = b'key:blpop:1', b'blpop:value:1' key2, value2 = b'key:blpop:2', b'blpop:value:2' @@ -40,7 +39,6 @@ async def test_blpop(redis): assert test_value == ['key:blpop:2', 'blpop:value:1'] -@pytest.mark.run_loop async def test_blpop_blocking_features(redis, create_redis, loop, server): key1, key2 = b'key:blpop:1', b'key:blpop:2' value = b'blpop:value:2' @@ -66,7 +64,6 @@ async def test_blpop_blocking_features(redis, create_redis, loop, server): other_redis.close() -@pytest.mark.run_loop async def test_brpop(redis): key1, value1 = b'key:brpop:1', b'brpop:value:1' key2, value2 = b'key:brpop:2', b'brpop:value:2' @@ -96,7 +93,6 @@ async def test_brpop(redis): assert test_value == ['key:brpop:2', 'brpop:value:1'] -@pytest.mark.run_loop async def test_brpop_blocking_features(redis, create_redis, server, loop): key1, key2 = b'key:brpop:1', b'key:brpop:2' value = b'brpop:value:2' @@ -121,7 +117,6 @@ async def test_brpop_blocking_features(redis, create_redis, server, loop): assert test_value is None -@pytest.mark.run_loop async def test_brpoplpush(redis): key = b'key:brpoplpush:1' value1, value2 = b'brpoplpush:value:1', b'brpoplpush:value:2' @@ -160,7 +155,6 @@ async def test_brpoplpush(redis): assert result == 'brpoplpush:value:2' -@pytest.mark.run_loop async def test_brpoplpush_blocking_features(redis, create_redis, server, loop): source = b'key:brpoplpush:12' value = b'brpoplpush:value:2' @@ -187,7 +181,6 @@ async def test_brpoplpush_blocking_features(redis, create_redis, server, loop): other_redis.close() -@pytest.mark.run_loop async def test_lindex(redis): key, value = b'key:lindex:1', 'value:{}' # setup list @@ -220,7 +213,6 @@ async def test_lindex(redis): await redis.lindex(key, b'one') -@pytest.mark.run_loop async def test_linsert(redis): key = b'key:linsert:1' value1, value2, value3, value4 = b'Hello', b'World', b'foo', b'bar' @@ -249,7 +241,6 @@ async def test_linsert(redis): await redis.linsert(None, value1, value3) -@pytest.mark.run_loop async def test_llen(redis): key = b'key:llen:1' value1, value2 = b'Hello', b'World' @@ -265,7 +256,6 @@ async def test_llen(redis): await redis.llen(None) -@pytest.mark.run_loop async def test_lpop(redis): key = b'key:lpop:1' value1, value2 = b'lpop:value:1', b'lpop:value:2' @@ -292,7 +282,6 @@ async def test_lpop(redis): await redis.lpop(None) -@pytest.mark.run_loop async def test_lpush(redis): key = b'key:lpush' value1, value2 = b'value:1', b'value:2' @@ -313,7 +302,6 @@ async def test_lpush(redis): await redis.lpush(None, value1) -@pytest.mark.run_loop async def test_lpushx(redis): key = b'key:lpushx' value1, value2 = b'value:1', b'value:2' @@ -337,7 +325,6 @@ async def test_lpushx(redis): await redis.lpushx(None, value1) -@pytest.mark.run_loop async def test_lrange(redis): key, value = b'key:lrange:1', 'value:{}' values = [value.format(i).encode('utf-8') for i in range(0, 10)] @@ -366,7 +353,6 @@ async def test_lrange(redis): await redis.lrange(key, 0, b'one') -@pytest.mark.run_loop async def test_lrem(redis): key, value = b'key:lrem:1', 'value:{}' values = [value.format(i % 2).encode('utf-8') for i in range(0, 10)] @@ -401,7 +387,6 @@ async def test_lrem(redis): await redis.lrem(key, b'ten', b'value:0') -@pytest.mark.run_loop async def test_lset(redis): key, value = b'key:lset', 'value:{}' values = [value.format(i).encode('utf-8') for i in range(0, 3)] @@ -424,7 +409,6 @@ async def test_lset(redis): await redis.lset(key, b'one', b'value:0') -@pytest.mark.run_loop async def test_ltrim(redis): key, value = b'key:ltrim', 'value:{}' values = [value.format(i).encode('utf-8') for i in range(0, 10)] @@ -455,7 +439,6 @@ async def test_ltrim(redis): await redis.ltrim(key, 0, b'one') -@pytest.mark.run_loop async def test_rpop(redis): key = b'key:rpop:1' value1, value2 = b'rpop:value:1', b'rpop:value:2' @@ -482,7 +465,6 @@ async def test_rpop(redis): await redis.rpop(None) -@pytest.mark.run_loop async def test_rpoplpush(redis): key = b'key:rpoplpush:1' value1, value2 = b'rpoplpush:value:1', b'rpoplpush:value:2' @@ -514,7 +496,6 @@ async def test_rpoplpush(redis): await redis.rpoplpush(key, None) -@pytest.mark.run_loop async def test_rpush(redis): key = b'key:rpush' value1, value2 = b'value:1', b'value:2' @@ -531,7 +512,6 @@ async def test_rpush(redis): await redis.rpush(None, value1) -@pytest.mark.run_loop async def test_rpushx(redis): key = b'key:rpushx' value1, value2 = b'value:1', b'value:2' diff --git a/tests/locks_test.py b/tests/locks_test.py index 0b7728e8a..5c8168a7a 100644 --- a/tests/locks_test.py +++ b/tests/locks_test.py @@ -1,10 +1,8 @@ import asyncio -import pytest from aioredis.locks import Lock -@pytest.mark.run_loop async def test_finished_waiter_cancelled(loop): lock = Lock() diff --git a/tests/pool_test.py b/tests/pool_test.py index 16bedebf4..c4de17059 100644 --- a/tests/pool_test.py +++ b/tests/pool_test.py @@ -39,7 +39,6 @@ def test_global_loop(create_pool, loop, server): _assert_defaults(pool) -@pytest.mark.run_loop async def test_clear(pool): _assert_defaults(pool) @@ -47,7 +46,6 @@ async def test_clear(pool): assert pool.freesize == 0 -@pytest.mark.run_loop @pytest.mark.parametrize('minsize', [None, -100, 0.0, 100]) async def test_minsize(minsize, create_pool, loop, server): @@ -57,7 +55,6 @@ async def test_minsize(minsize, create_pool, loop, server): minsize=minsize, maxsize=10, loop=loop) -@pytest.mark.run_loop @pytest.mark.parametrize('maxsize', [None, -100, 0.0, 1]) async def test_maxsize(maxsize, create_pool, loop, server): @@ -67,7 +64,6 @@ async def test_maxsize(maxsize, create_pool, loop, server): minsize=2, maxsize=maxsize, loop=loop) -@pytest.mark.run_loop async def test_create_connection_timeout(create_pool, loop, server): with patch.object(loop, 'create_connection') as\ open_conn_mock: @@ -85,7 +81,6 @@ def test_no_yield_from(pool): pass # pragma: no cover -@pytest.mark.run_loop async def test_simple_command(create_pool, loop, server): pool = await create_pool( server.tcp_address, @@ -100,7 +95,6 @@ async def test_simple_command(create_pool, loop, server): assert pool.freesize == 10 -@pytest.mark.run_loop async def test_create_new(create_pool, loop, server): pool = await create_pool( server.tcp_address, @@ -120,7 +114,6 @@ async def test_create_new(create_pool, loop, server): assert pool.freesize == 2 -@pytest.mark.run_loop async def test_create_constraints(create_pool, loop, server): pool = await create_pool( server.tcp_address, @@ -137,7 +130,6 @@ async def test_create_constraints(create_pool, loop, server): timeout=0.2) -@pytest.mark.run_loop async def test_create_no_minsize(create_pool, loop, server): pool = await create_pool( server.tcp_address, @@ -156,7 +148,6 @@ async def test_create_no_minsize(create_pool, loop, server): assert pool.freesize == 1 -@pytest.mark.run_loop async def test_create_pool_cls(create_pool, loop, server): class MyPool(ConnectionsPool): @@ -170,7 +161,6 @@ class MyPool(ConnectionsPool): assert isinstance(pool, MyPool) -@pytest.mark.run_loop async def test_create_pool_cls_invalid(create_pool, loop, server): with pytest.raises(AssertionError): await create_pool( @@ -179,7 +169,6 @@ async def test_create_pool_cls_invalid(create_pool, loop, server): pool_cls=type) -@pytest.mark.run_loop async def test_release_closed(create_pool, loop, server): pool = await create_pool( server.tcp_address, @@ -194,7 +183,6 @@ async def test_release_closed(create_pool, loop, server): assert pool.freesize == 0 -@pytest.mark.run_loop async def test_release_pending(create_pool, loop, server, caplog): pool = await create_pool( server.tcp_address, @@ -223,7 +211,6 @@ async def test_release_pending(create_pool, loop, server, caplog): ] -@pytest.mark.run_loop async def test_release_bad_connection(create_pool, create_redis, loop, server): pool = await create_pool( server.tcp_address, @@ -242,7 +229,6 @@ async def test_release_bad_connection(create_pool, create_redis, loop, server): await other_conn.wait_closed() -@pytest.mark.run_loop async def test_select_db(create_pool, loop, server): pool = await create_pool( server.tcp_address, @@ -253,7 +239,6 @@ async def test_select_db(create_pool, loop, server): assert conn.db == 1 -@pytest.mark.run_loop async def test_change_db(create_pool, loop, server): pool = await create_pool( server.tcp_address, @@ -280,7 +265,6 @@ async def test_change_db(create_pool, loop, server): assert pool.db == 1 -@pytest.mark.run_loop async def test_change_db_errors(create_pool, loop, server): pool = await create_pool( server.tcp_address, @@ -308,7 +292,6 @@ async def test_change_db_errors(create_pool, loop, server): @pytest.mark.xfail(reason="Need to refactor this test") -@pytest.mark.run_loop async def test_select_and_create(create_pool, loop, server): # trying to model situation when select and acquire # called simultaneously @@ -333,7 +316,6 @@ async def test_select_and_create(create_pool, loop, server): # await asyncio.wait_for(test(), 3, loop=loop) -@pytest.mark.run_loop async def test_response_decoding(create_pool, loop, server): pool = await create_pool( server.tcp_address, @@ -347,7 +329,6 @@ async def test_response_decoding(create_pool, loop, server): assert res == 'value' -@pytest.mark.run_loop async def test_hgetall_response_decoding(create_pool, loop, server): pool = await create_pool( server.tcp_address, @@ -363,7 +344,6 @@ async def test_hgetall_response_decoding(create_pool, loop, server): assert res == ['foo', 'bar', 'baz', 'zap'] -@pytest.mark.run_loop async def test_crappy_multiexec(create_pool, loop, server): pool = await create_pool( server.tcp_address, @@ -380,7 +360,6 @@ async def test_crappy_multiexec(create_pool, loop, server): assert value == 'def' -@pytest.mark.run_loop async def test_pool_size_growth(create_pool, server, loop): pool = await create_pool( server.tcp_address, @@ -409,7 +388,6 @@ async def task2(): await asyncio.gather(*tasks) -@pytest.mark.run_loop async def test_pool_with_closed_connections(create_pool, server, loop): pool = await create_pool( server.tcp_address, @@ -425,7 +403,6 @@ async def test_pool_with_closed_connections(create_pool, server, loop): assert conn1 is not conn2 -@pytest.mark.run_loop async def test_pool_close(create_pool, server, loop): pool = await create_pool( server.tcp_address, loop=loop) @@ -444,7 +421,6 @@ async def test_pool_close(create_pool, server, loop): assert (await conn.execute('ping')) == b'PONG' -@pytest.mark.run_loop async def test_pool_close__used(create_pool, server, loop): pool = await create_pool( server.tcp_address, loop=loop) @@ -460,7 +436,6 @@ async def test_pool_close__used(create_pool, server, loop): await conn.execute('ping') -@pytest.mark.run_loop @redis_version(2, 8, 0, reason="maxclients config setting") async def test_pool_check_closed_when_exception( create_pool, create_redis, start_server, loop, caplog): @@ -487,7 +462,6 @@ async def test_pool_check_closed_when_exception( ) -@pytest.mark.run_loop async def test_pool_get_connection(create_pool, server, loop): pool = await create_pool(server.tcp_address, minsize=1, maxsize=2, loop=loop) @@ -507,7 +481,6 @@ async def test_pool_get_connection(create_pool, server, loop): assert res == b'value' -@pytest.mark.run_loop async def test_pool_get_connection_with_pipelining(create_pool, server, loop): pool = await create_pool(server.tcp_address, minsize=1, maxsize=2, loop=loop) @@ -529,7 +502,6 @@ async def test_pool_get_connection_with_pipelining(create_pool, server, loop): @pytest.mark.skipif(sys.platform == "win32", reason="flaky on windows") -@pytest.mark.run_loop async def test_pool_idle_close(create_pool, start_server, loop, caplog): server = start_server('idle') conn = await create_pool(server.tcp_address, minsize=2, loop=loop) @@ -564,7 +536,6 @@ async def test_pool_idle_close(create_pool, start_server, loop, caplog): assert (await conn.execute('ping')) == b'PONG' -@pytest.mark.run_loop async def test_await(create_pool, server, loop): pool = await create_pool( server.tcp_address, @@ -575,7 +546,6 @@ async def test_await(create_pool, server, loop): assert msg == b'hello' -@pytest.mark.run_loop async def test_async_with(create_pool, server, loop): pool = await create_pool( server.tcp_address, @@ -586,7 +556,6 @@ async def test_async_with(create_pool, server, loop): assert msg == b'hello' -@pytest.mark.run_loop async def test_pool__drop_closed(create_pool, server, loop): pool = await create_pool(server.tcp_address, minsize=3, diff --git a/tests/pubsub_commands_test.py b/tests/pubsub_commands_test.py index 561f6ea7c..a6a34a2cc 100644 --- a/tests/pubsub_commands_test.py +++ b/tests/pubsub_commands_test.py @@ -14,7 +14,6 @@ async def _reader(channel, output, waiter, conn): await output.put(msg) -@pytest.mark.run_loop async def test_publish(create_connection, redis, server, loop): out = asyncio.Queue() fut = loop.create_future() @@ -30,7 +29,6 @@ async def test_publish(create_connection, redis, server, loop): sub.cancel() -@pytest.mark.run_loop async def test_publish_json(create_connection, redis, server, loop): out = asyncio.Queue() fut = loop.create_future() @@ -48,7 +46,6 @@ async def test_publish_json(create_connection, redis, server, loop): sub.cancel() -@pytest.mark.run_loop async def test_subscribe(redis): res = await redis.subscribe('chan:1', 'chan:2') assert redis.in_pubsub == 2 @@ -68,7 +65,6 @@ async def test_subscribe(redis): @pytest.mark.parametrize('create_redis', [ pytest.param(aioredis.create_redis_pool, id='pool'), ]) -@pytest.mark.run_loop async def test_subscribe_empty_pool(create_redis, server, loop, _closable): redis = await create_redis(server.tcp_address, loop=loop) _closable(redis) @@ -89,7 +85,6 @@ async def test_subscribe_empty_pool(create_redis, server, loop, _closable): [b'unsubscribe', b'chan:2', 0]] -@pytest.mark.run_loop async def test_psubscribe(redis, create_redis, server, loop): sub = redis res = await sub.psubscribe('patt:*', 'chan:*') @@ -115,7 +110,6 @@ async def test_psubscribe(redis, create_redis, server, loop): @pytest.mark.parametrize('create_redis', [ pytest.param(aioredis.create_redis_pool, id='pool'), ]) -@pytest.mark.run_loop async def test_psubscribe_empty_pool(create_redis, server, loop, _closable): sub = await create_redis(server.tcp_address, loop=loop) pub = await create_redis(server.tcp_address, loop=loop) @@ -142,7 +136,6 @@ async def test_psubscribe_empty_pool(create_redis, server, loop, _closable): @redis_version( 2, 8, 0, reason='PUBSUB CHANNELS is available since redis>=2.8.0') -@pytest.mark.run_loop async def test_pubsub_channels(create_redis, server, loop): redis = await create_redis( server.tcp_address, loop=loop) @@ -171,7 +164,6 @@ async def test_pubsub_channels(create_redis, server, loop): @redis_version( 2, 8, 0, reason='PUBSUB NUMSUB is available since redis>=2.8.0') -@pytest.mark.run_loop async def test_pubsub_numsub(create_redis, server, loop): redis = await create_redis( server.tcp_address, loop=loop) @@ -206,7 +198,6 @@ async def test_pubsub_numsub(create_redis, server, loop): @redis_version( 2, 8, 0, reason='PUBSUB NUMPAT is available since redis>=2.8.0') -@pytest.mark.run_loop async def test_pubsub_numpat(create_redis, server, loop, redis): sub = await create_redis( server.tcp_address, loop=loop) @@ -223,7 +214,6 @@ async def test_pubsub_numpat(create_redis, server, loop, redis): assert res == 1 -@pytest.mark.run_loop async def test_close_pubsub_channels(redis, loop): ch, = await redis.subscribe('chan:1') @@ -236,7 +226,6 @@ async def waiter(ch): await tsk -@pytest.mark.run_loop async def test_close_pubsub_patterns(redis, loop): ch, = await redis.psubscribe('chan:*') @@ -249,7 +238,6 @@ async def waiter(ch): await tsk -@pytest.mark.run_loop async def test_close_cancelled_pubsub_channel(redis): ch, = await redis.subscribe('chan:1') @@ -262,7 +250,6 @@ async def waiter(ch): tsk.cancel() -@pytest.mark.run_loop async def test_channel_get_after_close(create_redis, loop, server): sub = await create_redis( server.tcp_address, loop=loop) @@ -278,7 +265,6 @@ async def test_channel_get_after_close(create_redis, loop, server): assert await ch.get() -@pytest.mark.run_loop async def test_subscribe_concurrency(create_redis, server, loop): sub = await create_redis( server.tcp_address, loop=loop) @@ -306,7 +292,6 @@ async def publish(*args): @redis_version( 3, 2, 0, reason='PUBSUB PING is available since redis>=3.2.0') -@pytest.mark.run_loop async def test_pubsub_ping(redis): await redis.subscribe('chan:1', 'chan:2') @@ -320,7 +305,6 @@ async def test_pubsub_ping(redis): await redis.unsubscribe('chan:1', 'chan:2') -@pytest.mark.run_loop async def test_pubsub_channel_iter(create_redis, server, loop): sub = await create_redis(server.tcp_address, loop=loop) pub = await create_redis(server.tcp_address, loop=loop) @@ -341,7 +325,6 @@ async def coro(ch): assert await tsk == [b'{"Hello": "World"}', b'["message"]'] -@pytest.mark.run_loop @redis_version( 2, 8, 12, reason="extended `client kill` format required") async def test_pubsub_disconnection_notification(create_redis, server, loop): diff --git a/tests/pubsub_receiver_test.py b/tests/pubsub_receiver_test.py index 0ef780140..b7e1f33b0 100644 --- a/tests/pubsub_receiver_test.py +++ b/tests/pubsub_receiver_test.py @@ -63,7 +63,6 @@ def test_listener_pattern(loop): assert dict(mpsc.patterns) == {b'*': ch} -@pytest.mark.run_loop async def test_sender(loop): receiver = mock.Mock() @@ -96,7 +95,6 @@ def test_sender_close(): assert receiver.mock_calls == [] -@pytest.mark.run_loop async def test_subscriptions(create_connection, server, loop): sub = await create_connection(server.tcp_address, loop=loop) pub = await create_connection(server.tcp_address, loop=loop) @@ -122,7 +120,6 @@ async def test_subscriptions(create_connection, server, loop): assert msg == b"Hello world" -@pytest.mark.run_loop async def test_unsubscribe(create_connection, server, loop): sub = await create_connection(server.tcp_address, loop=loop) pub = await create_connection(server.tcp_address, loop=loop) @@ -166,7 +163,6 @@ async def test_unsubscribe(create_connection, server, loop): assert await waiter is None -@pytest.mark.run_loop async def test_stopped(create_connection, server, loop, caplog): sub = await create_connection(server.tcp_address, loop=loop) pub = await create_connection(server.tcp_address, loop=loop) @@ -199,7 +195,6 @@ async def test_stopped(create_connection, server, loop, caplog): assert res is False -@pytest.mark.run_loop async def test_wait_message(create_connection, server, loop): sub = await create_connection(server.tcp_address, loop=loop) pub = await create_connection(server.tcp_address, loop=loop) @@ -219,7 +214,6 @@ async def test_wait_message(create_connection, server, loop): assert res is True -@pytest.mark.run_loop async def test_decode_message(loop): mpsc = Receiver(loop) ch = mpsc.channel('channel:1') @@ -242,7 +236,6 @@ async def test_decode_message(loop): @pytest.mark.skipif(sys.version_info >= (3, 6), reason="json.loads accept bytes since Python 3.6") -@pytest.mark.run_loop async def test_decode_message_error(loop): mpsc = Receiver(loop) ch = mpsc.channel('channel:1') @@ -259,7 +252,6 @@ async def test_decode_message_error(loop): assert (await mpsc.get(decoder=json.loads)) == unexpected -@pytest.mark.run_loop async def test_decode_message_for_pattern(loop): mpsc = Receiver(loop) ch = mpsc.pattern('*') @@ -280,7 +272,6 @@ async def test_decode_message_for_pattern(loop): assert res[1] == (b'channel', {'hello': 'world'}) -@pytest.mark.run_loop async def test_pubsub_receiver_iter(create_redis, server, loop): sub = await create_redis(server.tcp_address, loop=loop) pub = await create_redis(server.tcp_address, loop=loop) @@ -313,7 +304,7 @@ async def coro(mpsc): assert not mpsc.is_active -@pytest.mark.run_loop(timeout=5) +@pytest.mark.timeout(5) async def test_pubsub_receiver_call_stop_with_empty_queue( create_redis, server, loop): sub = await create_redis(server.tcp_address, loop=loop) @@ -332,7 +323,6 @@ async def test_pubsub_receiver_call_stop_with_empty_queue( assert not mpsc.is_active -@pytest.mark.run_loop async def test_pubsub_receiver_stop_on_disconnect(create_redis, server, loop): pub = await create_redis(server.tcp_address, loop=loop) sub = await create_redis(server.tcp_address, loop=loop) diff --git a/tests/scripting_commands_test.py b/tests/scripting_commands_test.py index daecf0abb..c373b0678 100644 --- a/tests/scripting_commands_test.py +++ b/tests/scripting_commands_test.py @@ -4,7 +4,6 @@ from aioredis import ReplyError -@pytest.mark.run_loop async def test_eval(redis): await redis.delete('key:eval', 'value:eval') @@ -38,7 +37,6 @@ async def test_eval(redis): await redis.eval(None) -@pytest.mark.run_loop async def test_evalsha(redis): script = b"return 42" sha_hash = await redis.script_load(script) @@ -62,7 +60,6 @@ async def test_evalsha(redis): await redis.evalsha(None) -@pytest.mark.run_loop async def test_script_exists(redis): sha_hash1 = await redis.script_load(b'return 1') sha_hash2 = await redis.script_load(b'return 2') @@ -82,7 +79,6 @@ async def test_script_exists(redis): await redis.script_exists('123', None) -@pytest.mark.run_loop async def test_script_flush(redis): sha_hash1 = await redis.script_load(b'return 1') assert len(sha_hash1) == 40 @@ -94,7 +90,6 @@ async def test_script_flush(redis): assert res == [0] -@pytest.mark.run_loop async def test_script_load(redis): sha_hash1 = await redis.script_load(b'return 1') sha_hash2 = await redis.script_load(b'return 2') @@ -104,7 +99,6 @@ async def test_script_load(redis): assert res == [1, 1] -@pytest.mark.run_loop async def test_script_kill(create_redis, loop, server, redis): script = "while (1) do redis.call('TIME') end" diff --git a/tests/sentinel_commands_test.py b/tests/sentinel_commands_test.py index 0410ff6f7..66f63953d 100644 --- a/tests/sentinel_commands_test.py +++ b/tests/sentinel_commands_test.py @@ -16,7 +16,6 @@ BPO_30399 = sys.version_info >= (3, 7, 0, 'alpha', 3) -@pytest.mark.run_loop async def test_client_close(redis_sentinel): assert isinstance(redis_sentinel, RedisSentinel) assert not redis_sentinel.closed @@ -29,7 +28,6 @@ async def test_client_close(redis_sentinel): await redis_sentinel.wait_closed() -@pytest.mark.run_loop async def test_global_loop(sentinel, create_sentinel, loop): asyncio.set_event_loop(loop) @@ -41,12 +39,10 @@ async def test_global_loop(sentinel, create_sentinel, loop): asyncio.set_event_loop(None) -@pytest.mark.run_loop async def test_ping(redis_sentinel): assert b'PONG' == (await redis_sentinel.ping()) -@pytest.mark.run_loop async def test_master_info(redis_sentinel, sentinel): info = await redis_sentinel.master('master-no-fail') assert isinstance(info, dict) @@ -84,7 +80,6 @@ async def test_master_info(redis_sentinel, sentinel): assert 'link-refcount' in info -@pytest.mark.run_loop async def test_master__auth(create_sentinel, start_sentinel, start_server, loop): master = start_server('master_1', password='123') @@ -119,7 +114,6 @@ async def test_master__auth(create_sentinel, start_sentinel, await m3.set('mykey', 'myval') -@pytest.mark.run_loop async def test_master__no_auth(create_sentinel, sentinel, loop): client = await create_sentinel( [sentinel.tcp_address], password='123', timeout=1, loop=loop) @@ -129,25 +123,21 @@ async def test_master__no_auth(create_sentinel, sentinel, loop): await master.set('mykey', 'myval') -@pytest.mark.run_loop async def test_master__unknown(redis_sentinel): with pytest.raises(ReplyError): await redis_sentinel.master('unknown-master') -@pytest.mark.run_loop async def test_master_address(redis_sentinel, sentinel): _, port = await redis_sentinel.master_address('master-no-fail') assert port == sentinel.masters['master-no-fail'].tcp_address.port -@pytest.mark.run_loop async def test_master_address__unknown(redis_sentinel): res = await redis_sentinel.master_address('unknown-master') assert res is None -@pytest.mark.run_loop async def test_masters(redis_sentinel): masters = await redis_sentinel.masters() assert isinstance(masters, dict) @@ -156,7 +146,6 @@ async def test_masters(redis_sentinel): assert isinstance(masters['master-no-fail'], dict) -@pytest.mark.run_loop async def test_slave_info(sentinel, redis_sentinel): info = await redis_sentinel.slaves('master-no-fail') assert len(info) == 1 @@ -198,13 +187,11 @@ async def test_slave_info(sentinel, redis_sentinel): assert not missing -@pytest.mark.run_loop async def test_slave__unknown(redis_sentinel): with pytest.raises(ReplyError): await redis_sentinel.slaves('unknown-master') -@pytest.mark.run_loop async def test_sentinels_empty(redis_sentinel): res = await redis_sentinel.sentinels('master-no-fail') assert res == [] @@ -213,7 +200,7 @@ async def test_sentinels_empty(redis_sentinel): await redis_sentinel.sentinels('unknown-master') -@pytest.mark.run_loop(timeout=30) +@pytest.mark.timeout(30) async def test_sentinels__exist(create_sentinel, start_sentinel, start_server, loop): m1 = start_server('master-two-sentinels') @@ -235,7 +222,6 @@ async def test_sentinels__exist(create_sentinel, start_sentinel, assert info[0]['port'] in (s1.tcp_address.port, s2.tcp_address.port) -@pytest.mark.run_loop async def test_ckquorum(redis_sentinel): assert (await redis_sentinel.check_quorum('master-no-fail')) @@ -250,7 +236,6 @@ async def test_ckquorum(redis_sentinel): assert (await redis_sentinel.check_quorum('master-no-fail')) -@pytest.mark.run_loop async def test_set_option(redis_sentinel): assert (await redis_sentinel.set('master-no-fail', 'quorum', 10)) master = await redis_sentinel.master('master-no-fail') @@ -264,7 +249,6 @@ async def test_set_option(redis_sentinel): await redis_sentinel.set('masterA', 'foo', 'bar') -@pytest.mark.run_loop async def test_sentinel_role(sentinel, create_redis, loop): redis = await create_redis(sentinel.tcp_address, loop=loop) info = await redis.role() @@ -273,7 +257,7 @@ async def test_sentinel_role(sentinel, create_redis, loop): assert 'master-no-fail' in info.masters -@pytest.mark.run_loop(timeout=30) +@pytest.mark.timeout(30) async def test_remove(redis_sentinel, start_server, loop): m1 = start_server('master-to-remove') ok = await redis_sentinel.monitor( @@ -287,7 +271,7 @@ async def test_remove(redis_sentinel, start_server, loop): await redis_sentinel.remove('unknown-master') -@pytest.mark.run_loop(timeout=30) +@pytest.mark.timeout(30) async def test_monitor(redis_sentinel, start_server, loop, unused_port): m1 = start_server('master-to-monitor') ok = await redis_sentinel.monitor( @@ -298,7 +282,7 @@ async def test_monitor(redis_sentinel, start_server, loop, unused_port): assert port == m1.tcp_address.port -@pytest.mark.run_loop(timeout=5) +@pytest.mark.timeout(5) async def test_sentinel_master_pool_size(sentinel, create_sentinel, caplog): redis_s = await create_sentinel([sentinel.tcp_address], timeout=1, minsize=10, maxsize=10) diff --git a/tests/sentinel_failover_test.py b/tests/sentinel_failover_test.py index 8d607106a..fb4d2250f 100644 --- a/tests/sentinel_failover_test.py +++ b/tests/sentinel_failover_test.py @@ -14,7 +14,7 @@ pytestmark = pytest.mark.skip(reason="unstable on windows") -@pytest.mark.run_loop(timeout=40) +@pytest.mark.timeout(40) async def test_auto_failover(start_sentinel, start_server, create_sentinel, create_connection, loop): server1 = start_server('master-failover', ['slave-read-only yes']) @@ -55,7 +55,6 @@ async def test_auto_failover(start_sentinel, start_server, assert master.address[1] != old_port -@pytest.mark.run_loop async def test_sentinel_normal(sentinel, create_sentinel): redis_sentinel = await create_sentinel([sentinel.tcp_address], timeout=1) redis = redis_sentinel.master_for('masterA') @@ -76,7 +75,6 @@ async def test_sentinel_normal(sentinel, create_sentinel): @pytest.mark.xfail(reason="same sentinel; single master;") -@pytest.mark.run_loop async def test_sentinel_slave(sentinel, create_sentinel): redis_sentinel = await create_sentinel([sentinel.tcp_address], timeout=1) redis = redis_sentinel.slave_for('masterA') @@ -96,7 +94,6 @@ async def test_sentinel_slave(sentinel, create_sentinel): @pytest.mark.xfail(reason="Need proper sentinel configuration") -@pytest.mark.run_loop # (timeout=600) async def test_sentinel_slave_fail(sentinel, create_sentinel, loop): redis_sentinel = await create_sentinel([sentinel.tcp_address], timeout=1) @@ -132,7 +129,6 @@ async def test_sentinel_slave_fail(sentinel, create_sentinel, loop): @pytest.mark.xfail(reason="Need proper sentinel configuration") -@pytest.mark.run_loop async def test_sentinel_normal_fail(sentinel, create_sentinel, loop): redis_sentinel = await create_sentinel([sentinel.tcp_address], timeout=1) @@ -163,7 +159,7 @@ async def test_sentinel_normal_fail(sentinel, create_sentinel, loop): break -@pytest.mark.run_loop(timeout=30) +@pytest.mark.timeout(30) async def test_failover_command(start_server, start_sentinel, create_sentinel, loop): server = start_server('master-failover-cmd', ['slave-read-only yes']) diff --git a/tests/server_commands_test.py b/tests/server_commands_test.py index 6ffe3f3c4..2d7b36bdc 100644 --- a/tests/server_commands_test.py +++ b/tests/server_commands_test.py @@ -8,7 +8,6 @@ from _testutils import redis_version -@pytest.mark.run_loop async def test_client_list(redis, server, request): name = request.node.callspec.id assert (await redis.client_setname(name)) @@ -41,7 +40,6 @@ async def test_client_list(redis, server, request): assert expected in res -@pytest.mark.run_loop @pytest.mark.skipif(sys.platform == 'win32', reason="No unixsocket on Windows") async def test_client_list__unixsocket(create_redis, loop, server, request): @@ -76,7 +74,6 @@ async def test_client_list__unixsocket(create_redis, loop, server, request): assert expected in info -@pytest.mark.run_loop @redis_version( 2, 9, 50, reason='CLIENT PAUSE is available since redis >= 2.9.50') async def test_client_pause(redis): @@ -94,7 +91,6 @@ async def test_client_pause(redis): await redis.client_pause(-1) -@pytest.mark.run_loop async def test_client_getname(redis): res = await redis.client_getname() assert res is None @@ -108,7 +104,6 @@ async def test_client_getname(redis): @redis_version(2, 8, 13, reason="available since Redis 2.8.13") -@pytest.mark.run_loop async def test_command(redis): res = await redis.command() assert isinstance(res, list) @@ -116,14 +111,12 @@ async def test_command(redis): @redis_version(2, 8, 13, reason="available since Redis 2.8.13") -@pytest.mark.run_loop async def test_command_count(redis): res = await redis.command_count() assert res > 0 @redis_version(3, 0, 0, reason="available since Redis 3.0.0") -@pytest.mark.run_loop async def test_command_getkeys(redis): res = await redis.command_getkeys('get', 'key') assert res == ['key'] @@ -141,7 +134,6 @@ async def test_command_getkeys(redis): @redis_version(2, 8, 13, reason="available since Redis 2.8.13") -@pytest.mark.run_loop async def test_command_info(redis): res = await redis.command_info('get') assert res == [ @@ -154,7 +146,6 @@ async def test_command_info(redis): assert res == [None, None] -@pytest.mark.run_loop async def test_config_get(redis, server): res = await redis.config_get('port') assert res == {'port': str(server.tcp_address.port)} @@ -169,13 +160,11 @@ async def test_config_get(redis, server): await redis.config_get(b'port') -@pytest.mark.run_loop async def test_config_rewrite(redis): with pytest.raises(ReplyError): await redis.config_rewrite() -@pytest.mark.run_loop async def test_config_set(redis): cur_value = await redis.config_get('slave-read-only') res = await redis.config_set('slave-read-only', 'no') @@ -190,12 +179,10 @@ async def test_config_set(redis): await redis.config_set(100, 'databases') -# @pytest.mark.run_loop # @pytest.mark.skip("Not implemented") # def test_config_resetstat(): # pass -@pytest.mark.run_loop async def test_debug_object(redis): with pytest.raises(ReplyError): assert (await redis.debug_object('key')) is None @@ -206,7 +193,6 @@ async def test_debug_object(redis): assert res is not None -@pytest.mark.run_loop async def test_debug_sleep(redis): t1 = await redis.time() ok = await redis.debug_sleep(.2) @@ -215,7 +201,6 @@ async def test_debug_sleep(redis): assert t2 - t1 >= .2 -@pytest.mark.run_loop async def test_dbsize(redis): res = await redis.dbsize() assert res == 0 @@ -233,7 +218,6 @@ async def test_dbsize(redis): assert res == 1 -@pytest.mark.run_loop async def test_info(redis): res = await redis.info() assert isinstance(res, dict) @@ -245,13 +229,11 @@ async def test_info(redis): await redis.info('') -@pytest.mark.run_loop async def test_lastsave(redis): res = await redis.lastsave() assert res > 0 -@pytest.mark.run_loop @redis_version(2, 8, 12, reason='ROLE is available since redis>=2.8.12') async def test_role(redis): res = await redis.role() @@ -262,7 +244,6 @@ async def test_role(redis): } -@pytest.mark.run_loop async def test_save(redis): res = await redis.dbsize() assert res == 0 @@ -277,7 +258,6 @@ async def test_save(redis): pytest.param(None, id='no decoding'), pytest.param('utf-8', id='with decoding'), ]) -@pytest.mark.run_loop async def test_time(create_redis, server, loop, encoding): redis = await create_redis(server.tcp_address, loop=loop, encoding='utf-8') @@ -287,13 +267,11 @@ async def test_time(create_redis, server, loop, encoding): assert res == pytest.approx(now, abs=10) -@pytest.mark.run_loop async def test_slowlog_len(redis): res = await redis.slowlog_len() assert res >= 0 -@pytest.mark.run_loop async def test_slowlog_get(redis): res = await redis.slowlog_get() assert isinstance(res, list) @@ -309,7 +287,6 @@ async def test_slowlog_get(redis): assert not (await redis.slowlog_get('1')) -@pytest.mark.run_loop async def test_slowlog_reset(redis): ok = await redis.slowlog_reset() assert ok is True diff --git a/tests/set_commands_test.py b/tests/set_commands_test.py index a18b54f5c..43fd11047 100644 --- a/tests/set_commands_test.py +++ b/tests/set_commands_test.py @@ -9,7 +9,6 @@ async def add(redis, key, members): assert ok == 1 -@pytest.mark.run_loop async def test_sadd(redis): key, member = b'key:sadd', b'hello' # add member to the set, expected result: 1 @@ -28,7 +27,6 @@ async def test_sadd(redis): await redis.sadd(None, 10) -@pytest.mark.run_loop async def test_scard(redis): key, member = b'key:scard', b'hello' @@ -47,7 +45,6 @@ async def test_scard(redis): await redis.scard(None) -@pytest.mark.run_loop async def test_sdiff(redis): key1 = b'key:sdiff:1' key2 = b'key:sdiff:2' @@ -75,7 +72,6 @@ async def test_sdiff(redis): await redis.sdiff(key1, None) -@pytest.mark.run_loop async def test_sdiffstore(redis): key1 = b'key:sdiffstore:1' key2 = b'key:sdiffstore:2' @@ -107,7 +103,6 @@ async def test_sdiffstore(redis): await redis.sdiffstore(destkey, key1, None) -@pytest.mark.run_loop async def test_sinter(redis): key1 = b'key:sinter:1' key2 = b'key:sinter:2' @@ -135,7 +130,6 @@ async def test_sinter(redis): await redis.sinter(key1, None) -@pytest.mark.run_loop async def test_sinterstore(redis): key1 = b'key:sinterstore:1' key2 = b'key:sinterstore:2' @@ -167,7 +161,6 @@ async def test_sinterstore(redis): await redis.sinterstore(destkey, key1, None) -@pytest.mark.run_loop async def test_sismember(redis): key, member = b'key:sismember', b'hello' # add member to the set, expected result: 1 @@ -185,7 +178,6 @@ async def test_sismember(redis): await redis.sismember(None, b'world') -@pytest.mark.run_loop async def test_smembers(redis): key = b'key:smembers' member1 = b'hello' @@ -210,7 +202,6 @@ async def test_smembers(redis): await redis.smembers(None) -@pytest.mark.run_loop async def test_smove(redis): key1 = b'key:smove:1' key2 = b'key:smove:2' @@ -250,7 +241,6 @@ async def test_smove(redis): await redis.smove(key1, None, member1) -@pytest.mark.run_loop async def test_spop(redis): key = b'key:spop:1' members = b'one', b'two', b'three' @@ -284,7 +274,6 @@ async def test_spop(redis): 3, 2, 0, reason="The count argument in SPOP is available since redis>=3.2.0" ) -@pytest.mark.run_loop async def test_spop_count(redis): key = b'key:spop:1' members1 = b'one', b'two', b'three' @@ -316,7 +305,6 @@ async def test_spop_count(redis): assert len(test_result3) == 0 -@pytest.mark.run_loop async def test_srandmember(redis): key = b'key:srandmember:1' members = b'one', b'two', b'three', b'four', b'five', b'six', b'seven' @@ -354,7 +342,6 @@ async def test_srandmember(redis): await redis.srandmember(None) -@pytest.mark.run_loop async def test_srem(redis): key = b'key:srem:1' members = b'one', b'two', b'three', b'four', b'five', b'six', b'seven' @@ -379,7 +366,6 @@ async def test_srem(redis): await redis.srem(None, members) -@pytest.mark.run_loop async def test_sunion(redis): key1 = b'key:sunion:1' key2 = b'key:sunion:2' @@ -407,7 +393,6 @@ async def test_sunion(redis): await redis.sunion(key1, None) -@pytest.mark.run_loop async def test_sunionstore(redis): key1 = b'key:sunionstore:1' key2 = b'key:sunionstore:2' @@ -440,7 +425,6 @@ async def test_sunionstore(redis): @redis_version(2, 8, 0, reason='SSCAN is available since redis>=2.8.0') -@pytest.mark.run_loop async def test_sscan(redis): key = b'key:sscan' for i in range(1, 11): @@ -471,7 +455,6 @@ async def test_sscan(redis): @redis_version(2, 8, 0, reason='SSCAN is available since redis>=2.8.0') -@pytest.mark.run_loop async def test_isscan(redis): key = b'key:sscan' for i in range(1, 11): diff --git a/tests/sorted_set_commands_test.py b/tests/sorted_set_commands_test.py index b02119461..3a8eb82d4 100644 --- a/tests/sorted_set_commands_test.py +++ b/tests/sorted_set_commands_test.py @@ -6,7 +6,6 @@ @redis_version(5, 0, 0, reason='BZPOPMAX is available since redis>=5.0.0') -@pytest.mark.run_loop async def test_bzpopmax(redis): key1 = b'key:zpopmax:1' key2 = b'key:zpopmax:2' @@ -29,7 +28,6 @@ async def test_bzpopmax(redis): @redis_version(5, 0, 0, reason='BZPOPMIN is available since redis>=5.0.0') -@pytest.mark.run_loop async def test_bzpopmin(redis): key1 = b'key:zpopmin:1' key2 = b'key:zpopmin:2' @@ -51,7 +49,6 @@ async def test_bzpopmin(redis): await redis.bzpopmin(key2, timeout=-10) -@pytest.mark.run_loop async def test_zadd(redis): key = b'key:zadd' res = await redis.zadd(key, 1, b'one') @@ -81,7 +78,6 @@ async def test_zadd(redis): @redis_version( 3, 0, 2, reason='ZADD options is available since redis>=3.0.2', ) -@pytest.mark.run_loop async def test_zadd_options(redis): key = b'key:zaddopt' @@ -125,7 +121,6 @@ async def test_zadd_options(redis): await redis.zadd(key, 1, b'one', 2, b'two', incr=True) -@pytest.mark.run_loop async def test_zcard(redis): key = b'key:zcard' pairs = [1, b'one', 2, b'two', 3, b'three'] @@ -142,7 +137,6 @@ async def test_zcard(redis): await redis.zcard(None) -@pytest.mark.run_loop async def test_zcount(redis): key = b'key:zcount' pairs = [1, b'one', 1, b'uno', 2.5, b'two', 3, b'three', 7, b'seven'] @@ -186,7 +180,6 @@ async def test_zcount(redis): await redis.zcount(key, 10, 1) -@pytest.mark.run_loop async def test_zincrby(redis): key = b'key:zincrby' pairs = [1, b'one', 1, b'uno', 2.5, b'two', 3, b'three'] @@ -206,7 +199,6 @@ async def test_zincrby(redis): await redis.zincrby(key, 'one', 5) -@pytest.mark.run_loop async def test_zinterstore(redis): zset1 = [2, 'one', 2, 'two'] zset2 = [3, 'one', 3, 'three'] @@ -256,7 +248,6 @@ async def test_zinterstore(redis): @redis_version( 2, 8, 9, reason='ZLEXCOUNT is available since redis>=2.8.9') -@pytest.mark.run_loop async def test_zlexcount(redis): key = b'key:zlexcount' pairs = [0, b'a', 0, b'b', 0, b'c', 0, b'd', 0, b'e'] @@ -280,7 +271,6 @@ async def test_zlexcount(redis): @pytest.mark.parametrize('encoding', [None, 'utf-8']) -@pytest.mark.run_loop async def test_zrange(redis, encoding): key = b'key:zrange' scores = [1, 1, 2.5, 3, 7] @@ -313,7 +303,6 @@ async def test_zrange(redis, encoding): @redis_version( 2, 8, 9, reason='ZRANGEBYLEX is available since redis>=2.8.9') -@pytest.mark.run_loop async def test_zrangebylex(redis): key = b'key:zrangebylex' scores = [0] * 5 @@ -357,7 +346,6 @@ async def test_zrangebylex(redis): offset=1, count='one') -@pytest.mark.run_loop async def test_zrank(redis): key = b'key:zrank' scores = [1, 1, 2.5, 3, 7] @@ -379,7 +367,6 @@ async def test_zrank(redis): @pytest.mark.parametrize('encoding', [None, 'utf-8']) -@pytest.mark.run_loop async def test_zrangebyscore(redis, encoding): key = b'key:zrangebyscore' scores = [1, 1, 2.5, 3, 7] @@ -423,7 +410,6 @@ async def test_zrangebyscore(redis, encoding): await redis.zrangebyscore(key, 1, 7, offset=1, count='one') -@pytest.mark.run_loop async def test_zrem(redis): key = b'key:zrem' scores = [1, 1, 2.5, 3, 7] @@ -451,7 +437,6 @@ async def test_zrem(redis): @redis_version( 2, 8, 9, reason='ZREMRANGEBYLEX is available since redis>=2.8.9') -@pytest.mark.run_loop async def test_zremrangebylex(redis): key = b'key:zremrangebylex' members = [b'aaaa', b'b', b'c', b'd', b'e', b'foo', b'zap', b'zip', @@ -490,7 +475,6 @@ async def test_zremrangebylex(redis): await redis.zremrangebylex(key, b'a', 20) -@pytest.mark.run_loop async def test_zremrangebyrank(redis): key = b'key:zremrangebyrank' scores = [0, 1, 2, 3, 4, 5] @@ -517,7 +501,6 @@ async def test_zremrangebyrank(redis): await redis.zremrangebyrank(key, 0, 'last') -@pytest.mark.run_loop async def test_zremrangebyscore(redis): key = b'key:zremrangebyscore' scores = [1, 1, 2.5, 3, 7] @@ -552,7 +535,6 @@ async def test_zremrangebyscore(redis): @pytest.mark.parametrize('encoding', [None, 'utf-8']) -@pytest.mark.run_loop async def test_zrevrange(redis, encoding): key = b'key:zrevrange' scores = [1, 1, 2.5, 3, 7] @@ -587,7 +569,6 @@ async def test_zrevrange(redis, encoding): await redis.zrevrange(key, 0, 'last') -@pytest.mark.run_loop async def test_zrevrank(redis): key = b'key:zrevrank' scores = [1, 1, 2.5, 3, 7] @@ -608,7 +589,6 @@ async def test_zrevrank(redis): await redis.zrevrank(None, b'one') -@pytest.mark.run_loop async def test_zscore(redis): key = b'key:zscore' scores = [1, 1, 2.5, 3, 7] @@ -628,7 +608,6 @@ async def test_zscore(redis): assert res is None -@pytest.mark.run_loop async def test_zunionstore(redis): zset1 = [2, 'one', 2, 'two'] zset2 = [3, 'one', 3, 'three'] @@ -677,7 +656,6 @@ async def test_zunionstore(redis): @pytest.mark.parametrize('encoding', [None, 'utf-8']) -@pytest.mark.run_loop async def test_zrevrangebyscore(redis, encoding): key = b'key:zrevrangebyscore' scores = [1, 1, 2.5, 3, 7] @@ -724,7 +702,6 @@ async def test_zrevrangebyscore(redis, encoding): @redis_version( 2, 8, 9, reason='ZREVRANGEBYLEX is available since redis>=2.8.9') -@pytest.mark.run_loop async def test_zrevrangebylex(redis): key = b'key:zrevrangebylex' scores = [0] * 5 @@ -771,7 +748,6 @@ async def test_zrevrangebylex(redis): @redis_version(2, 8, 0, reason='ZSCAN is available since redis>=2.8.0') -@pytest.mark.run_loop async def test_zscan(redis): key = b'key:zscan' scores, members = [], [] @@ -805,7 +781,6 @@ async def test_zscan(redis): @redis_version(2, 8, 0, reason='ZSCAN is available since redis>=2.8.0') -@pytest.mark.run_loop async def test_izscan(redis): key = b'key:zscan' scores, members = [], [] @@ -845,7 +820,6 @@ async def coro(cmd): @redis_version(5, 0, 0, reason='ZPOPMAX is available since redis>=5.0.0') -@pytest.mark.run_loop async def test_zpopmax(redis): key = b'key:zpopmax' @@ -862,7 +836,6 @@ async def test_zpopmax(redis): @redis_version(5, 0, 0, reason='ZPOPMIN is available since redis>=5.0.0') -@pytest.mark.run_loop async def test_zpopmin(redis): key = b'key:zpopmin' diff --git a/tests/ssl_test.py b/tests/ssl_test.py index e31a99c12..bfb3b325e 100644 --- a/tests/ssl_test.py +++ b/tests/ssl_test.py @@ -1,7 +1,4 @@ -import pytest - -@pytest.mark.run_loop async def test_ssl_connection(create_connection, loop, server, ssl_proxy): ssl_port, ssl_ctx = ssl_proxy(server.tcp_address.port) @@ -11,7 +8,6 @@ async def test_ssl_connection(create_connection, loop, server, ssl_proxy): assert res == b'PONG' -@pytest.mark.run_loop async def test_ssl_redis(create_redis, loop, server, ssl_proxy): ssl_port, ssl_ctx = ssl_proxy(server.tcp_address.port) @@ -21,7 +17,6 @@ async def test_ssl_redis(create_redis, loop, server, ssl_proxy): assert res == b'PONG' -@pytest.mark.run_loop async def test_ssl_pool(create_pool, server, loop, ssl_proxy): ssl_port, ssl_ctx = ssl_proxy(server.tcp_address.port) diff --git a/tests/stream_commands_test.py b/tests/stream_commands_test.py index 446c27ccd..6ca8831a9 100644 --- a/tests/stream_commands_test.py +++ b/tests/stream_commands_test.py @@ -18,7 +18,6 @@ async def add_message_with_sleep(redis, loop, stream, fields): return result -@pytest.mark.run_loop async def test_xadd(redis, server_bin): fields = OrderedDict(( (b'field1', b'value1'), @@ -43,7 +42,6 @@ async def test_xadd(redis, server_bin): ) -@pytest.mark.run_loop async def test_xadd_maxlen_exact(redis, server_bin): message_id1 = await redis.xadd('test_stream', {'f1': 'v1'}) # noqa @@ -70,7 +68,6 @@ async def test_xadd_maxlen_exact(redis, server_bin): assert message3[1] == OrderedDict([(b'f3', b'v3')]) -@pytest.mark.run_loop async def test_xadd_manual_message_ids(redis, server_bin): await redis.xadd('test_stream', {'f1': 'v1'}, message_id='1515958771000-0') await redis.xadd('test_stream', {'f1': 'v1'}, message_id='1515958771000-1') @@ -85,7 +82,6 @@ async def test_xadd_manual_message_ids(redis, server_bin): ] -@pytest.mark.run_loop async def test_xadd_maxlen_inexact(redis, server_bin): await redis.xadd('test_stream', {'f1': 'v1'}) # Ensure the millisecond-based message ID increments @@ -107,7 +103,6 @@ async def test_xadd_maxlen_inexact(redis, server_bin): assert len(messages) < 1000 -@pytest.mark.run_loop async def test_xrange(redis, server_bin): stream = 'test_stream' fields = OrderedDict(( @@ -161,7 +156,6 @@ async def test_xrange(redis, server_bin): assert len(messages) == 2 -@pytest.mark.run_loop async def test_xrevrange(redis, server_bin): stream = 'test_stream' fields = OrderedDict(( @@ -215,7 +209,6 @@ async def test_xrevrange(redis, server_bin): assert len(messages) == 2 -@pytest.mark.run_loop async def test_xread_selection(redis, server_bin): """Test use of counts and starting IDs""" stream = 'test_stream' @@ -248,7 +241,6 @@ async def test_xread_selection(redis, server_bin): assert len(messages) == 2 -@pytest.mark.run_loop async def test_xread_blocking(redis, create_redis, loop, server, server_bin): """Test the blocking read features""" fields = OrderedDict(( @@ -283,7 +275,6 @@ async def test_xread_blocking(redis, create_redis, loop, server, server_bin): other_redis.close() -@pytest.mark.run_loop async def test_xgroup_create(redis, server_bin): # Also tests xinfo_groups() await redis.xadd('test_stream', {'a': 1}) @@ -297,7 +288,6 @@ async def test_xgroup_create(redis, server_bin): }] -@pytest.mark.run_loop async def test_xgroup_create_mkstream(redis, server_bin): await redis.xgroup_create('test_stream', 'test_group', mkstream=True) info = await redis.xinfo_groups('test_stream') @@ -309,7 +299,6 @@ async def test_xgroup_create_mkstream(redis, server_bin): }] -@pytest.mark.run_loop async def test_xgroup_create_already_exists(redis, server_bin): await redis.xadd('test_stream', {'a': 1}) await redis.xgroup_create('test_stream', 'test_group') @@ -317,14 +306,12 @@ async def test_xgroup_create_already_exists(redis, server_bin): await redis.xgroup_create('test_stream', 'test_group') -@pytest.mark.run_loop async def test_xgroup_setid(redis, server_bin): await redis.xadd('test_stream', {'a': 1}) await redis.xgroup_create('test_stream', 'test_group') await redis.xgroup_setid('test_stream', 'test_group', '$') -@pytest.mark.run_loop async def test_xgroup_destroy(redis, server_bin): await redis.xadd('test_stream', {'a': 1}) await redis.xgroup_create('test_stream', 'test_group') @@ -333,7 +320,6 @@ async def test_xgroup_destroy(redis, server_bin): assert not info -@pytest.mark.run_loop async def test_xread_group(redis): await redis.xadd('test_stream', {'a': 1}) await redis.xgroup_create('test_stream', 'test_group', latest_id='0') @@ -350,7 +336,6 @@ async def test_xread_group(redis): assert fields == {b'a': b'1'} -@pytest.mark.run_loop async def test_xread_group_with_no_ack(redis): await redis.xadd('test_stream', {'a': 1}) await redis.xgroup_create('test_stream', 'test_group', latest_id='0') @@ -367,7 +352,6 @@ async def test_xread_group_with_no_ack(redis): assert fields == {b'a': b'1'} -@pytest.mark.run_loop async def test_xack_and_xpending(redis): # Test a full xread -> xack cycle, using xpending to check the status message_id = await redis.xadd('test_stream', {'a': 1}) @@ -401,7 +385,6 @@ async def test_xack_and_xpending(redis): assert pending_count == 0 -@pytest.mark.run_loop async def test_xpending_get_messages(redis): # Like test_xack_and_xpending(), but using the start/end xpending() # params to get the messages @@ -427,7 +410,6 @@ async def test_xpending_get_messages(redis): assert num_deliveries == 1 -@pytest.mark.run_loop async def test_xpending_start_of_zero(redis): await redis.xadd('test_stream', {'a': 1}) await redis.xgroup_create('test_stream', 'test_group', latest_id='0') @@ -435,7 +417,6 @@ async def test_xpending_start_of_zero(redis): await redis.xpending('test_stream', 'test_group', 0, '+', 10) -@pytest.mark.run_loop async def test_xclaim_simple(redis): # Put a message in a pending state then reclaim it is XCLAIM message_id = await redis.xadd('test_stream', {'a': 1}) @@ -466,7 +447,6 @@ async def test_xclaim_simple(redis): assert pel == [[b'new_consumer', b'1']] -@pytest.mark.run_loop async def test_xclaim_min_idle_time_includes_messages(redis): message_id = await redis.xadd('test_stream', {'a': 1}) await redis.xgroup_create('test_stream', 'test_group', latest_id='0') @@ -484,7 +464,6 @@ async def test_xclaim_min_idle_time_includes_messages(redis): assert result -@pytest.mark.run_loop async def test_xclaim_min_idle_time_excludes_messages(redis): message_id = await redis.xadd('test_stream', {'a': 1}) await redis.xgroup_create('test_stream', 'test_group', latest_id='0') @@ -501,7 +480,6 @@ async def test_xclaim_min_idle_time_excludes_messages(redis): assert not result -@pytest.mark.run_loop async def test_xgroup_delconsumer(redis, create_redis, server): await redis.xadd('test_stream', {'a': 1}) await redis.xgroup_create('test_stream', 'test_group') @@ -522,14 +500,12 @@ async def test_xgroup_delconsumer(redis, create_redis, server): assert not info -@pytest.mark.run_loop async def test_xdel_stream(redis): message_id = await redis.xadd('test_stream', {'a': 1}) response = await redis.xdel('test_stream', id=message_id) assert response >= 0 -@pytest.mark.run_loop async def test_xtrim_stream(redis): await redis.xadd('test_stream', {'a': 1}) await redis.xadd('test_stream', {'b': 1}) @@ -538,14 +514,12 @@ async def test_xtrim_stream(redis): assert response >= 0 -@pytest.mark.run_loop async def test_xlen_stream(redis): await redis.xadd('test_stream', {'a': 1}) response = await redis.xlen('test_stream') assert response >= 0 -@pytest.mark.run_loop async def test_xinfo_consumers(redis): await redis.xadd('test_stream', {'a': 1}) await redis.xgroup_create('test_stream', 'test_group') @@ -563,7 +537,6 @@ async def test_xinfo_consumers(redis): assert isinstance(info[0], dict) -@pytest.mark.run_loop async def test_xinfo_stream(redis): await redis.xadd('test_stream', {'a': 1}) await redis.xgroup_create('test_stream', 'test_group') @@ -585,13 +558,11 @@ async def test_xinfo_stream(redis): assert isinstance(info, dict) -@pytest.mark.run_loop async def test_xinfo_help(redis): info = await redis.xinfo_help() assert info -@pytest.mark.run_loop @pytest.mark.parametrize('param', [0.1, '1']) async def test_xread_param_types(redis, param): with pytest.raises(TypeError): diff --git a/tests/stream_test.py b/tests/stream_test.py index 39ff358bd..1634c90e2 100644 --- a/tests/stream_test.py +++ b/tests/stream_test.py @@ -17,13 +17,11 @@ def reader(loop): return reader -@pytest.mark.run_loop async def test_feed_and_parse(reader): reader.feed_data(b'+PONG\r\n') assert (await reader.readobj()) == b'PONG' -@pytest.mark.run_loop async def test_buffer_available_after_RST(reader): reader.feed_data(b'+PONG\r\n') reader.set_exception(Exception()) @@ -46,7 +44,6 @@ def test_feed_no_data(reader): 'read_method', ['read', 'readline', 'readuntil', 'readexactly'] ) -@pytest.mark.run_loop async def test_read_flavors_not_supported(reader, read_method): with pytest.raises(RuntimeError): await getattr(reader, read_method)() diff --git a/tests/string_commands_test.py b/tests/string_commands_test.py index ab7f7b3f4..e924247b1 100644 --- a/tests/string_commands_test.py +++ b/tests/string_commands_test.py @@ -10,7 +10,6 @@ async def add(redis, key, value): assert ok is True -@pytest.mark.run_loop async def test_append(redis): len_ = await redis.append('my-key', 'Hello') assert len_ == 5 @@ -26,7 +25,6 @@ async def test_append(redis): await redis.append('none-key', None) -@pytest.mark.run_loop async def test_bitcount(redis): await add(redis, 'my-key', b'\x00\x10\x01') @@ -57,7 +55,6 @@ async def test_bitcount(redis): await redis.bitcount('my-key', 2, None) -@pytest.mark.run_loop async def test_bitop_and(redis): key1, value1 = b'key:bitop:and:1', 5 key2, value2 = b'key:bitop:and:2', 7 @@ -79,7 +76,6 @@ async def test_bitop_and(redis): await redis.bitop_and(destkey, key1, None) -@pytest.mark.run_loop async def test_bitop_or(redis): key1, value1 = b'key:bitop:or:1', 5 key2, value2 = b'key:bitop:or:2', 7 @@ -101,7 +97,6 @@ async def test_bitop_or(redis): await redis.bitop_or(destkey, key1, None) -@pytest.mark.run_loop async def test_bitop_xor(redis): key1, value1 = b'key:bitop:xor:1', 5 key2, value2 = b'key:bitop:xor:2', 7 @@ -123,7 +118,6 @@ async def test_bitop_xor(redis): await redis.bitop_xor(destkey, key1, None) -@pytest.mark.run_loop async def test_bitop_not(redis): key1, value1 = b'key:bitop:not:1', 5 await add(redis, key1, value1) @@ -141,7 +135,6 @@ async def test_bitop_not(redis): @redis_version(2, 8, 0, reason='BITPOS is available since redis>=2.8.0') -@pytest.mark.run_loop async def test_bitpos(redis): key, value = b'key:bitop', b'\xff\xf0\x00' await add(redis, key, value) @@ -174,7 +167,6 @@ async def test_bitpos(redis): test_value = await redis.bitpos(key, 7) -@pytest.mark.run_loop async def test_decr(redis): await redis.delete('key') @@ -193,7 +185,6 @@ async def test_decr(redis): await redis.decr(None) -@pytest.mark.run_loop async def test_decrby(redis): await redis.delete('key') @@ -216,7 +207,6 @@ async def test_decrby(redis): await redis.decrby('key', None) -@pytest.mark.run_loop async def test_get(redis): await add(redis, 'my-key', 'value') ret = await redis.get('my-key') @@ -233,7 +223,6 @@ async def test_get(redis): await redis.get(None) -@pytest.mark.run_loop async def test_getbit(redis): key, value = b'key:getbit', 10 await add(redis, key, value) @@ -261,7 +250,6 @@ async def test_getbit(redis): await redis.getbit(key, -7) -@pytest.mark.run_loop async def test_getrange(redis): key, value = b'key:getrange', b'This is a string' await add(redis, key, value) @@ -295,7 +283,6 @@ async def test_getrange(redis): await redis.getrange(key, 0, b'seven') -@pytest.mark.run_loop async def test_getset(redis): key, value = b'key:getset', b'hello' await add(redis, key, value) @@ -320,7 +307,6 @@ async def test_getset(redis): await redis.getset(None, b'asyncio') -@pytest.mark.run_loop async def test_incr(redis): await redis.delete('key') @@ -339,7 +325,6 @@ async def test_incr(redis): await redis.incr(None) -@pytest.mark.run_loop async def test_incrby(redis): await redis.delete('key') @@ -362,7 +347,6 @@ async def test_incrby(redis): await redis.incrby('key', None) -@pytest.mark.run_loop async def test_incrbyfloat(redis): await redis.delete('key') @@ -389,7 +373,6 @@ async def test_incrbyfloat(redis): await redis.incrbyfloat('key', '1.0') -@pytest.mark.run_loop async def test_mget(redis): key1, value1 = b'foo', b'bar' key2, value2 = b'baz', b'bzz' @@ -414,7 +397,6 @@ async def test_mget(redis): await redis.mget(key1, None) -@pytest.mark.run_loop async def test_mset(redis): key1, value1 = b'key:mset:1', b'hello' key2, value2 = b'key:mset:2', b'world' @@ -434,7 +416,6 @@ async def test_mset(redis): await redis.mset(key1, value1, key1) -@pytest.mark.run_loop async def test_mset_with_dict(redis): array = [str(n) for n in range(10)] _dict = dict.fromkeys(array, 'default value', ) @@ -448,7 +429,6 @@ async def test_mset_with_dict(redis): await redis.mset('param', ) -@pytest.mark.run_loop async def test_msetnx(redis): key1, value1 = b'key:msetnx:1', b'Hello' key2, value2 = b'key:msetnx:2', b'there' @@ -469,7 +449,6 @@ async def test_msetnx(redis): await redis.msetnx(key1, value1, key2) -@pytest.mark.run_loop async def test_psetex(redis, loop): key, value = b'key:psetex:1', b'Hello' # test expiration in milliseconds @@ -491,7 +470,6 @@ async def test_psetex(redis, loop): await redis.psetex(key, 7.5, value) -@pytest.mark.run_loop async def test_set(redis): ok = await redis.set('my-key', 'value') assert ok is True @@ -506,7 +484,6 @@ async def test_set(redis): await redis.set(None, 'value') -@pytest.mark.run_loop async def test_set_expire(redis, loop): key, value = b'key:set:expire', b'foo' # test expiration in milliseconds @@ -534,7 +511,6 @@ async def test_set_expire(redis, loop): assert result_4 is None -@pytest.mark.run_loop async def test_set_only_if_not_exists(redis): key, value = b'key:set:only_if_not_exists', b'foo' await redis.set( @@ -550,7 +526,6 @@ async def test_set_only_if_not_exists(redis): assert result_2 == value -@pytest.mark.run_loop async def test_set_only_if_exists(redis): key, value = b'key:set:only_if_exists', b'only_if_exists:foo' # ensure that such key does not exits, and value not sets @@ -566,7 +541,6 @@ async def test_set_only_if_exists(redis): assert result_2 == b'foo' -@pytest.mark.run_loop async def test_set_wrong_input(redis): key, value = b'key:set:', b'foo' @@ -578,7 +552,6 @@ async def test_set_wrong_input(redis): await redis.set(key, value, pexpire=7.8) -@pytest.mark.run_loop async def test_setbit(redis): key = b'key:setbit' result = await redis.setbit(key, 7, 1) @@ -596,7 +569,6 @@ async def test_setbit(redis): await redis.setbit(key, 1, 7) -@pytest.mark.run_loop async def test_setex(redis, loop): key, value = b'key:setex:1', b'Hello' tr = redis.multi_exec() @@ -627,7 +599,6 @@ async def test_setex(redis, loop): await redis.setex(key, b'one', value) -@pytest.mark.run_loop async def test_setnx(redis): key, value = b'key:setnx:1', b'Hello' # set fresh new value @@ -649,7 +620,6 @@ async def test_setnx(redis): await redis.setnx(None, value) -@pytest.mark.run_loop async def test_setrange(redis): key, value = b'key:setrange', b'Hello World' await add(redis, key, value) @@ -671,7 +641,6 @@ async def test_setrange(redis): await redis.setrange(key, -1, b'Redis') -@pytest.mark.run_loop async def test_strlen(redis): key, value = b'key:strlen', b'asyncio' await add(redis, key, value) @@ -685,7 +654,6 @@ async def test_strlen(redis): await redis.strlen(None) -@pytest.mark.run_loop async def test_cancel_hang(redis): exists_coro = redis.execute("EXISTS", b"key:test1") exists_coro.cancel() @@ -693,7 +661,6 @@ async def test_cancel_hang(redis): assert not exists_check -@pytest.mark.run_loop async def test_set_enc(create_redis, loop, server): redis = await create_redis( server.tcp_address, loop=loop, encoding='utf-8') diff --git a/tests/task_cancellation_test.py b/tests/task_cancellation_test.py index ecc178a54..e1999813c 100644 --- a/tests/task_cancellation_test.py +++ b/tests/task_cancellation_test.py @@ -3,7 +3,6 @@ import asyncio -@pytest.mark.run_loop async def test_future_cancellation(create_connection, loop, server): conn = await create_connection( server.tcp_address, loop=loop) diff --git a/tests/transaction_commands_test.py b/tests/transaction_commands_test.py index 4582d636b..bb813a0a2 100644 --- a/tests/transaction_commands_test.py +++ b/tests/transaction_commands_test.py @@ -5,7 +5,6 @@ from aioredis import ConnectionClosedError -@pytest.mark.run_loop async def test_multi_exec(redis, loop): await redis.delete('foo', 'bar') @@ -40,14 +39,12 @@ async def test_multi_exec(redis, loop): await f1 -@pytest.mark.run_loop async def test_empty(redis): tr = redis.multi_exec() res = await tr.execute() assert res == [] -@pytest.mark.run_loop async def test_double_execute(redis): tr = redis.multi_exec() await tr.execute() @@ -57,7 +54,6 @@ async def test_double_execute(redis): await tr.incr('foo') -@pytest.mark.run_loop async def test_connection_closed(redis): tr = redis.multi_exec() fut1 = tr.quit() @@ -89,7 +85,6 @@ async def test_connection_closed(redis): (ConnectionClosedError, ConnectionError)) -@pytest.mark.run_loop async def test_discard(redis): await redis.delete('foo') tr = redis.multi_exec() @@ -108,7 +103,6 @@ async def test_discard(redis): assert res == 1 -@pytest.mark.run_loop async def test_exec_error(redis): tr = redis.multi_exec() fut = tr.connection.execute('INCRBY', 'key', '1.0') @@ -126,7 +120,6 @@ async def test_exec_error(redis): await fut -@pytest.mark.run_loop async def test_command_errors(redis): tr = redis.multi_exec() fut = tr.incrby('key', 1.0) @@ -136,7 +129,6 @@ async def test_command_errors(redis): await fut -@pytest.mark.run_loop async def test_several_command_errors(redis): tr = redis.multi_exec() fut1 = tr.incrby('key', 1.0) @@ -149,7 +141,6 @@ async def test_several_command_errors(redis): await fut2 -@pytest.mark.run_loop async def test_error_in_connection(redis): await redis.set('foo', 1) tr = redis.multi_exec() @@ -162,7 +153,6 @@ async def test_error_in_connection(redis): await fut2 -@pytest.mark.run_loop async def test_watch_unwatch(redis): res = await redis.watch('key') assert res is True @@ -180,7 +170,6 @@ async def test_watch_unwatch(redis): assert res is True -@pytest.mark.run_loop async def test_encoding(redis): res = await redis.set('key', 'value') assert res is True @@ -201,7 +190,6 @@ async def test_encoding(redis): assert res == {'foo': 'val1', 'bar': 'val2'} -@pytest.mark.run_loop async def test_global_encoding(redis, create_redis, server, loop): redis = await create_redis( server.tcp_address, @@ -225,7 +213,6 @@ async def test_global_encoding(redis, create_redis, server, loop): assert res == {'foo': 'val1', 'bar': 'val2'} -@pytest.mark.run_loop async def test_transaction__watch_error(redis, create_redis, server, loop): other = await create_redis( server.tcp_address, loop=loop) @@ -250,7 +237,6 @@ async def test_transaction__watch_error(redis, create_redis, server, loop): await fut2 -@pytest.mark.run_loop async def test_multi_exec_and_pool_release(redis): # Test the case when pool connection is released before # `exec` result is received. @@ -271,7 +257,6 @@ async def test_multi_exec_and_pool_release(redis): assert (await fut1) is None -@pytest.mark.run_loop async def test_multi_exec_db_select(redis): await redis.set('foo', 'bar')