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()