huskies: merge 1152 story Set HUSKIES_GATEWAY_URL on every sled container so 1136's relay actually spawns

2026-05-19 17:50:01 +00:00
parent 398726a14a
commit 9a5b6f4d92
4 changed files with 164 additions and 1 deletions
@@ -365,4 +365,115 @@ mod tests {
            received.event
        );
    }
+
+    /// Extends `relay_end_to_end_stage_transition_reaches_gateway_broadcast` to
+    /// cover the full wiring path: `project_docker_run_args` embeds
+    /// `HUSKIES_GATEWAY_URL` in the sled's argv; when that URL is used to start
+    /// the relay, a transition fired inside the sled reaches the gateway's CRDT
+    /// event_log within 1 second.
+    #[tokio::test]
+    async fn project_docker_run_args_gateway_url_wires_relay() {
+        use crate::chat::transport::matrix::new_project::project_docker_run_args;
+        use crate::http::gateway::{gateway_event_push_handler, gateway_generate_token_handler};
+        use crate::service::gateway::{GatewayConfig, GatewayState, ProjectEntry};
+        use poem::EndpointExt as _;
+        use poem::listener::TcpAcceptor;
+        use std::collections::BTreeMap;
+        use std::path::PathBuf;
+        use tokio::net::TcpListener;
+
+        crate::crdt_state::init_for_test();
+
+        // Spin up an in-process gateway server on an ephemeral port so we have
+        // a real URL to embed in the docker run args.
+        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+        let gateway_url = format!("http://127.0.0.1:{}", addr.port());
+
+        // project_docker_run_args embeds the gateway URL: this is the production
+        // code path that sets HUSKIES_GATEWAY_URL on the sled container.
+        let docker_args = project_docker_run_args(
+            "huskies-sled-relay",
+            3200,
+            2300,
+            "ssh-ed25519 AAAA...",
+            "Test User",
+            "test@example.com",
+            None,
+            &gateway_url,
+        );
+
+        // Extract the injected URL exactly as the sled would read it from its env.
+        let injected_url = docker_args
+            .windows(2)
+            .find(|w| w[0] == "-e" && w[1].starts_with("HUSKIES_GATEWAY_URL="))
+            .map(|w| w[1].trim_start_matches("HUSKIES_GATEWAY_URL=").to_string())
+            .expect("project_docker_run_args must inject HUSKIES_GATEWAY_URL");
+
+        assert_eq!(injected_url, gateway_url, "injected URL must match input");
+
+        // Set up gateway state for the relay project.
+        let mut projects = BTreeMap::new();
+        projects.insert(
+            "sled-relay".to_string(),
+            ProjectEntry::with_url("http://sled-relay:3001"),
+        );
+        let config = GatewayConfig {
+            projects,
+            sled_tokens: BTreeMap::new(),
+        };
+        let state = Arc::new(GatewayState::new(config, PathBuf::new(), 9001).unwrap());
+        let mut gw_rx = state.event_tx.subscribe();
+
+        let route = poem::Route::new()
+            .at(
+                "/gateway/tokens",
+                poem::post(gateway_generate_token_handler),
+            )
+            .at(
+                "/gateway/events/push",
+                poem::get(gateway_event_push_handler),
+            )
+            .data(state.clone());
+
+        tokio::spawn(async move {
+            let acceptor = TcpAcceptor::from_tokio(listener).unwrap();
+            let _ = poem::Server::new_with_acceptor(acceptor).run(route).await;
+        });
+
+        // Spawn the relay using the URL extracted from the docker run args —
+        // this simulates what the sled does when it reads HUSKIES_GATEWAY_URL
+        // from its container environment.
+        let broadcaster = Arc::new(StatusBroadcaster::new());
+        spawn_relay_task(
+            injected_url,
+            "sled-relay".into(),
+            Arc::clone(&broadcaster),
+            reqwest::Client::new(),
+        );
+
+        tokio::time::sleep(std::time::Duration::from_millis(200)).await;
+
+        broadcaster.publish(StatusEvent::StageTransition {
+            story_id: "99_docker_args_relay".into(),
+            story_name: "Docker Args Relay".into(),
+            from_stage: "1_backlog".into(),
+            to_stage: "2_current".into(),
+        });
+
+        let received = tokio::time::timeout(std::time::Duration::from_secs(1), gw_rx.recv())
+            .await
+            .expect("timed out: event did not reach gateway within 1 s")
+            .expect("gateway broadcast channel closed unexpectedly");
+
+        assert_eq!(received.project, "sled-relay");
+        assert!(
+            matches!(
+                received.event,
+                StoredEvent::StageTransition { ref story_id, .. } if story_id == "99_docker_args_relay"
+            ),
+            "unexpected gateway event: {:?}",
+            received.event
+        );
+    }
 }