test: prune redundant cases and add high-risk coverage across crates (#4208)

Remove or consolidate 57 test cases that cannot catch regressions
(literal-constant asserts, construct-then-assert, derived-serde
round-trips, near-duplicate env/getter matrices) in common, config,
iam, madmin, and object-capacity, keeping all wire-format and
error-path guards. Add 13 tests for previously uncovered high-risk
behavior: filemeta version-sort determinism and merge resilience to
garbage headers, zip extraction path-traversal rejection and exact
limit boundaries, JWT tampered-signature rejection, and the bytes
variant of dual-key (rustfs/minio) metadata fallback and precedence.

Test-only change; no production code touched.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

crates/filemeta/src/filemeta/version.rs

@@ -3543,6 +3543,76 @@ mod tests {
         assert_eq!(fi.transition_version_id, Some(id));
     }
 
+    #[test]
+    fn version_header_sorts_before_prefers_object_over_delete_marker_on_equal_mod_time() {
+        let object = FileMetaVersionHeader {
+            version_id: Some(Uuid::from_u128(1)),
+            mod_time: Some(sample_mod_time()),
+            version_type: VersionType::Object,
+            ..Default::default()
+        };
+        let delete_marker = FileMetaVersionHeader {
+            version_id: Some(Uuid::from_u128(2)),
+            version_type: VersionType::Delete,
+            ..object
+        };
+
+        // With equal mod_time the tie is broken by "prefer lower types":
+        // Object (1) sorts before Delete (2), regardless of version_id.
+        assert!(object.sorts_before(&delete_marker));
+        assert!(!delete_marker.sorts_before(&object));
+    }
+
+    #[test]
+    fn version_header_sorts_before_equal_mod_time_is_deterministic_and_antisymmetric() {
+        let a = FileMetaVersionHeader {
+            version_id: Some(Uuid::from_u128(1)),
+            mod_time: Some(sample_mod_time()),
+            version_type: VersionType::Object,
+            ..Default::default()
+        };
+        let b = FileMetaVersionHeader {
+            version_id: Some(Uuid::from_u128(2)),
+            ..a.clone()
+        };
+
+        // Equal mod_time and version_type: the higher version_id sorts first,
+        // and exactly one of the two orderings holds so merge sees a stable
+        // total order for distinct headers.
+        assert!(b.sorts_before(&a));
+        assert!(!a.sorts_before(&b));
+        assert_ne!(a.sorts_before(&b), b.sorts_before(&a));
+
+        // A header never sorts before an identical header.
+        assert!(!a.sorts_before(&a.clone()));
+    }
+
+    #[test]
+    fn merge_file_meta_versions_survives_garbage_header_stream() {
+        let valid = FileMetaShallowVersion {
+            header: sample_header(),
+            meta: Vec::new(),
+        };
+        let garbage = FileMetaShallowVersion {
+            header: FileMetaVersionHeader {
+                version_id: None,
+                mod_time: None,
+                signature: [0xde, 0xad, 0xbe, 0xef],
+                version_type: VersionType::Invalid,
+                flags: 0xff,
+                ec_n: 0,
+                ec_m: 0,
+            },
+            meta: b"not-a-valid-msgpack-version".to_vec(),
+        };
+
+        // One disk returns a garbage header alongside two healthy streams:
+        // merge must not panic and must still return the quorum version.
+        let merged = merge_file_meta_versions(2, true, 0, &[vec![valid.clone()], vec![valid.clone()], vec![garbage]]);
+
+        assert_eq!(merged, vec![valid]);
+    }
+
     #[test]
     fn meta_object_init_free_version_rejects_invalid_tier_free_version_id() {
         let mut sys = HashMap::new();