spikard 0.6.2 → 0.7.1

data/vendor/crates/spikard-http/src/testing/test_client.rs

@@ -81,7 +81,7 @@ impl TestClient {
         let mut request = self.server.post(&full_path);
 
         if let Some(headers_vec) = headers {
-            request = self.add_headers(request, headers_vec.clone())?;
+            request = self.add_headers(request, headers_vec)?;
         }
 
         if let Some((form_fields, files)) = multipart {
@@ -90,7 +90,9 @@ impl TestClient {
             request = request.add_header("content-type", &content_type);
             request = request.bytes(Bytes::from(body));
         } else if let Some(form_fields) = form_data {
-            let encoded = super::encode_urlencoded_body(&serde_json::to_value(&form_fields).unwrap_or(Value::Null))
+            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));
@@ -241,6 +243,67 @@ impl TestClient {
         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)
+    pub async fn graphql_subscription(
+        &self,
+        _query: &str,
+        _variables: Option<Value>,
+        _operation_name: Option<&str>,
+    ) -> Result<(), SnapshotError> {
+        // For now, return a placeholder - full WebSocket implementation comes later
+        Err(SnapshotError::Decompression(
+            "GraphQL subscriptions not yet implemented".to_string(),
+        ))
+    }
+
     /// Add headers to a test request builder
     fn add_headers(
         &self,
@@ -258,6 +321,18 @@ impl TestClient {
     }
 }
 
+/// 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 {
@@ -308,4 +383,82 @@ mod tests {
         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");
+    }
 }

data/vendor/crates/spikard-http/src/testing.rs

@@ -44,6 +44,28 @@ impl ResponseSnapshot {
     pub fn header(&self, name: &str) -> Option<&str> {
         self.headers.get(&name.to_ascii_lowercase()).map(|s| s.as_str())
     }
+
+    /// Extract GraphQL data from response
+    pub fn graphql_data(&self) -> Result<Value, SnapshotError> {
+        let body: Value = serde_json::from_slice(&self.body)
+            .map_err(|e| SnapshotError::Decompression(format!("Failed to parse JSON: {}", e)))?;
+
+        body.get("data")
+            .cloned()
+            .ok_or_else(|| SnapshotError::Decompression("No 'data' field in GraphQL response".to_string()))
+    }
+
+    /// Extract GraphQL errors from response
+    pub fn graphql_errors(&self) -> Result<Vec<Value>, SnapshotError> {
+        let body: Value = serde_json::from_slice(&self.body)
+            .map_err(|e| SnapshotError::Decompression(format!("Failed to parse JSON: {}", e)))?;
+
+        Ok(body
+            .get("errors")
+            .and_then(|e| e.as_array())
+            .cloned()
+            .unwrap_or_default())
+    }
 }
 
 /// Possible errors while converting an Axum response into a snapshot.
