refactor

Author: Byron

gix/src/repository/object.rs

@@ -94,6 +94,8 @@ impl crate::Repository {
     /// Obtain information about an object without fully decoding it, or fail if the object doesn't exist.
     ///
     /// Note that despite being cheaper than [`Self::find_object()`], there is still some effort traversing delta-chains.
+    /// Also note that for empty trees and blobs, it will always report it to exist in loose objects, even if they don't
+    /// exist or if they exist in a pack.
     #[doc(alias = "read_header", alias = "git2")]
     pub fn find_header(&self, id: impl Into<ObjectId>) -> Result<gix_odb::find::Header, object::find::existing::Error> {
         let id = id.into();

gix/tests/gix/repository/object.rs

@@ -1,3 +1,5 @@
+use gix_odb::Header;
+use gix_pack::Find;
 use gix_testtools::tempfile;
 
 use crate::util::named_subrepo_opts;
@@ -538,77 +540,44 @@ mod find {
             }),
             "empty blob is considered a loose object"
         );
-
-        // Note: Unlike empty tree, empty blobs might actually exist in the repository.
-        // The key point is that has_object() should always return true for empty blobs,
-        // regardless of whether they are physically stored or not.
         Ok(())
     }
 }
 
 #[test]
-fn empty_blob_is_always_considered_present() -> crate::Result {
-    use gix_object::Find;
-    
-    // Test with an empty in-memory repository to ensure empty blob is considered present
-    // even when it doesn't physically exist
-    let repo = empty_bare_in_memory_repo()?;
-    let empty_blob = gix::hash::ObjectId::empty_blob(repo.object_hash());
-    
-    // The key behavior being tested: has_object should return true for empty blob
-    assert!(repo.has_object(empty_blob), "empty blob should always be considered present");
-    
-    // Verify that the lower-level object database doesn't have it
-    let mut buf = Vec::new();
-    let lower_level_result = repo.objects.try_find(&empty_blob, &mut buf)?;
-    
-    // Empty blob might or might not exist at the lower level - that's implementation dependent
-    // But has_object should always return true regardless
-    match lower_level_result {
-        Some(_) => {
-            // If it exists at the lower level, that's fine
-        }
-        None => {
-            // If it doesn't exist at the lower level, has_object should still return true
-            // thanks to our special handling
-        }
-    }
-    
-    Ok(())
-}
-
-#[test]
-fn empty_blob_edge_cases() -> crate::Result {
+fn empty_objects_are_always_present_but_not_in_plumbing() -> crate::Result {
     let repo = empty_bare_in_memory_repo()?;
     let empty_blob_id = gix::hash::ObjectId::empty_blob(repo.object_hash());
-    
-    // Test all the related methods for empty blobs
-    assert!(repo.has_object(&empty_blob_id), "has_object should return true");
-    
-    // Test find_header
+
+    assert!(
+        repo.has_object(empty_blob_id),
+        "empty object is always present even if it's not"
+    );
+    assert!(!repo.objects.contains(&empty_blob_id));
+
     let header = repo.find_header(empty_blob_id)?;
     assert_eq!(header.kind(), gix_object::Kind::Blob);
     assert_eq!(header.size(), 0);
-    
-    // Test try_find_header
+    assert_eq!(repo.objects.try_header(&empty_blob_id)?, None);
+
     let header = repo.try_find_header(empty_blob_id)?.expect("should find header");
     assert_eq!(header.kind(), gix_object::Kind::Blob);
     assert_eq!(header.size(), 0);
-    
-    // Test find_object
+
     let obj = repo.find_object(empty_blob_id)?;
     assert_eq!(obj.kind, gix_object::Kind::Blob);
     assert_eq!(obj.data.len(), 0);
-    
-    // Test try_find_object
+
+    let mut buf = Vec::new();
+    assert_eq!(repo.objects.try_find(&empty_blob_id, &mut buf)?, None);
+
     let obj = repo.try_find_object(empty_blob_id)?.expect("should find object");
     assert_eq!(obj.kind, gix_object::Kind::Blob);
     assert_eq!(obj.data.len(), 0);
-    
-    // Test that we can get a blob from the object
-    let blob = obj.into_blob();
+
+    let blob = obj.try_into_blob()?;
     assert_eq!(blob.data.len(), 0);
-    
+
     Ok(())
 }