1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

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