package gitrepo import ( "testing" "gitweb/internal/store" ) // TestResolveRefAmbiguity exercises the slash-in-ref disambiguation against a // real repo that has a branch "feature/x" and a tag "v1.0.0". func TestResolveRefAmbiguity(t *testing.T) { root := t.TempDir() repoPath := makeBareRepo(t, root, "u@d.com", "demo.git") st := store.NewLocalStore(root) c := newTestCache(t, st, CacheOptions{}) repo, release, err := c.Get(repoPath) if err != nil { t.Fatalf("Get: %v", err) } defer release() tests := []struct { name string in string wantRef string wantSubPath string }{ {"empty -> HEAD", "", "HEAD", ""}, {"branch only", "main", "main", ""}, {"branch + path", "main/main.go", "main", "main.go"}, {"slashed branch only", "feature/x", "feature/x", ""}, {"slashed branch + path", "feature/x/main.go", "feature/x", "main.go"}, {"tag only", "v1.0.0", "v1.0.0", ""}, {"tag + path", "v1.0.0/README.md", "v1.0.0", "README.md"}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { h, ref, sub, err := ResolveRef(repo, tt.in) if err != nil { t.Fatalf("ResolveRef(%q): %v", tt.in, err) } if ref != tt.wantRef || sub != tt.wantSubPath { t.Fatalf("ResolveRef(%q) = ref %q sub %q, want ref %q sub %q", tt.in, ref, sub, tt.wantRef, tt.wantSubPath) } if h.IsZero() { t.Fatalf("ResolveRef(%q): zero hash", tt.in) } if _, err := repo.CommitObject(h); err != nil { t.Fatalf("ResolveRef(%q): hash %s is not a commit: %v", tt.in, h, err) } }) } // A full commit hash resolves as its own ref. head, _ := repo.Head() full := head.Hash().String() h, ref, sub, err := ResolveRef(repo, full+"/main.go") if err != nil { t.Fatalf("ResolveRef(hash): %v", err) } if ref != full || sub != "main.go" || h != head.Hash() { t.Fatalf("hash ref: got ref %q sub %q hash %s", ref, sub, h) } // An unknown ref errors. if _, _, _, err := ResolveRef(repo, "nope/x.go"); err != ErrRefNotFound { t.Fatalf("want ErrRefNotFound, got %v", err) } }