spikard-http 0.13.0

//! Core test client for Spikard applications
//!
//! This module provides a language-agnostic TestClient that can be wrapped by
//! language bindings (PyO3, napi-rs, magnus) to provide Pythonic, JavaScripty, and
//! Ruby-like APIs respectively.
//!
//! The core client handles all HTTP method dispatch, query params, header management,
//! body encoding (JSON, form-data, multipart), and response snapshot capture.

use super::{ResponseSnapshot, SnapshotError, snapshot_response};
use axum::http::{HeaderName, HeaderValue, Method};
use axum_test::TestServer;
use bytes::Bytes;
use serde_json::Value;
use std::sync::{Arc, Mutex};
use std::time::Duration;
use tokio::time::timeout;
use urlencoding::encode;

type MultipartPayload = Option<(Vec<(String, String)>, Vec<super::MultipartFilePart>)>;
const GRAPHQL_WS_MESSAGE_TIMEOUT: Duration = Duration::from_secs(2);
const GRAPHQL_WS_MAX_CONTROL_MESSAGES: usize = 32;

/// Snapshot of a GraphQL subscription exchange over WebSocket.
#[derive(Debug, Clone, PartialEq)]
pub struct GraphQLSubscriptionSnapshot {
    /// Operation id used for the subscription request.
    pub operation_id: String,
    /// Whether the server acknowledged the GraphQL WebSocket connection.
    pub acknowledged: bool,
    /// First `next.payload` received for this subscription, if any.
    pub event: Option<Value>,
    /// GraphQL protocol errors emitted by the server.
    pub errors: Vec<Value>,
    /// Whether a `complete` frame was observed for this operation.
    pub complete_received: bool,
}

/// Core test client for making HTTP requests to a Spikard application.
///
/// This struct wraps axum-test's TestServer and provides a language-agnostic
/// interface for making HTTP requests, sending WebSocket connections, and
/// handling Server-Sent Events. Language bindings wrap this to provide
/// native API surfaces.
pub struct TestClient {
    mock_server: Arc<TestServer>,
    router: axum::Router,
    http_server: Mutex<Option<Arc<TestServer>>>,
}

impl TestClient {
    /// Create a new test client from an Axum router
    pub fn from_router(router: axum::Router) -> Result<Self, String> {
        let mock_server =
            TestServer::try_new(router.clone()).map_err(|e| format!("Failed to create test server: {}", e))?;

        Ok(Self {
            mock_server: Arc::new(mock_server),
            router,
            http_server: Mutex::new(None),
        })
    }

    /// Get or initialize the underlying socket-backed test server for WebSocket traffic.
    pub fn http_server(&self) -> Result<Arc<TestServer>, SnapshotError> {
        let mut guard = self
            .http_server
            .lock()
            .map_err(|_| SnapshotError::Decompression("Failed to lock HTTP test server state".to_string()))?;

        if let Some(server) = guard.as_ref() {
            return Ok(Arc::clone(server));
        }

        if tokio::runtime::Handle::try_current().is_err() {
            return Err(SnapshotError::Decompression(
                "WebSocket test transport requires an active Tokio runtime".to_string(),
            ));
        }

        let server = Arc::new(
            TestServer::builder()
                .http_transport()
                .try_build(self.router.clone())
                .map_err(|e| SnapshotError::Decompression(format!("Failed to create test server: {}", e)))?,
        );
        *guard = Some(Arc::clone(&server));
        Ok(server)
    }

    /// Make a GET request
    pub async fn get(
        &self,
        path: &str,
        query_params: Option<Vec<(String, String)>>,
        headers: Option<Vec<(String, String)>>,
    ) -> Result<ResponseSnapshot, SnapshotError> {
        let full_path = build_full_path(path, query_params.as_deref());
        let mut request = self.mock_server.get(&full_path);

        if let Some(headers_vec) = headers {
            request = self.add_headers(request, headers_vec)?;
        }

        let response = request.await;
        snapshot_response(response).await
    }

