Refactor ApiError derive macro and update tests/deps

Moved and refactored the ApiError derive macro implementation into a dedicated module in rustapi-macros, simplifying and improving its logic. Updated imports and re-exports to support the new macro location. Added rustapi-testing as a dev-dependency and updated test code to use it. Minor code cleanups and #[allow(dead_code)] annotations were added to suppress warnings in test and property test code. Removed the semver check job from the CI workflow.

Author: Tuntii

.github/workflows/ci.yml

@@ -154,15 +154,5 @@ jobs:
         env:
           RUSTDOCFLAGS: -D warnings
 
-  semver:
-    name: SemVer Checks
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - name: Install Rust
-        uses: dtolnay/rust-toolchain@stable
-      - name: Install cargo-semver-checks
-        uses: taiki-e/install-action@cargo-semver-checks
-      - name: Check for breaking changes
-        run: cargo semver-checks check-release
+
 

Cargo.lock

@@ -70,6 +70,7 @@ rustapi-openapi = { workspace = true, default-features = false }
 [dev-dependencies]
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 proptest = "1.4"
+rustapi-testing = { workspace = true }
 [features]
 default = ["swagger-ui", "tracing"]
 swagger-ui = ["rustapi-openapi/swagger-ui"]

crates/rustapi-core/Cargo.toml

@@ -333,37 +333,6 @@ mod tests {
         }
     }
 