@@ -377,6 +399,9 @@ impl SseEvent {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use axum::body::Body;
+    use axum::response::Response;
+    use std::io::Write;
 
     #[test]
     fn sse_stream_parses_multiple_events() {
@@ -403,4 +428,150 @@ mod tests {
         };
         assert!(event.as_json().is_err());
     }
+
+    #[test]
+    fn test_graphql_data_extraction() {
+        let mut headers = HashMap::new();
+        headers.insert("content-type".to_string(), "application/json".to_string());
+
+        let graphql_response = serde_json::json!({
+            "data": {
+                "user": {
+                    "id": "1",
+                    "name": "Alice"
+                }
+            }
+        });
+
+        let snapshot = ResponseSnapshot {
+            status: 200,
+            headers,
+            body: serde_json::to_vec(&graphql_response).unwrap(),
+        };
+
+        let data = snapshot.graphql_data().expect("data extraction");
+        assert_eq!(data["user"]["id"], "1");
+        assert_eq!(data["user"]["name"], "Alice");
+    }
+
+    #[test]
+    fn test_graphql_errors_extraction() {
+        let mut headers = HashMap::new();
+        headers.insert("content-type".to_string(), "application/json".to_string());
+
+        let graphql_response = serde_json::json!({
+            "errors": [
+                {
+                    "message": "Field not found",
+                    "path": ["user", "email"]
+                },
+                {
+                    "message": "Unauthorized",
+                    "extensions": { "code": "UNAUTHENTICATED" }
+                }
+            ]
+        });
+
+        let snapshot = ResponseSnapshot {
+            status: 400,
+            headers,
+            body: serde_json::to_vec(&graphql_response).unwrap(),
+        };
+
+        let errors = snapshot.graphql_errors().expect("errors extraction");
+        assert_eq!(errors.len(), 2);
+        assert_eq!(errors[0]["message"], "Field not found");
+        assert_eq!(errors[1]["message"], "Unauthorized");
+    }
+
+    #[test]
+    fn test_graphql_missing_data_field() {
+        let mut headers = HashMap::new();
+        headers.insert("content-type".to_string(), "application/json".to_string());
+
+        let graphql_response = serde_json::json!({
+            "errors": [{ "message": "Query failed" }]
+        });
+
+        let snapshot = ResponseSnapshot {
+            status: 400,
+            headers,
+            body: serde_json::to_vec(&graphql_response).unwrap(),
+        };
+
+        let result = snapshot.graphql_data();
+        assert!(result.is_err());
+        assert!(result.unwrap_err().to_string().contains("No 'data' field"));
+    }
+
+    #[test]
+    fn test_graphql_empty_errors() {
+        let mut headers = HashMap::new();
+        headers.insert("content-type".to_string(), "application/json".to_string());
+
+        let graphql_response = serde_json::json!({
+            "data": { "result": null }
+        });
+
+        let snapshot = ResponseSnapshot {
+            status: 200,
+            headers,
+            body: serde_json::to_vec(&graphql_response).unwrap(),
+        };
+
+        let errors = snapshot.graphql_errors().expect("errors extraction");
+        assert!(errors.is_empty());
+    }
+
+    fn gzip_bytes(input: &[u8]) -> Vec<u8> {
+        let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
+        encoder.write_all(input).expect("gzip write");
+        encoder.finish().expect("gzip finish")
+    }
+
+    fn brotli_bytes(input: &[u8]) -> Vec<u8> {
+        let mut encoder = brotli::CompressorWriter::new(Vec::new(), 4096, 5, 22);
+        encoder.write_all(input).expect("brotli write");
+        encoder.into_inner()
+    }
+
+    #[tokio::test]
+    async fn snapshot_http_response_decodes_gzip_body() {
+        let body = b"hello gzip";
+        let compressed = gzip_bytes(body);
+        let response = Response::builder()
+            .status(200)
+            .header("content-encoding", "gzip")
+            .body(Body::from(compressed))
+            .unwrap();
+
+        let snapshot = snapshot_http_response(response).await.expect("snapshot");
+        assert_eq!(snapshot.body, body);
+    }
+
+    #[tokio::test]
+    async fn snapshot_http_response_decodes_brotli_body() {
+        let body = b"hello brotli";
+        let compressed = brotli_bytes(body);
+        let response = Response::builder()
+            .status(200)
+            .header("content-encoding", "br")
+            .body(Body::from(compressed))
+            .unwrap();
+
+        let snapshot = snapshot_http_response(response).await.expect("snapshot");
+        assert_eq!(snapshot.body, body);
+    }
+
+    #[tokio::test]
+    async fn snapshot_http_response_leaves_plain_body() {
+        let body = b"plain";
+        let response = Response::builder()
+            .status(200)
+            .body(Body::from(body.as_slice()))
+            .unwrap();
+
+        let snapshot = snapshot_http_response(response).await.expect("snapshot");
+        assert_eq!(snapshot.body, body);
+    }
 }

data/vendor/crates/spikard-http/src/websocket.rs

