spikard 0.6.2 → 0.7.1

data/vendor/crates/spikard-core/tests/bindings_response_tests.rs

@@ -0,0 +1,136 @@
+use brotli::Decompressor;
+use flate2::read::GzDecoder;
+use spikard_core::{CompressionConfig, RawResponse, StaticAsset};
+use std::collections::HashMap;
+use std::io::Read;
+
+fn decode_gzip(payload: &[u8]) -> Vec<u8> {
+    let mut decoder = GzDecoder::new(payload);
+    let mut buf = Vec::new();
+    decoder.read_to_end(&mut buf).expect("gzip decode failed");
+    buf
+}
+
+fn decode_brotli(payload: &[u8]) -> Vec<u8> {
+    let mut decoder = Decompressor::new(payload, 4096);
+    let mut buf = Vec::new();
+    decoder.read_to_end(&mut buf).expect("brotli decode failed");
+    buf
+}
+
+#[test]
+fn raw_response_does_not_compress_empty_or_partial_content() {
+    let mut headers = HashMap::new();
+    headers.insert("content-type".to_string(), "application/json".to_string());
+
+    let mut empty = RawResponse::new(200, headers.clone(), Vec::new());
+    let cfg = CompressionConfig {
+        min_size: 1,
+        ..Default::default()
+    };
+    empty.apply_compression(&HashMap::new(), &cfg);
+    assert!(!empty.headers.contains_key("content-encoding"));
+    assert!(empty.body.is_empty());
+
+    let mut partial = RawResponse::new(206, headers, b"{\"ok\":true}".to_vec());
+    partial.apply_compression(&HashMap::new(), &cfg);
+    assert!(!partial.headers.contains_key("content-encoding"));
+}
+
+#[test]
+fn raw_response_respects_existing_content_encoding_and_min_size() {
+    let mut headers = HashMap::new();
+    headers.insert("content-encoding".to_string(), "gzip".to_string());
+
+    let mut response = RawResponse::new(200, headers, b"x".repeat(4096));
+    let cfg = CompressionConfig::default();
+    response.apply_compression(&HashMap::new(), &cfg);
+    assert_eq!(
+        response.headers.get("content-encoding").map(String::as_str),
+        Some("gzip")
+    );
+
+    let mut small = RawResponse::new(200, HashMap::new(), b"x".repeat(10));
+    let cfg = CompressionConfig {
+        min_size: 1024,
+        ..Default::default()
+    };
+    small.apply_compression(&HashMap::new(), &cfg);
+    assert!(!small.headers.contains_key("content-encoding"));
+}
+
+#[test]
+fn raw_response_prefers_brotli_when_accepted() {
+    let original = b"hello world ".repeat(256);
+    let mut response = RawResponse::new(200, HashMap::new(), original.clone());
+
+    let mut request_headers = HashMap::new();
+    request_headers.insert("Accept-Encoding".to_string(), "br, gzip".to_string());
+
+    let cfg = CompressionConfig {
+        min_size: 1,
+        quality: 6,
+        gzip: true,
+        brotli: true,
+    };
+
+    response.apply_compression(&request_headers, &cfg);
+
+    assert_eq!(response.headers.get("content-encoding").map(String::as_str), Some("br"));
+    assert_eq!(
+        response.headers.get("vary").map(String::as_str),
+        Some("Accept-Encoding")
+    );
+    assert_eq!(decode_brotli(&response.body), original);
+}
+
+#[test]
+fn raw_response_falls_back_to_gzip() {
+    let original = b"hello world ".repeat(256);
+    let mut response = RawResponse::new(200, HashMap::new(), original.clone());
+
+    let mut request_headers = HashMap::new();
+    request_headers.insert("Accept-Encoding".to_string(), "gzip".to_string());
+
+    let cfg = CompressionConfig {
+        min_size: 1,
+        quality: 6,
+        gzip: true,
+        brotli: true,
+    };
+
+    response.apply_compression(&request_headers, &cfg);
+
+    assert_eq!(
+        response.headers.get("content-encoding").map(String::as_str),
+        Some("gzip")
+    );
+    assert_eq!(decode_gzip(&response.body), original);
+}
+
+#[test]
+fn static_asset_serves_get_and_head_only() {
+    let mut headers = HashMap::new();
+    headers.insert("content-type".to_string(), "text/plain".to_string());
+
+    let asset = StaticAsset {
+        route: "/static/hello.txt".to_string(),
+        headers,
+        body: b"hello".to_vec(),
+    };
+
+    let get = asset.serve("GET", "/static/hello.txt").expect("expected GET response");
+    assert_eq!(get.status, 200);
+    assert_eq!(get.body, b"hello");
+    assert_eq!(get.headers.get("content-length").map(String::as_str), Some("5"));
+
+    let head = asset
+        .serve("HEAD", "/static/hello.txt")
+        .expect("expected HEAD response");
+    assert_eq!(head.status, 200);
+    assert!(head.body.is_empty());
+    assert_eq!(head.headers.get("content-length").map(String::as_str), Some("5"));
+
+    assert!(asset.serve("POST", "/static/hello.txt").is_none());
+    assert!(asset.serve("GET", "/static/other.txt").is_none());
+}

data/vendor/crates/spikard-core/tests/di_dependency_defaults.rs

@@ -0,0 +1,37 @@
+#![cfg(feature = "di")]
+
+use http::Request;
+use spikard_core::RequestData;
+use spikard_core::di::{Dependency, DependencyError, ResolvedDependencies};
+use std::any::Any;
+use std::sync::Arc;
+
+struct DummyDependency;
+
+impl Dependency for DummyDependency {
+    fn resolve(
+        &self,
+        _request: &Request<()>,
+        _request_data: &RequestData,
+        _resolved: &ResolvedDependencies,
+    ) -> std::pin::Pin<
+        Box<dyn std::future::Future<Output = Result<Arc<dyn Any + Send + Sync>, DependencyError>> + Send + '_>,
+    > {
+        Box::pin(async move { Ok(Arc::new(()) as Arc<dyn Any + Send + Sync>) })
+    }
+
+    fn key(&self) -> &str {
+        "dummy"
+    }
+
+    fn depends_on(&self) -> Vec<String> {
+        Vec::new()
+    }
+}
+
+#[test]
+fn dependency_defaults_are_false() {
+    let dep = DummyDependency;
+    assert!(!dep.cacheable());
+    assert!(!dep.singleton());
+}