cmd/gitbayd/hook_test.go

  1package main
  2
  3import (
  4	"fmt"
  5	"os"
  6	"os/exec"
  7	"strings"
  8	"testing"
  9
 10	"gitbay.org/gitbay/internal/hookd"
 11	"gitbay.org/gitbay/internal/policy"
 12)
 13
 14// fastImportRepo builds a repository with n commits on main in one
 15// process. A loop of `git commit` would be n forks, which is the cost this
 16// test exists to rule out of the code under test.
 17func fastImportRepo(t *testing.T, n int) (string, string) {
 18	t.Helper()
 19	dir := t.TempDir()
 20	run := func(args ...string) {
 21		t.Helper()
 22		cmd := exec.Command("git", args...)
 23		cmd.Dir = dir
 24		if out, err := cmd.CombinedOutput(); err != nil {
 25			t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, out)
 26		}
 27	}
 28	run("init", "-q", "--initial-branch=main", ".")
 29
 30	var b strings.Builder
 31	for i := 1; i <= n; i++ {
 32		fmt.Fprintf(&b, "commit refs/heads/main\n")
 33		fmt.Fprintf(&b, "mark :%d\n", i)
 34		fmt.Fprintf(&b, "author A U Thor <a@example.test> %d +0000\n", 1600000000+i)
 35		fmt.Fprintf(&b, "committer A U Thor <a@example.test> %d +0000\n", 1600000000+i)
 36		msg := fmt.Sprintf("commit %d", i)
 37		fmt.Fprintf(&b, "data %d\n%s\n", len(msg), msg)
 38		if i > 1 {
 39			fmt.Fprintf(&b, "from :%d\n", i-1)
 40		}
 41		fmt.Fprintf(&b, "M 644 inline f.txt\ndata %d\n%d\n", len(fmt.Sprint(i))+1, i)
 42		fmt.Fprintf(&b, "\n")
 43	}
 44	cmd := exec.Command("git", "fast-import", "--quiet")
 45	cmd.Dir = dir
 46	cmd.Stdin = strings.NewReader(b.String())
 47	if out, err := cmd.CombinedOutput(); err != nil {
 48		t.Fatalf("fast-import: %v\n%s", err, out)
 49	}
 50	// pre-receive runs before the ref moves, so the incoming objects are
 51	// present but reachable from nothing — which is what makes
 52	// `rev-list --not --all` list them. Dropping the ref reproduces that;
 53	// the objects stay until a gc that never runs here.
 54	head := gitOut(t, dir, "rev-parse", "main")
 55	run("update-ref", "-d", "refs/heads/main")
 56	return dir, head
 57}
 58
 59// streamIncomingCommits runs in the hook process, whose working directory
 60// is the repository, so the test chdirs the same way git would.
 61func inRepo(t *testing.T, dir string, f func()) {
 62	t.Helper()
 63	prev, err := os.Getwd()
 64	if err != nil {
 65		t.Fatal(err)
 66	}
 67	if err := os.Chdir(dir); err != nil {
 68		t.Fatal(err)
 69	}
 70	defer os.Chdir(prev)
 71	f()
 72}
 73
 74// A push large enough that its object names do not fit a pipe buffer:
 75// writing them all before reading git's output deadlocks, which is why
 76// stdin is fed from its own goroutine. 4000 names is roughly 160 KiB,
 77// well past the usual 64 KiB pipe.
 78func TestStreamIncomingCommitsLargePush(t *testing.T) {
 79	const n = 4000
 80	dir, head := fastImportRepo(t, n)
 81
 82	// No ref exists, so every commit is incoming — the shape of a
 83	// first push of an existing history.
 84	updates := []policy.RefUpdate{{Old: strings.Repeat("0", 40), New: head, Ref: "refs/heads/main"}}
 85
 86	var got []hookd.RawCommit
 87	inRepo(t, dir, func() {
 88		if err := streamIncomingCommits(updates, func(rc hookd.RawCommit) error {
 89			got = append(got, rc)
 90			return nil
 91		}); err != nil {
 92			t.Fatalf("streaming: %v", err)
 93		}
 94	})
 95	if len(got) != n {
 96		t.Fatalf("streamed %d commits, want %d", len(got), n)
 97	}
 98	seen := map[string]bool{}
 99	for _, rc := range got {
100		if seen[rc.SHA] {
101			t.Fatalf("%s streamed twice", rc.SHA)
102		}
103		seen[rc.SHA] = true
104		// The raw object is what signature verification parses; a record
105		// misread by a byte would still look plausible here without this.
106		if !strings.HasPrefix(string(rc.Raw), "tree ") {
107			t.Fatalf("%s does not look like a raw commit: %.60q", rc.SHA, rc.Raw)
108		}
109		if !strings.Contains(string(rc.Raw), "A U Thor <a@example.test>") {
110			t.Fatalf("%s raw object is truncated: %.200q", rc.SHA, rc.Raw)
111		}
112	}
113	if !seen[head] {
114		t.Fatal("the pushed tip was not among the streamed commits")
115	}
116}
117
118// A ref that already exists contributes nothing, and a delete contributes
119// nothing: neither introduces an object to verify.
120func TestStreamIncomingCommitsNothingToDo(t *testing.T) {
121	dir, head := fastImportRepo(t, 3)
122	zero := strings.Repeat("0", 40)
123
124	inRepo(t, dir, func() {
125		n := 0
126		err := streamIncomingCommits([]policy.RefUpdate{
127			{Old: head, New: zero, Ref: "refs/heads/main", IsDelete: true},
128		}, func(hookd.RawCommit) error { n++; return nil })
129		if err != nil || n != 0 {
130			t.Fatalf("delete streamed %d commits (%v)", n, err)
131		}
132	})
133
134	// With the ref restored the tip is reachable, so nothing is incoming:
135	// a push of what the repository already has verifies nothing.
136	cmd := exec.Command("git", "update-ref", "refs/heads/main", head)
137	cmd.Dir = dir
138	if out, err := cmd.CombinedOutput(); err != nil {
139		t.Fatalf("update-ref: %v\n%s", err, out)
140	}
141	inRepo(t, dir, func() {
142		n := 0
143		err := streamIncomingCommits([]policy.RefUpdate{
144			{Old: head, New: head, Ref: "refs/heads/main"},
145		}, func(hookd.RawCommit) error { n++; return nil })
146		if err != nil || n != 0 {
147			t.Fatalf("already-present tip streamed %d commits (%v)", n, err)
148		}
149	})
150}
151
152// An error from the callback — the socket going away mid-push — stops the
153// walk instead of reading the rest of the history into nothing.
154func TestStreamIncomingCommitsCallbackError(t *testing.T) {
155	// Large enough that git is still writing when the callback gives up:
156	// without killing it, git blocks on a full pipe and Wait blocks on
157	// git, and this test hangs rather than fails.
158	dir, head := fastImportRepo(t, 4000)
159	inRepo(t, dir, func() {
160		n := 0
161		err := streamIncomingCommits(
162			[]policy.RefUpdate{{Old: strings.Repeat("0", 40), New: head, Ref: "refs/heads/main"}},
163			func(hookd.RawCommit) error {
164				n++
165				if n == 5 {
166					return fmt.Errorf("socket closed")
167				}
168				return nil
169			})
170		if err == nil {
171			t.Fatal("callback error did not stop the walk")
172		}
173		if n != 5 {
174			t.Fatalf("kept streaming after the error: %d commits", n)
175		}
176	})
177}
178
179func gitOut(t *testing.T, dir string, args ...string) string {
180	t.Helper()
181	cmd := exec.Command("git", args...)
182	cmd.Dir = dir
183	out, err := cmd.Output()
184	if err != nil {
185		t.Fatalf("git %s: %v", strings.Join(args, " "), err)
186	}
187	return strings.TrimSpace(string(out))
188}