test: close host-testable coverage gaps (handler, nested-AppConfig checker, AdapterPushContext, run_native_cli, compression)

crates/edgezero-adapter/src/cli_support.rs

@@ -223,4 +223,23 @@ mod tests {
         let found = find_manifest_upwards(&child, "demo.toml").expect("manifest");
         assert_eq!(found, root.join("demo.toml"));
     }
+
+    #[test]
+    fn run_native_cli_missing_program_surfaces_install_hint() {
+        let err = run_native_cli("edgezero-no-such-program-xyz", &[], "install the thing")
+            .expect_err("missing program must error");
+        assert!(err.contains("install the thing"), "got: {err}");
+    }
+
+    #[test]
+    fn run_native_cli_nonzero_exit_is_error() {
+        // `false` exits non-zero on every supported CI host (unix/macOS).
+        let err = run_native_cli("false", &[], "hint").expect_err("non-zero exit must error");
+        // Pin the exit-status branch specifically — `!is_empty()` would
+        // also pass for the wrong (not-found / spawn) branch.
+        assert!(
+            err.contains("exited with status"),
+            "expected the exit-status branch, got: {err}"
+        );
+    }
 }

crates/edgezero-adapter/src/registry.rs

@@ -626,4 +626,67 @@ mod tests {
             "expected Unsupported variant from default local impl"
         );
     }
+
+    #[test]
+    fn push_context_new_is_prod_with_no_paths() {
+        let ctx = AdapterPushContext::new();
+        assert!(!ctx.local);
+        assert_eq!(ctx.manifest_adapter_deploy_cmd, None);
+        assert_eq!(ctx.runtime_config_path, None);
+    }
+
+    #[test]
+    fn push_context_builders_set_each_field() {
+        let path = Path::new("runtime-config.toml");
+        let ctx = AdapterPushContext::new()
+            .with_local(true)
+            .with_manifest_adapter_deploy_cmd("spin cloud deploy")
+            .with_runtime_config_path(path);
+        assert!(ctx.local);
+        assert_eq!(ctx.manifest_adapter_deploy_cmd, Some("spin cloud deploy"));
+        assert_eq!(ctx.runtime_config_path, Some(path));
+    }
+
+    #[test]
+    fn default_validation_and_kind_methods_are_noops() {
+        // `FIRST` overrides only `execute` + `name`, so every other
+        // method here exercises the trait's default impl.
+        assert!(FIRST.merged_id_kinds().is_empty());
+        assert!(FIRST.single_store_kinds().is_empty());
+        assert_eq!(
+            FIRST.validate_adapter_manifest(Path::new("/tmp"), None, None),
+            Ok(())
+        );
+        assert_eq!(
+            FIRST.validate_app_config_keys(&["greeting", "service.timeout_ms"]),
+            Ok(())
+        );
+        let entry = TypedSecretEntry::new("vault", "api_token", "demo_api_token");
+        assert_eq!(FIRST.validate_typed_secrets(&[entry]), Ok(()));
+    }
+
+    #[test]
+    fn default_push_config_entries_error_names_the_adapter() {
+        // Unlike the no-op defaults above, the push defaults RETURN AN
+        // ERROR that interpolates the adapter name — load-bearing for CLI
+        // UX, so assert the message content, not just `is_err`.
+        let root = Path::new("/tmp");
+        let store = ResolvedStoreId::from_logical("app_config");
+        let ctx = AdapterPushContext::new();
+
+        let err = FIRST
+            .push_config_entries(root, None, None, &store, &[], &ctx, false)
+            .expect_err("default push must be unsupported");
+        assert!(err.contains("dummy"), "should name the adapter: {err}");
+        assert!(err.contains("does not implement"), "msg: {err}");
+
+        let local_err = FIRST
+            .push_config_entries_local(root, None, None, &store, &[], &ctx, false)
+            .expect_err("default local push must be unsupported");
+        assert!(
+            local_err.contains("dummy"),
+            "should name the adapter: {local_err}"
+        );
+        assert!(local_err.contains("--local"), "msg: {local_err}");
+    }
 }

