GitLabgitlab-org
cli
main
1//go:build !integration
3package git
5import (
6 "errors"
7 "fmt"
8 "os"
9 "os/exec"
10 "path/filepath"
11 "reflect"
12 "testing"
14 "github.com/stretchr/testify/assert"
15 "github.com/stretchr/testify/require"
16 gomock "go.uber.org/mock/gomock"
18 git_testing "gitlab.com/gitlab-org/cli/internal/git/testing"
19 "gitlab.com/gitlab-org/cli/internal/run"
20 "gitlab.com/gitlab-org/cli/test"
21)
23func getEnv(key, fallback string) string {
24 if value, ok := os.LookupEnv(key); ok {
25 return value
26 }
27 return fallback
28}
30func TestRemoteBranchExists(t *testing.T) {
31 tests := []struct {
32 name string
33 branch string
34 mockOut string
35 mockErr bool
36 expected bool
37 }{
38 {
39 name: "branch exists",
40 branch: "main",
41 mockErr: false,
42 expected: true,
43 },
44 {
45 name: "branch does not exist",
46 branch: "non-existent-branch",
47 mockErr: true,
48 expected: false,
49 },
50 }
52 for _, tt := range tests {
53 t.Run(tt.name, func(t *testing.T) {
54 ctrl := gomock.NewController(t)
55 mockCmd := git_testing.NewMockGitRunner(ctrl)
57 if tt.mockErr {
58 mockCmd.EXPECT().Git("ls-remote",
59 "--exit-code",
60 "--heads",
61 DefaultRemote,
62 tt.branch).Return("", errors.New("can't find branch"))
63 } else {
64 mockCmd.EXPECT().Git("ls-remote",
65 "--exit-code",
66 "--heads",
67 DefaultRemote,
68 tt.branch)
69 }
71 result := RemoteBranchExists(tt.branch, mockCmd)
73 assert.Equal(t, tt.expected, result)
74 })
75 }
76}
78func Test_isFilesystemPath(t *testing.T) {
79 type args struct {
80 p string
81 }
82 tests := []struct {
83 name string
84 args args
85 want bool
86 }{
87 {
88 name: "Filesystem",
89 args: args{"./.git"},
90 want: true,
91 },
92 {
93 name: "Filesystem",
94 args: args{".git"},
95 want: false,
96 },
97 }
98 for _, tt := range tests {
99 t.Run(fmt.Sprintf("%s - %s", tt.name, tt.args.p), func(t *testing.T) {
100 if got := isFilesystemPath(tt.args.p); got != tt.want {
101 t.Errorf("isFilesystemPath() = %v, want %v", got, tt.want)
102 }
103 })
104 }
105}
107func Test_UncommittedChangeCount(t *testing.T) {
108 type c struct {
109 Label string
110 Expected int
111 Output string
112 }
113 cases := []c{
114 {Label: "no changes", Expected: 0, Output: ""},
115 {Label: "one change", Expected: 1, Output: " M poem.txt"},
116 {Label: "untracked file", Expected: 2, Output: " M poem.txt\n?? new.txt"},
117 }
119 teardown := run.SetPrepareCmd(func(*exec.Cmd) run.Runnable {
120 return &test.OutputStub{}
121 })
122 defer teardown()
124 for _, v := range cases {
125 _ = run.SetPrepareCmd(func(*exec.Cmd) run.Runnable {
126 return &test.OutputStub{Out: []byte(v.Output)}
127 })
128 ucc, _ := UncommittedChangeCount()
130 if ucc != v.Expected {
131 t.Errorf("got unexpected ucc value: %d for case %s", ucc, v.Label)
132 }
133 }
134}
136func Test_CurrentBranch(t *testing.T) {
137 cs, teardown := test.InitCmdStubber()
138 defer teardown()
140 expected := "branch-name"
142 cs.Stub(expected)
144 result, err := CurrentBranch()
145 if err != nil {
146 t.Errorf("got unexpected error: %v", err)
147 }
148 if len(cs.Calls) != 1 {
149 t.Errorf("expected 1 Git call, saw %d", len(cs.Calls))
150 }
151 if result != expected {
152 t.Errorf("unexpected branch name: %s instead of %s", result, expected)
153 }
154}
156func Test_CurrentBranch_detached_head(t *testing.T) {
157 cs, teardown := test.InitCmdStubber()
158 defer teardown()
160 cs.StubError("")
162 _, err := CurrentBranch()
163 if err == nil {
164 t.Errorf("expected an error")
165 }
166 if !errors.Is(err, ErrNotOnAnyBranch) {
167 t.Errorf("got unexpected error: %s instead of %s.", err, ErrNotOnAnyBranch)
168 }
169 if len(cs.Calls) != 1 {
170 t.Errorf("expected 1 Git call, saw %d.", len(cs.Calls))
171 }
172}
174func Test_CurrentBranch_unexpected_error(t *testing.T) {
175 cs, teardown := test.InitCmdStubber()
176 defer teardown()
178 cs.StubError("lol")
180 expectedError := "lol\nstub: lol"
182 _, err := CurrentBranch()
183 if err == nil {
184 t.Errorf("expected an error")
185 }
186 if err.Error() != expectedError {
187 t.Errorf("got unexpected error: %s instead of %s.", err.Error(), expectedError)
188 }
189 if len(cs.Calls) != 1 {
190 t.Errorf("expected 1 Git call, saw %d.", len(cs.Calls))
191 }
192}
194func TestReadBranchConfig(t *testing.T) {
195 cs, teardown := test.InitCmdStubber()
196 defer teardown()
198 cs.Stub(`branch.branch-name.remote origin
199branch.branch.remote git@gitlab.com:glab-test/test.git
200branch.branch.merge refs/heads/branch-name`)
202 u, err := ParseURL("git@gitlab.com:glab-test/test.git")
203 require.NoError(t, err)
204 wantCfg := BranchConfig{
205 "origin",
206 u,
207 "refs/heads/branch-name",
208 }
210 t.Run("", func(t *testing.T) {
211 if gotCfg := ReadBranchConfig("branch-name"); !reflect.DeepEqual(gotCfg, wantCfg) {
212 t.Errorf("ReadBranchConfig() = %v, want %v", gotCfg, wantCfg)
213 }
214 })
215}
217func Test_parseRemotes(t *testing.T) {
218 remoteList := []string{
219 "mona\tgit@gitlab.com:monalisa/myfork.git (fetch)",
220 "origin\thttps://gitlab.com/monalisa/octo-cat.git (fetch)",
221 "origin\thttps://gitlab.com/monalisa/octo-cat-push.git (push)",
222 "upstream\thttps://example.com/nowhere.git (fetch)",
223 "upstream\thttps://gitlab.com/hubot/tools (push)",
224 "zardoz\thttps://example.com/zed.git (push)",
225 }
226 r := parseRemotes(remoteList)
227 eq(t, len(r), 4)
229 eq(t, r[0].Name, "mona")
230 eq(t, r[0].FetchURL.String(), "ssh://git@gitlab.com/monalisa/myfork.git")
231 if r[0].PushURL != nil {
232 t.Errorf("expected no PushURL, got %q", r[0].PushURL)
233 }
234 eq(t, r[1].Name, "origin")
235 eq(t, r[1].FetchURL.Path, "/monalisa/octo-cat.git")
236 eq(t, r[1].PushURL.Path, "/monalisa/octo-cat-push.git")
238 eq(t, r[2].Name, "upstream")
239 eq(t, r[2].FetchURL.Host, "example.com")
240 eq(t, r[2].PushURL.Host, "gitlab.com")
242 eq(t, r[3].Name, "zardoz")
243}
245func TestGetDefaultBranch(t *testing.T) {
246 tests := []struct {
247 name string
248 args string
249 want string
250 wantErr bool
251 }{
252 {
253 name: "No Params",
254 want: "master",
255 },
256 {
257 name: "Different Remote",
258 want: "master",
259 args: "profclems/test",
260 },
261 {
262 name: "Invalid repo",
263 want: "main",
264 args: "testssz",
265 wantErr: true,
266 },
267 }
268 for _, tt := range tests {
269 t.Run(tt.name, func(t *testing.T) {
270 got, err := GetDefaultBranch(tt.args)
271 if (err != nil) != tt.wantErr {
272 t.Logf("GetDefaultBranch() error = %v, wantErr %v", err, tt.wantErr)
273 return
274 }
275 if got != tt.want {
276 t.Errorf("GetDefaultBranch() got = %v, want %v", got, tt.want)
277 }
278 })
279 }
281 t.Run("get branch from HEAD", func(t *testing.T) {
282 cs, teardown := test.InitCmdStubber()
283 defer teardown()
285 cs.Stub(`* remote origin
286Fetch URL: https://gitlab.com/gitlab-community/cli.git
287Push URL: https://gitlab.com/gitlab-community/cli.git
288HEAD branch: main`)
290 got, err := GetDefaultBranch("origin")
291 require.NoError(t, err)
292 assert.Equal(t, "main", got)
293 })
294}
296func TestGetRemoteURL(t *testing.T) {
297 t.Run("is valid", func(t *testing.T) {
298 InitGitRepo(t)
300 _, err := GitCommand("config", "remote.origin.url", getEnv("CI_PROJECT_PATH", "gitlab-org/cli")).Output()
301 require.NoError(t, err)
303 got, err := GetRemoteURL("origin")
305 require.Contains(t, got, getEnv("CI_PROJECT_PATH", "gitlab-org/cli"))
306 require.NoError(t, err)
307 })
309 t.Run("is not valid", func(t *testing.T) {
310 InitGitRepo(t)
312 got, err := GetRemoteURL("lkajwflkwejlakjdsal")
314 require.Contains(t, got, "")
315 if err == nil {
316 t.Errorf("GetRemoteURL() error = %v, wantErr %v", err, true)
317 }
318 })
319}
321func TestGitCommonDir(t *testing.T) {
322 t.Run("normal repo", func(t *testing.T) {
323 repoDir := InitGitRepo(t)
325 got, err := GitCommonDir()
326 require.NoError(t, err)
327 // git rev-parse --git-common-dir may return a relative path (".git")
328 // when cwd is the repo root, so normalize before comparing.
329 absGot, err := filepath.Abs(got)
330 require.NoError(t, err)
331 require.Equal(t, filepath.Join(repoDir, ".git"), absGot)
332 })
334 t.Run("worktree", func(t *testing.T) {
335 repoDir := InitGitRepoWithCommit(t)
336 worktreeDir := t.TempDir()
338 addCmd := GitCommand("worktree", "add", worktreeDir, "-b", "worktree-branch")
339 addCmd.Dir = repoDir
340 _, err := run.PrepareCmd(addCmd).Output()
341 require.NoError(t, err)
343 t.Chdir(worktreeDir)
345 got, err := GitCommonDir()
346 require.NoError(t, err)
347 // git resolves symlinks in returned paths (macOS: /var → /private/var),
348 // so resolve both sides before comparing.
349 wantResolved, err := filepath.EvalSymlinks(filepath.Join(repoDir, ".git"))
350 require.NoError(t, err)
351 gotResolved, err := filepath.EvalSymlinks(got)
352 require.NoError(t, err)
353 require.Equal(t, wantResolved, gotResolved)
354 })
355}
357func TestDescribeByTags(t *testing.T) {
358 cases := map[string]struct {
359 expected string
360 output string
361 errorValue error
362 }{
363 "commit is tag": {
364 expected: "1.0.0",
365 output: "1.0.0",
366 errorValue: nil,
367 },
368 "commit is not tag": {
369 expected: "1.0.0-1-g4aa1b8",
370 output: "1.0.0-1-g4aa1b8",
371 errorValue: nil,
372 },
373 }
375 for name, v := range cases {
376 t.Run(name, func(t *testing.T) {
377 InitGitRepoWithCommit(t)
379 _, err := exec.Command("git", "tag", v.output).Output()
380 require.NoError(t, err)
382 version, err := DescribeByTags()
383 require.Equal(t, v.errorValue, errors.Unwrap(err))
384 require.Equal(t, v.expected, version, "unexpected version value for case %s", name)
385 })
386 }
387}
389func TestOutputLines(t *testing.T) {
390 t.Parallel()
392 tests := []struct {
393 name string
394 input string
395 expect []string
396 }{
397 {
398 name: "empty output",
399 input: "",
400 expect: []string{""},
401 },
402 {
403 name: "single line without final newline",
404 input: "alpha",
405 expect: []string{"alpha"},
406 },
407 {
408 name: "LF without final newline",
409 input: "alpha\nbeta",
410 expect: []string{"alpha", "beta"},
411 },
412 {
413 name: "LF with final newline",
414 input: "alpha\nbeta\n",
415 expect: []string{"alpha", "beta"},
416 },
417 {
418 name: "LF with empty interior line",
419 input: "alpha\n\nbeta\n",
420 expect: []string{"alpha", "", "beta"},
421 },
422 {
423 name: "CRLF without final newline",
424 input: "alpha\r\nbeta",
425 expect: []string{"alpha", "beta"},
426 },
427 {
428 name: "CRLF with final newline",
429 input: "alpha\r\nbeta\r\n",
430 expect: []string{"alpha", "beta"},
431 },
432 {
433 name: "CRLF with empty interior line",
434 input: "alpha\r\n\r\nbeta\r\n",
435 expect: []string{"alpha", "", "beta"},
436 },
437 {
438 name: "isolated carriage return",
439 input: "alpha\rbeta",
440 expect: []string{"alpha\rbeta"},
441 },
442 {
443 name: "terminal carriage return",
444 input: "alpha\r",
445 expect: []string{"alpha\r"},
446 },
447 }
449 for _, tt := range tests {
450 t.Run(tt.name, func(t *testing.T) {
451 t.Parallel()
452 assert.Equal(t, tt.expect, outputLines([]byte(tt.input)))
453 })
454 }
455}
457func Test_assertValidConfig(t *testing.T) {
458 t.Run("config key is valid with three levels", func(t *testing.T) {
459 err := assertValidConfigKey("remote.this.testsuite")
460 require.NoError(t, err)
461 })
462 t.Run("config key is valid with two levels", func(t *testing.T) {
463 err := assertValidConfigKey("this.testsuite")
464 require.NoError(t, err)
465 })
467 t.Run("panic modes", func(t *testing.T) {
468 err := assertValidConfigKey("this")
469 require.Error(t, err)
470 require.Errorf(t, err, "incorrect Git configuration key.")
471 })
472}
474func Test_configValueExists(t *testing.T) {
475 tests := []struct {
476 name string
477 value string
478 key string
479 check string
480 exists bool
481 }{
482 {
483 name: "config value exists",
484 value: "rocks",
485 check: "rocks",
486 exists: true,
487 },
488 {
489 name: "config value doesn't exist",
490 value: "stinks",
491 check: "rocks",
492 exists: false,
493 },
494 }
495 for _, tt := range tests {
496 t.Run(tt.name, func(t *testing.T) {
497 InitGitRepo(t)
498 err := SetRemoteConfig("this", "testsuite", tt.value)
499 require.NoError(t, err)
501 result, err := configValueExists("remote.this.testsuite", tt.check)
503 require.NoError(t, err)
504 require.Equal(t, tt.exists, result)
505 })
506 }
507}
509func TestSetConfig(t *testing.T) {
510 tests := []struct {
511 name string
512 value string
513 valueExists bool
514 oldValue string
515 expected string
516 }{
517 {
518 name: "config value already exists",
519 value: "hello",
520 valueExists: true,
521 oldValue: "goodbye",
522 expected: "goodbye\nhello\n",
523 },
524 {
525 name: "config value doesn't exist",
526 value: "hey",
527 valueExists: false,
528 expected: "hey\n",
529 },
530 }
532 for _, tt := range tests {
533 t.Run(tt.name, func(t *testing.T) {
534 InitGitRepo(t)
536 if tt.valueExists {
537 _, err := exec.Command("git", "config", "cool.testcase", tt.oldValue).Output()
538 require.NoError(t, err)
539 }
541 err := SetConfig("cool.testcase", tt.value)
542 require.NoError(t, err)
544 output, err := exec.Command("git", "config", "--get-all", "cool.testcase").Output()
546 require.Equal(t, tt.expected, string(output))
547 require.NoError(t, err)
548 })
549 }
550}
552func TestListTags(t *testing.T) {
553 cases := map[string]struct {
554 expected []string
555 output string
556 wantErr bool
557 errString string
558 }{
559 "no tags": {
560 expected: nil,
561 output: "",
562 wantErr: false,
563 },
564 "invalid repository": {
565 expected: nil,
566 output: "",
567 wantErr: true,
568 errString: "fatal: not a git repository (or any of the parent directories): .git\ngit: exit status 128",
569 },
570 "no tags w/ extra newline": {
571 expected: []string(nil),
572 output: "\n",
573 wantErr: false,
574 },
575 "single semver tag": {
576 expected: []string{"1.0.0"},
577 output: "1.0.0",
578 wantErr: false,
579 },
580 "multiple semver tags": {
581 expected: []string{"1.0.0", "2.0.0", "3.0.0"},
582 output: "1.0.0\n2.0.0\n3.0.0",
583 wantErr: false,
584 },
585 "multiple semver tags with extra newlines": {
586 expected: []string{"1.0.0", "2.0.0", "3.0.0"},
587 output: "1.0.0\n2.0.0\n3.0.0\n\n",
588 wantErr: false,
589 },
590 "single non-semver tag": {
591 expected: []string{"a"},
592 output: "a",
593 wantErr: false,
594 },
595 "multiple non-semver tag": {
596 expected: []string{"a", "b"},
597 output: "a\nb",
598 wantErr: false,
599 },
600 }
602 unsetGitHookEnv(t)
603 t.Setenv("GIT_CONFIG_GLOBAL", "/dev/null")
604 t.Setenv("GIT_DISCOVERY_ACROSS_FILESYSTEM", "true")
606 for name, tt := range cases {
607 t.Run(name, func(t *testing.T) {
608 if tt.wantErr {
609 tempDir := t.TempDir()
610 // move to a directory without a .git subdirectory
611 t.Chdir(tempDir)
613 tags, err := ListTags()
614 require.Equal(t, tt.errString, errors.Unwrap(err).Error())
615 require.Equal(t, tt.expected, tags)
616 } else {
617 InitGitRepoWithCommit(t)
619 for tag := range tt.expected {
620 _, err := exec.Command("git", "tag", tt.expected[tag]).Output()
621 require.NoError(t, err)
622 }
624 tags, err := ListTags()
625 require.Equal(t, tt.expected, tags)
626 require.NoError(t, err)
627 }
628 })
629 }
630}
632func TestGitUserName(t *testing.T) {
633 testCases := []struct {
634 desc string
635 setName string
636 expected string
637 }{
638 {
639 desc: "with a set name",
640 setName: "Bob",
641 expected: "Bob\n",
642 },
643 // NOTE: it's not possible to do any kind of committing without setting
644 // a username for git, so it's unlikely this would not set
645 }
646 for _, tC := range testCases {
647 t.Run(tC.desc, func(t *testing.T) {
648 InitGitRepo(t)
650 _ = SetLocalConfig("user.name", tC.setName)
652 output, err := GitUserName()
653 require.NoError(t, err)
655 require.Equal(t, tC.expected, string(output))
656 })
657 }
658}
660func TestSetRemoteResolution(t *testing.T) {
661 tests := []struct {
662 name string
663 resolution string
664 expectedKey string
665 expectedValue string
666 }{
667 {
668 name: "base resolution uses glab-resolved-base key",
669 resolution: "base",
670 expectedKey: "remote.origin.glab-resolved-base",
671 expectedValue: "base",
672 },
673 {
674 name: "base: resolution uses glab-resolved-base key",
675 resolution: "base: gitlab.com/gitlab-org/cli",
676 expectedKey: "remote.origin.glab-resolved-base",
677 expectedValue: "base: gitlab.com/gitlab-org/cli",
678 },
679 {
680 name: "head resolution uses glab-resolved-head key",
681 resolution: "head",
682 expectedKey: "remote.origin.glab-resolved-head",
683 expectedValue: "head",
684 },
685 {
686 name: "head: resolution uses glab-resolved-head key",
687 resolution: "head: gitlab.com/user/fork",
688 expectedKey: "remote.origin.glab-resolved-head",
689 expectedValue: "head: gitlab.com/user/fork",
690 },
691 {
692 name: "other resolution uses legacy glab-resolved key",
693 resolution: "something-else",
694 expectedKey: "remote.origin.glab-resolved",
695 expectedValue: "something-else",
696 },
697 {
698 name: "basement does not match base prefix",
699 resolution: "basement",
700 expectedKey: "remote.origin.glab-resolved",
701 expectedValue: "basement",
702 },
703 {
704 name: "baseball does not match base prefix",
705 resolution: "baseball",
706 expectedKey: "remote.origin.glab-resolved",
707 expectedValue: "baseball",
708 },
709 {
710 name: "header does not match head prefix",
711 resolution: "header",
712 expectedKey: "remote.origin.glab-resolved",
713 expectedValue: "header",
714 },
715 {
716 name: "heading does not match head prefix",
717 resolution: "heading",
718 expectedKey: "remote.origin.glab-resolved",
719 expectedValue: "heading",
720 },
721 }
723 for _, tc := range tests {
724 t.Run(tc.name, func(t *testing.T) {
725 InitGitRepo(t)
727 // Call SetRemoteResolution
728 err := SetRemoteResolution("origin", tc.resolution)
729 require.NoError(t, err)
731 // Verify the correct config key was set
732 cmd := exec.Command("git", "config", tc.expectedKey)
733 output, err := run.PrepareCmd(cmd).Output()
734 require.NoError(t, err)
736 assert.Equal(t, tc.expectedValue, string(output[:len(output)-1])) // trim trailing newline
737 })
738 }
739}
741func Test_cloneTargetDir(t *testing.T) {
742 tests := []struct {
743 name string
744 cloneURL string
745 want string
746 }{
747 {"https with .git", "https://gitlab.com/group/source.git", "source"},
748 {"https without .git", "https://gitlab.com/group/source", "source"},
749 {"trailing slash", "https://gitlab.com/group/source/", "source"},
750 {"dot git with trailing slash", "https://gitlab.com/group/source.git/", "source"},
751 {"scp style", "git@gitlab.com:group/source.git", "source"},
752 }
753 for _, tt := range tests {
754 t.Run(tt.name, func(t *testing.T) {
755 assert.Equal(t, tt.want, cloneTargetDir(tt.cloneURL))
756 })
757 }
758}
760// TestRemotes_OutsideRepoReturnsErrNotAGitRepository pins the contract callers
761// depend on: outside a repo, Remotes() reports ErrNotAGitRepository via
762// errors.Is, regardless of locale. Callers must not match git's message text —
763// git translates it, so a substring check silently stops matching for anyone
764// not running in English.
765func TestRemotes_OutsideRepoReturnsErrNotAGitRepository(t *testing.T) {
766 // Cannot call t.Parallel(): t.Chdir and t.Setenv are incompatible with it.
767 unsetGitHookEnv(t)
768 t.Setenv("LC_ALL", "de_DE.UTF-8")
769 t.Setenv("LANG", "de_DE.UTF-8")
771 t.Chdir(t.TempDir())
773 _, err := Remotes()
775 require.ErrorIs(t, err, ErrNotAGitRepository)
777 // The underlying failure is preserved for display, not replaced. Assert on
778 // the exit-status suffix that run.CmdError appends: it is the one part of
779 // the message that is neither localized nor added by ErrNotAGitRepository.
780 assert.Contains(t, err.Error(), "git: exit status 128")
781}
783// TestRemotes_InsideRepoReturnsUnderlyingError covers the other half of the
784// branch that ErrNotAGitRepository introduced. When we are inside a repo but
785// `git remote -v` fails for an unrelated reason, the raw error must pass
786// through unchanged — labelling it ErrNotAGitRepository would make a genuine
787// git failure look like "no repo here" and silently trigger the caller's
788// fallback to --repo.
789func TestRemotes_InsideRepoReturnsUnderlyingError(t *testing.T) {
790 // Cannot call t.Parallel(): InitGitRepo uses t.Chdir, and we swap a
791 // package-level var below.
792 InitGitRepo(t)
794 // Fail only `git remote -v`; everything else — crucially GitDir's
795 // `rev-parse` — runs for real against the repo InitGitRepo just created, so
796 // the "am I in a repo" check genuinely succeeds rather than being mocked.
797 original := run.PrepareCmd
798 teardown := run.SetPrepareCmd(func(cmd *exec.Cmd) run.Runnable {
799 if len(cmd.Args) > 1 && cmd.Args[1] == "remote" {
800 return &test.OutputStub{Error: errors.New("simulated git remote failure")}
801 }
802 return original(cmd)
803 })
804 defer teardown()
806 _, err := Remotes()
808 require.Error(t, err, "the stubbed git remote invocation should fail")
809 require.NotErrorIs(t, err, ErrNotAGitRepository,
810 "a real git failure inside a repo must not be reported as 'not a git repository'")
811 assert.Contains(t, err.Error(), "simulated git remote failure",
812 "the underlying git error should pass through unchanged")
813}
815func Test_RebaseInProgress(t *testing.T) {
816 InitGitRepo(t)
818 assert.False(t, RebaseInProgress(), "a fresh repo has no rebase in progress")
820 gitDir, err := GitDir()
821 require.NoError(t, err)
823 // Git records an in-flight rebase as a rebase-merge or rebase-apply
824 // directory inside the git dir; either one means "in progress".
825 rebaseMerge := filepath.Join(gitDir, "rebase-merge")
826 require.NoError(t, os.MkdirAll(rebaseMerge, 0o755))
827 assert.True(t, RebaseInProgress(), "rebase-merge directory should be detected")
829 require.NoError(t, os.RemoveAll(rebaseMerge))
830 require.NoError(t, os.MkdirAll(filepath.Join(gitDir, "rebase-apply"), 0o755))
831 assert.True(t, RebaseInProgress(), "rebase-apply directory should be detected")
832}
Diagnostics6 git calls · 25 ms
CallStatusSizeTime025 ms
discover200185 B2 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=2 git.response.bytes=185 git.server.agent=git/2.56.g1891de4-Linux git.server.object_format=sha1 git.server.caps=agent ls-refs fetch server-option object-format git.server.fetch=shallow wait-for-done filter git.protocol.version=2 git.pkt.frames=9 git.pkt.data=7 git.pkt.flush=2 git.pkt.delim=0 git.pkt.bytes=185 git.pkt.payload.max=35
ls-refs20058 KiB2 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=2 git.response.bytes=59849 git.response.cache=UPDATING git.response.duration_ms=2 git.protocol.version=2 git.pkt.frames=731 git.pkt.data=730 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=59849 git.pkt.payload.max=143 git.ls_refs.count=730 git.ls_refs.head=refs/heads/main
fetchtree:0 · deepen 1020032 KiB · hit2 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=2 git.response.bytes=32926 git.response.cache=HIT git.response.duration_ms=2 git.fetch.filter=tree:0 git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9 git.fetch.haves.count=0 git.fetch.deepen=10 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=22 git.pkt.data=20 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=32926 git.pkt.payload.max=32046 git.sideband.band1.bytes=32046 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=80 git.pack.bytes=32046 git.pack.ofs_delta=36 git.pack.ref_delta=0 git.pack.chain.max=2 git.pack.trailer=cb0bad5d7ffc514895d8b21c4dd470327f90bc91 git.pack.full=44Open pack map
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · hit3 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=3 git.response.bytes=4273 git.response.cache=HIT git.response.duration_ms=3 git.fetch.filter=combine:blob:none+tree:2 git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9 git.fetch.haves.count=0 git.fetch.deepen=1 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=7 git.pkt.data=5 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=4273 git.pkt.payload.max=4173 git.sideband.band1.bytes=4173 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=11 git.pack.bytes=4173 git.fetch.wide.objects=11 git.fetch.wide.extra_bytes=3930 git.fetch.wide.blobs=0
fetchtree:0200510 B · hit3 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=3 git.response.bytes=510 git.response.cache=HIT git.response.duration_ms=3 git.fetch.filter=tree:0 git.fetch.wants=a3147172443266d011121808a125248c5c915972 git.fetch.haves.count=0 git.fetch.deepen=0 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=4 git.pkt.data=3 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=510 git.pkt.payload.max=483 git.sideband.band1.bytes=483 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=483 git.pack.trailer=4ef234d86a93490a6a3da3549aa13a474a5c9eacOpen pack map
fetch2005.5 KiB · hit17 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=17 git.response.bytes=5675 git.response.cache=HIT git.response.duration_ms=17 git.fetch.wants=176bf19f3d107dda3973fb9a847d9528512df865 git.fetch.haves.count=0 git.fetch.deepen=0 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=4 git.pkt.data=3 git.pkt.flush=1 git.pkt.delim=0 git.pkt.bytes=5675 git.pkt.payload.max=5648 git.sideband.band1.bytes=5648 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0
Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.
- Remote
- https://gitlab.com/gitlab-org/cli
- Ref
- refs/heads/main
- Commit
- 0dd7574dce9e385c5c30540e6c15657adc6bdce9
- cf-ray
- a5e12387f8b17fd8
- Request
- de408099…
- Protocol
- v2 · sha1
- Agent
- git/2.56.g1891de4-Linux
- Filter
- advertised
- Fetch
- shallow wait-for-done filter
- Capabilities
- agent ls-refs fetch server-option object-format