@@ -90,20 +90,31 @@ pub trait WebSocketHandler: Send + Sync {
 /// Contains the message handler and optional JSON schemas for validating
 /// incoming and outgoing messages. This state is shared among all connections
 /// to the same WebSocket endpoint.
-#[derive(Debug)]
 pub struct WebSocketState<H: WebSocketHandler> {
     /// The message handler implementation
     handler: Arc<H>,
+    /// Factory for producing per-connection handlers
+    handler_factory: Arc<dyn Fn() -> Result<Arc<H>, String> + Send + Sync>,
     /// Optional JSON Schema for validating incoming messages
     message_schema: Option<Arc<jsonschema::Validator>>,
     /// Optional JSON Schema for validating outgoing responses
     response_schema: Option<Arc<jsonschema::Validator>>,
 }
 
+impl<H: WebSocketHandler> std::fmt::Debug for WebSocketState<H> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("WebSocketState")
+            .field("message_schema", &self.message_schema.is_some())
+            .field("response_schema", &self.response_schema.is_some())
+            .finish()
+    }
+}
+
 impl<H: WebSocketHandler> Clone for WebSocketState<H> {
     fn clone(&self) -> Self {
         Self {
             handler: Arc::clone(&self.handler),
+            handler_factory: Arc::clone(&self.handler_factory),
             message_schema: self.message_schema.clone(),
             response_schema: self.response_schema.clone(),
         }
@@ -125,8 +136,13 @@ impl<H: WebSocketHandler + 'static> WebSocketState<H> {
     /// let state = WebSocketState::new(MyHandler);
     /// ```
     pub fn new(handler: H) -> Self {
+        let handler = Arc::new(handler);
         Self {
-            handler: Arc::new(handler),
+            handler_factory: Arc::new({
+                let handler = Arc::clone(&handler);
+                move || Ok(Arc::clone(&handler))
+            }),
+            handler,
             message_schema: None,
             response_schema: None,
         }
@@ -187,8 +203,56 @@ impl<H: WebSocketHandler + 'static> WebSocketState<H> {
             None
         };
 
+        let handler = Arc::new(handler);
         Ok(Self {
-            handler: Arc::new(handler),
+            handler_factory: Arc::new({
+                let handler = Arc::clone(&handler);
+                move || Ok(Arc::clone(&handler))
+            }),
+            handler,
+            message_schema: message_validator,
+            response_schema: response_validator,
+        })
+    }
+
+    /// Create new WebSocket state with a handler factory and optional validation schemas.
+    ///
+    /// The factory is invoked once per connection, enabling per-connection handler state.
+    pub fn with_factory<F>(
+        factory: F,
+        message_schema: Option<serde_json::Value>,
+        response_schema: Option<serde_json::Value>,
+    ) -> Result<Self, String>
+    where
+        F: Fn() -> Result<H, String> + Send + Sync + 'static,
+    {
+        let message_validator = if let Some(schema) = message_schema {
+            Some(Arc::new(
+                jsonschema::validator_for(&schema).map_err(|e| format!("Invalid message schema: {}", e))?,
+            ))
+        } else {
+            None
+        };
+
+        let response_validator = if let Some(schema) = response_schema {
+            Some(Arc::new(
+                jsonschema::validator_for(&schema).map_err(|e| format!("Invalid response schema: {}", e))?,
+            ))
+        } else {
+            None
+        };
+
+        let factory = Arc::new(factory);
+        let handler = factory()
+            .map(Arc::new)
+            .map_err(|e| format!("Failed to build WebSocket handler: {}", e))?;
+
+        Ok(Self {
+            handler_factory: Arc::new({
+                let factory = Arc::clone(&factory);
+                move || factory().map(Arc::new)
+            }),
+            handler,
             message_schema: message_validator,
             response_schema: response_validator,
         })
@@ -258,7 +322,16 @@ async fn handle_socket<H: WebSocketHandler>(mut socket: WebSocket, state: WebSoc
     info!("WebSocket client connected");
     trace_ws("socket:connected");
 
-    state.handler.on_connect().await;
+    let handler = match (state.handler_factory)() {
+        Ok(handler) => handler,
+        Err(err) => {
+            error!("Failed to create WebSocket handler: {}", err);
+            trace_ws("socket:handler-factory:error");
+            return;
+        }
+    };
+
+    handler.on_connect().await;
     trace_ws("socket:on_connect:done");
 
     while let Some(msg) = socket.recv().await {
@@ -285,7 +358,7 @@ async fn handle_socket<H: WebSocketHandler>(mut socket: WebSocket, state: WebSoc
                             continue;
                         }
 
-                        if let Some(response) = state.handler.handle_message(json_msg).await {
+                        if let Some(response) = handler.handle_message(json_msg).await {
                             trace_ws("handler:response:some");
                             if let Some(validator) = &state.response_schema
                                 && !validator.is_valid(&response)
@@ -358,7 +431,7 @@ async fn handle_socket<H: WebSocketHandler>(mut socket: WebSocket, state: WebSoc
         }
     }
 
-    state.handler.on_disconnect().await;
+    handler.on_disconnect().await;
     trace_ws("socket:on_disconnect:done");
     info!("WebSocket client disconnected");
 }