crates/edgezero-cli/src/bin/check_no_nested_app_config.rs

@@ -351,3 +351,227 @@ fn main() {
 
     println!("check_no_nested_app_config: OK");
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn known(names: &[&str]) -> HashSet<String> {
+        names.iter().map(|name| String::from(*name)).collect()
+    }
+
+    fn ty(src: &str) -> Type {
+        syn::parse_str(src).expect("type parse")
+    }
+
+    #[test]
+    fn struct_derives_app_config_detects_path_suffixed_derive() {
+        let item: syn::ItemStruct =
+            syn::parse_str("#[derive(Debug, edgezero_core::AppConfig)] struct C { x: u8 }")
+                .expect("struct parse");
+        assert!(struct_derives_app_config(&item));
+    }
+
+    #[test]
+    fn struct_derives_app_config_false_without_it() {
+        let item: syn::ItemStruct =
+            syn::parse_str("#[derive(Debug)] struct C { x: u8 }").expect("struct parse");
+        assert!(!struct_derives_app_config(&item));
+    }
+
+    #[test]
+    fn type_contains_app_config_unwraps_nested_wrappers() {
+        let set = known(&["ChildConfig"]);
+        assert_eq!(
+            type_contains_app_config_struct(&ty("ChildConfig"), &set).as_deref(),
+            Some("ChildConfig")
+        );
+        assert_eq!(
+            type_contains_app_config_struct(&ty("Option<Vec<Box<ChildConfig>>>"), &set).as_deref(),
+            Some("ChildConfig")
+        );
+    }
+
+    #[test]
+    fn type_contains_app_config_none_for_unrelated_types() {
+        let set = known(&["ChildConfig"]);
+        assert_eq!(type_contains_app_config_struct(&ty("String"), &set), None);
+        assert_eq!(
+            type_contains_app_config_struct(&ty("Vec<String>"), &set),
+            None
+        );
+    }
+
+    #[test]
+    fn type_contains_app_config_unwraps_every_container_arm() {
+        // Each of these exercises a distinct arm of the recursive match
+        // (Rc/Arc path-wrappers, array, slice, reference, paren, tuple in
+        // either position, and cross-arm combinations). A regression that
+        // deleted any arm — e.g. stops detecting `(ChildConfig, u8)` —
+        // would defeat the CI gate and ship green without these.
+        let set = known(&["ChildConfig"]);
+        for src in [
+            "Rc<ChildConfig>",
+            "Arc<ChildConfig>",
+            "[ChildConfig; 4]",                // Type::Array
+            "[ChildConfig]",                   // Type::Slice
+            "&ChildConfig",                    // Type::Reference
+            "(ChildConfig)",                   // Type::Paren
+            "(ChildConfig, u8)",               // tuple, first position
+            "(u8, ChildConfig)",               // tuple, second position
+            "Vec<(String, Arc<ChildConfig>)>", // path -> tuple -> path
+            "Option<[Box<ChildConfig>; 2]>",   // path -> array -> path
+        ] {
+            assert_eq!(
+                type_contains_app_config_struct(&ty(src), &set).as_deref(),
+                Some("ChildConfig"),
+                "should detect ChildConfig in `{src}`"
+            );
+        }
+    }
+
+    #[test]
+    fn type_contains_app_config_negatives_including_unwrapped_generic() {
+        let set = known(&["ChildConfig"]);
+        for src in ["String", "Vec<String>", "(u8, String)", "[u8; 4]"] {
+            assert_eq!(
+                type_contains_app_config_struct(&ty(src), &set),
+                None,
+                "should NOT detect ChildConfig in `{src}`"
+            );
+        }
+        // Documented limitation: arbitrary generics (not the whitelisted
+        // transparent wrappers) are NOT unwrapped, so an AppConfig buried
+        // in a `HashMap` value is intentionally not flagged.
+        assert_eq!(
+            type_contains_app_config_struct(&ty("HashMap<String, ChildConfig>"), &set),
+            None
+        );
+    }
+
+    #[test]
+    fn struct_derives_app_config_handles_bare_ident_and_multi_derive() {
+        let bare: syn::ItemStruct =
+            syn::parse_str("#[derive(AppConfig)] struct C { x: u8 }").expect("parse");
+        assert!(struct_derives_app_config(&bare), "bare `AppConfig` ident");
+
+        let multi: syn::ItemStruct =
+            syn::parse_str("#[derive(Debug)] #[derive(Clone, AppConfig)] struct C { x: u8 }")
+                .expect("parse");
+        assert!(
+            struct_derives_app_config(&multi),
+            "AppConfig in a second derive attribute"
+        );
+    }
+
+    #[test]
+    fn struct_derives_app_config_rejects_suffix_collision_and_non_derive() {
+        let suffix: syn::ItemStruct =
+            syn::parse_str("#[derive(AppConfigExt)] struct C { x: u8 }").expect("parse");
+        assert!(
+            !struct_derives_app_config(&suffix),
+            "must be an exact ident match, not a substring"
+        );
+
+        let non_derive: syn::ItemStruct =
+            syn::parse_str("#[repr(C)] struct C { x: u8 }").expect("parse");
+        assert!(!struct_derives_app_config(&non_derive));
+    }
+
+    // --- end-to-end detection: the two-pass visitor pipeline ---
+    // Drives the collectors directly (no file IO) so the binary's actual
+    // job — scan source, flag a real nested-AppConfig, count it — is
+    // proven, not just the leaf helpers.
+
+    fn violations_in(src: &str) -> usize {
+        let file: syn::File = syn::parse_str(src).expect("source parses");
+        let mut collector = AppConfigStructCollector::new();
+        collector.visit_file(&file);
+        let mut visitor =
+            NestedAppConfigVisitor::new(Path::new("test.rs"), &collector.app_config_structs);
+        visitor.visit_file(&file);
+        visitor.violations
+    }
+
+    #[test]
+    fn detects_nested_app_config_through_wrapper() {
+        let src = "
+            #[derive(edgezero_core::AppConfig)]
+            struct Inner { secret: String }
+            #[derive(edgezero_core::AppConfig)]
+            struct Outer { inner: Option<Inner> }
+        ";
+        assert_eq!(violations_in(src), 1);
+    }
+
+    #[test]
+    fn no_violation_when_field_type_is_not_app_config() {
+        let src = "
+            struct Plain { x: u8 }
+            #[derive(edgezero_core::AppConfig)]
+            struct Outer { plain: Plain }
+        ";
+        assert_eq!(violations_in(src), 0);
+    }
+
+    #[test]
+    fn no_violation_when_outer_struct_is_not_app_config() {
+        let src = "
+            #[derive(edgezero_core::AppConfig)]
+            struct Inner { secret: String }
+            struct Outer { inner: Inner }
+        ";
+        assert_eq!(violations_in(src), 0);
+    }
+
+    #[test]
+    fn counts_multiple_nested_violations() {
+        let src = "
+            #[derive(edgezero_core::AppConfig)]
+            struct Inner { secret: String }
+            #[derive(edgezero_core::AppConfig)]
+            struct Outer { a: Inner, b: Vec<Inner> }
+        ";
+        assert_eq!(violations_in(src), 2);
+    }
+
+    #[test]
+    fn detects_violation_regardless_of_definition_order() {
+        // Inner defined AFTER Outer: the two-pass (collect-all-then-check)
+        // design must still catch it; a naive single pass would miss it.
+        let src = "
+            #[derive(edgezero_core::AppConfig)]
+            struct Outer { inner: Inner }
+            #[derive(edgezero_core::AppConfig)]
+            struct Inner { secret: String }
+        ";
+        assert_eq!(violations_in(src), 1);
+    }
+
+    #[test]
+    fn no_false_positive_from_appconfig_in_doc_comment() {
+        // The walk inspects field TYPES only — `AppConfig` appearing in a
+        // doc comment is not a violation (the module's headline property).
+        let src = "
+            #[derive(edgezero_core::AppConfig)]
+            struct Outer {
+                /// mentions AppConfig in prose, but the field type is String
+                note: String,
+            }
+        ";
+        assert_eq!(violations_in(src), 0);
+    }
+
+    #[test]
+    fn detects_nested_in_tuple_struct_unnamed_field() {
+        // Exercises the `<unnamed>` field-name branch + Span::call_site
+        // fallback in the visitor.
+        let src = "
+            #[derive(edgezero_core::AppConfig)]
+            struct Inner { secret: String }
+            #[derive(edgezero_core::AppConfig)]
+            struct Outer(Inner);
+        ";
+        assert_eq!(violations_in(src), 1);
+    }
+}

