path: root/obj_tree_test.go

package furgit

import (
	"bytes"
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"testing"
)

func TestTreeWrite(t *testing.T) {
	repoPath, cleanup := setupTestRepo(t)
	defer cleanup()

	blobData := []byte("file content")
	blobHash := gitHashObject(t, repoPath, "blob", blobData)

	repo, err := OpenRepository(repoPath)
	if err != nil {
		t.Fatalf("OpenRepository failed: %v", err)
	}
	defer func() { _ = repo.Close() }()

	blobHashObj, _ := repo.ParseHash(blobHash)
	tree := &Tree{
		Entries: []TreeEntry{
			{Mode: 0o100644, Name: []byte("file.txt"), ID: blobHashObj},
		},
	}

	treeHash, err := repo.WriteLooseObject(tree)
	if err != nil {
		t.Fatalf("WriteLooseObject failed: %v", err)
	}

	gitType := string(gitCatFile(t, repoPath, "-t", treeHash.String()))
	if gitType != "tree" {
		t.Errorf("git type: got %q, want %q", gitType, "tree")
	}

	gitLsTree := gitCmd(t, repoPath, "ls-tree", treeHash.String())
	if !strings.Contains(gitLsTree, "file.txt") {
		t.Errorf("git ls-tree doesn't contain file.txt: %s", gitLsTree)
	}
	if !strings.Contains(gitLsTree, blobHash) {
		t.Errorf("git ls-tree doesn't contain blob hash: %s", gitLsTree)
	}
}

func TestTreeRead(t *testing.T) {
	repoPath, cleanup := setupTestRepo(t)
	defer cleanup()

	workDir, cleanupWork := setupWorkDir(t)
	defer cleanupWork()

	err := os.WriteFile(filepath.Join(workDir, "a.txt"), []byte("content a"), 0o644)
	if err != nil {
		t.Fatalf("failed to write a.txt: %v", err)
	}
	err = os.WriteFile(filepath.Join(workDir, "b.txt"), []byte("content b"), 0o644)
	if err != nil {
		t.Fatalf("failed to write b.txt: %v", err)
	}
	err = os.WriteFile(filepath.Join(workDir, "c.txt"), []byte("content c"), 0o644)
	if err != nil {
		t.Fatalf("failed to write c.txt: %v", err)
	}

	gitCmd(t, repoPath, "--work-tree="+workDir, "add", ".")
	treeHash := gitCmd(t, repoPath, "--work-tree="+workDir, "write-tree")

	repo, err := OpenRepository(repoPath)
	if err != nil {
		t.Fatalf("OpenRepository failed: %v", err)
	}
	defer func() { _ = repo.Close() }()

	hash, _ := repo.ParseHash(treeHash)
	obj, err := repo.ReadObject(hash)
	if err != nil {
		t.Fatalf("ReadObject failed: %v", err)
	}

	tree, ok := obj.(*StoredTree)
	if !ok {
		t.Fatalf("expected *StoredTree, got %T", obj)
	}

	if len(tree.Entries) != 3 {
		t.Fatalf("entries count: got %d, want 3", len(tree.Entries))
	}

	expectedNames := []string{"a.txt", "b.txt", "c.txt"}
	for i, expected := range expectedNames {
		if string(tree.Entries[i].Name) != expected {
			t.Errorf("entry[%d] name: got %q, want %q", i, tree.Entries[i].Name, expected)
		}
	}

	if tree.ObjectType() != ObjectTypeTree {
		t.Errorf("ObjectType(): got %d, want %d", tree.ObjectType(), ObjectTypeTree)
	}
}

