add

ecstore/src/file_meta.rs

@@ -2520,7 +2520,7 @@ mod test {
         fi3.mod_time = Some(time3);
         fm.add_version(fi3).unwrap();
 
-                // Sort first to ensure latest is at the front
+        // Sort first to ensure latest is at the front
         fm.sort_by_mod_time();
 
         // Should return the first version's mod time (lastest_mod_time returns first version's time)
@@ -2690,7 +2690,7 @@ mod test {
         assert!(result.is_err());
     }
 
-            #[test]
+    #[test]
     fn test_is_latest_delete_marker() {
         // Test the is_latest_delete_marker function with simple data
         // Since the function is complex and requires specific XL format,
@@ -2798,9 +2798,7 @@ async fn test_file_info_from_raw() {
 
     let encoded = fm.marshal_msg().unwrap();
 
-    let raw_info = RawFileInfo {
-        buf: encoded,
-    };
+    let raw_info = RawFileInfo { buf: encoded };
 
     let result = file_info_from_raw(raw_info, "test-bucket", "test-object", false).await;
     assert!(result.is_ok());
@@ -2833,26 +2831,26 @@ fn test_file_meta_load_function() {
     assert!(result.is_err());
 }
 
-            #[test]
-    fn test_file_meta_read_bytes_header() {
-        // Test read_bytes_header function - it expects the first 5 bytes to be msgpack bin length
-        // Create a buffer with proper msgpack bin format for a 9-byte binary
-        let mut buf = vec![0xc4, 0x09]; // msgpack bin8 format for 9 bytes
-        buf.extend_from_slice(b"test data"); // 9 bytes of data
-        buf.extend_from_slice(b"extra"); // additional data
+#[test]
+fn test_file_meta_read_bytes_header() {
+    // Test read_bytes_header function - it expects the first 5 bytes to be msgpack bin length
+    // Create a buffer with proper msgpack bin format for a 9-byte binary
+    let mut buf = vec![0xc4, 0x09]; // msgpack bin8 format for 9 bytes
+    buf.extend_from_slice(b"test data"); // 9 bytes of data
+    buf.extend_from_slice(b"extra"); // additional data
 
-        let result = FileMeta::read_bytes_header(&buf);
-        assert!(result.is_ok());
-        let (length, remaining) = result.unwrap();
-        assert_eq!(length, 9); // "test data" length
-        // remaining should be everything after the 5-byte header (but we only have 2-byte header)
-        assert_eq!(remaining.len(), buf.len() - 5);
+    let result = FileMeta::read_bytes_header(&buf);
+    assert!(result.is_ok());
+    let (length, remaining) = result.unwrap();
+    assert_eq!(length, 9); // "test data" length
+                           // remaining should be everything after the 5-byte header (but we only have 2-byte header)
+    assert_eq!(remaining.len(), buf.len() - 5);
 
-        // Test with buffer too small
-        let small_buf = vec![0u8; 2];
-        let result = FileMeta::read_bytes_header(&small_buf);
-        assert!(result.is_err());
-    }
+    // Test with buffer too small
+    let small_buf = vec![0u8; 2];
+    let result = FileMeta::read_bytes_header(&small_buf);
+    assert!(result.is_err());
+}
 
 #[test]
 fn test_file_meta_get_set_idx() {
@@ -3080,11 +3078,11 @@ fn test_file_meta_version_header_ordering() {
     // Test partial_cmp
     assert!(header1.partial_cmp(&header2).is_some());
 
-            // Test cmp - header2 should be greater (newer)
-        use std::cmp::Ordering;
-        assert_eq!(header1.cmp(&header2), Ordering::Less); // header1 has earlier time
-        assert_eq!(header2.cmp(&header1), Ordering::Greater); // header2 has later time
-        assert_eq!(header1.cmp(&header1), Ordering::Equal);
+    // Test cmp - header2 should be greater (newer)
+    use std::cmp::Ordering;
+    assert_eq!(header1.cmp(&header2), Ordering::Less); // header1 has earlier time
+    assert_eq!(header2.cmp(&header1), Ordering::Greater); // header2 has later time
+    assert_eq!(header1.cmp(&header1), Ordering::Equal);
 }
 
 #[test]
@@ -3110,10 +3108,7 @@ fn test_merge_file_meta_versions_edge_cases() {
     version2.header.version_id = Some(Uuid::new_v4());
     version2.header.mod_time = Some(OffsetDateTime::from_unix_timestamp(2000).unwrap());
 
-    let versions = vec![
-        vec![version1.clone()],
-        vec![version2.clone()],
-    ];
+    let versions = vec![vec![version1.clone()], vec![version2.clone()]];
 
     let _merged_strict = merge_file_meta_versions(1, true, 10, &versions);
     let merged_non_strict = merge_file_meta_versions(1, false, 10, &versions);
@@ -3191,9 +3186,7 @@ async fn test_get_file_info_edge_cases() {
 #[tokio::test]
 async fn test_file_info_from_raw_edge_cases() {
     // Test with empty buffer
-    let empty_raw = RawFileInfo {
-        buf: vec![],
-    };
+    let empty_raw = RawFileInfo { buf: vec![] };
     let result = file_info_from_raw(empty_raw, "bucket", "object", false).await;
     assert!(result.is_err());
 
@@ -3227,12 +3220,12 @@ fn test_meta_object_edge_cases() {
     obj.data_dir = None;
     assert!(obj.use_data_dir());
 
-            // Test use_inlinedata (always returns false in current implementation)
-        obj.size = 128 * 1024; // 128KB threshold
-        assert!(!obj.use_inlinedata()); // Should be false
+    // Test use_inlinedata (always returns false in current implementation)
+    obj.size = 128 * 1024; // 128KB threshold
+    assert!(!obj.use_inlinedata()); // Should be false
 
-        obj.size = 128 * 1024 - 1;
-        assert!(!obj.use_inlinedata()); // Should also be false (always false)
+    obj.size = 128 * 1024 - 1;
+    assert!(!obj.use_inlinedata()); // Should also be false (always false)
 }
 
 #[test]
@@ -3244,17 +3237,17 @@ fn test_file_meta_version_header_edge_cases() {
     header.ec_m = 0;
     assert!(!header.has_ec());
 
-            // Test matches_not_strict with different signatures but same version_id
-        let mut other = FileMetaVersionHeader::default();
-        let version_id = Some(Uuid::new_v4());
-        header.version_id = version_id;
-        other.version_id = version_id;
-        header.version_type = VersionType::Object;
-        other.version_type = VersionType::Object;
-        header.signature = [1, 2, 3, 4];
-        other.signature = [5, 6, 7, 8];
-        // Should match because they have same version_id and type
-        assert!(header.matches_not_strict(&other));
+    // Test matches_not_strict with different signatures but same version_id
+    let mut other = FileMetaVersionHeader::default();
+    let version_id = Some(Uuid::new_v4());
+    header.version_id = version_id;
+    other.version_id = version_id;
+    header.version_type = VersionType::Object;
+    other.version_type = VersionType::Object;
+    header.signature = [1, 2, 3, 4];
+    other.signature = [5, 6, 7, 8];
+    // Should match because they have same version_id and type
+    assert!(header.matches_not_strict(&other));
 
     // Test sorts_before with same mod_time but different version_id
     let time = OffsetDateTime::from_unix_timestamp(1000).unwrap();
@@ -3286,12 +3279,12 @@ fn test_file_meta_add_version_edge_cases() {
     fi2.mod_time = Some(OffsetDateTime::now_utc());
     fm.add_version(fi2).unwrap();
 
-            // Should still have only one version, but updated
-        assert_eq!(fm.versions.len(), 1);
-        let (_, version) = fm.find_version(version_id).unwrap();
-        if let Some(obj) = version.object {
-            assert_eq!(obj.size, 2048); // Size gets updated when adding same version_id
-        }
+    // Should still have only one version, but updated
+    assert_eq!(fm.versions.len(), 1);
+    let (_, version) = fm.find_version(version_id).unwrap();
+    if let Some(obj) = version.object {
+        assert_eq!(obj.size, 2048); // Size gets updated when adding same version_id
+    }
 }
 
 #[test]
@@ -3324,12 +3317,11 @@ fn test_file_meta_shard_data_dir_count_edge_cases() {
     fi.mod_time = Some(OffsetDateTime::now_utc());
     fm.add_version(fi).unwrap();
 
-            let count = fm.shard_data_dir_count(&version_id, &data_dir);
-        assert_eq!(count, 0); // Should be 0 because user_data_dir() requires flag
+    let count = fm.shard_data_dir_count(&version_id, &data_dir);
+    assert_eq!(count, 0); // Should be 0 because user_data_dir() requires flag
 
     // Test with different version_id
     let other_version_id = Some(Uuid::new_v4());
-            let count = fm.shard_data_dir_count(&other_version_id, &data_dir);
-        assert_eq!(count, 1); // Should be 1 because the version has matching data_dir and user_data_dir() is true
+    let count = fm.shard_data_dir_count(&other_version_id, &data_dir);
+    assert_eq!(count, 1); // Should be 1 because the version has matching data_dir and user_data_dir() is true
 }
-

ecstore/src/set_disk.rs

@@ -5890,7 +5890,7 @@ mod tests {
             erasure: ErasureInfo {
                 data_blocks: 4,
                 parity_blocks: 2,
-                index: 1, // Must be > 0 for is_valid() to return true
+                index: 1,                             // Must be > 0 for is_valid() to return true
                 distribution: vec![1, 2, 3, 4, 5, 6], // Must match data_blocks + parity_blocks
                 ..Default::default()
             },
@@ -5902,7 +5902,7 @@ mod tests {
             erasure: ErasureInfo {
                 data_blocks: 6,
                 parity_blocks: 3,
-                index: 1, // Must be > 0 for is_valid() to return true
+                index: 1,                                      // Must be > 0 for is_valid() to return true
                 distribution: vec![1, 2, 3, 4, 5, 6, 7, 8, 9], // Must match data_blocks + parity_blocks
                 ..Default::default()
             },
@@ -5914,7 +5914,7 @@ mod tests {
             erasure: ErasureInfo {
                 data_blocks: 2,
                 parity_blocks: 1,
-                index: 1, // Must be > 0 for is_valid() to return true
+                index: 1,                    // Must be > 0 for is_valid() to return true
                 distribution: vec![1, 2, 3], // Must match data_blocks + parity_blocks
                 ..Default::default()
             },
@@ -6019,11 +6019,7 @@ mod tests {
     #[test]
     fn test_join_errs() {
         // Test joining error messages
-        let errs = vec![
-            None,
-            Some(Error::from_string("error1")),
-            Some(Error::from_string("error2")),
-        ];
+        let errs = vec![None, Some(Error::from_string("error1")), Some(Error::from_string("error2"))];
         let joined = join_errs(&errs);
         assert!(joined.contains("<nil>"));
         assert!(joined.contains("error1"));

ecstore/src/store_api.rs

@@ -1153,7 +1153,11 @@ mod tests {
         assert_eq!(file_info.get_etag(), None);
 
         // With etag
-        file_info.metadata.as_mut().unwrap().insert("etag".to_string(), "test-etag".to_string());
+        file_info
+            .metadata
+            .as_mut()
+            .unwrap()
+            .insert("etag".to_string(), "test-etag".to_string());
         assert_eq!(file_info.get_etag(), Some("test-etag".to_string()));
     }
 
@@ -1282,10 +1286,7 @@ mod tests {
         file_info.set_healing();
 
         assert!(file_info.metadata.is_some());
-        assert_eq!(
-            file_info.metadata.as_ref().unwrap().get(RUSTFS_HEALING),
-            Some(&"true".to_string())
-        );
+        assert_eq!(file_info.metadata.as_ref().unwrap().get(RUSTFS_HEALING), Some(&"true".to_string()));
     }
 
     #[test]
@@ -1656,10 +1657,11 @@ mod tests {
         assert!(!object_info.is_compressed());
 
         // With compression metadata
-        object_info.user_defined.as_mut().unwrap().insert(
-            format!("{}compression", RESERVED_METADATA_PREFIX),
-            "gzip".to_string()
-        );
+        object_info
+            .user_defined
+            .as_mut()
+            .unwrap()
+            .insert(format!("{}compression", RESERVED_METADATA_PREFIX), "gzip".to_string());
         assert!(object_info.is_compressed());
     }
 
@@ -1866,7 +1868,7 @@ mod tests {
         let shard_size = erasure.shard_size(1000);
         assert_eq!(shard_size, 1000); // 1000 / 1 = 1000
 
-                // Test with zero block size - this will cause division by zero in shard_size
+        // Test with zero block size - this will cause division by zero in shard_size
         // So we need to test with non-zero block_size but zero data_blocks was already fixed above
         let erasure = ErasureInfo {
             data_blocks: 4,