Add TreeEntry model and update ls_tree tests for improved tree parsing

- Introduced `TreeEntry` dataclass to encapsulate tree entry properties for `ls_tree`.
- Refactored `_parse_tree_content` to yield `TreeEntry` objects, enhancing type safety and clarity.
- Updated `ls_tree` tests with detailed assertions for file and directory structure using Git tree entries.
- Added `create_git_tree` fixture for consistent test repository setup.

Author: LesPrimus

app/models/blob.py

@@ -7,8 +7,3 @@
 class Blob:
     header: bytes
     body: bytes
-
-
-@dataclass(frozen=True, kw_only=True)
-class Tree:
-    entries: list[Blob]

app/models/git.py

@@ -4,6 +4,7 @@
 import re
 import sys
 import zlib
+from dataclasses import dataclass
 from enum import StrEnum, auto
 
 __all__ = ["Git"]
@@ -29,6 +30,17 @@ def mode(self):
                 raise ValueError(f"Invalid GitObject: {self}")
 
 
+@dataclass(frozen=True, kw_only=True)
+class TreeEntry:
+    mode: bytes
+    file_name: bytes
+    raw_hash: bytes
+
+    @property
+    def hash(self):
+        return binascii.hexlify(self.raw_hash).decode()
+
+
 class Git:
     ignore_patterns = {".git", "__pycache__", ".pytest_cache", ".venv", "HEAD"}
 
@@ -141,7 +153,7 @@ def create_tree(
         return tree_hash
 
     @staticmethod
-    def _parse_tree_content(content: bytes) -> Iterator[dict[str, bytes]]:
+    def _parse_tree_content(content: bytes) -> Iterator[TreeEntry]:
         pattern = re.compile(
             rb"""
                     (?P<mode>\d+)
@@ -153,7 +165,7 @@ def _parse_tree_content(content: bytes) -> Iterator[dict[str, bytes]]:
             re.VERBOSE,
         )
         for match in pattern.finditer(content):
-            yield match.groupdict()
+            yield TreeEntry(**match.groupdict())
 
     def ls_tree(self, hash_value: str, *, name_only: bool = False):
         object_path = self.objects_folder / hash_value[:2] / hash_value[2:]
@@ -168,5 +180,5 @@ def ls_tree(self, hash_value: str, *, name_only: bool = False):
         entries = list(self._parse_tree_content(content))
         if name_only:
             for entry in entries:
-                print(entry["file_name"].decode())
+                print(entry.file_name.decode())
         return entries

tests/test_git.py

@@ -1,5 +1,7 @@
 import contextlib
 import pathlib
+import subprocess
+from operator import attrgetter
 
 import pytest
 
@@ -12,6 +14,52 @@ def change_to_tmp_dir(tmp_path):
         yield tmp_path
 
 
+@pytest.fixture
+def create_git_tree(change_to_tmp_dir):
+    """Create a test Git repository with a predefined structure.
+
+    Creates:
+        parent_folder/
+            ├── file1.txt ("hello")
+            └── child_folder/
+                └── file2.txt ("world")
+
+    Returns:
+        str: Hash value of the created Git tree
+    """
+
+    parent_folder = change_to_tmp_dir / "parent_folder"
+    parent_folder.mkdir()
+    file1 = parent_folder / "file1.txt"
+    file1.write_text("hello")
+    #
+    child_folder = parent_folder / "child_folder"
+    child_folder.mkdir()
+    file2 = child_folder / "file2.txt"
+    file2.write_text("world")
+
+    for cmd in [
+        ["git", "init", "."],
+        ["git", "add", "."],
+    ]:
+        result = subprocess.run(
+            cmd, cwd=change_to_tmp_dir, capture_output=True, text=True
+        )
+        if result.returncode != 0:
+            raise RuntimeError(f"Failed to run git command: {cmd}\n{result.stderr}")
+
+    result = subprocess.run(
+        ["git", "write-tree"], cwd=change_to_tmp_dir, capture_output=True, text=True
+    )
+    if result.returncode != 0:
+        raise RuntimeError(f"Failed to run git command: {cmd}\n{result.stderr}")
+    hash_value = result.stdout.strip()
+    if not hash_value or len(hash_value) != 40:
+        raise RuntimeError(f"Failed to get tree hash: {hash_value}")
+
+    return hash_value
+
+
 class TestGit:
     def test_init_repo(self, change_to_tmp_dir):
         git = Git()
@@ -50,27 +98,45 @@ def test_hash_object(
         assert expected_path.exists() == write
         assert capsys.readouterr().out == hash_value
 
-    def test_write_tree(self, change_to_tmp_dir):
+    def test_write_tree(self, create_git_tree):
         git = Git()
-        git.init_repo()
+        entries = git.ls_tree(create_git_tree)
+
+        # Test that we have exactly one entry (parent_folder)
+        assert len(entries) == 1
+
+        # Test parent_folder properties
+        parent_entry = entries[0]
+        assert parent_entry.mode == b"40000"  # Directory mode
+        assert parent_entry.file_name == b"parent_folder"
+
+        # Get the contents of parent_folder
+        parent_entries = git.ls_tree(parent_entry.hash)
+
+        # Should have two entries: file1.txt and child_folder
+        assert len(parent_entries) == 2
+
+        # Sort entries by filename for consistent testing
+        parent_entries.sort(key=attrgetter("file_name"))
+
+        # Test child_folder
+        child_folder_entry = parent_entries[0]
+        assert child_folder_entry.mode == b"40000"  # Directory mode
+        assert child_folder_entry.file_name == b"child_folder"
+
+        # Test file1.txt
+        file1_entry = parent_entries[1]
+        assert file1_entry.mode == b"100644"  # File mode
+        assert file1_entry.file_name == b"file1.txt"
+
+        # Test contents of child_folder
+        child_entries = git.ls_tree(child_folder_entry.hash)
+
+        # Should have one file: file2.txt
+        assert len(child_entries) == 1
+        file2_entry = child_entries[0]
+        assert file2_entry.mode == b"100644"  # File mode
+        assert file2_entry.file_name == b"file2.txt"
 
-        parent_dir = change_to_tmp_dir / "parent_dir"
-        parent_dir.mkdir()
-        file1 = parent_dir / "file1.txt"
-        file1.write_text("hello")
-        file2 = parent_dir / "file2.txt"
-        file2.write_text("World")
-        inner_dir = parent_dir / "inner_dir"
-        inner_dir.mkdir()
-
-        inner_file1 = inner_dir / "inner_file1.txt"
-        inner_file1.write_text("Hello World!")
-
-        # Create tree specifically for parent_dir
-        hash_values = git.create_tree("parent_dir")
-
-        # Now we should see both files
-        entries = git.ls_tree(hash_values, name_only=True)
-        print(entries)
-        return
-        assert len(entries) == 2
+        assert git.cat_file(file1_entry.hash).body == b"hello"
+        assert git.cat_file(file2_entry.hash).body == b"world"