Upgrade to aioredis 2 (#611)

Author: Dreamsorcerer

aiohttp_session/redis_storage.py

@@ -1,6 +1,5 @@
 import json
 import uuid
-import warnings
 from distutils.version import StrictVersion
 from typing import Any, Callable, Optional
 
@@ -11,15 +10,15 @@
 try:
     import aioredis
 except ImportError:  # pragma: no cover
-    aioredis = None
+    aioredis = None  # type: ignore[assignment]
 
 
 class RedisStorage(AbstractStorage):
     """Redis storage"""
 
-    def __init__(  # type: ignore[no-any-unimported]  # TODO: aioredis
+    def __init__(
         self,
-        redis_pool: 'aioredis.commands.Redis', *,
+        redis_pool: "aioredis.Redis", *,
         cookie_name: str = "AIOHTTP_SESSION",
         domain: Optional[str] = None,
         max_age: Optional[int] = None,
@@ -39,15 +38,8 @@ def __init__(  # type: ignore[no-any-unimported]  # TODO: aioredis
         if StrictVersion(aioredis.__version__).version < (1, 0):
             raise RuntimeError("aioredis<1.0 is not supported")
         self._key_factory = key_factory
-        if isinstance(redis_pool, aioredis.pool.ConnectionsPool):
-            warnings.warn(
-                "using a pool created with aioredis.create_pool is deprecated"
-                "please use a pool created with aioredis.create_redis_pool",
-                DeprecationWarning
-            )
-            redis_pool = aioredis.commands.Redis(redis_pool)
-        elif not isinstance(redis_pool, aioredis.commands.Redis):
-            raise TypeError("Expected aioredis.commands.Redis got {}".format(type(redis_pool)))
+        if not isinstance(redis_pool, aioredis.Redis):
+            raise TypeError("Expected aioredis.Redis got {}".format(type(redis_pool)))
         self._redis = redis_pool
 
     async def load_session(self, request: web.Request) -> Session:
@@ -88,8 +80,4 @@ async def save_session(
                                  max_age=session.max_age)
 
         data = self._encoder(self._get_session_data(session))
-        max_age = session.max_age
-        expire = max_age if max_age is not None else 0
-        await self._redis.set(self.cookie_name + '_' + key,
-                              data,
-                              expire=expire)
+        await self._redis.set(self.cookie_name + '_' + key, data, ex=session.max_age)  # type: ignore[arg-type] # noqa: B950

demo/redis_storage.py

@@ -15,9 +15,9 @@ async def handler(request: web.Request) -> web.Response:
     return web.Response(text=text)
 
 
-async def redis_pool(app: web.Application) -> AsyncIterator[aioredis.commands.Redis]:  # type: ignore[no-any-unimported]  # noqa: B950
-    redis_address = ('127.0.0.1', '6379')
-    async with await aioredis.create_redis_pool(redis_address, timeout=1) as redis:
+async def redis_pool(app: web.Application) -> AsyncIterator[None]:
+    redis_address = "redis://127.0.0.1:6379"
+    async with aioredis.from_url(redis_address, timeout=1) as redis:  # type: ignore[no-untyped-call]  # noqa: B950
         storage = RedisStorage(redis)
         setup(app, storage)
         yield

requirements-dev.txt

@@ -7,7 +7,7 @@ flake8-requirements==1.5.1
 sphinx==4.1.2
 pep257==0.7.0
 -e .
-aioredis==1.2
+aioredis==2.0.0
 cryptography==3.4.8
 docker==5.0.0
 pynacl==1.4.0

tests/conftest.py

@@ -4,7 +4,7 @@
 import sys
 import time
 import uuid
-from typing import Generator, Tuple
+from typing import Iterator
 
 import aiomcache
 import aioredis
@@ -23,10 +23,6 @@ class _ContainerInfo(TypedDict):
     container: docker_models.containers.Container
 
 
-class _RedisParams(TypedDict):
-    address: Tuple[str, int]
-
-
 class _MemcachedParams(TypedDict):
     host: str
     port: int
@@ -41,8 +37,8 @@ def unused_port() -> int:
     return port
 
 
-@pytest.fixture(scope='session')
-def loop() -> Generator[asyncio.AbstractEventLoop, None, None]:
+@pytest.fixture(scope="session")
+def loop() -> Iterator[asyncio.AbstractEventLoop]:
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(None)
 
@@ -73,8 +69,9 @@ def redis_server(  # type: ignore[misc]  # No docker types.
     docker: DockerClient,
     session_id: str,
     loop: asyncio.AbstractEventLoop,
-) -> Generator[_ContainerInfo, None, None]:
+) -> Iterator[_ContainerInfo]:
     image = 'redis:{}'.format('latest')
+    asyncio.set_event_loop(loop)
 
     if sys.platform.startswith('darwin'):
         port = unused_port()
@@ -104,10 +101,8 @@ def redis_server(  # type: ignore[misc]  # No docker types.
     delay = 0.1
     for _i in range(20):
         try:
-            conn = loop.run_until_complete(
-                aioredis.create_connection((host, port), loop=loop)
-            )
-            loop.run_until_complete(conn.execute('SET', 'foo', 'bar'))
+            conn = aioredis.from_url("redis://{}:{}".format(host, port))  # type: ignore[no-untyped-call]  # noqa: B950
+            loop.run_until_complete(conn.set("foo", "bar"))
             break
         except ConnectionRefusedError:
             time.sleep(delay)
@@ -122,30 +117,32 @@ def redis_server(  # type: ignore[misc]  # No docker types.
 
 
 @pytest.fixture
-def redis_params(redis_server: _ContainerInfo) -> _RedisParams:  # type: ignore[misc]
-    return dict(address=(redis_server['host'], redis_server['port']))
+def redis_url(redis_server: _ContainerInfo) -> str:  # type: ignore[misc]
+    return "redis://{}:{}".format(redis_server["host"], redis_server["port"])
 
 
 @pytest.fixture
-def redis(  # type: ignore[misc]  # TODO: aioredis
+def redis(
     loop: asyncio.AbstractEventLoop,
-    redis_params: _RedisParams,
-) -> Generator[aioredis.commands.Redis, None, None]:
-    async def start() -> aioredis.commands.Redis:
-        return await aioredis.create_redis_pool(loop=loop, **redis_params)
+    redis_url: str,
+) -> Iterator[aioredis.Redis]:
+    async def start(pool: aioredis.ConnectionPool) -> aioredis.Redis:
+        return aioredis.Redis(connection_pool=pool)
 
-    pool = loop.run_until_complete(start())
-    yield pool
-    if pool is not None:
-        pool.close()
-        loop.run_until_complete(pool.wait_closed())
+    asyncio.set_event_loop(loop)
+    pool = aioredis.ConnectionPool.from_url(redis_url)
+    redis = loop.run_until_complete(start(pool))
+    yield redis
+    if redis is not None:
+        redis.close()  # type: ignore[no-untyped-call]
+        loop.run_until_complete(pool.disconnect())
 
 
 @pytest.fixture(scope='session')
 def memcached_server(  # type: ignore[misc]  # No docker types.
     docker: DockerClient,
     session_id: str, loop: asyncio.AbstractEventLoop,
-) -> Generator[_ContainerInfo, None, None]:
+) -> Iterator[_ContainerInfo]:
 
     image = 'memcached:{}'.format('latest')
 
@@ -201,7 +198,7 @@ def memcached_params(memcached_server: _ContainerInfo) -> _MemcachedParams:  # t
 def memcached(  # type: ignore[misc]
     loop: asyncio.AbstractEventLoop,
     memcached_params: _MemcachedParams
-) -> Generator[aiomcache.Client, None, None]:
+) -> Iterator[aiomcache.Client]:
     conn = aiomcache.Client(loop=loop, **memcached_params)
     yield conn
     conn.close()

tests/test_redis_storage.py

@@ -2,7 +2,7 @@
 import json
 import time
 import uuid
-from typing import Any, Callable, Dict, MutableMapping, Optional, Tuple, cast
+from typing import Any, Callable, Dict, MutableMapping, Optional, cast
 
 import aioredis
 import pytest
@@ -18,7 +18,7 @@
 
 def create_app(
     handler: _Handler,
-    redis: aioredis.commands.Redis,
+    redis: aioredis.Redis,
     max_age: Optional[int] = None,
     key_factory: Callable[[], str] = lambda: uuid.uuid4().hex
 ) -> web.Application:
@@ -31,7 +31,7 @@ def create_app(
 
 async def make_cookie(
     client: TestClient,
-    redis: aioredis.commands.Redis,
+    redis: aioredis.Redis,
     data: Dict[Any, Any]
 ) -> None:
     session_data = {
@@ -49,7 +49,7 @@ async def make_cookie(
 
 async def make_cookie_with_bad_value(
     client: TestClient,
-    redis: aioredis.commands.Redis
+    redis: aioredis.Redis
 ) -> None:
     key = uuid.uuid4().hex
     await redis.set('AIOHTTP_SESSION_' + key, '')
@@ -61,7 +61,7 @@ async def make_cookie_with_bad_value(
 
 async def load_cookie(
     client: TestClient,
-    redis: aioredis.commands.Redis
+    redis: aioredis.Redis
 ) -> Any:
     cookies = client.session.cookie_jar.filter_cookies(client.make_url('/'))
     key = cookies['AIOHTTP_SESSION']
@@ -73,7 +73,7 @@ async def load_cookie(
 
 async def test_create_new_session(
     aiohttp_client: AiohttpClient,
-    redis: aioredis.commands.Redis
+    redis: aioredis.Redis
 ) -> None:
 
     async def handler(request: web.Request) -> web.StreamResponse:
@@ -91,7 +91,7 @@ async def handler(request: web.Request) -> web.StreamResponse:
 
 async def test_load_existing_session(
     aiohttp_client: AiohttpClient,
-    redis: aioredis.commands.Redis
+    redis: aioredis.Redis
 ) -> None:
 
     async def handler(request: web.Request) -> web.StreamResponse:
@@ -110,7 +110,7 @@ async def handler(request: web.Request) -> web.StreamResponse:
 
 async def test_load_bad_session(
     aiohttp_client: AiohttpClient,
-    redis: aioredis.commands.Redis
+    redis: aioredis.Redis
 ) -> None:
 
     async def handler(request: web.Request) -> web.StreamResponse:
@@ -129,7 +129,7 @@ async def handler(request: web.Request) -> web.StreamResponse:
 
 async def test_change_session(
     aiohttp_client: AiohttpClient,
-    redis: aioredis.commands.Redis
+    redis: aioredis.Redis
 ) -> None:
 
     async def handler(request: web.Request) -> web.StreamResponse:
@@ -158,7 +158,7 @@ async def handler(request: web.Request) -> web.StreamResponse:
 
 async def test_clear_cookie_on_session_invalidation(
     aiohttp_client: AiohttpClient,
-    redis: aioredis.commands.Redis
+    redis: aioredis.Redis
 ) -> None:
 
     async def handler(request: web.Request) -> web.StreamResponse:
@@ -181,7 +181,7 @@ async def handler(request: web.Request) -> web.StreamResponse:
 
 async def test_create_cookie_in_handler(
     aiohttp_client: AiohttpClient,
-    redis: aioredis.commands.Redis
+    redis: aioredis.Redis
 ) -> None:
 
     async def handler(request: web.Request) -> web.StreamResponse:
@@ -210,7 +210,7 @@ async def handler(request: web.Request) -> web.StreamResponse:
 
 async def test_set_ttl_on_session_saving(
     aiohttp_client: AiohttpClient,
-    redis: aioredis.commands.Redis
+    redis: aioredis.Redis
 ) -> None:
 
     async def handler(request: web.Request) -> web.StreamResponse:
@@ -232,7 +232,7 @@ async def handler(request: web.Request) -> web.StreamResponse:
 
 async def test_set_ttl_manually_set(
     aiohttp_client: AiohttpClient,
-    redis: aioredis.commands.Redis
+    redis: aioredis.Redis
 ) -> None:
 
     async def handler(request: web.Request) -> web.StreamResponse:
@@ -255,7 +255,7 @@ async def handler(request: web.Request) -> web.StreamResponse:
 
 async def test_create_new_session_if_key_doesnt_exists_in_redis(
     aiohttp_client: AiohttpClient,
-    redis: aioredis.commands.Redis
+    redis: aioredis.Redis
 ) -> None:
 
     async def handler(request: web.Request) -> web.StreamResponse:
@@ -274,7 +274,7 @@ async def handler(request: web.Request) -> web.StreamResponse:
 
 async def test_create_storage_with_custom_key_factory(
     aiohttp_client: AiohttpClient,
-    redis: aioredis.commands.Redis
+    redis: aioredis.Redis
 ) -> None:
 
     async def handler(request: web.Request) -> web.StreamResponse:
@@ -299,7 +299,7 @@ def key_factory() -> str:
 
 async def test_redis_session_fixation(
     aiohttp_client: AiohttpClient,
-    redis: aioredis.commands.Redis
+    redis: aioredis.Redis
 ) -> None:
 
     async def login(request: web.Request) -> web.StreamResponse:
@@ -328,14 +328,12 @@ async def logout(request: web.Request) -> web.StreamResponse:
     assert resp.cookies['AIOHTTP_SESSION'].value != evil_cookie
 
 
-async def test_redis_from_create_pool(
-    redis_params: Dict[str, Tuple[str, int]]
-) -> None:
+async def test_redis_from_create_pool(redis_url: str) -> None:
 
     async def handler(request: web.Request) -> web.StreamResponse:
         pass
 
-    redis = await aioredis.create_redis(**redis_params)
+    redis = aioredis.from_url(redis_url)  # type: ignore[no-untyped-call]
     create_app(handler=handler, redis=redis)
 
 
@@ -345,7 +343,7 @@ async def handler(request: web.Request) -> web.StreamResponse:
         pass
 
     with pytest.raises(TypeError):
-        create_app(handler=handler, redis=None)
+        create_app(handler=handler, redis=None)  # type: ignore[arg-type]
 
 
 async def test_no_aioredis_installed(mocker: MockFixture) -> None:
@@ -355,7 +353,7 @@ async def handler(request: web.Request) -> web.StreamResponse:
 
     mocker.patch('aiohttp_session.redis_storage.aioredis', None)
     with pytest.raises(RuntimeError):
-        create_app(handler=handler, redis=None)
+        create_app(handler=handler, redis=None)  # type: ignore[arg-type]
 
 
 async def test_old_aioredis_version(mocker: MockFixture) -> None:
@@ -369,12 +367,12 @@ def __init__(self, *args: object, **kwargs: object) -> None:
 
     mocker.patch('aiohttp_session.redis_storage.StrictVersion', Dummy)
     with pytest.raises(RuntimeError):
-        create_app(handler=handler, redis=None)
+        create_app(handler=handler, redis=None)  # type: ignore[arg-type]
 
 
 async def test_load_session_dont_load_expired_session(
     aiohttp_client: AiohttpClient,
-    redis: aioredis.commands.Redis
+    redis: aioredis.Redis
 ) -> None:
 
     async def handler(request: web.Request) -> web.StreamResponse: