test: Added integration tests for flow authorization, reservation and…

.github/workflows/ci.yaml

@@ -27,8 +27,15 @@ jobs:
           --health-timeout 5s
           --health-retries 5
 
-    env:
-      DB_HOST: localhost  # override docker container name from .env
+      redis:
+        image: redis:7-alpine
+        ports:
+          - 6379:6379
+        options: >-
+          --health-cmd 'redis-cli ping'
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
 # =====
 # Hardcode will be replaced with secrets GitHub Repo
 # =====

pyproject.toml

@@ -33,6 +33,7 @@ dev = [
     'pytest>=9.0.2',
     'pytest-asyncio>=1.3.0',
     'pytest-cov>=7.0.0',
+    'pytest-env>=1.5.0',
     'ruff>=0.15.0',
 ]
 
@@ -56,7 +57,12 @@ python_classes = ['Test*']
 python_functions = ['test_*']
 pythonpath = ['.']
 asyncio_mode = 'auto'
-asyncio_default_fixture_loop_scope = 'function'
+asyncio_default_fixture_loop_scope = 'session'
+asyncio_default_test_loop_scope = 'session'
+env = [
+    'DB_HOST=localhost',
+    'REDIS_HOST=localhost'
+]
 
 [tool.mypy]
 python_version = '3.11'

tests/conftest.py

@@ -2,6 +2,8 @@
 from collections.abc import AsyncGenerator
 
 import pytest_asyncio
