internal/control/mr_test.go

  1package control
  2
  3import (
  4	"bytes"
  5	"encoding/json"
  6	"os"
  7	"path/filepath"
  8	"slices"
  9	"strconv"
 10	"strings"
 11	"testing"
 12
 13	"gitbay.org/gitbay/internal/protocol"
 14	"gitbay.org/gitbay/internal/store"
 15)
 16
 17// mrTestCtx runs control commands as owner against st, capturing output.
 18func mrTestCtx(st *store.Store, owner store.User) (*Ctx, *bytes.Buffer, *bytes.Buffer) {
 19	out, errOut := &bytes.Buffer{}, &bytes.Buffer{}
 20	c := &Ctx{User: owner, Scope: "full", Store: st, Stdout: out, Stderr: errOut}
 21	return c, out, errOut
 22}
 23
 24// twoMRTestRepo is a repository with two open merge requests, both
 25// authored by the returned owner, so authorOrWrite never gets in the way.
 26func twoMRTestRepo(t *testing.T) (*store.Store, store.Repo, store.User) {
 27	t.Helper()
 28	st, repo, uid := newQueueTestRepo(t)
 29	owner := store.User{ID: uid, Username: "alice"}
 30	if _, err := st.CreateMR(repo.ID, uid, repo.ID, "feature1", "main", "one", "", "abc111", "md", false); err != nil {
 31		t.Fatal(err)
 32	}
 33	if _, err := st.CreateMR(repo.ID, uid, repo.ID, "feature2", "main", "two", "", "abc222", "md", false); err != nil {
 34		t.Fatal(err)
 35	}
 36	return st, repo, owner
 37}
 38
 39func mrShowJSON(t *testing.T, st *store.Store, owner store.User, path string, n int64) mrOut {
 40	t.Helper()
 41	c, out, errOut := mrTestCtx(st, owner)
 42	if code := Dispatch(c, []string{"mr", "show", path, strconv.FormatInt(n, 10), "--json"}); code != protocol.ExitOK {
 43		t.Fatalf("mr show: exit %d, %s", code, errOut.String())
 44	}
 45	var env struct {
 46		Data mrOut `json:"data"`
 47	}
 48	if err := json.Unmarshal(out.Bytes(), &env); err != nil {
 49		t.Fatalf("mr show JSON: %v\n%s", err, out.String())
 50	}
 51	return env.Data
 52}
 53
 54// eventDataFor pulls the most recent data_json for a kind, so a test can
 55// check what mr close recorded without a store accessor built just for it.
 56func eventDataFor(t *testing.T, st *store.Store, kind string) string {
 57	t.Helper()
 58	var data string
 59	err := st.DB.QueryRow("SELECT data_json FROM events WHERE kind = ? ORDER BY id DESC LIMIT 1", kind).Scan(&data)
 60	if err != nil {
 61		t.Fatalf("event %s: %v", kind, err)
 62	}
 63	return data
 64}
 65
 66// Closing a merge request can name the one that carries its change
 67// forward; mr show and the mr.closed event both then carry it (#223).
 68func TestMRCloseWithBy(t *testing.T) {
 69	st, repo, owner := twoMRTestRepo(t)
 70	c, _, errOut := mrTestCtx(st, owner)
 71	if code := Dispatch(c, []string{"mr", "close", repo.Path(), "1", "--by", "2"}); code != protocol.ExitOK {
 72		t.Fatalf("mr close: exit %d, %s", code, errOut.String())
 73	}
 74	got := mrShowJSON(t, st, owner, repo.Path(), 1)
 75	if got.State != "closed" || got.SupersededBy != 2 {
 76		t.Fatalf("mr show !1 = %+v, want closed superseded_by 2", got)
 77	}
 78	if data := eventDataFor(t, st, "mr.closed"); !strings.Contains(data, `"by":2`) {
 79		t.Fatalf("mr.closed event = %s, want it to carry by:2", data)
 80	}
 81}
 82
 83// mr close --by refuses a merge request naming itself.
 84func TestMRCloseBySelfRefused(t *testing.T) {
 85	st, repo, owner := twoMRTestRepo(t)
 86	c, _, errOut := mrTestCtx(st, owner)
 87	code := Dispatch(c, []string{"mr", "close", repo.Path(), "1", "--by", "1"})
 88	if code != protocol.ExitUsage {
 89		t.Fatalf("exit = %d, want %d; stderr: %s", code, protocol.ExitUsage, errOut.String())
 90	}
 91	if !strings.Contains(errOut.String(), "cannot supersede itself") {
 92		t.Fatalf("stderr = %q, want it to say a merge request cannot supersede itself", errOut.String())
 93	}
 94}
 95
 96// mr close --by refuses a merge request number that does not exist in
 97// the repository.
 98func TestMRCloseByMissingRefused(t *testing.T) {
 99	st, repo, owner := twoMRTestRepo(t)
100	c, _, errOut := mrTestCtx(st, owner)
101	code := Dispatch(c, []string{"mr", "close", repo.Path(), "1", "--by", "99"})
102	if code != protocol.ExitNotFound {
103		t.Fatalf("exit = %d, want %d; stderr: %s", code, protocol.ExitNotFound, errOut.String())
104	}
105	if !strings.Contains(errOut.String(), "no merge request !99") {
106		t.Fatalf("stderr = %q, want it to name !99 as missing", errOut.String())
107	}
108}
109
110// mr edit --superseded-by sets and clears the field on a closed merge
111// request.
112func TestMREditSupersededBySetAndClear(t *testing.T) {
113	st, repo, owner := twoMRTestRepo(t)
114	c, _, errOut := mrTestCtx(st, owner)
115	if code := Dispatch(c, []string{"mr", "close", repo.Path(), "1"}); code != protocol.ExitOK {
116		t.Fatalf("mr close: exit %d, %s", code, errOut.String())
117	}
118	c, _, errOut = mrTestCtx(st, owner)
119	if code := Dispatch(c, []string{"mr", "edit", repo.Path(), "1", "--superseded-by", "2"}); code != protocol.ExitOK {
120		t.Fatalf("mr edit --superseded-by 2: exit %d, %s", code, errOut.String())
121	}
122	if got := mrShowJSON(t, st, owner, repo.Path(), 1); got.SupersededBy != 2 {
123		t.Fatalf("SupersededBy = %d, want 2", got.SupersededBy)
124	}
125	c, _, errOut = mrTestCtx(st, owner)
126	if code := Dispatch(c, []string{"mr", "edit", repo.Path(), "1", "--superseded-by", "none"}); code != protocol.ExitOK {
127		t.Fatalf("mr edit --superseded-by none: exit %d, %s", code, errOut.String())
128	}
129	if got := mrShowJSON(t, st, owner, repo.Path(), 1); got.SupersededBy != 0 {
130		t.Fatalf("SupersededBy after clear = %d, want 0", got.SupersededBy)
131	}
132}
133
134// mr edit --superseded-by refuses a self-reference the same way mr close
135// --by does.
136func TestMREditSupersededBySelfRefused(t *testing.T) {
137	st, repo, owner := twoMRTestRepo(t)
138	c, _, errOut := mrTestCtx(st, owner)
139	if code := Dispatch(c, []string{"mr", "close", repo.Path(), "1"}); code != protocol.ExitOK {
140		t.Fatalf("mr close: exit %d, %s", code, errOut.String())
141	}
142	c, _, errOut = mrTestCtx(st, owner)
143	code := Dispatch(c, []string{"mr", "edit", repo.Path(), "1", "--superseded-by", "1"})
144	if code != protocol.ExitUsage {
145		t.Fatalf("exit = %d, want %d; stderr: %s", code, protocol.ExitUsage, errOut.String())
146	}
147	if !strings.Contains(errOut.String(), "cannot supersede itself") {
148		t.Fatalf("stderr = %q, want it to say a merge request cannot supersede itself", errOut.String())
149	}
150}
151
152// mr edit --superseded-by refuses a merge request number that does not
153// exist in the repository.
154func TestMREditSupersededByMissingRefused(t *testing.T) {
155	st, repo, owner := twoMRTestRepo(t)
156	c, _, errOut := mrTestCtx(st, owner)
157	if code := Dispatch(c, []string{"mr", "close", repo.Path(), "1"}); code != protocol.ExitOK {
158		t.Fatalf("mr close: exit %d, %s", code, errOut.String())
159	}
160	c, _, errOut = mrTestCtx(st, owner)
161	code := Dispatch(c, []string{"mr", "edit", repo.Path(), "1", "--superseded-by", "99"})
162	if code != protocol.ExitNotFound {
163		t.Fatalf("exit = %d, want %d; stderr: %s", code, protocol.ExitNotFound, errOut.String())
164	}
165	if !strings.Contains(errOut.String(), "no merge request !99") {
166		t.Fatalf("stderr = %q, want it to name !99 as missing", errOut.String())
167	}
168}
169
170// mr edit --superseded-by refuses an open merge request: only a closed
171// one can be superseded.
172func TestMREditSupersededByOnOpenMRRefused(t *testing.T) {
173	st, repo, owner := twoMRTestRepo(t)
174	c, _, errOut := mrTestCtx(st, owner)
175	code := Dispatch(c, []string{"mr", "edit", repo.Path(), "1", "--superseded-by", "2"})
176	if code != protocol.ExitUsage {
177		t.Fatalf("exit = %d, want %d; stderr: %s", code, protocol.ExitUsage, errOut.String())
178	}
179	if !strings.Contains(errOut.String(), "only a closed merge request can be superseded") {
180		t.Fatalf("stderr = %q, want the closed-only refusal", errOut.String())
181	}
182}
183
184// mr show pluralizes multi-row section headings with counts.
185func TestMRShowPluralizesMultiRowSections(t *testing.T) {
186	st, repo, uid := newQueueTestRepo(t)
187	owner := store.User{ID: uid, Username: "alice"}
188
189	// Create git commits for the MR
190	git := gitRunner(t)
191	root := t.TempDir()
192
193	// Create a temporary repository to set up commits
194	src := filepath.Join(root, "src")
195	os.MkdirAll(src, 0o755)
196	git(root, "init", "-q", "-b", "main", "src")
197
198	// Create base commit on main
199	os.WriteFile(filepath.Join(src, "file.txt"), []byte("content"), 0o644)
200	git(src, "add", ".")
201	git(src, "commit", "-q", "-m", "initial")
202
203	// Create feature branch with 2 commits
204	git(src, "checkout", "-q", "-b", "feature")
205	os.WriteFile(filepath.Join(src, "file.txt"), []byte("content1"), 0o644)
206	git(src, "add", ".")
207	git(src, "commit", "-q", "-m", "commit1")
208
209	os.WriteFile(filepath.Join(src, "file.txt"), []byte("content2"), 0o644)
210	git(src, "add", ".")
211	git(src, "commit", "-q", "-m", "commit2")
212	headSHA := strings.TrimSpace(git(src, "rev-parse", "HEAD"))
213
214	// Clone as a bare repository to the gitbay path
215	dir := RepoDir(root, repo.OwnerName, repo.Name)
216	os.MkdirAll(filepath.Dir(dir), 0o755)
217	git(root, "clone", "-q", "--bare", "src", dir)
218
219	// Create the MR head ref in the bare repository
220	git(dir, "update-ref", "refs/merge-requests/1/head", headSHA)
221
222	// Create an MR
223	_, err := st.CreateMR(repo.ID, uid, repo.ID, "feature", "main", "Feature", "", headSHA, "md", false)
224	if err != nil {
225		t.Fatalf("CreateMR: %v", err)
226	}
227
228	// Add 2 checks
229	if err := st.SetCommitStatus(repo.ID, headSHA, "check1", "success", "", "", 0); err != nil {
230		t.Fatal(err)
231	}
232	if err := st.SetCommitStatus(repo.ID, headSHA, "check2", "success", "", "", 0); err != nil {
233		t.Fatal(err)
234	}
235
236	// Add 2 reviews
237	bob, err := st.CreateUser("bob", false)
238	if err != nil {
239		t.Fatal(err)
240	}
241	if err := st.AddMRReview(1, bob, "approve", headSHA); err != nil {
242		t.Fatal(err)
243	}
244	charlie, err := st.CreateUser("charlie", false)
245	if err != nil {
246		t.Fatal(err)
247	}
248	if err := st.AddMRReview(1, charlie, "approve", headSHA); err != nil {
249		t.Fatal(err)
250	}
251
252	// Call mr show in plain text mode
253	c, out, errOut := mrTestCtx(st, owner)
254	c.Cfg.Server.Root = root
255	if code := Dispatch(c, []string{"mr", "show", repo.Path(), "1"}); code != protocol.ExitOK {
256		t.Fatalf("mr show: exit %d, %s", code, errOut.String())
257	}
258
259	outStr := out.String()
260	for _, want := range []string{"commits (2):", "checks (2):", "reviews (2):"} {
261		if !strings.Contains(outStr, want) {
262			t.Errorf("missing %q in:\n%s", want, outStr)
263		}
264	}
265}
266
267// require-contexts stores a deduplicated list and turns require_checks
268// on with it; an empty list clears the contexts and leaves
269// require_checks as it was. A context with whitespace is refused (#258).
270func TestRequireContextsSetsAndClears(t *testing.T) {
271	st, repo, uid := newQueueTestRepo(t)
272	alice := store.User{ID: uid, Username: "alice"}
273	dispatch := func(args ...string) int {
274		t.Helper()
275		c, _, _ := mrTestCtx(st, alice)
276		return Dispatch(c, args)
277	}
278	contexts := func(names ...string) int {
279		t.Helper()
280		return dispatch(append([]string{"repo", "settings", "require-contexts", repo.Path()}, names...)...)
281	}
282	settings := func() store.RepoSettings {
283		t.Helper()
284		got, err := st.RepoByID(repo.ID)
285		if err != nil {
286			t.Fatal(err)
287		}
288		return got.Settings
289	}
290
291	if settings().RequireChecks {
292		t.Fatal("require_checks on in a new repository")
293	}
294	if code := contexts("lint", "ext/deploy", "lint"); code != protocol.ExitOK {
295		t.Fatalf("set: exit %d", code)
296	}
297	if s := settings(); !slices.Equal(s.RequiredContexts, []string{"lint", "ext/deploy"}) || !s.RequireChecks {
298		t.Fatalf("stored %v, require_checks %v; want [lint ext/deploy], on", s.RequiredContexts, s.RequireChecks)
299	}
300	if code := contexts("bad context"); code != protocol.ExitUsage {
301		t.Fatalf("a context with a space: exit %d", code)
302	}
303	if code := contexts(); code != protocol.ExitOK {
304		t.Fatalf("clear: exit %d", code)
305	}
306	if s := settings(); len(s.RequiredContexts) != 0 || !s.RequireChecks {
307		t.Fatalf("after clearing: contexts %v, require_checks %v; want none, still on", s.RequiredContexts, s.RequireChecks)
308	}
309	if code := dispatch("repo", "settings", "require-checks", repo.Path(), "off"); code != protocol.ExitOK {
310		t.Fatalf("require-checks off: exit %d", code)
311	}
312	if code := contexts(); code != protocol.ExitOK {
313		t.Fatalf("clear again: exit %d", code)
314	}
315	if settings().RequireChecks {
316		t.Fatal("clearing the list turned require_checks on")
317	}
318}
319
320// settings show prints the checks gate beside the contexts it waits for,
321// so a list that turned the gate on is visible where the gate is (#258).
322func TestSettingsShowRequiredContexts(t *testing.T) {
323	st, repo, uid := newQueueTestRepo(t)
324	alice := store.User{ID: uid, Username: "alice"}
325	c, _, _ := mrTestCtx(st, alice)
326	if code := Dispatch(c, []string{"repo", "settings", "require-contexts", repo.Path(), "ext/deploy", "lint"}); code != protocol.ExitOK {
327		t.Fatalf("require-contexts: exit %d", code)
328	}
329	c, out, _ := mrTestCtx(st, alice)
330	if code := Dispatch(c, []string{"repo", "settings", "show", repo.Path()}); code != protocol.ExitOK {
331		t.Fatalf("settings show: exit %d", code)
332	}
333	got := strings.Join(strings.Fields(out.String()), " ")
334	for _, want := range []string{"require checks true", "required contexts ext/deploy, lint"} {
335		if !strings.Contains(got, want) {
336			t.Errorf("settings show lacks %q:\n%s", want, out.String())
337		}
338	}
339}