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)
}

}