*: Lint

1 files changed, 28 insertions, 3 deletions

diff --git a/refstore/reftable/reftable_test.go b/refstore/reftable/reftable_test.go
index 2a6e0738..26aa7584 100644
--- a/refstore/reftable/reftable_test.go
+++ b/refstore/reftable/reftable_test.go
@@ -17,6 +17,7 @@ import (
 // newBareReftableRepo creates a bare repository that uses reftable ref storage.
 func newBareReftableRepo(tb testing.TB, algo objectid.Algorithm) *testgit.TestRepo {
 	tb.Helper()
+
 	return testgit.NewRepo(tb, testgit.RepoOptions{
 		ObjectFormat: algo,
 		Bare:         true,
@@ -27,15 +28,19 @@ func newBareReftableRepo(tb testing.TB, algo objectid.Algorithm) *testgit.TestRe
 // openStore opens a reftable store against repoDir/reftable.
 func openStore(tb testing.TB, repoDir string, algo objectid.Algorithm) *reftable.Store {
 	tb.Helper()
+
 	root, err := os.OpenRoot(filepath.Join(repoDir, "reftable"))
 	if err != nil {
 		tb.Fatalf("OpenRoot(reftable): %v", err)
 	}
+
 	tb.Cleanup(func() { _ = root.Close() })
+
 	store, err := reftable.New(root, algo)
 	if err != nil {
 		tb.Fatalf("reftable.New: %v", err)
 	}
+
 	return store
 }
 
@@ -48,14 +53,17 @@ func TestResolveAndResolveFully(t *testing.T) {
 		repo.SymbolicRef(t, "HEAD", "refs/heads/main")
 
 		store := openStore(t, repo.Dir(), algo)
+
 		head, err := store.Resolve("HEAD")
 		if err != nil {
 			t.Fatalf("Resolve(HEAD): %v", err)
 		}
+
 		sym, ok := head.(ref.Symbolic)
 		if !ok {
 			t.Fatalf("Resolve(HEAD) type = %T, want ref.Symbolic", head)
 		}
+
 		if sym.Target != "refs/heads/main" {
 			t.Fatalf("Resolve(HEAD) target = %q, want refs/heads/main", sym.Target)
 		}
@@ -64,11 +72,13 @@ func TestResolveAndResolveFully(t *testing.T) {
 		if err != nil {
 			t.Fatalf("ResolveFully(HEAD): %v", err)
 		}
+
 		if main.ID != id {
 			t.Fatalf("ResolveFully(HEAD) id = %s, want %s", main.ID, id)
 		}
 
-		if _, err := store.Resolve("refs/heads/missing"); !errors.Is(err, refstore.ErrReferenceNotFound) {
+		_, err = store.Resolve("refs/heads/missing")
+		if !errors.Is(err, refstore.ErrReferenceNotFound) {
 			t.Fatalf("Resolve(missing) error = %v", err)
 		}
 	})
@@ -82,7 +92,9 @@ func TestResolveFullyCycle(t *testing.T) {
 		repo.SymbolicRef(t, "refs/heads/b", "refs/heads/a")
 
 		store := openStore(t, repo.Dir(), algo)
-		if _, err := store.ResolveFully("refs/heads/a"); err == nil {
+
+		_, err := store.ResolveFully("refs/heads/a")
+		if err == nil {
 			t.Fatalf("ResolveFully(cycle) expected error")
 		}
 	})
@@ -99,14 +111,17 @@ func TestListAndShorten(t *testing.T) {
 		repo.UpdateRef(t, "refs/remotes/origin/main", id)
 
 		store := openStore(t, repo.Dir(), algo)
+
 		all, err := store.List("")
 		if err != nil {
 			t.Fatalf("List(all): %v", err)
 		}
+
 		names := make([]string, 0, len(all))
 		for _, entry := range all {
 			names = append(names, entry.Name())
 		}
+
 		want := []string{"HEAD", "refs/heads/feature", "refs/heads/main", "refs/remotes/origin/main", "refs/tags/main"}
 		if !slices.Equal(names, want) {
 			t.Fatalf("List(all) = %v, want %v", names, want)
@@ -116,10 +131,12 @@ func TestListAndShorten(t *testing.T) {
 		if err != nil {
 			t.Fatalf("List(heads): %v", err)
 		}
+
 		headNames := make([]string, 0, len(heads))
 		for _, entry := range heads {
 			headNames = append(headNames, entry.Name())
 		}
+
 		wantHeads := []string{"refs/heads/feature", "refs/heads/main"}
 		if !slices.Equal(headNames, wantHeads) {
 			t.Fatalf("List(heads) = %v, want %v", headNames, wantHeads)
@@ -129,6 +146,7 @@ func TestListAndShorten(t *testing.T) {
 		if err != nil {
 			t.Fatalf("Shorten(remote): %v", err)
 		}
+
 		if short != "origin/main" {
 			t.Fatalf("Shorten(remote) = %q, want origin/main", short)
 		}
@@ -146,7 +164,9 @@ func TestTombstoneNewestWins(t *testing.T) {
 		repo.DeleteRef(t, "refs/heads/main")
 
 		store := openStore(t, repo.Dir(), algo)
-		if _, err := store.Resolve("refs/heads/main"); !errors.Is(err, refstore.ErrReferenceNotFound) {
+
+		_, err := store.Resolve("refs/heads/main")
+		if !errors.Is(err, refstore.ErrReferenceNotFound) {
 			t.Fatalf("Resolve(main) after delete error = %v", err)
 		}
 	})
@@ -160,20 +180,25 @@ func TestAnnotatedTagPeeled(t *testing.T) {
 		tagID := repo.TagAnnotated(t, "v1.0.0", commitID, "annotated")
 
 		store := openStore(t, repo.Dir(), algo)
+
 		resolved, err := store.Resolve("refs/tags/v1.0.0")
 		if err != nil {
 			t.Fatalf("Resolve(tag): %v", err)
 		}
+
 		detached, ok := resolved.(ref.Detached)
 		if !ok {
 			t.Fatalf("Resolve(tag) type = %T, want ref.Detached", resolved)
 		}
+
 		if detached.ID != tagID {
 			t.Fatalf("Resolve(tag) id = %s, want %s", detached.ID, tagID)
 		}
+
 		if detached.Peeled == nil {
 			t.Fatalf("Resolve(tag) peeled = nil")
 		}
+
 		if *detached.Peeled != commitID {
 			t.Fatalf("Resolve(tag) peeled = %s, want %s", *detached.Peeled, commitID)
 		}