-    /// A request interceptor that modifies a header
-    #[derive(Clone)]
-    struct HeaderModifyingRequestInterceptor {
-        header_name: &'static str,
-        header_value: String,
-    }
-
-    impl HeaderModifyingRequestInterceptor {
-        fn new(header_name: &'static str, header_value: impl Into<String>) -> Self {
-            Self {
-                header_name,
-                header_value: header_value.into(),
-            }
-        }
-    }
-
-    impl RequestInterceptor for HeaderModifyingRequestInterceptor {
-        fn intercept(&self, mut request: Request) -> Request {
-            // Store the value in extensions since we can't modify headers directly
-            // In a real implementation, we'd need mutable header access
-            request
-                .extensions_mut()
-                .insert(format!("{}:{}", self.header_name, self.header_value));
-            request
-        }
-
-        fn clone_box(&self) -> Box<dyn RequestInterceptor> {
-            Box::new(self.clone())
-        }
-    }
-
     /// A response interceptor that modifies a header
     #[derive(Clone)]
     struct HeaderModifyingResponseInterceptor {

crates/rustapi-core/src/interceptor.rs

@@ -1030,7 +1030,7 @@ mod tests {
     #[test]
     fn test_state_tracking() {
         #[derive(Clone)]
-        struct MyState(String);
+        struct MyState(#[allow(dead_code)] String);
 
         let router = Router::new().state(MyState("test".to_string()));
 
@@ -1094,7 +1094,7 @@ mod tests {
     #[test]
     fn test_state_type_ids_merged_on_nest() {
         #[derive(Clone)]
-        struct NestedState(String);
+        struct NestedState(#[allow(dead_code)] String);
 
         async fn handler() -> &'static str {
             "handler"
@@ -1911,7 +1911,7 @@ mod property_tests {
             has_nested_state in any::<bool>(),
         ) {
             #[derive(Clone)]
-            struct TestState(i32);
+            struct TestState(#[allow(dead_code)] i32);
 
             async fn handler() -> &'static str { "handler" }
 

crates/rustapi-core/src/router.rs

@@ -187,15 +187,15 @@ mod property_tests {
     use futures_util::StreamExt;
     use proptest::prelude::*;
 
-    /// **Feature: v1-features-roadmap, Property 23: Streaming memory bounds**
-    /// **Validates: Requirements 11.2**
-    ///
-    /// For streaming request bodies:
-    /// - Memory usage SHALL never exceed configured limit
-    /// - Streams exceeding limit SHALL be rejected with 413 Payload Too Large
-    /// - Bytes read counter SHALL accurately track consumed bytes
-    /// - Limit of None SHALL allow unlimited streaming
-    /// - Multiple chunks SHALL be correctly aggregated for limit checking
+    // Feature: v1-features-roadmap, Property 23: Streaming memory bounds
+    // Validates: Requirements 11.2
+    //
+    // For streaming request bodies:
+    // - Memory usage SHALL never exceed configured limit
+    // - Streams exceeding limit SHALL be rejected with 413 Payload Too Large
+    // - Bytes read counter SHALL accurately track consumed bytes
+    // - Limit of None SHALL allow unlimited streaming
+    // - Multiple chunks SHALL be correctly aggregated for limit checking
 
     proptest! {
         #![proptest_config(ProptestConfig::with_cases(100))]
@@ -294,7 +294,7 @@ mod property_tests {
             num_chunks in 3usize..6,
         ) {
             tokio::runtime::Runtime::new().unwrap().block_on(async {
-                let total_size = chunk_size * num_chunks;
+                let _total_size = chunk_size * num_chunks;
                 let limit = chunk_size + 50; // Less than total
 
                 let chunks: Vec<Result<Bytes, crate::error::ApiError>> = (0..num_chunks)

crates/rustapi-core/src/stream.rs

@@ -4,7 +4,7 @@ use proptest::prelude::*;
 use rustapi_core::post;
 use rustapi_core::BodyStream;
 use rustapi_core::RustApi;
-use rustapi_core::TestClient;
+use rustapi_testing::{TestClient, TestRequest};
 
 #[tokio::test]
 async fn test_streaming_body_buffered_small() {
@@ -60,7 +60,7 @@ async fn test_streaming_body_buffered_large_fail() {
     // So StreamingBody should fail.
 
     let response = client
-        .request(rustapi_core::TestRequest::post("/stream").body(bytes))
+        .request(TestRequest::post("/stream").body(bytes))
         .await;
 
     // Handler catches error and returns string "Error: ..."
@@ -111,7 +111,7 @@ proptest! {
             // So this should always succeed.
 
             let response = client
-                .request(rustapi_core::TestRequest::post("/stream").body(bytes))
+                .request(TestRequest::post("/stream").body(bytes))
                 .await;
 
             response.assert_status(StatusCode::OK);

crates/rustapi-core/tests/streaming_test.rs

@@ -0,0 +1,86 @@
+use quote::quote;
+use syn::{parse_macro_input, Data, DeriveInput, Expr, Lit, Meta};
+
+pub fn expand_derive_api_error(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = &input.ident;
+
+    let variants = match &input.data {
+        Data::Enum(data) => &data.variants,
+        _ => {
+            return syn::Error::new_spanned(input, "ApiError can only be derived for enums")
+                .to_compile_error()
+                .into()
+        }
+    };
+
+    let mut match_arms = Vec::new();
+
+    for variant in variants {
+        let variant_name = &variant.ident;
+        let attrs = &variant.attrs;
+
+        // Parse #[error(...)] attributes
+        let mut status = None;
+        let mut code = None;
+        let mut message = None;
+
+        for attr in attrs {
+            if attr.path().is_ident("error") {
+                if let Ok(nested) = attr.parse_args_with(
+                    syn::punctuated::Punctuated::<Meta, syn::Token![,]>::parse_terminated,
+                ) {
+                    for meta in nested {
+                        if let Meta::NameValue(nv) = meta {
+                            if nv.path.is_ident("status") {
+                                if let Expr::Lit(lit) = &nv.value {
+                                    if let Lit::Int(i) = &lit.lit {
+                                        status = Some(i.base10_parse::<u16>().unwrap());
+                                    }
+                                }
+                            } else if nv.path.is_ident("code") {
+                                if let Expr::Lit(lit) = &nv.value {
+                                    if let Lit::Str(s) = &lit.lit {
+                                        code = Some(s.value());
+                                    }
+                                }
+                            } else if nv.path.is_ident("message") {
+                                if let Expr::Lit(lit) = &nv.value {
+                                    if let Lit::Str(s) = &lit.lit {
+                                        message = Some(s.value());
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        let status = status.unwrap_or(500);
+        let code = code.unwrap_or_else(|| "internal_server_error".to_string());
+        let message = message.unwrap_or_else(|| "Internal Server Error".to_string());
+
+        match_arms.push(quote! {
+            #name::#variant_name => {
+                ::rustapi_core::ApiError::new(
+                    ::rustapi_core::StatusCode::from_u16(#status).unwrap(),
+                    #code,
+                    #message
+                ).into_response()
+            }
+        });
+    }
+
+    let expanded = quote! {
+        impl ::rustapi_core::IntoResponse for #name {
+            fn into_response(self) -> ::rustapi_core::Response {
+                match self {
+                    #(#match_arms)*
+                }
+            }
+        }
+    };
+
+    expanded.into()
+}