func TestTreeEntry(t *testing.T) {
	repoPath, cleanup := setupTestRepo(t)
	defer cleanup()

	workDir, cleanupWork := setupWorkDir(t)
	defer cleanupWork()

	err := os.WriteFile(filepath.Join(workDir, "a.txt"), []byte("content a"), 0o644)
	if err != nil {
		t.Fatalf("failed to write a.txt: %v", err)
	}
	err = os.WriteFile(filepath.Join(workDir, "b.txt"), []byte("content b"), 0o644)
	if err != nil {
		t.Fatalf("failed to write b.txt: %v", err)
	}
	err = os.WriteFile(filepath.Join(workDir, "c.txt"), []byte("content c"), 0o644)
	if err != nil {
		t.Fatalf("failed to write c.txt: %v", err)
	}

	gitCmd(t, repoPath, "--work-tree="+workDir, "add", ".")
	treeHash := gitCmd(t, repoPath, "--work-tree="+workDir, "write-tree")

	repo, err := OpenRepository(repoPath)
	if err != nil {
		t.Fatalf("OpenRepository failed: %v", err)
	}
	defer func() { _ = repo.Close() }()

	hash, _ := repo.ParseHash(treeHash)
	obj, _ := repo.ReadObject(hash)
	tree := obj.(*StoredTree)

	entry := tree.Entry([]byte("b.txt"))
	if entry == nil {
		t.Fatal("Entry returned nil for existing entry")
	}
	if !bytes.Equal(entry.Name, []byte("b.txt")) {
		t.Errorf("entry name: got %q, want %q", entry.Name, "b.txt")
	}

	notFound := tree.Entry([]byte("notfound.txt"))
	if notFound != nil {
		t.Error("Entry returned non-nil for non-existing entry")
	}
}

func TestTreeEntryRecursive(t *testing.T) {
	repoPath, cleanup := setupTestRepo(t)
	defer cleanup()

	workDir, cleanupWork := setupWorkDir(t)
	defer cleanupWork()

	err := os.MkdirAll(filepath.Join(workDir, "dir"), 0o755)
	if err != nil {
		t.Fatalf("failed to create dir: %v", err)
	}
	err = os.WriteFile(filepath.Join(workDir, "file1.txt"), []byte("file1"), 0o644)
	if err != nil {
		t.Fatalf("failed to write file1.txt: %v", err)
	}
	err = os.WriteFile(filepath.Join(workDir, "file2.txt"), []byte("file2"), 0o644)
	if err != nil {
		t.Fatalf("failed to write file2.txt: %v", err)
	}
	err = os.WriteFile(filepath.Join(workDir, "dir", "nested.txt"), []byte("nested"), 0o644)
	if err != nil {
		t.Fatalf("failed to write dir/nested.txt: %v", err)
	}

	gitCmd(t, repoPath, "--work-tree="+workDir, "add", ".")
	treeHash := gitCmd(t, repoPath, "--work-tree="+workDir, "write-tree")

	repo, err := OpenRepository(repoPath)
	if err != nil {
		t.Fatalf("OpenRepository failed: %v", err)
	}
	defer func() { _ = repo.Close() }()

	hash, _ := repo.ParseHash(treeHash)
	obj, _ := repo.ReadObject(hash)
	tree := obj.(*StoredTree)

	entry, err := tree.EntryRecursive(repo, [][]byte{[]byte("file1.txt")})
	if err != nil {
		t.Fatalf("EntryRecursive file1.txt failed: %v", err)
	}
	if !bytes.Equal(entry.Name, []byte("file1.txt")) {
		t.Errorf("entry name: got %q, want %q", entry.Name, "file1.txt")
	}

	gitShow := string(gitCatFile(t, repoPath, "blob", entry.ID.String()))
	if gitShow != "file1" {
		t.Errorf("file1 content from git: got %q, want %q", gitShow, "file1")
	}

	nestedEntry, err := tree.EntryRecursive(repo, [][]byte{[]byte("dir"), []byte("nested.txt")})
	if err != nil {
		t.Fatalf("EntryRecursive dir/nested.txt failed: %v", err)
	}
	if !bytes.Equal(nestedEntry.Name, []byte("nested.txt")) {
		t.Errorf("nested entry name: got %q, want %q", nestedEntry.Name, "nested.txt")
	}

	gitShowNested := string(gitCatFile(t, repoPath, "blob", nestedEntry.ID.String()))
	if gitShowNested != "nested" {
		t.Errorf("nested content from git: got %q, want %q", gitShowNested, "nested")
	}

	_, err = tree.EntryRecursive(repo, [][]byte{[]byte("nonexistent.txt")})
	if err == nil {
		t.Error("expected error for nonexistent path")
	}

	_, err = tree.EntryRecursive(repo, [][]byte{})
	if err == nil {
		t.Error("expected error for empty path")
	}
}

