refactor(api): expand and test api as stealth http interface

2026-07-16 12:38:11 -07:00 · 2026-04-05 20:16:24 -03:00
parent 1b06b64d98
commit 720342f880
13 changed files with 1001 additions and 39 deletions
@@ -0,0 +1,158 @@
+use std::net::SocketAddr;
+
+use reqwest::StatusCode;
+use serde_json::json;
+use tokio::sync::oneshot;
+
+#[tokio::test]
+async fn root_path_with_descriptor_is_not_found() {
+    let server = TestServer::spawn().await;
+    let client = reqwest::Client::new();
+
+    let response = client
+        .get(server.url("/?descriptor=123"))
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(response.status(), StatusCode::NOT_FOUND);
+    server.stop().await;
+}
+
+#[tokio::test]
+async fn scan_get_is_not_allowed() {
+    let server = TestServer::spawn().await;
+    let client = reqwest::Client::new();
+
+    let response = client
+        .get(server.url("/api/wallet/scan?descriptor=wpkh(xpub.../0/*)"))
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(response.status(), StatusCode::METHOD_NOT_ALLOWED);
+    server.stop().await;
+}
+
+#[tokio::test]
+async fn scan_post_with_valid_descriptor_returns_503_without_rpc() {
+    let server = TestServer::spawn().await;
+    let client = reqwest::Client::new();
+
+    let response = client
+        .post(server.url("/api/wallet/scan"))
+        .json(&json!({
+            "descriptor": "wpkh(xpub.../0/*)"
+        }))
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(response.status(), StatusCode::SERVICE_UNAVAILABLE);
+    let body: serde_json::Value = response.json().await.unwrap();
+    assert_eq!(body["error"]["code"], "scanner_not_configured");
+    server.stop().await;
+}
+
+#[tokio::test]
+async fn scan_post_with_invalid_descriptor_returns_bad_request() {
+    let server = TestServer::spawn().await;
+    let client = reqwest::Client::new();
+
+    let response = client
+        .post(server.url("/api/wallet/scan"))
+        .json(&json!({
+            "descriptor": "123"
+        }))
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+    let body: serde_json::Value = response.json().await.unwrap();
+    assert_eq!(body["error"]["code"], "invalid_scan_input");
+    server.stop().await;
+}
+
+#[tokio::test]
+async fn scan_post_with_descriptors_returns_503_without_rpc() {
+    let server = TestServer::spawn().await;
+    let client = reqwest::Client::new();
+
+    let response = client
+        .post(server.url("/api/wallet/scan"))
+        .json(&json!({
+            "descriptors": ["wpkh(xpub.../0/*)", "wpkh(xpub.../1/*)"]
+        }))
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(response.status(), StatusCode::SERVICE_UNAVAILABLE);
+    let body: serde_json::Value = response.json().await.unwrap();
+    assert_eq!(body["error"]["code"], "scanner_not_configured");
+    server.stop().await;
+}
+
+#[tokio::test]
+async fn scan_post_rejects_multiple_input_sources() {
+    let server = TestServer::spawn().await;
+    let client = reqwest::Client::new();
+
+    let response = client
+        .post(server.url("/api/wallet/scan"))
+        .json(&json!({
+            "descriptor": "abc",
+            "utxos": [{
+                "txid": "0000000000000000000000000000000000000000000000000000000000000001",
+                "vout": 0
+            }]
+        }))
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
+    let body: serde_json::Value = response.json().await.unwrap();
+    assert_eq!(body["error"]["code"], "bad_request");
+    server.stop().await;
+}
+
+struct TestServer {
+    address: SocketAddr,
+    shutdown_tx: Option<oneshot::Sender<()>>,
+    handle: tokio::task::JoinHandle<()>,
+}
+
+impl TestServer {
+    async fn spawn() -> Self {
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let address = listener.local_addr().unwrap();
+        let (shutdown_tx, shutdown_rx) = oneshot::channel();
+
+        let server = axum::serve(listener, stealth_api::app()).with_graceful_shutdown(async {
+            let _ = shutdown_rx.await;
+        });
+
+        let handle = tokio::spawn(async move {
+            let _ = server.await;
+        });
+
+        Self {
+            address,
+            shutdown_tx: Some(shutdown_tx),
+            handle,
+        }
+    }
+
+    fn url(&self, path_and_query: &str) -> String {
+        format!("http://{}{}", self.address, path_and_query)
+    }
+
+    async fn stop(mut self) {
+        if let Some(tx) = self.shutdown_tx.take() {
+            let _ = tx.send(());
+        }
+        let _ = self.handle.await;
+    }
+}