    /// Make a POST request
    pub async fn post(
        &self,
        path: &str,
        json: Option<Value>,
        form_data: Option<Vec<(String, String)>>,
        multipart: MultipartPayload,
        query_params: Option<Vec<(String, String)>>,
        headers: Option<Vec<(String, String)>>,
    ) -> Result<ResponseSnapshot, SnapshotError> {
        let full_path = build_full_path(path, query_params.as_deref());
        let mut request = self.mock_server.post(&full_path);

        if let Some(headers_vec) = headers {
            request = self.add_headers(request, headers_vec)?;
        }

        if let Some((form_fields, files)) = multipart {
            let (body, boundary) = super::build_multipart_body(&form_fields, &files);
            let content_type = format!("multipart/form-data; boundary={}", boundary);
            request = request.add_header("content-type", &content_type);
            request = request.bytes(Bytes::from(body));
        } else if let Some(form_fields) = form_data {
            let fields_value = serde_json::to_value(&form_fields)
                .map_err(|e| SnapshotError::Decompression(format!("Failed to serialize form fields: {}", e)))?;
            let encoded = super::encode_urlencoded_body(&fields_value)
                .map_err(|e| SnapshotError::Decompression(format!("Form encoding failed: {}", e)))?;
            request = request.add_header("content-type", "application/x-www-form-urlencoded");
            request = request.bytes(Bytes::from(encoded));
        } else if let Some(json_value) = json {
            request = request.json(&json_value);
        }

        let response = request.await;
        snapshot_response(response).await
    }

    /// Make a request with a raw body payload.
    pub async fn request_raw(
        &self,
        method: Method,
        path: &str,
        body: Bytes,
        query_params: Option<Vec<(String, String)>>,
        headers: Option<Vec<(String, String)>>,
    ) -> Result<ResponseSnapshot, SnapshotError> {
        let full_path = build_full_path(path, query_params.as_deref());
        let mut request = self.mock_server.method(method, &full_path);

        if let Some(headers_vec) = headers {
            request = self.add_headers(request, headers_vec)?;
        }

        request = request.bytes(body);
        let response = request.await;
        snapshot_response(response).await
    }

    /// Make a PUT request
    pub async fn put(
        &self,
        path: &str,
        json: Option<Value>,
        query_params: Option<Vec<(String, String)>>,
        headers: Option<Vec<(String, String)>>,
    ) -> Result<ResponseSnapshot, SnapshotError> {
        let full_path = build_full_path(path, query_params.as_deref());
        let mut request = self.mock_server.put(&full_path);

        if let Some(headers_vec) = headers {
            request = self.add_headers(request, headers_vec)?;
        }

        if let Some(json_value) = json {
            request = request.json(&json_value);
        }

        let response = request.await;
        snapshot_response(response).await
    }

    /// Make a PATCH request
    pub async fn patch(
        &self,
        path: &str,
        json: Option<Value>,
        query_params: Option<Vec<(String, String)>>,
        headers: Option<Vec<(String, String)>>,
    ) -> Result<ResponseSnapshot, SnapshotError> {
        let full_path = build_full_path(path, query_params.as_deref());
        let mut request = self.mock_server.patch(&full_path);

        if let Some(headers_vec) = headers {
            request = self.add_headers(request, headers_vec)?;
        }

        if let Some(json_value) = json {
            request = request.json(&json_value);
        }

        let response = request.await;
        snapshot_response(response).await
    }

    /// Make a DELETE request
    pub async fn delete(
        &self,
        path: &str,
        query_params: Option<Vec<(String, String)>>,
        headers: Option<Vec<(String, String)>>,
    ) -> Result<ResponseSnapshot, SnapshotError> {
        let full_path = build_full_path(path, query_params.as_deref());
        let mut request = self.mock_server.delete(&full_path);

        if let Some(headers_vec) = headers {
            request = self.add_headers(request, headers_vec)?;
        }

        let response = request.await;
        snapshot_response(response).await
    }

    /// Make an OPTIONS request
    pub async fn options(
        &self,
        path: &str,
        query_params: Option<Vec<(String, String)>>,
        headers: Option<Vec<(String, String)>>,
    ) -> Result<ResponseSnapshot, SnapshotError> {
        let full_path = build_full_path(path, query_params.as_deref());
        let mut request = self.mock_server.method(Method::OPTIONS, &full_path);

        if let Some(headers_vec) = headers {
            request = self.add_headers(request, headers_vec)?;
        }

        let response = request.await;
        snapshot_response(response).await
    }

    /// Make a HEAD request
    pub async fn head(
        &self,
        path: &str,
        query_params: Option<Vec<(String, String)>>,
        headers: Option<Vec<(String, String)>>,
    ) -> Result<ResponseSnapshot, SnapshotError> {
        let full_path = build_full_path(path, query_params.as_deref());
        let mut request = self.mock_server.method(Method::HEAD, &full_path);

        if let Some(headers_vec) = headers {
            request = self.add_headers(request, headers_vec)?;
        }

        let response = request.await;
        snapshot_response(response).await
    }

