Feature/pools (#110)

* Redis changed to pool.

Signed-off-by: Pavel Kirilin <win10@list.ru>

Author: s3rius

fastapi_template/template/{{cookiecutter.project_name}}/{{cookiecutter.project_name}}/conftest.py

@@ -10,8 +10,10 @@
 from unittest.mock import Mock
 
 {%- if cookiecutter.enable_redis == "True" %}
-from fakeredis.aioredis import FakeRedis
-from {{cookiecutter.project_name}}.services.redis.dependency import get_redis_connection
+from fakeredis import FakeServer
+from fakeredis.aioredis import FakeConnection
+from redis.asyncio import ConnectionPool
+from {{cookiecutter.project_name}}.services.redis.dependency import get_redis_pool
 {%- endif %}
 {%- if cookiecutter.enable_rmq == "True" %}
 from aio_pika import Channel
@@ -425,15 +427,19 @@ async def test_kafka_producer() -> AsyncGenerator[AIOKafkaProducer, None]:
 
 {% if cookiecutter.enable_redis == "True" -%}
 @pytest.fixture
-async def fake_redis() -> AsyncGenerator[FakeRedis, None]:
+async def fake_redis_pool() -> AsyncGenerator[ConnectionPool, None]:
     """
     Get instance of a fake redis.
 
     :yield: FakeRedis instance.
     """
-    redis = FakeRedis(decode_responses=True)
-    yield redis
-    await redis.close()
+    server = FakeServer()
+    server.connected = True
+    pool = ConnectionPool(connection_class=FakeConnection, server=server)
+
+    yield pool
+
+    await pool.disconnect()
 
 {%- endif %}
 
@@ -445,7 +451,7 @@ def fastapi_app(
     dbpool: AsyncConnectionPool,
     {%- endif %}
     {% if cookiecutter.enable_redis == "True" -%}
-    fake_redis: FakeRedis,
+    fake_redis_pool: ConnectionPool,
     {%- endif %}
     {%- if cookiecutter.enable_rmq == 'True' %}
     test_rmq_pool: Pool[Channel],
@@ -466,7 +472,7 @@ def fastapi_app(
     application.dependency_overrides[get_db_pool] = lambda: dbpool
     {%- endif %}
     {%- if cookiecutter.enable_redis == "True" %}
-    application.dependency_overrides[get_redis_connection] = lambda: fake_redis
+    application.dependency_overrides[get_redis_pool] = lambda: fake_redis_pool
     {%- endif %}
     {%- if cookiecutter.enable_rmq == 'True' %}
     application.dependency_overrides[get_rmq_channel_pool] = lambda: test_rmq_pool

fastapi_template/template/{{cookiecutter.project_name}}/{{cookiecutter.project_name}}/services/redis/dependency.py

@@ -4,18 +4,21 @@
 from starlette.requests import Request
 
 
-async def get_redis_connection(request: Request) -> AsyncGenerator[Redis, None]:  # pragma: no cover
+async def get_redis_pool(request: Request) -> AsyncGenerator[Redis, None]:  # pragma: no cover
     """
-    Get redis client.
+    Returns connection pool.
 
-    This dependency aquires connection from pool.
+    You can use it like this:
+
+    >>> from redis.asyncio import ConnectionPool, Redis
+    >>>
+    >>> async def handler(redis_pool: ConnectionPool = Depends(get_redis_pool)):
+    >>>     async with Redis(connection_pool=redis_pool) as redis:
+    >>>         await redis.get('key')
+
+    I use pools so you don't acquire connection till the end of the handler.
 
     :param request: current request.
-    :yield:  redis client.
+    :returns:  redis connection pool.
     """
-    redis_client = Redis(connection_pool=request.app.state.redis_pool)
-
-    try:  # noqa: WPS501
-        yield redis_client
-    finally:
-        await redis_client.close()
+    return request.app.state.redis_pool

fastapi_template/template/{{cookiecutter.project_name}}/{{cookiecutter.project_name}}/tests/test_redis.py

@@ -5,20 +5,20 @@
 from fastapi import FastAPI
 from httpx import AsyncClient
 from starlette import status
-from fakeredis.aioredis import FakeRedis
+from redis.asyncio import ConnectionPool, Redis
 
 
 @pytest.mark.anyio
 async def test_setting_value(
     fastapi_app: FastAPI,
-    fake_redis: FakeRedis,
+    fake_redis_pool: ConnectionPool,
     client: AsyncClient,
 ) -> None:
     """
     Tests that you can set value in redis.
 
     :param fastapi_app: current application fixture.
-    :param fake_redis: fake redis instance.
+    :param fake_redis_pool: fake redis pool.
     :param client: client fixture.
     """
     {%- if cookiecutter.api_type == 'rest' %}
@@ -53,26 +53,28 @@ async def test_setting_value(
     {%- endif %}
 
     assert response.status_code == status.HTTP_200_OK
-    actual_value = await fake_redis.get(test_key)
-    assert actual_value == test_val
+    async with Redis(connection_pool=fake_redis_pool) as redis:
+        actual_value = await redis.get(test_key)
+    assert actual_value.decode() == test_val
 
 
 @pytest.mark.anyio
 async def test_getting_value(
     fastapi_app: FastAPI,
-    fake_redis: FakeRedis,
+    fake_redis_pool: ConnectionPool,
     client: AsyncClient,
 ) -> None:
     """
     Tests that you can get value from redis by key.
 
     :param fastapi_app: current application fixture.
-    :param fake_redis: fake redis instance.
+    :param fake_redis_pool: fake redis pool.
     :param client: client fixture.
     """
     test_key = uuid.uuid4().hex
     test_val = uuid.uuid4().hex
-    await fake_redis.set(test_key, test_val)
+    async with Redis(connection_pool=fake_redis_pool) as redis:
+        await redis.set(test_key, test_val)
 
     {%- if cookiecutter.api_type == 'rest' %}
     url = fastapi_app.url_path_for('get_redis_value')

fastapi_template/template/{{cookiecutter.project_name}}/{{cookiecutter.project_name}}/web/api/redis/views.py

@@ -1,8 +1,8 @@
-from redis.asyncio import Redis
+from redis.asyncio import ConnectionPool, Redis
 from fastapi import APIRouter
 from fastapi.param_functions import Depends
 
-from {{cookiecutter.project_name}}.services.redis.dependency import get_redis_connection
+from {{cookiecutter.project_name}}.services.redis.dependency import get_redis_pool
 from {{cookiecutter.project_name}}.web.api.redis.schema import RedisValueDTO
 
 router = APIRouter()
@@ -11,16 +11,17 @@
 @router.get("/", response_model=RedisValueDTO)
 async def get_redis_value(
     key: str,
-    redis: Redis = Depends(get_redis_connection),
+    redis_pool: ConnectionPool = Depends(get_redis_pool),
 ) -> RedisValueDTO:
     """
     Get value from redis.
 
     :param key: redis key, to get data from.
-    :param redis: redis connection.
+    :param redis_pool: redis connection pool.
     :returns: information from redis.
     """
-    redis_value = await redis.get(key)
+    async with Redis(connection_pool=redis_pool) as redis:
+        redis_value = await redis.get(key)
     return RedisValueDTO(
         key=key,
         value=redis_value,
@@ -30,13 +31,14 @@ async def get_redis_value(
 @router.put("/")
 async def set_redis_value(
     redis_value: RedisValueDTO,
-    redis: Redis = Depends(get_redis_connection),
+    redis_pool: ConnectionPool = Depends(get_redis_pool),
 ) -> None:
     """
     Set value in redis.
 
     :param redis_value: new value data.
-    :param redis: redis connection.
+    :param redis_pool: redis connection pool.
     """
     if redis_value.value is not None:
-        await redis.set(name=redis_value.key, value=redis_value.value)
+        async with Redis(connection_pool=redis_pool) as redis:
+            await redis.set(name=redis_value.key, value=redis_value.value)

fastapi_template/template/{{cookiecutter.project_name}}/{{cookiecutter.project_name}}/web/gql/context.py

@@ -2,8 +2,8 @@
 from strawberry.fastapi import BaseContext
 
 {%- if cookiecutter.enable_redis == "True" %}
-from redis.asyncio import Redis
-from {{cookiecutter.project_name}}.services.redis.dependency import get_redis_connection
+from redis.asyncio import ConnectionPool
+from {{cookiecutter.project_name}}.services.redis.dependency import get_redis_pool
 {%- endif %}
 
 {%- if cookiecutter.enable_rmq == "True" %}
@@ -18,14 +18,12 @@
 {%- endif %}
 
 
-{%- if cookiecutter.db_info.name != 'none' %}
-from {{cookiecutter.project_name}}.db.dependencies import get_db_session
-{%- endif %}
-
 {%- if cookiecutter.orm == "sqlalchemy" %}
 from sqlalchemy.ext.asyncio import AsyncSession
+from {{cookiecutter.project_name}}.db.dependencies import get_db_session
 {%- elif cookiecutter.orm == "psycopg" %}
-from psycopg import AsyncConnection
+from psycopg_pool import AsyncConnectionPool
+from {{cookiecutter.project_name}}.db.dependencies import get_db_pool
 {%- endif %}
 
 
@@ -35,29 +33,32 @@ class Context(BaseContext):
     def __init__(
         self,
         {%- if cookiecutter.enable_redis == "True" %}
-        redis: Redis = Depends(get_redis_connection),
+        redis_pool: ConnectionPool = Depends(get_redis_pool),
         {%- endif %}
         {%- if cookiecutter.enable_rmq == "True" %}
         rabbit: Pool[Channel] = Depends(get_rmq_channel_pool),
         {%- endif %}
         {%- if cookiecutter.orm == "sqlalchemy" %}
         db_connection: AsyncSession = Depends(get_db_session),
         {%- elif cookiecutter.orm == "psycopg" %}
-        db_connection: AsyncConnection[Any] = Depends(get_db_session),
+        db_pool: AsyncConnectionPool = Depends(get_db_pool),
         {%- endif %}
         {%- if cookiecutter.enable_kafka == "True" %}
         kafka_producer: AIOKafkaProducer = Depends(get_kafka_producer),
         {%- endif %}
     ) -> None:
         {%- if cookiecutter.enable_redis == "True" %}
-        self.redis = redis
+        self.redis_pool = redis_pool
         {%- endif %}
         {%- if cookiecutter.enable_rmq == "True" %}
         self.rabbit = rabbit
         {%- endif %}
-        {%- if cookiecutter.orm in ["sqlalchemy", "psycopg"] %}
+        {%- if cookiecutter.orm  == "sqlalchemy" %}
         self.db_connection = db_connection
         {%- endif %}
+        {%- if cookiecutter.orm == "psycopg" %}
+        self.db_pool = db_pool
+        {%- endif %}
         {%- if cookiecutter.enable_kafka == "True" %}
         self.kafka_producer = kafka_producer
         {%- endif %}

fastapi_template/template/{{cookiecutter.project_name}}/{{cookiecutter.project_name}}/web/gql/dummy/mutation.py

@@ -26,8 +26,10 @@ async def create_dummy_model(
         :param name: name of a dummy.
         :return: name of a dummt model.
         """
-        {%- if cookiecutter.orm in ["sqlalchemy", "psycopg"] %}
+        {%- if cookiecutter.orm == "sqlalchemy" %}
         dao = DummyDAO(info.context.db_connection)
+        {%- elif cookiecutter.orm == "psycopg" %}
+        dao = DummyDAO(info.context.db_pool)
         {%- else %}
         dao = DummyDAO()
         {%- endif %}

fastapi_template/template/{{cookiecutter.project_name}}/{{cookiecutter.project_name}}/web/gql/dummy/query.py

@@ -31,8 +31,10 @@ async def get_dummy_models(
         :param offset: offset of dummy objects, defaults to 0.
         :return: list of dummy obbjects from database.
         """
-        {%- if cookiecutter.orm in ["sqlalchemy", "psycopg"] %}
+        {%- if cookiecutter.orm == "sqlalchemy" %}
         dao = DummyDAO(info.context.db_connection)
+        {%- elif cookiecutter.orm == "psycopg" %}
+        dao = DummyDAO(info.context.db_pool)
         {%- else %}
         dao = DummyDAO()
         {%- endif %}

fastapi_template/template/{{cookiecutter.project_name}}/{{cookiecutter.project_name}}/web/gql/redis/mutation.py

@@ -3,7 +3,7 @@
 
 from {{cookiecutter.project_name}}.web.gql.context import Context
 from {{cookiecutter.project_name}}.web.gql.redis.schema import RedisDTO, RedisDTOInput
-
+from redis.asyncio import Redis
 
 @strawberry.type
 class Mutation:
@@ -22,5 +22,6 @@ async def set_redis_value(
         :param info: connection info.
         :return: key and value.
         """
-        await info.context.redis.set(name=data.key, value=data.value)
+        async with Redis(connection_pool=info.context.redis_pool) as redis:
+            await redis.set(name=data.key, value=data.value)
         return RedisDTO(key=data.key, value=data.value)  # type: ignore

fastapi_template/template/{{cookiecutter.project_name}}/{{cookiecutter.project_name}}/web/gql/redis/query.py

@@ -3,7 +3,7 @@
 
 from {{cookiecutter.project_name}}.web.gql.context import Context
 from {{cookiecutter.project_name}}.web.gql.redis.schema import RedisDTO
-
+from redis.asyncio import Redis
 
 @strawberry.type
 class Query:
@@ -18,7 +18,8 @@ async def get_redis_value(self, key: str, info: Info[Context, None]) -> RedisDTO
         :param info: resolver context.
         :return: information from redis.
         """
-        val = await info.context.redis.get(name=key)
+        async with Redis(connection_pool=info.context.redis_pool) as redis:
+            val = await redis.get(name=key)
         if isinstance(val, bytes):
             val = val.decode("utf-8")
         return RedisDTO(key=key, value=val)  # type: ignore