Add test cases for hotfix-web-ui

Author: davidsteiner

Cargo.lock

@@ -24,5 +24,9 @@ mime_guess = { workspace = true }
 rust-embed = { workspace = true, features = ["axum-ex"] }
 thiserror = { workspace = true }
 
+[dev-dependencies]
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
+tower = { workspace = true }
+
 [lints]
 workspace = true

crates/hotfix-web-ui/Cargo.toml

@@ -19,10 +19,8 @@ pub trait SessionInfoProvider: Clone + Send + Sync {
 
 /// Build a router for the dashboard UI
 ///
-/// This returns a router that works with any state `S` where you can
-/// extract a `P: SessionInfoProvider` using `axum::extract::FromRef`.
-///
-/// Typically, your state will be a struct with a `controller` field.
+/// This requires router state that can serve the required data
+/// to the endpoints as defined in [`SessionInfoProvider`].
 pub fn build_ui_router<S, P>() -> Router<S>
 where
     S: Clone + Send + Sync + 'static,
@@ -33,3 +31,102 @@ where
         .route("/", get(dashboard::dashboard_handler::<S, P>))
         .route("/static/{*file}", get(assets::static_handler))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use axum::body::Body;
+    use axum::http::{Request, StatusCode};
+    use hotfix::session::{SessionInfo, Status};
+    use tower::ServiceExt;
+
+    #[derive(Clone)]
+    struct MockSessionProvider {
+        session_info: SessionInfo,
+    }
+
+    #[async_trait::async_trait]
+    impl SessionInfoProvider for MockSessionProvider {
+        async fn get_session_info(&self) -> anyhow::Result<SessionInfo> {
+            Ok(self.session_info.clone())
+        }
+    }
+
+    fn create_test_app() -> Router {
+        let provider = MockSessionProvider {
+            session_info: SessionInfo {
+                next_sender_seq_number: 42,
+                next_target_seq_number: 100,
+                status: Status::Active,
+            },
+        };
+        build_ui_router::<MockSessionProvider, MockSessionProvider>().with_state(provider)
+    }
+
+    #[tokio::test]
+    async fn test_dashboard_returns_html() {
+        let app = create_test_app();
+
+        let response = app
+            .oneshot(Request::builder().uri("/").body(Body::empty()).unwrap())
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::OK);
+
+        let content_type = response
+            .headers()
+            .get("content-type")
+            .and_then(|v| v.to_str().ok());
+        assert!(
+            content_type.is_some_and(|ct| ct.contains("text/html")),
+            "Expected HTML content type"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_static_asset_returns_file() {
+        let app = create_test_app();
+
+        let response = app
+            .oneshot(
+                Request::builder()
+                    .uri("/static/tailwind.js")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::OK);
+
+        let content_type = response
+            .headers()
+            .get("content-type")
+            .and_then(|v| v.to_str().ok());
+        assert!(
+            content_type.is_some_and(
+                |ct| ct.contains("javascript") || ct.contains("application/x-javascript")
+            ),
+            "Expected JavaScript content type, got: {:?}",
+            content_type
+        );
+    }
+
+    #[tokio::test]
+    async fn test_static_asset_not_found() {
+        let app = create_test_app();
+
+        let response = app
+            .oneshot(
+                Request::builder()
+                    .uri("/static/nonexistent.js")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(response.status(), StatusCode::NOT_FOUND);
+    }
+}

crates/hotfix-web-ui/src/lib.rs

@@ -13,7 +13,7 @@ pub fn when<T>(target: T) -> When<T> {
 
 impl When<&SessionSpy> {
     pub async fn requests_disconnect(self) {
-        self.target.session_handle().shutdown(false).await;
+        self.target.session_handle().shutdown(false).await.unwrap();
     }
 
     pub async fn sends_message(self, message: TestMessage) {