func TestTreeLarge(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping large tree test in short mode")
	}

	repoPath, cleanup := setupTestRepo(t)
	defer cleanup()

	gitCmd(t, repoPath, "config", "gc.auto", "0")

	workDir, cleanupWork := setupWorkDir(t)
	defer cleanupWork()

	numFiles := 1000
	for i := 0; i < numFiles; i++ {
		filename := filepath.Join(workDir, fmt.Sprintf("file%04d.txt", i))
		content := fmt.Sprintf("Content for file %d\n", i)
		err := os.WriteFile(filename, []byte(content), 0o644)
		if err != nil {
			t.Fatalf("failed to write %s: %v", filename, err)
		}
	}

	gitCmd(t, repoPath, "--work-tree="+workDir, "add", ".")
	treeHash := gitCmd(t, repoPath, "--work-tree="+workDir, "write-tree")

	repo, err := OpenRepository(repoPath)
	if err != nil {
		t.Fatalf("OpenRepository failed: %v", err)
	}
	defer func() { _ = repo.Close() }()

	hash, _ := repo.ParseHash(treeHash)
	obj, _ := repo.ReadObject(hash)
	tree := obj.(*StoredTree)

	if len(tree.Entries) != numFiles {
		t.Errorf("tree entries: got %d, want %d", len(tree.Entries), numFiles)
	}

	gitCount := gitCmd(t, repoPath, "ls-tree", treeHash)
	gitLines := strings.Count(gitCount, "\n") + 1
	if len(tree.Entries) != gitLines {
		t.Errorf("furgit found %d entries, git found %d", len(tree.Entries), gitLines)
	}

	for i := 0; i < 10; i++ {
		idx := i * (numFiles / 10)
		expectedName := fmt.Sprintf("file%04d.txt", idx)
		entry := tree.Entry([]byte(expectedName))
		if entry == nil {
			t.Errorf("expected to find entry %s", expectedName)
			continue
		}

		blobObj, _ := repo.ReadObject(entry.ID)
		blob := blobObj.(*StoredBlob)

		expectedContent := fmt.Sprintf("Content for file %d\n", idx)
		if string(blob.Data) != expectedContent {
			t.Errorf("blob %s: got %q, want %q", expectedName, blob.Data, expectedContent)
		}

		gitData := gitCatFile(t, repoPath, "blob", entry.ID.String())
		if !bytes.Equal(blob.Data, gitData) {
			t.Errorf("blob %s: furgit data doesn't match git data", expectedName)
		}
	}
}

func TestTreeInsertEntry(t *testing.T) {
	tree := &Tree{
		Entries: []TreeEntry{
			{Mode: FileModeRegular, Name: []byte("alpha"), ID: Hash{}},
			{Mode: FileModeRegular, Name: []byte("gamma"), ID: Hash{}},
		},
	}

	if err := tree.InsertEntry(TreeEntry{Mode: FileModeRegular, Name: []byte("beta"), ID: Hash{}}); err != nil {
		t.Fatalf("InsertEntry failed: %v", err)
	}
	if len(tree.Entries) != 3 {
		t.Fatalf("entries count: got %d, want 3", len(tree.Entries))
	}
	if string(tree.Entries[1].Name) != "beta" {
		t.Fatalf("inserted order mismatch: got %q, want %q", tree.Entries[1].Name, "beta")
	}

	if err := tree.InsertEntry(TreeEntry{Mode: FileModeRegular, Name: []byte("beta"), ID: Hash{}}); err == nil {
		t.Fatal("expected duplicate insert error")
	}

	var nilTree *Tree
	if err := nilTree.InsertEntry(TreeEntry{Mode: FileModeRegular, Name: []byte("x"), ID: Hash{}}); err == nil {
		t.Fatal("expected error for nil tree")
	}
}