    /// Make a TRACE request
    pub async fn trace(
        &self,
        path: &str,
        query_params: Option<Vec<(String, String)>>,
        headers: Option<Vec<(String, String)>>,
    ) -> Result<ResponseSnapshot, SnapshotError> {
        let full_path = build_full_path(path, query_params.as_deref());
        let mut request = self.mock_server.method(Method::TRACE, &full_path);

        if let Some(headers_vec) = headers {
            request = self.add_headers(request, headers_vec)?;
        }

        let response = request.await;
        snapshot_response(response).await
    }

    /// Send a GraphQL query/mutation to a custom endpoint
    pub async fn graphql_at(
        &self,
        endpoint: &str,
        query: &str,
        variables: Option<Value>,
        operation_name: Option<&str>,
    ) -> Result<ResponseSnapshot, SnapshotError> {
        let body = build_graphql_body(query, variables, operation_name);
        self.post(endpoint, Some(body), None, None, None, None).await
    }

    /// Send a GraphQL query/mutation
    pub async fn graphql(
        &self,
        query: &str,
        variables: Option<Value>,
        operation_name: Option<&str>,
    ) -> Result<ResponseSnapshot, SnapshotError> {
        self.graphql_at("/graphql", query, variables, operation_name).await
    }

    /// Send a GraphQL query and return HTTP status code separately
    ///
    /// This method allows tests to distinguish between:
    /// - HTTP-level errors (400/422 for invalid requests)
    /// - GraphQL-level errors (200 with errors in response body)
    ///
    /// # Example
    /// ```ignore
    /// let (status, snapshot) = client.graphql_with_status(
    ///     "query { invalid syntax",
    ///     None,
    ///     None
    /// ).await?;
    /// assert_eq!(status, 400); // HTTP parse error
    /// ```
    pub async fn graphql_with_status(
        &self,
        query: &str,
        variables: Option<Value>,
        operation_name: Option<&str>,
    ) -> Result<(u16, ResponseSnapshot), SnapshotError> {
        let snapshot = self.graphql(query, variables, operation_name).await?;
        let status = snapshot.status;
        Ok((status, snapshot))
    }

    /// Send a GraphQL subscription (WebSocket) to a custom endpoint.
    ///
    /// Uses the `graphql-transport-ws` protocol and captures the first `next` payload.
    /// After the first payload is received, this client sends `complete` to unsubscribe.
    pub async fn graphql_subscription_at(
        &self,
        endpoint: &str,
        query: &str,
        variables: Option<Value>,
        operation_name: Option<&str>,
    ) -> Result<GraphQLSubscriptionSnapshot, SnapshotError> {
        let operation_id = "spikard-subscription-1".to_string();
        let http_server = self.http_server()?;
        let upgrade = http_server
            .get_websocket(endpoint)
            .add_header("sec-websocket-protocol", "graphql-transport-ws")
            .await;

        if upgrade.status_code().as_u16() != 101 {
            return Err(SnapshotError::Decompression(format!(
                "GraphQL subscription upgrade failed with status {}",
                upgrade.status_code()
            )));
        }

        let mut websocket = super::WebSocketConnection::new(upgrade.into_websocket().await);

        websocket
            .send_json(&serde_json::json!({"type": "connection_init"}))
            .await;
        wait_for_graphql_ack(&mut websocket).await?;

        websocket
            .send_json(&serde_json::json!({
                "id": operation_id,
                "type": "subscribe",
                "payload": build_graphql_body(query, variables, operation_name),
            }))
            .await;

        let mut event = None;
        let mut errors = Vec::new();
        let mut complete_received = false;

        for _ in 0..GRAPHQL_WS_MAX_CONTROL_MESSAGES {
            let message = timeout(
                GRAPHQL_WS_MESSAGE_TIMEOUT,
                receive_graphql_protocol_message(&mut websocket),
            )
            .await
            .map_err(|_| {
                SnapshotError::Decompression("Timed out waiting for GraphQL subscription message".to_string())
            })??;

            let message_type = message.get("type").and_then(Value::as_str).unwrap_or_default();
            match message_type {
                "next"
                    if message
                        .get("id")
                        .and_then(Value::as_str)
                        .is_none_or(|id| id == operation_id) =>
                {
                    event = message.get("payload").cloned();

                    websocket
                        .send_json(&serde_json::json!({
                            "id": operation_id,
                            "type": "complete",
                        }))
                        .await;

                    if let Ok(next_message) = timeout(
                        GRAPHQL_WS_MESSAGE_TIMEOUT,
                        receive_graphql_protocol_message(&mut websocket),
                    )
                    .await
                        && let Ok(next_message) = next_message
                        && next_message.get("type").and_then(Value::as_str) == Some("complete")
                        && next_message
                            .get("id")
                            .and_then(Value::as_str)
                            .is_none_or(|id| id == operation_id)
                    {
                        complete_received = true;
                    }
                    break;
                }
                "error" => {
                    errors.push(message.get("payload").cloned().unwrap_or(message));
                    break;
                }
                "complete"
                    if message
                        .get("id")
                        .and_then(Value::as_str)
                        .is_none_or(|id| id == operation_id) =>
                {
                    complete_received = true;
                    break;
                }
                "ping" => {
                    let mut pong = serde_json::json!({"type": "pong"});
                    if let Some(payload) = message.get("payload") {
                        pong["payload"] = payload.clone();
                    }
                    websocket.send_json(&pong).await;
                }
                "pong" => {}
                _ => {}
            }
        }

        websocket.close().await;

        if event.is_none() && errors.is_empty() && !complete_received {
            return Err(SnapshotError::Decompression(
                "No GraphQL subscription event received before timeout".to_string(),
            ));
        }

        Ok(GraphQLSubscriptionSnapshot {
            operation_id,
            acknowledged: true,
            event,
            errors,
            complete_received,
        })
    }

