Release: NX9-Auth v0.3.0

tests/runtime_lifecycle_test.rs

@@ -0,0 +1,104 @@
+use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::Duration;
+
+use nx9_auth::config::Config;
+use nx9_auth::runtime::{
+    Application, HookRegistry, RuntimeState, ShutdownHook, ShutdownPriority, WorkerManager,
+};
+
+struct TestHook {
+    name: &'static str,
+    priority: ShutdownPriority,
+    counter: Arc<AtomicUsize>,
+    sequence: Arc<tokio::sync::Mutex<Vec<&'static str>>>,
+}
+
+#[async_trait::async_trait]
+impl ShutdownHook for TestHook {
+    fn name(&self) -> &'static str {
+        self.name
+    }
+
+    fn priority(&self) -> ShutdownPriority {
+        self.priority
+    }
+
+    async fn shutdown(&self) -> anyhow::Result<()> {
+        self.counter.fetch_add(1, Ordering::SeqCst);
+        let mut seq = self.sequence.lock().await;
+        seq.push(self.name);
+        Ok(())
+    }
+}
+
+#[tokio::test]
+async fn test_runtime_application_builder() -> anyhow::Result<()> {
+    let mut config = Config::default();
+    config.server.host = "127.0.0.1".to_string();
+    config.server.port = 0; // OS assigned port
+    config.database.url = Some("sqlite::memory:".to_string());
+
+    let mut app = Application::builder(config).build().await?;
+    assert_eq!(app.state(), RuntimeState::Starting);
+
+    app.perform_shutdown().await?;
+    assert_eq!(app.state(), RuntimeState::Stopped);
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_shutdown_hook_execution_order() {
+    let counter = Arc::new(AtomicUsize::new(0));
+    let sequence = Arc::new(tokio::sync::Mutex::new(Vec::new()));
+
+    let hook_last = TestHook {
+        name: "hook_last",
+        priority: ShutdownPriority::Last,
+        counter: counter.clone(),
+        sequence: sequence.clone(),
+    };
+    let hook_first = TestHook {
+        name: "hook_first",
+        priority: ShutdownPriority::First,
+        counter: counter.clone(),
+        sequence: sequence.clone(),
+    };
+    let hook_normal = TestHook {
+        name: "hook_normal",
+        priority: ShutdownPriority::Normal,
+        counter: counter.clone(),
+        sequence: sequence.clone(),
+    };
+
+    let mut registry = HookRegistry::new();
+    registry.register(Box::new(hook_last));
+    registry.register(Box::new(hook_first));
+    registry.register(Box::new(hook_normal));
+
+    assert_eq!(registry.len(), 3);
+    registry.execute_all().await;
+
+    assert_eq!(counter.load(Ordering::SeqCst), 3);
+
+    let seq = sequence.lock().await;
+    assert_eq!(*seq, vec!["hook_first", "hook_normal", "hook_last"]);
+}
+
+#[tokio::test]
+async fn test_worker_manager_lifecycle() {
+    let mut mgr = WorkerManager::new();
+    let group = mgr.group("background-jobs");
+
+    let counter = Arc::new(AtomicUsize::new(0));
+    let c = counter.clone();
+    group.spawn(async move {
+        tokio::time::sleep(Duration::from_millis(50)).await;
+        c.fetch_add(1, Ordering::SeqCst);
+    });
+
+    assert_eq!(mgr.active_tasks(), 1);
+    mgr.shutdown_all(Duration::from_secs(2)).await;
+    assert_eq!(mgr.active_tasks(), 0);
+    assert_eq!(counter.load(Ordering::SeqCst), 1);
+}