func TestTreeRemoveEntry(t *testing.T) {
	tree := &Tree{
		Entries: []TreeEntry{
			{Mode: FileModeRegular, Name: []byte("alpha"), ID: Hash{}},
			{Mode: FileModeRegular, Name: []byte("beta"), ID: Hash{}},
			{Mode: FileModeRegular, Name: []byte("gamma"), ID: Hash{}},
		},
	}

	if err := tree.RemoveEntry([]byte("beta")); err != nil {
		t.Fatalf("RemoveEntry failed: %v", err)
	}
	if len(tree.Entries) != 2 {
		t.Fatalf("entries count: got %d, want 2", len(tree.Entries))
	}
	if string(tree.Entries[0].Name) != "alpha" || string(tree.Entries[1].Name) != "gamma" {
		t.Fatalf("remove order mismatch: got %q, %q", tree.Entries[0].Name, tree.Entries[1].Name)
	}

	if err := tree.RemoveEntry([]byte("beta")); err == nil {
		t.Fatal("expected ErrNotFound for missing entry")
	}

	var nilTree *Tree
	if err := nilTree.RemoveEntry([]byte("alpha")); err == nil {
		t.Fatal("expected error for nil tree")
	}
}

func TestTreeEntryNameCompare(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name         string
		entryName    []byte
		entryMode    FileMode
		searchName   []byte
		searchIsTree bool
		want         int
	}{
		{
			name:       "equal file names",
			entryName:  []byte("alpha"),
			entryMode:  FileModeRegular,
			searchName: []byte("alpha"),
			want:       0,
		},
		{
			name:         "equal tree names",
			entryName:    []byte("dir"),
			entryMode:    FileModeDir,
			searchName:   []byte("dir"),
			searchIsTree: true,
			want:         0,
		},
		{
			name:       "lexicographic less",
			entryName:  []byte("alpha"),
			entryMode:  FileModeRegular,
			searchName: []byte("beta"),
			want:       -1,
		},
		{
			name:       "lexicographic greater",
			entryName:  []byte("gamma"),
			entryMode:  FileModeRegular,
			searchName: []byte("beta"),
			want:       1,
		},
		{
			name:         "file sorts before same-name dir",
			entryName:    []byte("same"),
			entryMode:    FileModeRegular,
			searchName:   []byte("same"),
			searchIsTree: true,
			want:         -1,
		},
		{
			name:         "dir sorts after same-name file",
			entryName:    []byte("same"),
			entryMode:    FileModeDir,
			searchName:   []byte("same"),
			searchIsTree: false,
			want:         1,
		},
		{
			name:         "dir sorts before longer file",
			entryName:    []byte("a"),
			entryMode:    FileModeDir,
			searchName:   []byte("ab"),
			searchIsTree: false,
			want:         -1,
		},
		{
			name:       "file sorts before longer file",
			entryName:  []byte("a"),
			entryMode:  FileModeRegular,
			searchName: []byte("ab"),
			want:       -1,
		},
		{
			name:         "search tree compares after exact file name",
			entryName:    []byte("a"),
			entryMode:    FileModeRegular,
			searchName:   []byte("a"),
			searchIsTree: true,
			want:         -1,
		},
		{
			name:         "entry tree compares after exact search file",
			entryName:    []byte("a"),
			entryMode:    FileModeDir,
			searchName:   []byte("a"),
			searchIsTree: false,
			want:         1,
		},
		{
			name:         "slash impact mid-compare",
			entryName:    []byte("a"),
			entryMode:    FileModeDir,
			searchName:   []byte("a0"),
			searchIsTree: false,
			want:         -1,
		},
		{
			name:         "file sorts after same prefix dir",
			entryName:    []byte("a0"),
			entryMode:    FileModeRegular,
			searchName:   []byte("a"),
			searchIsTree: true,
			want:         1,
		},
	}

	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			got := TreeEntryNameCompare(tt.entryName, tt.entryMode, tt.searchName, tt.searchIsTree)
			if got < 0 {
				got = -1
			} else if got > 0 {
				got = 1
			}
			if got != tt.want {
				t.Fatalf("compare(%q,%v,%q,%v) = %d, want %d", tt.entryName, tt.entryMode, tt.searchName, tt.searchIsTree, got, tt.want)
			}
		})
	}
}