    /// Send a GraphQL subscription (WebSocket).
    ///
    /// Uses `/graphql` as the default subscription endpoint.
    pub async fn graphql_subscription(
        &self,
        query: &str,
        variables: Option<Value>,
        operation_name: Option<&str>,
    ) -> Result<GraphQLSubscriptionSnapshot, SnapshotError> {
        self.graphql_subscription_at("/graphql", query, variables, operation_name)
            .await
    }

    /// Add headers to a test request builder
    fn add_headers(
        &self,
        mut request: axum_test::TestRequest,
        headers: Vec<(String, String)>,
    ) -> Result<axum_test::TestRequest, SnapshotError> {
        for (key, value) in headers {
            let header_name = HeaderName::from_bytes(key.as_bytes())
                .map_err(|e| SnapshotError::InvalidHeader(format!("Invalid header name: {}", e)))?;
            let header_value = HeaderValue::from_str(&value)
                .map_err(|e| SnapshotError::InvalidHeader(format!("Invalid header value: {}", e)))?;
            request = request.add_header(header_name, header_value);
        }
        Ok(request)
    }
}

async fn wait_for_graphql_ack(websocket: &mut super::WebSocketConnection) -> Result<(), SnapshotError> {
    for _ in 0..GRAPHQL_WS_MAX_CONTROL_MESSAGES {
        let message = timeout(GRAPHQL_WS_MESSAGE_TIMEOUT, receive_graphql_protocol_message(websocket))
            .await
            .map_err(|_| SnapshotError::Decompression("Timed out waiting for GraphQL connection_ack".to_string()))??;

        match message.get("type").and_then(Value::as_str).unwrap_or_default() {
            "connection_ack" => return Ok(()),
            "ping" => {
                let mut pong = serde_json::json!({"type": "pong"});
                if let Some(payload) = message.get("payload") {
                    pong["payload"] = payload.clone();
                }
                websocket.send_json(&pong).await;
            }
            "connection_error" | "error" => {
                return Err(SnapshotError::Decompression(format!(
                    "GraphQL subscription rejected during init: {}",
                    message
                )));
            }
            _ => {}
        }
    }

    Err(SnapshotError::Decompression(
        "No GraphQL connection_ack received".to_string(),
    ))
}

async fn receive_graphql_protocol_message(websocket: &mut super::WebSocketConnection) -> Result<Value, SnapshotError> {
    loop {
        match websocket.receive_message().await {
            super::WebSocketMessage::Text(text) => {
                return serde_json::from_str::<Value>(&text).map_err(|e| {
                    SnapshotError::Decompression(format!("Failed to parse GraphQL WebSocket message as JSON: {}", e))
                });
            }
            super::WebSocketMessage::Binary(bytes) => {
                return serde_json::from_slice::<Value>(&bytes).map_err(|e| {
                    SnapshotError::Decompression(format!(
                        "Failed to parse GraphQL binary WebSocket message as JSON: {}",
                        e
                    ))
                });
            }
            super::WebSocketMessage::Ping(_) | super::WebSocketMessage::Pong(_) => continue,
            super::WebSocketMessage::Close(reason) => {
                return Err(SnapshotError::Decompression(format!(
                    "GraphQL WebSocket connection closed before response: {:?}",
                    reason
                )));
            }
        }
    }
}