crates/edgezero-core/src/compression.rs

@@ -107,4 +107,26 @@ mod tests {
 
         assert_eq!(decoded, b"hello brotli");
     }
+
+    #[test]
+    fn decode_gzip_stream_surfaces_error_on_invalid_input() {
+        let garbage = b"this is definitely not a gzip member".to_vec();
+        let stream = stream::iter(vec![Ok::<Vec<u8>, io::Error>(garbage)]);
+        let result =
+            block_on(async { decode_gzip_stream(stream).try_collect::<Vec<Bytes>>().await });
+        assert!(result.is_err(), "invalid gzip must decode to an error");
+    }
+
+    #[test]
+    fn decode_brotli_stream_surfaces_error_on_invalid_input() {
+        // A high-bit-set lead byte is not a valid brotli stream prefix.
+        let garbage = vec![0xFF_u8; 64];
+        let stream = stream::iter(vec![Ok::<Vec<u8>, io::Error>(garbage)]);
+        let result = block_on(async {
+            decode_brotli_stream(stream)
+                .try_collect::<Vec<Bytes>>()
+                .await
+        });
+        assert!(result.is_err(), "invalid brotli must decode to an error");
+    }
 }

crates/edgezero-core/src/handler.rs

@@ -38,3 +38,49 @@ where
         Arc::new(self)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::body::Body;