+from httpx import ASGITransport, AsyncClient
+from redis.asyncio import Redis
 from sqlalchemy.ext.asyncio import (
     AsyncEngine,
     AsyncSession,
@@ -15,6 +17,7 @@
 import app.services.user.models  # noqa: F401
 from app.core.config import settings
 from app.core.database import Base
+from app.main import app as main_app
 
 
 def _test_db_url() -> str:
@@ -54,3 +57,32 @@ async def db_session(
 ) -> AsyncGenerator[AsyncSession, None]:
     async with db_session_factory() as session:
         yield session
+
+
+def _test_redis_url() -> str:
+    host = os.environ.get('REDIS_HOST', 'localhost')
+    return f'redis://{host}:{settings.redis_port}'
+
+
+@pytest_asyncio.fixture
+async def redis_client() -> AsyncGenerator[Redis, None]:
+    redis = Redis.from_url(_test_redis_url(), decode_responses=True)
+    await redis.flushdb()
+    yield redis
+    await redis.flushdb()
+    await redis.aclose()
+
+
+@pytest_asyncio.fixture
+async def async_client(
+    db_session_factory: async_sessionmaker[AsyncSession], redis_client: Redis
+) -> AsyncGenerator[AsyncClient, None]:
+    from app.core.lua_scripts import RATE_LIMIT_LUA_SCRIPT
+
+    main_app.state.redis = redis_client
+    main_app.state.rate_limit_script = redis_client.register_script(
+        RATE_LIMIT_LUA_SCRIPT
+    )
+    transport = ASGITransport(app=main_app)
+    async with AsyncClient(transport=transport, base_url='http://testserver') as client:
+        yield client

tests/test_integration_auth.py

@@ -0,0 +1,46 @@
+from http import HTTPStatus
+from uuid import uuid4
+
+import pytest
+from httpx import AsyncClient
+
+
+@pytest.mark.asyncio(loop_scope='session')
+async def test_auth_flow(async_client: AsyncClient) -> None:
+    test_email = f'{uuid4().hex[:8]}@example.com'
+    test_password = 'super_secret_password'
+    response = await async_client.post(
+        '/api/v1/users', json={'email': test_email, 'password': test_password}
+    )
+    assert response.status_code == HTTPStatus.CREATED
+    response_data = response.json()
+    assert response_data['email'] == test_email
+
+    response = await async_client.post(
+        '/api/v1/users', json={'email': test_email, 'password': test_password}
+    )
+    assert response.status_code == HTTPStatus.BAD_REQUEST
+    response_data = response.json()
+    assert 'already' in response_data['detail']
+
+    response = await async_client.post(
+        '/api/v1/auth/token', data={'username': test_email, 'password': test_password}
+    )
+    assert response.status_code == HTTPStatus.OK
+    response_data = response.json()
+    access_token = response_data['access_token']
+    refresh_token = response_data['refresh_token']
+
+    response = await async_client.post(
+        '/api/v1/auth/refresh', json={'refresh_token': refresh_token}
+    )
+    assert response.status_code == HTTPStatus.OK
+    response_data = response.json()
+    access_token = response_data['access_token']
+
+    response = await async_client.get(
+        '/api/v1/users/me', headers={'Authorization': f'Bearer {access_token}'}
+    )
+    assert response.status_code == HTTPStatus.OK
+    response_data = response.json()
+    assert response_data['email'] == test_email

tests/test_integration_orders.py

@@ -0,0 +1,57 @@
+from http import HTTPStatus
+from uuid import uuid4
+
+from httpx import AsyncClient
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.services.inventory.models import Product
+
+
+async def test_reserve_order_flow(
+    async_client: AsyncClient, db_session: AsyncSession
+) -> None:
+    test_email = f'{uuid4().hex[:8]}@example.com'
+    test_password = 'super_secret_password'
+    test_product_id = uuid4()
+    idempotency_key = uuid4().hex
+    test_product = Product(
+        id=test_product_id,
+        name='Hatchback 02 blue',
+        description='dayz car such as golf II blue',
+        price='150',
+        qty_available=5,
+    )
+    db_session.add(test_product)
+    await db_session.commit()
+    test_user = await async_client.post(
+        '/api/v1/users', json={'email': test_email, 'password': test_password}
+    )
+    assert test_user.status_code == HTTPStatus.CREATED
+    test_user_login = await async_client.post(
+        '/api/v1/auth/token', data={'username': test_email, 'password': test_password}
+    )
+    assert test_user_login.status_code == HTTPStatus.OK
+    test_user_access_token = test_user_login.json()['access_token']
+    headers = {
+        'Authorization': f'Bearer {test_user_access_token}',
+        'X-Idempotency-Key': idempotency_key,
+    }
+    test_reserve = await async_client.post(
+        '/api/v1/inventory/reserve',
+        json={'product_id': str(test_product_id), 'quantity': 1},
+        headers=headers,
+    )
+    assert test_reserve.status_code == HTTPStatus.OK
+    test_reserve_data = test_reserve.json()
+    assert 'id' in test_reserve_data
+    reservation_id = test_reserve_data['id']
+    order_idempotency_key = uuid4().hex
+    headers['X-Idempotency-Key'] = order_idempotency_key
+    test_order = await async_client.post(
+        '/api/v1/orders/', json={'reservation_id': reservation_id}, headers=headers
+    )
+    assert test_order.status_code == HTTPStatus.OK
+    test_order_data = test_order.json()
+    assert test_order_data['status'] == 'pending'
+    assert test_order_data['total_amount'] == '150.00'
+    assert 'id' in test_order_data

tests/test_integration_reserve.py

@@ -0,0 +1,73 @@
+from http import HTTPStatus
+from uuid import uuid4
+
+from httpx import AsyncClient
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.services.inventory.models import Product
+
+
+async def test_reserve_flow(
+    async_client: AsyncClient,
+    db_session: AsyncSession,
+) -> None:
+    test_email = f'{uuid4().hex[:8]}@example.com'
+    test_password = 'super_secret_password'
+    test_product_id = uuid4()
+    idempotency_key = uuid4().hex
+    test_product = Product(
+        id=test_product_id,
+        name='Hatchback 02 red',
+        description='dayz car such as golf II',
+        price='100',
+        qty_available=5,
+    )
+    db_session.add(test_product)
+    await db_session.commit()
+    test_user = await async_client.post(
+        '/api/v1/users', json={'email': test_email, 'password': test_password}
+    )
+    assert test_user.status_code == HTTPStatus.CREATED
+    test_user_login = await async_client.post(
+        '/api/v1/auth/token', data={'username': test_email, 'password': test_password}
+    )
+    assert test_user_login.status_code == HTTPStatus.OK
+    test_user_access_token = test_user_login.json()['access_token']
+    headers = {
+        'Authorization': f'Bearer {test_user_access_token}',
+        'X-Idempotency-Key': idempotency_key,
+    }
+    test_reserve = await async_client.post(
+        '/api/v1/inventory/reserve',
+        json={'product_id': str(test_product_id), 'quantity': 1},
+        headers=headers,
+    )
+    assert test_reserve.status_code == HTTPStatus.OK
+    test_reserve_data = test_reserve.json()
+    assert 'id' in test_reserve_data
+    assert test_reserve_data['product_id'] == str(test_product_id)
+    assert test_reserve_data['status'] == 'pending'
+
+    test_reserve = await async_client.post(
+        '/api/v1/inventory/reserve',
+        json={'product_id': str(test_product_id), 'quantity': 1},
+        headers=headers,
+    )
+    assert test_reserve.status_code == HTTPStatus.OK
+    test_reserve_data = test_reserve.json()
+    assert 'id' in test_reserve_data
+    assert test_reserve_data['product_id'] == str(test_product_id)
+
+    status_codes = []
+    for _ in range(20):
+        response = await async_client.post(
+            '/api/v1/inventory/reserve',
+            json={'product_id': str(test_product_id), 'quantity': 1},
+            headers={
+                'Authorization': f'Bearer {test_user_access_token}',
+                'X-Idempotency-Key': uuid4().hex,
+            },
+        )
+        status_codes.append(response.status_code)
+
+    assert HTTPStatus.TOO_MANY_REQUESTS in status_codes