Integration tests (#3)

Reviewed-on: root/pssecret#3
Co-authored-by: Ivan Golikov <root@ivnglkv.me>
Co-committed-by: Ivan Golikov <root@ivnglkv.me>

tests/conftest.py

@@ -0,0 +1,38 @@
+from collections.abc import AsyncGenerator
+
+import pytest
+from fastapi.testclient import TestClient
+from pydantic_settings import SettingsConfigDict
+from redis import asyncio as aioredis
+
+from pssecret.main import app
+from pssecret.settings import Settings, get_settings
+
+
+class TestSettings(Settings):
+    model_config = SettingsConfigDict(env_file=".test.env")
+
+
+@pytest.fixture
+def settings() -> Settings:
+    return TestSettings()
+
+
+@pytest.fixture()
+async def redis_server(settings: Settings) -> AsyncGenerator[aioredis.Redis]:
+    redis = await aioredis.from_url(str(settings.redis_url))
+    yield redis
+    await redis.flushdb()
+
+
+def get_test_settings() -> Settings:
+    return TestSettings()
+
+
+@pytest.fixture(scope="session")
+def client() -> TestClient:
+    client_ = TestClient(app)
+
+    app.dependency_overrides[get_settings] = get_test_settings
+
+    return client_

tests/factories.py

@@ -0,0 +1,6 @@
+from polyfactory.factories.pydantic_factory import ModelFactory
+
+from pssecret.models import Secret
+
+
+class SecretFactory(ModelFactory[Secret]): ...

tests/integration/test_api.py

@@ -0,0 +1,33 @@
+from fastapi.testclient import TestClient
+
+from tests.factories import SecretFactory
+
+
+def test_store_secret_returns_key(client: TestClient):
+    response = client.post("/secret", json=dict(SecretFactory().build()))
+
+    assert response.json()["key"]
+
+
+def test_stored_secret_could_be_retrieved(client: TestClient):
+    secret = SecretFactory().build()
+    response = client.post("/secret", json=dict(secret))
+
+    retrieval_key: str = response.json()["key"]
+
+    response = client.get(f"/secret/{retrieval_key}")
+
+    assert response.json()["data"] == secret.data
+
+
+def test_stored_secret_could_be_retrieved_only_once(client: TestClient):
+    secret = SecretFactory().build()
+    response = client.post("/secret", json=dict(secret))
+
+    retrieval_key: str = response.json()["key"]
+
+    client.get(f"/secret/{retrieval_key}")
+    response = client.get(f"/secret/{retrieval_key}")
+
+    assert response.status_code == 404
+    assert secret.data not in response.text

tests/integration/test_utils.py

@@ -0,0 +1,35 @@
+from unittest.mock import patch
+
+from redis.asyncio import Redis
+
+from pssecret.utils import get_new_key, save_secret
+
+from ..factories import SecretFactory
+
+
+async def test_get_new_key_returns_key(redis_server: Redis) -> None:
+    assert isinstance(await get_new_key(redis_server), str)
+
+
+async def test_get_new_key_returns_free_key(redis_server: Redis) -> None:
+    new_key = await get_new_key(redis_server)
+    res = not await redis_server.exists(new_key)
+    assert res
+
+
+@patch("pssecret.utils.uuid4", side_effect=("used", "free"))
+async def test_get_new_key_skips_used_keys(_, redis_server: Redis) -> None:
+    await redis_server.set("used", "")
+
+    assert await get_new_key(redis_server) == "free"
+
+
+async def test_save_secret_data(redis_server: Redis) -> None:
+    secret = SecretFactory.build()
+
+    key = await save_secret(secret, redis_server)
+
+    redis_data: bytes | None = await redis_server.get(key)
+
+    assert redis_data is not None
+    assert redis_data.decode() == secret.data