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

180 lines
6.9 KiB
Python

from dataclasses import dataclass
from pathlib import Path
from tempfile import TemporaryDirectory
import asyncio
import unittest
from plba.config import (
ApplicationConfigLoadError,
ApplicationConfigLoader,
ApplicationConfigManager,
ConfigReloadStatus,
)
from plba.runtime import ApplicationLifecycle, ApplicationRuntime, RuntimeContext
from plba.runtime.worker import (
WorkerConfig,
WorkerDefinition,
WorkerRegistry,
WorkerSupervisor,
)
@dataclass(frozen=True)
class ServiceConfig:
service_name: str
def decode_service_config(raw: dict[str, object]) -> ServiceConfig:
name = raw.get("service_name")
if not isinstance(name, str):
raise ValueError("service_name is required")
return ServiceConfig(name)
class ApplicationConfigTests(unittest.TestCase):
def test_loads_common_fields_and_typed_application_config(self) -> None:
with TemporaryDirectory() as directory:
path = Path(directory) / "config.yaml"
path.write_text(
"application_id: service-a\nservice_name: alpha\n"
"workers:\n sync:\n pause_seconds: 5\n",
encoding="utf-8",
)
manager = ApplicationConfigManager(
ApplicationConfigLoader(path, decode_service_config)
)
snapshot = manager.load_initial()
self.assertEqual(snapshot.application_id, "service-a")
self.assertEqual(snapshot.application_config, ServiceConfig("alpha"))
self.assertEqual(manager.get_worker_config("sync").pause_seconds, 5)
self.assertFalse(manager.get_worker_config("undeclared").disabled)
def test_invalid_initial_file_blocks_startup(self) -> None:
with TemporaryDirectory() as directory:
path = Path(directory) / "config.yaml"
path.write_text("workers: [not-a-mapping]\n", encoding="utf-8")
manager = ApplicationConfigManager(
ApplicationConfigLoader(path, decode_service_config)
)
with self.assertRaises(ApplicationConfigLoadError):
manager.load_initial()
def test_reload_is_atomic_and_invalid_update_keeps_last_snapshot(self) -> None:
with TemporaryDirectory() as directory:
path = Path(directory) / "config.yaml"
path.write_text("service_name: alpha\n", encoding="utf-8")
manager = ApplicationConfigManager(
ApplicationConfigLoader(path, decode_service_config)
)
previous = manager.load_initial()
path.write_text("service_name: beta\n", encoding="utf-8")
reloaded = manager.reload_if_changed()
self.assertEqual(reloaded.status, ConfigReloadStatus.RELOADED)
self.assertEqual(previous.application_config, ServiceConfig("alpha"))
self.assertEqual(manager.current().application_config, ServiceConfig("beta"))
revision = manager.current().revision
path.write_text("service_name: [invalid]\n", encoding="utf-8")
failed = manager.reload_if_changed()
self.assertEqual(failed.status, ConfigReloadStatus.FAILED)
self.assertEqual(manager.current().revision, revision)
self.assertEqual(manager.current().application_config, ServiceConfig("beta"))
def test_disabled_worker_does_not_require_a_schedule(self) -> None:
with TemporaryDirectory() as directory:
path = Path(directory) / "config.yaml"
path.write_text("service_name: alpha\nworkers:\n inactive:\n disabled: true\n", encoding="utf-8")
manager = ApplicationConfigManager(
ApplicationConfigLoader(path, decode_service_config)
)
manager.load_initial()
self.assertTrue(manager.get_worker_config("inactive").disabled)
class ConfigWatcherTests(unittest.IsolatedAsyncioTestCase):
async def test_watcher_reports_invalid_reload_and_stops_promptly(self) -> None:
with TemporaryDirectory() as directory:
path = Path(directory) / "config.yaml"
path.write_text("service_name: alpha\n", encoding="utf-8")
manager = ApplicationConfigManager(
ApplicationConfigLoader(path, decode_service_config)
)
manager.load_initial()
stop_event = asyncio.Event()
error_reported = asyncio.Event()
async def report_error(_: Exception) -> None:
error_reported.set()
async def write_invalid() -> None:
await asyncio.sleep(0.01)
path.write_text("workers: []\n", encoding="utf-8")
watcher = asyncio.create_task(
manager.watch(stop_event, 0.02, report_error)
)
writer = asyncio.create_task(write_invalid())
await asyncio.wait_for(error_reported.wait(), timeout=1)
stop_event.set()
await asyncio.wait_for(watcher, timeout=1)
await writer
class ConfigRuntimeIntegrationTests(unittest.IsolatedAsyncioTestCase):
async def test_disabled_change_waits_until_next_application_start(self) -> None:
with TemporaryDirectory() as directory:
path = Path(directory) / "config.yaml"
path.write_text(
"service_name: alpha\nworkers:\n sync:\n pause_seconds: 0.01\n",
encoding="utf-8",
)
manager = ApplicationConfigManager(
ApplicationConfigLoader(path, decode_service_config)
)
manager.load_initial()
first_cycle = asyncio.Event()
later_cycle = asyncio.Event()
calls = 0
async def process() -> None:
nonlocal calls
calls += 1
first_cycle.set()
if calls >= 2:
later_cycle.set()
registry = WorkerRegistry()
registry.register(WorkerDefinition("sync", process))
supervisor = WorkerSupervisor(registry, manager)
runtime = ApplicationRuntime(RuntimeContext("service-a"), supervisor)
await runtime.start()
await asyncio.wait_for(first_cycle.wait(), timeout=1)
path.write_text(
"service_name: alpha\nworkers:\n sync:\n disabled: true\n",
encoding="utf-8",
)
self.assertEqual(manager.reload_if_changed().status, ConfigReloadStatus.RELOADED)
await asyncio.wait_for(later_cycle.wait(), timeout=1)
self.assertEqual(runtime.lifecycle, ApplicationLifecycle.RUNNING)
await runtime.stop()
before_restart = calls
restarted = await runtime.start()
await asyncio.sleep(0.03)
self.assertEqual(restarted.workers.started, ())
self.assertEqual(calls, before_restart)
await runtime.stop()
if __name__ == "__main__":
unittest.main()