*: refstore -> ref/store

1 files changed, 178 insertions, 0 deletions

diff --git a/ref/store/files/transaction_update_test.go b/ref/store/files/transaction_update_test.go
new file mode 100644
index 00000000..62879b32
--- /dev/null
+++ b/ref/store/files/transaction_update_test.go
@@ -0,0 +1,178 @@
+package files_test
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"codeberg.org/lindenii/furgit/internal/testgit"
+	objectid "codeberg.org/lindenii/furgit/object/id"
+	"codeberg.org/lindenii/furgit/ref"
+	"codeberg.org/lindenii/furgit/ref/store"
+)
+
+func TestFilesTransactionPackedUpdateCreatesLooseOverride(t *testing.T) {
+	t.Parallel()
+
+	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
+		testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})
+		_, _, oldID := testRepo.MakeCommit(t, "old packed")
+		_, _, newID := testRepo.MakeCommit(t, "new loose")
+		testRepo.UpdateRef(t, "refs/heads/main", oldID)
+		testRepo.PackRefs(t, "--all", "--prune")
+
+		store := openFilesStore(t, testRepo, algo)
+
+		tx, err := store.BeginTransaction()
+		if err != nil {
+			t.Fatalf("BeginTransaction: %v", err)
+		}
+
+		err = tx.Update("refs/heads/main", newID, oldID)
+		if err != nil {
+			t.Fatalf("Update queue: %v", err)
+		}
+
+		err = tx.Commit()
+		if err != nil {
+			t.Fatalf("Commit: %v", err)
+		}
+
+		got, err := store.ResolveToDetached("refs/heads/main")
+		if err != nil {
+			t.Fatalf("ResolveToDetached(main): %v", err)
+		}
+
+		if got.ID != newID {
+			t.Fatalf("ResolveToDetached(main) = %s, want %s", got.ID, newID)
+		}
+
+		packedRefs := string(testRepo.ReadFile(t, "packed-refs"))
+		if !strings.Contains(packedRefs, oldID.String()+" refs/heads/main\n") {
+			t.Fatalf("packed-refs lost old packed main entry:\n%s", packedRefs)
+		}
+
+		looseMain := string(testRepo.ReadFile(t, "refs/heads/main"))
+		if strings.TrimSpace(looseMain) != newID.String() {
+			t.Fatalf("loose refs/heads/main = %q, want %q", strings.TrimSpace(looseMain), newID.String())
+		}
+	})
+}
+
+func TestFilesTransactionDeletesPackedAndLooseRefs(t *testing.T) {
+	t.Parallel()
+
+	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
+		testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})
+		_, _, packedOnlyID := testRepo.MakeCommit(t, "packed only")
+		_, _, bothID := testRepo.MakeCommit(t, "both")
+		testRepo.UpdateRef(t, "refs/heads/packed", packedOnlyID)
+		testRepo.UpdateRef(t, "refs/heads/both", bothID)
+		testRepo.PackRefs(t, "--all", "--prune")
+		testRepo.UpdateRef(t, "refs/heads/both", bothID)
+
+		store := openFilesStore(t, testRepo, algo)
+
+		tx, err := store.BeginTransaction()
+		if err != nil {
+			t.Fatalf("BeginTransaction: %v", err)
+		}
+
+		err = tx.Delete("refs/heads/packed", packedOnlyID)
+		if err != nil {
+			t.Fatalf("Delete(packed): %v", err)
+		}
+
+		err = tx.Delete("refs/heads/both", bothID)
+		if err != nil {
+			t.Fatalf("Delete(both): %v", err)
+		}
+
+		err = tx.Commit()
+		if err != nil {
+			t.Fatalf("Commit(delete): %v", err)
+		}
+
+		_, err = store.Resolve("refs/heads/packed")
+		if !errors.Is(err, refstore.ErrReferenceNotFound) {
+			t.Fatalf("Resolve(packed after delete) error = %v", err)
+		}
+
+		_, err = store.Resolve("refs/heads/both")
+		if !errors.Is(err, refstore.ErrReferenceNotFound) {
+			t.Fatalf("Resolve(both after delete) error = %v", err)
+		}
+
+		packedRefs := string(testRepo.ReadFile(t, "packed-refs"))
+		if strings.Contains(packedRefs, "refs/heads/packed\n") || strings.Contains(packedRefs, "refs/heads/both\n") {
+			t.Fatalf("packed-refs still contains deleted refs:\n%s", packedRefs)
+		}
+	})
+}
+
+func TestFilesTransactionDerefAndDirectSymbolic(t *testing.T) {
+	t.Parallel()
+
+	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
+		testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})
+		_, _, firstID := testRepo.MakeCommit(t, "first")
+		_, _, secondID := testRepo.MakeCommit(t, "second")
+		testRepo.UpdateRef(t, "refs/heads/main", firstID)
+		testRepo.SymbolicRef(t, "HEAD", "refs/heads/main")
+
+		store := openFilesStore(t, testRepo, algo)
+
+		tx, err := store.BeginTransaction()
+		if err != nil {
+			t.Fatalf("BeginTransaction(update): %v", err)
+		}
+
+		err = tx.Update("HEAD", secondID, firstID)
+		if err != nil {
+			t.Fatalf("Update(HEAD): %v", err)
+		}
+
+		err = tx.Commit()
+		if err != nil {
+			t.Fatalf("Commit(update HEAD): %v", err)
+		}
+
+		mainRef, err := store.ResolveToDetached("refs/heads/main")
+		if err != nil {
+			t.Fatalf("ResolveToDetached(main): %v", err)
+		}
+
+		if mainRef.ID != secondID {
+			t.Fatalf("main after Update(HEAD) = %s, want %s", mainRef.ID, secondID)
+		}
+
+		tx, err = store.BeginTransaction()
+		if err != nil {
+			t.Fatalf("BeginTransaction(update symbolic): %v", err)
+		}
+
+		err = tx.UpdateSymbolic("HEAD", "refs/heads/next", "refs/heads/main")
+		if err != nil {
+			t.Fatalf("UpdateSymbolic(HEAD): %v", err)
+		}
+
+		err = tx.Commit()
+		if err != nil {
+			t.Fatalf("Commit(update symbolic HEAD): %v", err)
+		}
+
+		headRef, err := store.Resolve("HEAD")
+		if err != nil {
+			t.Fatalf("Resolve(HEAD): %v", err)
+		}
+
+		headSym, ok := headRef.(ref.Symbolic)
+		if !ok {
+			t.Fatalf("Resolve(HEAD) type = %T, want ref.Symbolic", headRef)
+		}
+
+		if headSym.Target != "refs/heads/next" {
+			t.Fatalf("HEAD target = %q, want %q", headSym.Target, "refs/heads/next")
+		}
+	})
+}