Files
plba_v2/tests/test_settings.py
2026-10-10 19:36:32 +03:00

109 lines
4.0 KiB
Python

from collections.abc import Mapping
from typing import Any
import unittest
from plba.settings import (
PostgresSettingsRepository,
SettingInvalidError,
SettingKey,
SettingNotFoundError,
SettingsDatabaseUnavailableError,
SettingsReader,
)
class FakeSettingsRepository:
def __init__(self, values: list[str]) -> None:
self.values = values
self.calls: list[tuple[str, str | None]] = []
async def fetch_values(self, setting_key: str, config_key: str | None = None) -> list[str]:
self.calls.append((setting_key, config_key))
return list(self.values)
class FakeConnection:
def __init__(self, rows: list[Mapping[str, Any]] | None = None, error: Exception | None = None) -> None:
self.rows = rows or []
self.error = error
self.query: str | None = None
self.parameters: tuple[object, ...] = ()
async def fetch(self, query: str, *parameters: object) -> list[Mapping[str, Any]]:
self.query = query
self.parameters = parameters
if self.error:
raise self.error
return self.rows
class FakeAcquire:
def __init__(self, connection: FakeConnection) -> None:
self.connection = connection
async def __aenter__(self) -> FakeConnection:
return self.connection
async def __aexit__(self, *_: object) -> None:
return None
class FakePool:
def __init__(self, connection: FakeConnection) -> None:
self.connection = connection
def acquire(self) -> FakeAcquire:
return FakeAcquire(self.connection)
class SettingsReaderTests(unittest.IsolatedAsyncioTestCase):
async def test_reader_decodes_all_values_in_repository_order(self) -> None:
repository = FakeSettingsRepository(["4", "9"])
reader = SettingsReader(repository)
key: SettingKey[int] = SettingKey("retry_count", int)
values = await reader.read(key, config_key="orders")
self.assertEqual(values, [4, 9])
self.assertEqual(repository.calls, [("retry_count", "orders")])
async def test_reader_uses_optional_default_and_reports_missing_required(self) -> None:
reader = SettingsReader(FakeSettingsRepository([]))
optional: SettingKey[int] = SettingKey("limit", int, required=False, default=20)
self.assertEqual(await reader.read(optional), [20])
with self.assertRaises(SettingNotFoundError):
await reader.read(SettingKey("required", int))
async def test_reader_exposes_decoder_failure(self) -> None:
reader = SettingsReader(FakeSettingsRepository(["bad-value"]))
with self.assertRaises(SettingInvalidError) as raised:
await reader.read(SettingKey("limit", int))
self.assertIsInstance(raised.exception.__cause__, ValueError)
async def test_postgres_adapter_parameterizes_filters_and_orders(self) -> None:
connection = FakeConnection([{"setting_value": "first"}, {"setting_value": "second"}])
repository = PostgresSettingsRepository(FakePool(connection), "app_data")
values = await repository.fetch_values("theme", "north")
self.assertEqual(values, ["first", "second"])
self.assertIn('"app_data".settings', connection.query or "")
self.assertIn("ORDER BY sort_order ASC, id ASC", connection.query or "")
self.assertEqual(connection.parameters, ("theme", "north"))
self.assertNotIn("theme", connection.query or "")
async def test_postgres_adapter_rejects_unsafe_schema_and_wraps_db_errors(self) -> None:
with self.assertRaises(ValueError):
PostgresSettingsRepository(FakePool(FakeConnection()), 'data"; DROP TABLE settings;--')
repository = PostgresSettingsRepository(
FakePool(FakeConnection(error=RuntimeError("connection failed"))), "app_data"
)
with self.assertRaises(SettingsDatabaseUnavailableError) as raised:
await repository.fetch_values("theme")
self.assertIsInstance(raised.exception.__cause__, RuntimeError)
if __name__ == "__main__":
unittest.main()