aboutsummaryrefslogtreecommitdiff
path: root/ref/store/files/packed_delete_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'ref/store/files/packed_delete_test.go')
-rw-r--r--ref/store/files/packed_delete_test.go292
1 files changed, 292 insertions, 0 deletions
diff --git a/ref/store/files/packed_delete_test.go b/ref/store/files/packed_delete_test.go
new file mode 100644
index 00000000..3d14b71a
--- /dev/null
+++ b/ref/store/files/packed_delete_test.go
@@ -0,0 +1,292 @@
+package files_test
+
+import (
+ "errors"
+ "os"
+ "slices"
+ "sync"
+ "testing"
+ "time"
+
+ "codeberg.org/lindenii/furgit/internal/testgit"
+ objectid "codeberg.org/lindenii/furgit/object/id"
+ "codeberg.org/lindenii/furgit/ref/store"
+)
+
+func TestFilesTransactionPackedDeleteFailureLeavesRefsUnchanged(t *testing.T) {
+ t.Parallel()
+
+ testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
+ t.Run("packed-refs.lock held", func(t *testing.T) {
+ t.Parallel()
+
+ testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true, RefFormat: "files"})
+ _, _, packedID := testRepo.MakeCommit(t, "packed")
+ _, _, looseID := testRepo.MakeCommit(t, "loose")
+ prefix := "refs/locked-packed-refs"
+
+ testRepo.UpdateRef(t, prefix+"/foo", packedID)
+ testRepo.PackRefs(t, "--all", "--prune")
+ testRepo.UpdateRef(t, prefix+"/foo", looseID)
+ unchanged := forEachRefLines(testRepo.Run(t, "for-each-ref", "--format=%(objectname) %(refname)", prefix))
+ testRepo.WriteFile(t, "packed-refs.lock", []byte{}, 0o644)
+
+ store := openFilesStore(t, testRepo, algo)
+
+ tx, err := store.BeginTransaction()
+ if err != nil {
+ t.Fatalf("BeginTransaction(lock held): %v", err)
+ }
+
+ err = tx.Delete(prefix+"/foo", looseID)
+ if err != nil {
+ t.Fatalf("Delete(lock held) queue: %v", err)
+ }
+
+ err = tx.Commit()
+ if err == nil {
+ t.Fatal("Commit(lock held) unexpectedly succeeded")
+ }
+
+ actual := forEachRefLines(testRepo.Run(t, "for-each-ref", "--format=%(objectname) %(refname)", prefix))
+ if !slices.Equal(actual, unchanged) {
+ t.Fatalf("ShowRef after failed delete = %v, want %v", actual, unchanged)
+ }
+
+ got, err := store.ResolveToDetached(prefix + "/foo")
+ if err != nil {
+ t.Fatalf("ResolveToDetached(lock held): %v", err)
+ }
+
+ if got.ID != looseID {
+ t.Fatalf("ResolveToDetached(lock held) = %s, want %s", got.ID, looseID)
+ }
+
+ gitRoot := testRepo.OpenGitRoot(t)
+
+ _, statErr := gitRoot.Stat(prefix + "/foo.lock")
+ if !errors.Is(statErr, os.ErrNotExist) {
+ t.Fatalf("unexpected leftover loose lock: %v", statErr)
+ }
+ })
+
+ t.Run("packed-refs.new exists", func(t *testing.T) {
+ t.Parallel()
+
+ testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true, RefFormat: "files"})
+ _, _, packedID := testRepo.MakeCommit(t, "packed")
+ _, _, looseID := testRepo.MakeCommit(t, "loose")
+ prefix := "refs/failed-packed-refs"
+
+ testRepo.UpdateRef(t, prefix+"/foo", packedID)
+ testRepo.PackRefs(t, "--all", "--prune")
+ testRepo.UpdateRef(t, prefix+"/foo", looseID)
+ unchanged := forEachRefLines(testRepo.Run(t, "for-each-ref", "--format=%(objectname) %(refname)", prefix))
+ testRepo.WriteFile(t, "packed-refs.new", []byte{}, 0o644)
+
+ store := openFilesStore(t, testRepo, algo)
+
+ tx, err := store.BeginTransaction()
+ if err != nil {
+ t.Fatalf("BeginTransaction(new exists): %v", err)
+ }
+
+ err = tx.Delete(prefix+"/foo", looseID)
+ if err != nil {
+ t.Fatalf("Delete(new exists) queue: %v", err)
+ }
+
+ err = tx.Commit()
+ if err == nil {
+ t.Fatal("Commit(new exists) unexpectedly succeeded")
+ }
+
+ actual := forEachRefLines(testRepo.Run(t, "for-each-ref", "--format=%(objectname) %(refname)", prefix))
+ if !slices.Equal(actual, unchanged) {
+ t.Fatalf("ShowRef after failed delete = %v, want %v", actual, unchanged)
+ }
+
+ got, err := store.ResolveToDetached(prefix + "/foo")
+ if err != nil {
+ t.Fatalf("ResolveToDetached(new exists): %v", err)
+ }
+
+ if got.ID != looseID {
+ t.Fatalf("ResolveToDetached(new exists) = %s, want %s", got.ID, looseID)
+ }
+ })
+ })
+}
+
+func TestFilesPackedRefDeleteDoesNotCreateDirectories(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, RefFormat: "files"})
+ _, _, commitID := testRepo.MakeCommit(t, "packed-only")
+ name := "refs/heads/d1/d2/r1"
+
+ testRepo.UpdateRef(t, name, commitID)
+ testRepo.PackRefs(t, "--all", "--prune")
+
+ gitRoot := testRepo.OpenGitRoot(t)
+
+ _, err := gitRoot.Stat("refs/heads/d1/d2")
+ if !errors.Is(err, os.ErrNotExist) {
+ t.Fatalf("refs/heads/d1/d2 unexpectedly exists before delete: %v", err)
+ }
+
+ store := openFilesStore(t, testRepo, algo)
+
+ tx, err := store.BeginTransaction()
+ if err != nil {
+ t.Fatalf("BeginTransaction: %v", err)
+ }
+
+ err = tx.Delete(name, commitID)
+ if err != nil {
+ t.Fatalf("Delete queue: %v", err)
+ }
+
+ err = tx.Commit()
+ if err != nil {
+ t.Fatalf("Commit: %v", err)
+ }
+
+ _, err = gitRoot.Stat("refs/heads/d1/d2")
+ if !errors.Is(err, os.ErrNotExist) {
+ t.Fatalf("refs/heads/d1/d2 unexpectedly exists after delete: %v", err)
+ }
+
+ _, err = gitRoot.Stat("refs/heads/d1")
+ if !errors.Is(err, os.ErrNotExist) {
+ t.Fatalf("refs/heads/d1 unexpectedly exists after delete: %v", err)
+ }
+ })
+}
+
+func TestFilesPackedRefIgnoresEmptyDirectories(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, RefFormat: "files"})
+ _, _, commitID := testRepo.MakeCommit(t, "packed-visible")
+ prefix := "refs/e-for-each-ref"
+ name := prefix + "/foo"
+
+ testRepo.UpdateRef(t, name, commitID)
+ expected := forEachRefLines(testRepo.Run(t, "for-each-ref", "--format=%(objectname) %(refname)", prefix))
+ testRepo.PackRefs(t, "--all", "--prune")
+ testRepo.WriteFileAll(t, prefix+"/foo/bar/baz/.keep", []byte{}, 0o755, 0o644)
+ testRepo.Remove(t, prefix+"/foo/bar/baz/.keep")
+
+ store := openFilesStore(t, testRepo, algo)
+
+ got, err := store.ResolveToDetached(name)
+ if err != nil {
+ t.Fatalf("ResolveToDetached: %v", err)
+ }
+
+ if got.ID != commitID {
+ t.Fatalf("ResolveToDetached = %s, want %s", got.ID, commitID)
+ }
+
+ actual := make([]string, 0)
+
+ listed, err := store.List(prefix + "/*")
+ if err != nil {
+ t.Fatalf("List: %v", err)
+ }
+
+ for _, entry := range listed {
+ actual = append(actual, entry.Name())
+ }
+
+ fullActual := make([]string, 0, len(actual))
+ for _, name := range actual {
+ refValue, resolveErr := store.ResolveToDetached(name)
+ if resolveErr != nil {
+ t.Fatalf("ResolveToDetached(%q): %v", name, resolveErr)
+ }
+
+ fullActual = append(fullActual, refValue.ID.String()+" "+name)
+ }
+
+ slices.Sort(fullActual)
+
+ if !slices.Equal(fullActual, expected) {
+ t.Fatalf("for-each-ref view = %v, want %v", fullActual, expected)
+ }
+ })
+}
+
+func TestFilesDeleteWaitsForPackedRefsLockWithoutIntermediateState(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, RefFormat: "files"})
+ _, _, packedID := testRepo.MakeCommit(t, "packed")
+ _, _, looseID := testRepo.MakeCommit(t, "loose")
+ prefix := "refs/slow-transaction"
+
+ testRepo.UpdateRef(t, prefix+"/foo", packedID)
+ testRepo.PackRefs(t, "--all", "--prune")
+ testRepo.UpdateRef(t, prefix+"/foo", looseID)
+ testRepo.WriteFile(t, "packed-refs.lock", []byte{}, 0o644)
+
+ store := openFilesStore(t, testRepo, algo)
+
+ tx, err := store.BeginTransaction()
+ if err != nil {
+ t.Fatalf("BeginTransaction: %v", err)
+ }
+
+ err = tx.Delete(prefix+"/foo", looseID)
+ if err != nil {
+ t.Fatalf("Delete queue: %v", err)
+ }
+
+ done := make(chan error, 1)
+
+ var wg sync.WaitGroup
+
+ wg.Go(func() {
+ done <- tx.Commit()
+ })
+
+ time.Sleep(75 * time.Millisecond)
+
+ select {
+ case err := <-done:
+ t.Fatalf("Commit finished too early: %v", err)
+ default:
+ }
+
+ got, err := store.ResolveToDetached(prefix + "/foo")
+ if err != nil {
+ t.Fatalf("ResolveToDetached while lock held: %v", err)
+ }
+
+ if got.ID != looseID {
+ t.Fatalf("ResolveToDetached while lock held = %s, want %s", got.ID, looseID)
+ }
+
+ testRepo.Remove(t, "packed-refs.lock")
+
+ select {
+ case err := <-done:
+ if err != nil {
+ t.Fatalf("Commit after lock release: %v", err)
+ }
+ case <-time.After(2 * time.Second):
+ t.Fatal("Commit did not finish after lock release")
+ }
+
+ wg.Wait()
+
+ _, err = store.Resolve(prefix + "/foo")
+ if !errors.Is(err, refstore.ErrReferenceNotFound) {
+ t.Fatalf("Resolve after delete error = %v, want ErrReferenceNotFound", err)
+ }
+ })
+}
generated by cgit v1.3.1-10-gc9f91 (git 2.54.0) at 2026-05-25 13:54:17 +0000