ref: df1f2fb3daa1acd25c88510f259d5535fb482126
dir: /ref/store/files/resolve_list_test.go/
package files_test
import (
"slices"
"testing"
"codeberg.org/lindenii/furgit/internal/testgit"
objectid "codeberg.org/lindenii/furgit/object/id"
"codeberg.org/lindenii/furgit/ref"
)
func TestFilesResolveAndListOverlay(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})
_, _, packedID := testRepo.MakeCommit(t, "packed base")
_, _, looseID := testRepo.MakeCommit(t, "loose override")
testRepo.UpdateRef(t, "refs/heads/main", packedID)
testRepo.UpdateRef(t, "refs/tags/v1", packedID)
testRepo.SymbolicRef(t, "HEAD", "refs/heads/main")
testRepo.PackRefs(t, "--all", "--prune")
testRepo.UpdateRef(t, "refs/heads/main", looseID)
testRepo.UpdateRef(t, "refs/heads/dev", looseID)
store := openFilesStore(t, testRepo, algo)
resolvedMain, err := store.Resolve("refs/heads/main")
if err != nil {
t.Fatalf("Resolve(main): %v", err)
}
mainDet, ok := resolvedMain.(ref.Detached)
if !ok {
t.Fatalf("Resolve(main) type = %T, want ref.Detached", resolvedMain)
}
if mainDet.ID != looseID {
t.Fatalf("Resolve(main) id = %s, want %s", mainDet.ID, looseID)
}
resolvedHead, err := store.Resolve("HEAD")
if err != nil {
t.Fatalf("Resolve(HEAD): %v", err)
}
headSym, ok := resolvedHead.(ref.Symbolic)
if !ok {
t.Fatalf("Resolve(HEAD) type = %T, want ref.Symbolic", resolvedHead)
}
if headSym.Target != "refs/heads/main" {
t.Fatalf("Resolve(HEAD) target = %q, want %q", headSym.Target, "refs/heads/main")
}
fullHead, err := store.ResolveToDetached("HEAD")
if err != nil {
t.Fatalf("ResolveToDetached(HEAD): %v", err)
}
if fullHead.ID != looseID {
t.Fatalf("ResolveToDetached(HEAD) = %s, want %s", fullHead.ID, looseID)
}
allRefs, err := store.List("")
if err != nil {
t.Fatalf("List(\"\"): %v", err)
}
names := make([]string, 0, len(allRefs))
for _, entry := range allRefs {
names = append(names, entry.Name())
}
slices.Sort(names)
want := []string{"HEAD", "refs/heads/dev", "refs/heads/main", "refs/tags/v1"}
if !slices.Equal(names, want) {
t.Fatalf("List(\"\") names = %v, want %v", names, want)
}
})
}
func TestFilesLooseRefParsingMatchesGit(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, RefFormat: "files"})
oid := testRepo.HashObject(t, "blob", []byte("payload\n"))
testRepo.WriteFileAll(t, ".git/refs/heads/no-lf", []byte(oid.String()), 0o755, 0o644)
testRepo.WriteFileAll(t, ".git/refs/heads/trailing-ws", []byte(oid.String()+" "), 0o755, 0o644)
testRepo.WriteFileAll(t, ".git/refs/heads/leading-ws", []byte(" "+oid.String()+"\n"), 0o755, 0o644)
testRepo.WriteFileAll(t, ".git/refs/heads/sym-trailing", []byte("ref: refs/heads/main "), 0o755, 0o644)
testRepo.WriteFileAll(t, ".git/refs/heads/sym-leading", []byte(" ref: refs/heads/main\n"), 0o755, 0o644)
store := openFilesStore(t, testRepo, algo)
got, err := store.ResolveToDetached("refs/heads/no-lf")
if err != nil {
t.Fatalf("ResolveToDetached(no-lf): %v", err)
}
if got.ID != oid {
t.Fatalf("ResolveToDetached(no-lf) = %s, want %s", got.ID, oid)
}
got, err = store.ResolveToDetached("refs/heads/trailing-ws")
if err != nil {
t.Fatalf("ResolveToDetached(trailing-ws): %v", err)
}
if got.ID != oid {
t.Fatalf("ResolveToDetached(trailing-ws) = %s, want %s", got.ID, oid)
}
_, err = store.Resolve("refs/heads/leading-ws")
if err == nil {
t.Fatal("Resolve(leading-ws) unexpectedly succeeded")
}
resolved, err := store.Resolve("refs/heads/sym-trailing")
if err != nil {
t.Fatalf("Resolve(sym-trailing): %v", err)
}
sym, ok := resolved.(ref.Symbolic)
if !ok {
t.Fatalf("Resolve(sym-trailing) type = %T, want ref.Symbolic", resolved)
}
if sym.Target != "refs/heads/main" {
t.Fatalf("Resolve(sym-trailing) target = %q, want %q", sym.Target, "refs/heads/main")
}
_, err = store.Resolve("refs/heads/sym-leading")
if err == nil {
t.Fatal("Resolve(sym-leading) unexpectedly succeeded")
}
})
}
func TestFilesRejectMalformedPackedRefs(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")
testRepo.UpdateRef(t, "refs/heads/main", commitID)
testRepo.PackRefs(t, "--all", "--prune")
hex := commitID.String()
cases := []struct {
name string
content string
}{
{
name: "unterminated line",
content: "# pack-refs with: peeled fully-peeled sorted\n" + hex + " refs/heads/main",
},
{
name: "junk line",
content: "# pack-refs with: peeled fully-peeled sorted\nbogus content\n",
},
{
name: "short oid",
content: "# pack-refs with: peeled fully-peeled sorted\n" + hex[:7] + " refs/heads/main\n",
},
{
name: "trailing garbage after oid",
content: "# pack-refs with: peeled fully-peeled sorted\n" + hex + "xrefs/heads/main\n",
},
{
name: "malformed peeled line",
content: "# pack-refs with: peeled fully-peeled sorted\n" + hex + " refs/tags/v1\n^" + hex + " garbage\n",
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
testRepo.WriteFile(t, "packed-refs", []byte(tc.content), 0o644)
store := openFilesStore(t, testRepo, algo)
_, err := store.List("")
if err == nil {
t.Fatal("List unexpectedly succeeded")
}
})
}
})
}
func TestFilesPackedRefsReadSemanticsMatchGit(t *testing.T) {
t.Parallel()
testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
t.Run("stale packed entry is still readable", func(t *testing.T) {
t.Parallel()
testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, RefFormat: "files"})
testRepo.Run(t, "commit", "--allow-empty", "-m", "one")
oneID, err := objectid.ParseHex(algo, testRepo.Run(t, "rev-parse", "HEAD"))
if err != nil {
t.Fatalf("ParseHex(one): %v", err)
}
testRepo.Run(t, "tag", "-a", "v1.0", "-m", "v1.0", "HEAD")
testRepo.PackRefs(t, "--all", "--prune")
testRepo.Run(t, "checkout", "--orphan", "another")
testRepo.Run(t, "commit", "--allow-empty", "-m", "two")
testRepo.Run(t, "checkout", "-B", "main")
testRepo.Run(t, "branch", "-D", "another")
testRepo.Run(t, "reflog", "expire", "--expire=now", "--all")
testRepo.Run(t, "prune")
store := openFilesStore(t, testRepo, algo)
got, err := store.ResolveToDetached("refs/heads/main")
if err != nil {
t.Fatalf("ResolveToDetached(main): %v", err)
}
if got.ID == oneID {
t.Fatalf("ResolveToDetached(main) unexpectedly returned stale packed id %s", oneID)
}
tagRef, err := store.Resolve("refs/tags/v1.0")
if err != nil {
t.Fatalf("Resolve(tag): %v", err)
}
tagDet, ok := tagRef.(ref.Detached)
if !ok {
t.Fatalf("Resolve(tag) type = %T, want ref.Detached", tagRef)
}
if tagDet.ID.Algorithm().Size() == 0 {
t.Fatal("Resolve(tag) returned zero object id")
}
})
t.Run("exact unicode packed ref remains enumerable", func(t *testing.T) {
t.Parallel()
testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, RefFormat: "files"})
_, _, commitID := testRepo.MakeCommit(t, "unicode")
testRepo.UpdateRef(t, "refs/heads/\ue43f", commitID)
testRepo.UpdateRef(t, "refs/heads/z", commitID)
testRepo.PackRefs(t, "--all", "--prune")
store := openFilesStore(t, testRepo, algo)
listed, err := store.List("refs/heads/z")
if err != nil {
t.Fatalf("List(refs/heads/z): %v", err)
}
if len(listed) != 1 {
t.Fatalf("List(refs/heads/z) len = %d, want 1", len(listed))
}
if listed[0].Name() != "refs/heads/z" {
t.Fatalf("List(refs/heads/z)[0] = %q, want %q", listed[0].Name(), "refs/heads/z")
}
})
})
}