+    use crate::http::{request_builder, Method, StatusCode};
+    use crate::params::PathParams;
+    use futures::executor::block_on;
+
+    fn ctx() -> RequestContext {
+        let request = request_builder()
+            .method(Method::GET)
+            .uri("/")
+            .body(Body::empty())
+            .expect("request");
+        RequestContext::new(request, PathParams::default())
+    }
+
+    #[test]
+    fn into_handler_wraps_closure_and_call_runs_it() {
+        async fn ok(_ctx: RequestContext) -> Result<&'static str, EdgeError> {
+            Ok("hi")
+        }
+        let handler = ok.into_handler();
+        let response = block_on(handler.call(ctx())).expect("ok response");
+        assert_eq!(response.status(), StatusCode::OK);
+        // Prove the closure's return value actually flowed through
+        // `into_response` — not just that *some* default-OK response came
+        // back. A bridge that dropped the body would still be status 200.
+        assert_eq!(response.body().as_bytes(), Some(&b"hi"[..]));
+    }
+
+    #[test]
+    fn call_propagates_handler_error() {
+        async fn boom(_ctx: RequestContext) -> Result<&'static str, EdgeError> {
+            // `EdgeError::internal` takes `E: Into<anyhow::Error>`; a bare
+            // `&str` does not satisfy that bound, so wrap with `anyhow!`.
+            Err(EdgeError::internal(anyhow::anyhow!("boom")))
+        }
+        let handler = boom.into_handler();
+        let Err(error) = block_on(handler.call(ctx())) else {
+            panic!("expected error");
+        };
+        assert_eq!(error.status(), StatusCode::INTERNAL_SERVER_ERROR);
+    }
+}