/// Build a GraphQL request body from query, variables, and operation name
pub fn build_graphql_body(query: &str, variables: Option<Value>, operation_name: Option<&str>) -> Value {
    let mut body = serde_json::json!({ "query": query });
    if let Some(vars) = variables {
        body["variables"] = vars;
    }
    if let Some(op_name) = operation_name {
        body["operationName"] = Value::String(op_name.to_string());
    }
    body
}

/// Build a full path with query parameters
fn build_full_path(path: &str, query_params: Option<&[(String, String)]>) -> String {
    match query_params {
        None | Some(&[]) => path.to_string(),
        Some(params) => {
            let query_string: Vec<String> = params
                .iter()
                .map(|(k, v)| format!("{}={}", encode(k), encode(v)))
                .collect();

            if path.contains('?') {
                format!("{}&{}", path, query_string.join("&"))
            } else {
                format!("{}?{}", path, query_string.join("&"))
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use axum::{
        Router,
        extract::ws::{Message, WebSocketUpgrade},
        routing::get,
    };

    #[test]
    fn build_full_path_no_params() {
        let path = "/users";
        assert_eq!(build_full_path(path, None), "/users");
        assert_eq!(build_full_path(path, Some(&[])), "/users");
    }

    #[test]
    fn build_full_path_with_params() {
        let path = "/users";
        let params = vec![
            ("id".to_string(), "123".to_string()),
            ("name".to_string(), "test user".to_string()),
        ];
        let result = build_full_path(path, Some(&params));
        assert!(result.starts_with("/users?"));
        assert!(result.contains("id=123"));
        assert!(result.contains("name=test%20user"));
    }

    #[test]
    fn build_full_path_existing_query() {
        let path = "/users?active=true";
        let params = vec![("id".to_string(), "123".to_string())];
        let result = build_full_path(path, Some(&params));
        assert_eq!(result, "/users?active=true&id=123");
    }

    #[test]
    fn test_graphql_query_builder() {
        let query = "{ users { id name } }";
        let variables = Some(serde_json::json!({ "limit": 10 }));
        let op_name = Some("GetUsers");

        let mut body = serde_json::json!({ "query": query });
        if let Some(vars) = variables {
            body["variables"] = vars;
        }
        if let Some(op_name) = op_name {
            body["operationName"] = Value::String(op_name.to_string());
        }

        assert_eq!(body["query"], query);
        assert_eq!(body["variables"]["limit"], 10);
        assert_eq!(body["operationName"], "GetUsers");
    }

    #[test]
    fn test_graphql_with_status_method() {
        let query = "query { hello }";
        let body = serde_json::json!({
            "query": query,
            "variables": null,
            "operationName": null
        });

        // This test validates the method signature and return type
        // Actual HTTP status testing will happen in integration tests
        let expected_fields = vec!["query", "variables", "operationName"];
        for field in expected_fields {
            assert!(body.get(field).is_some(), "Missing field: {}", field);
        }
    }

    #[test]
    fn test_build_graphql_body_basic() {
        let query = "{ users { id name } }";
        let body = build_graphql_body(query, None, None);

        assert_eq!(body["query"], query);
        assert!(body.get("variables").is_none() || body["variables"].is_null());
        assert!(body.get("operationName").is_none() || body["operationName"].is_null());
    }

    #[test]
    fn test_build_graphql_body_with_variables() {
        let query = "query GetUser($id: ID!) { user(id: $id) { name } }";
        let variables = Some(serde_json::json!({ "id": "123" }));
        let body = build_graphql_body(query, variables, None);

        assert_eq!(body["query"], query);
        assert_eq!(body["variables"]["id"], "123");
    }

    #[test]
    fn test_build_graphql_body_with_operation_name() {
        let query = "query GetUsers { users { id } }";
        let op_name = Some("GetUsers");
        let body = build_graphql_body(query, None, op_name);

        assert_eq!(body["query"], query);
        assert_eq!(body["operationName"], "GetUsers");
    }

    #[test]
    fn test_build_graphql_body_all_fields() {
        let query = "mutation CreateUser($name: String!) { createUser(name: $name) { id } }";
        let variables = Some(serde_json::json!({ "name": "Alice" }));
        let op_name = Some("CreateUser");
        let body = build_graphql_body(query, variables, op_name);

        assert_eq!(body["query"], query);
        assert_eq!(body["variables"]["name"], "Alice");
        assert_eq!(body["operationName"], "CreateUser");
    }

    #[tokio::test]
    async fn graphql_subscription_returns_first_event_and_completes() {
        let app = Router::new().route(
            "/graphql",
            get(|ws: WebSocketUpgrade| async move {
                ws.on_upgrade(|mut socket| async move {
                    while let Some(result) = socket.recv().await {
                        let Ok(Message::Text(text)) = result else {
                            continue;
                        };
                        let Ok(message): Result<Value, _> = serde_json::from_str(&text) else {
                            continue;
                        };

                        match message.get("type").and_then(Value::as_str) {
                            Some("connection_init") => {
                                let _ = socket
                                    .send(Message::Text(
                                        serde_json::json!({"type":"connection_ack"}).to_string().into(),
                                    ))
                                    .await;
                            }
                            Some("subscribe") => {
                                let id = message.get("id").and_then(Value::as_str).unwrap_or("1");
                                let _ = socket
                                    .send(Message::Text(
                                        serde_json::json!({
                                            "id": id,
                                            "type": "next",
                                            "payload": {"data": {"ticker": "AAPL"}},
                                        })
                                        .to_string()
                                        .into(),
                                    ))
                                    .await;

                                if let Some(Ok(Message::Text(complete_text))) = socket.recv().await {
                                    let Ok(complete_message): Result<Value, _> = serde_json::from_str(&complete_text)
                                    else {
                                        break;
                                    };
                                    if complete_message.get("type").and_then(Value::as_str) == Some("complete") {
                                        let _ = socket
                                            .send(Message::Text(
                                                serde_json::json!({"id": id, "type":"complete"}).to_string().into(),
                                            ))
                                            .await;
                                    }
                                }
                                break;
                            }
                            _ => {}
                        }
                    }
                })
            }),
        );

        let client = TestClient::from_router(app).expect("client");
        assert!(client.http_server.lock().expect("lock").is_none());

        let snapshot = client
            .graphql_subscription("subscription { ticker }", None, None)
            .await
            .expect("subscription snapshot");

        assert!(snapshot.acknowledged);
        assert_eq!(snapshot.errors, Vec::<Value>::new());
        assert_eq!(snapshot.event, Some(serde_json::json!({"data": {"ticker": "AAPL"}})));
        assert!(snapshot.complete_received);
        assert!(client.http_server.lock().expect("lock").is_some());
    }

    #[tokio::test]
    async fn graphql_subscription_surfaces_connection_error() {
        let app = Router::new().route(
            "/graphql",
            get(|ws: WebSocketUpgrade| async move {
                ws.on_upgrade(|mut socket| async move {
                    while let Some(result) = socket.recv().await {
                        let Ok(Message::Text(text)) = result else {
                            continue;
                        };
                        let Ok(message): Result<Value, _> = serde_json::from_str(&text) else {
                            continue;
                        };

                        if message.get("type").and_then(Value::as_str) == Some("connection_init") {
                            let _ = socket
                                .send(Message::Text(
                                    serde_json::json!({
                                        "type": "connection_error",
                                        "payload": {"message": "not authorized"},
                                    })
                                    .to_string()
                                    .into(),
                                ))
                                .await;
                            break;
                        }
                    }
                })
            }),
        );

        let client = TestClient::from_router(app).expect("client");
        assert!(client.http_server.lock().expect("lock").is_none());

        let error = client
            .graphql_subscription("subscription { privateFeed }", None, None)
            .await
            .expect_err("expected connection error");

        assert!(error.to_string().contains("connection_error"));
        assert!(client.http_server.lock().expect("lock").is_some());
    }

    #[tokio::test]
    async fn http_requests_do_not_initialize_socket_transport() {
        let app = Router::new().route("/health", get(|| async { "ok" }));

        let client = TestClient::from_router(app).expect("client");
        assert!(client.http_server.lock().expect("lock").is_none());

        let snapshot = client.get("/health", None, None).await.expect("response snapshot");

        assert_eq!(snapshot.status, 200);
        assert_eq!(snapshot.text().expect("body"), "ok");
        assert!(client.http_server.lock().expect("lock").is_none());
    }
}