test: assert real behavior in three assertion-less tests (#5993)

test_format_v1 (ecstore layout::format) only printed its results; the pinned v1 format.json literal never parsed at all because "this": null fails Uuid deserialization, and the Err was silently discarded. Fix the fixture to the real on-disk shape (MinIO and RustFS always write a concrete disk UUID there) and assert a serialize->parse roundtrip identity plus every pinned field of the literal.

test_console_cors_configuration discarded all four parse_cors_origins results; parse_cors_origins returns an opaque CorsLayer, so the test now drives real CORS preflight requests through an axum router and asserts the allow-origin outcomes: wildcard answers any origin with *, a configured list echoes listed origins and refuses unlisted ones, empty/unset configurations allow no cross-origin caller.

test_heal_channel_processor_new only constructed the processor; it now asserts the response channel accepts a send.

Ref rustfs/backlog#1836 (PR1).

rustfs/src/admin/console_test.rs

@@ -17,29 +17,73 @@ mod tests {
     use crate::config::Opt;
     use serial_test::serial;
 
+    /// Sends a CORS preflight request through a router wrapped with the given
+    /// layer and returns the `access-control-allow-origin` header, if any.
+    async fn preflight_allow_origin(cors: tower_http::cors::CorsLayer, origin: &str) -> Option<String> {
+        use axum::{Router, body::Body, routing::get};
+        use tower::ServiceExt;
+
+        let app = Router::new().route("/", get(|| async { "ok" })).layer(cors);
+        let response = app
+            .oneshot(
+                http::Request::builder()
+                    .method(http::Method::OPTIONS)
+                    .uri("/")
+                    .header(http::header::ORIGIN, origin)
+                    .header(http::header::ACCESS_CONTROL_REQUEST_METHOD, "GET")
+                    .body(Body::empty())
+                    .expect("preflight request must build"),
+            )
+            .await
+            .expect("preflight request must not fail");
+
+        response
+            .headers()
+            .get(http::header::ACCESS_CONTROL_ALLOW_ORIGIN)
+            .map(|value| value.to_str().expect("allow-origin header must be valid UTF-8").to_string())
+    }
+
     #[tokio::test]
     #[serial]
     async fn test_console_cors_configuration() {
-        // Test CORS configuration parsing
         use crate::admin::console::parse_cors_origins;
-        // Test wildcard origin
-        let cors_wildcard = Some("*".to_string());
-        let _layer1 = parse_cors_origins(cors_wildcard.as_ref());
-        // Should create a layer without error
 
-        // Test specific origins
-        let cors_specific = Some("http://localhost:3000,https://admin.example.com".to_string());
-        let _layer2 = parse_cors_origins(cors_specific.as_ref());
-        // Should create a layer without error
+        // Wildcard configuration must allow any origin.
+        let wildcard = parse_cors_origins(Some(&"*".to_string()));
+        assert_eq!(
+            preflight_allow_origin(wildcard, "http://anywhere.example").await.as_deref(),
+            Some("*"),
+            "wildcard configuration must answer preflight with a permissive allow-origin"
+        );
 
-        // Test empty origin
-        let cors_empty = Some("".to_string());
-        let _layer3 = parse_cors_origins(cors_empty.as_ref());
-        // Should create a layer without error (falls back to permissive)
+        // An explicit list must echo listed origins and refuse unlisted ones.
+        let listed = parse_cors_origins(Some(&"http://localhost:3000,https://admin.example.com".to_string()));
+        assert_eq!(
+            preflight_allow_origin(listed, "http://localhost:3000").await.as_deref(),
+            Some("http://localhost:3000"),
+            "a listed origin must be echoed back on preflight"
+        );
+        let listed = parse_cors_origins(Some(&"http://localhost:3000,https://admin.example.com".to_string()));
+        assert_eq!(
+            preflight_allow_origin(listed, "https://other.example").await,
+            None,
+            "an unlisted origin must not receive an allow-origin header"
+        );
 
-        // Test no origin
-        let _layer4 = parse_cors_origins(None);
-        // Should create a layer without error (uses default)
+        // Empty and unset configurations fall back to same-origin only:
+        // no cross-origin caller may be allowed.
+        let empty = parse_cors_origins(Some(&"".to_string()));
+        assert_eq!(
+            preflight_allow_origin(empty, "http://localhost:3000").await,
+            None,
+            "empty configuration must not allow any cross-origin caller"
+        );
+        let unset = parse_cors_origins(None);
+        assert_eq!(
+            preflight_allow_origin(unset, "http://localhost:3000").await,
+            None,
+            "unset configuration must not allow any cross-origin caller"
+        );
     }
 
     #[tokio::test]