GitLabgitlab-org
cli
main
1// Code generated by MockGen. DO NOT EDIT.
2// Source: gitlab.com/gitlab-org/cli/internal/git (interfaces: Git)
3//
4// Generated by this command:
5//
6// mockgen -typed -destination=./git_runner.go -package=gittest gitlab.com/gitlab-org/cli/internal/git Git
7//
9// Package gittest is a generated GoMock package.
10package gittest
12import (
13 reflect "reflect"
15 git "gitlab.com/gitlab-org/cli/internal/git"
16 gomock "go.uber.org/mock/gomock"
17)
19// MockGit is a mock of Git interface.
20type MockGit struct {
21 ctrl *gomock.Controller
22 recorder *MockGitMockRecorder
23 isgomock struct{}
24}
26// MockGitMockRecorder is the mock recorder for MockGit.
27type MockGitMockRecorder struct {
28 mock *MockGit
29}
31// NewMockGit creates a new mock instance.
32func NewMockGit(ctrl *gomock.Controller) *MockGit {
33 mock := &MockGit{ctrl: ctrl}
34 mock.recorder = &MockGitMockRecorder{mock}
35 return mock
36}
38// EXPECT returns an object that allows the caller to indicate expected use.
39func (m *MockGit) EXPECT() *MockGitMockRecorder {
40 return m.recorder
41}
43// CheckoutBranch mocks base method.
44func (m *MockGit) CheckoutBranch(branch string) error {
45 m.ctrl.T.Helper()
46 ret := m.ctrl.Call(m, "CheckoutBranch", branch)
47 ret0, _ := ret[0].(error)
48 return ret0
49}
51// CheckoutBranch indicates an expected call of CheckoutBranch.
52func (mr *MockGitMockRecorder) CheckoutBranch(branch any) *MockGitCheckoutBranchCall {
53 mr.mock.ctrl.T.Helper()
54 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckoutBranch", reflect.TypeOf((*MockGit)(nil).CheckoutBranch), branch)
55 return &MockGitCheckoutBranchCall{Call: call}
56}
58// MockGitCheckoutBranchCall wrap *gomock.Call
59type MockGitCheckoutBranchCall struct {
60 *gomock.Call
61}
63// Return rewrite *gomock.Call.Return
64func (c *MockGitCheckoutBranchCall) Return(arg0 error) *MockGitCheckoutBranchCall {
65 c.Call = c.Call.Return(arg0)
66 return c
67}
69// Do rewrite *gomock.Call.Do
70func (c *MockGitCheckoutBranchCall) Do(f func(string) error) *MockGitCheckoutBranchCall {
71 c.Call = c.Call.Do(f)
72 return c
73}
75// DoAndReturn rewrite *gomock.Call.DoAndReturn
76func (c *MockGitCheckoutBranchCall) DoAndReturn(f func(string) error) *MockGitCheckoutBranchCall {
77 c.Call = c.Call.DoAndReturn(f)
78 return c
79}
81// CheckoutNewBranch mocks base method.
82func (m *MockGit) CheckoutNewBranch(branch string) error {
83 m.ctrl.T.Helper()
84 ret := m.ctrl.Call(m, "CheckoutNewBranch", branch)
85 ret0, _ := ret[0].(error)
86 return ret0
87}
89// CheckoutNewBranch indicates an expected call of CheckoutNewBranch.
90func (mr *MockGitMockRecorder) CheckoutNewBranch(branch any) *MockGitCheckoutNewBranchCall {
91 mr.mock.ctrl.T.Helper()
92 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckoutNewBranch", reflect.TypeOf((*MockGit)(nil).CheckoutNewBranch), branch)
93 return &MockGitCheckoutNewBranchCall{Call: call}
94}
96// MockGitCheckoutNewBranchCall wrap *gomock.Call
97type MockGitCheckoutNewBranchCall struct {
98 *gomock.Call
99}
101// Return rewrite *gomock.Call.Return
102func (c *MockGitCheckoutNewBranchCall) Return(arg0 error) *MockGitCheckoutNewBranchCall {
103 c.Call = c.Call.Return(arg0)
104 return c
105}
107// Do rewrite *gomock.Call.Do
108func (c *MockGitCheckoutNewBranchCall) Do(f func(string) error) *MockGitCheckoutNewBranchCall {
109 c.Call = c.Call.Do(f)
110 return c
111}
113// DoAndReturn rewrite *gomock.Call.DoAndReturn
114func (c *MockGitCheckoutNewBranchCall) DoAndReturn(f func(string) error) *MockGitCheckoutNewBranchCall {
115 c.Call = c.Call.DoAndReturn(f)
116 return c
117}
119// CommitBody mocks base method.
120func (m *MockGit) CommitBody(sha string) (string, error) {
121 m.ctrl.T.Helper()
122 ret := m.ctrl.Call(m, "CommitBody", sha)
123 ret0, _ := ret[0].(string)
124 ret1, _ := ret[1].(error)
125 return ret0, ret1
126}
128// CommitBody indicates an expected call of CommitBody.
129func (mr *MockGitMockRecorder) CommitBody(sha any) *MockGitCommitBodyCall {
130 mr.mock.ctrl.T.Helper()
131 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitBody", reflect.TypeOf((*MockGit)(nil).CommitBody), sha)
132 return &MockGitCommitBodyCall{Call: call}
133}
135// MockGitCommitBodyCall wrap *gomock.Call
136type MockGitCommitBodyCall struct {
137 *gomock.Call
138}
140// Return rewrite *gomock.Call.Return
141func (c *MockGitCommitBodyCall) Return(arg0 string, arg1 error) *MockGitCommitBodyCall {
142 c.Call = c.Call.Return(arg0, arg1)
143 return c
144}
146// Do rewrite *gomock.Call.Do
147func (c *MockGitCommitBodyCall) Do(f func(string) (string, error)) *MockGitCommitBodyCall {
148 c.Call = c.Call.Do(f)
149 return c
150}
152// DoAndReturn rewrite *gomock.Call.DoAndReturn
153func (c *MockGitCommitBodyCall) DoAndReturn(f func(string) (string, error)) *MockGitCommitBodyCall {
154 c.Call = c.Call.DoAndReturn(f)
155 return c
156}
158// Commits mocks base method.
159func (m *MockGit) Commits(baseRef, headRef string) ([]*git.Commit, error) {
160 m.ctrl.T.Helper()
161 ret := m.ctrl.Call(m, "Commits", baseRef, headRef)
162 ret0, _ := ret[0].([]*git.Commit)
163 ret1, _ := ret[1].(error)
164 return ret0, ret1
165}
167// Commits indicates an expected call of Commits.
168func (mr *MockGitMockRecorder) Commits(baseRef, headRef any) *MockGitCommitsCall {
169 mr.mock.ctrl.T.Helper()
170 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commits", reflect.TypeOf((*MockGit)(nil).Commits), baseRef, headRef)
171 return &MockGitCommitsCall{Call: call}
172}
174// MockGitCommitsCall wrap *gomock.Call
175type MockGitCommitsCall struct {
176 *gomock.Call
177}
179// Return rewrite *gomock.Call.Return
180func (c *MockGitCommitsCall) Return(arg0 []*git.Commit, arg1 error) *MockGitCommitsCall {
181 c.Call = c.Call.Return(arg0, arg1)
182 return c
183}
185// Do rewrite *gomock.Call.Do
186func (c *MockGitCommitsCall) Do(f func(string, string) ([]*git.Commit, error)) *MockGitCommitsCall {
187 c.Call = c.Call.Do(f)
188 return c
189}
191// DoAndReturn rewrite *gomock.Call.DoAndReturn
192func (c *MockGitCommitsCall) DoAndReturn(f func(string, string) ([]*git.Commit, error)) *MockGitCommitsCall {
193 c.Call = c.Call.DoAndReturn(f)
194 return c
195}
197// CurrentBranch mocks base method.
198func (m *MockGit) CurrentBranch() (string, error) {
199 m.ctrl.T.Helper()
200 ret := m.ctrl.Call(m, "CurrentBranch")
201 ret0, _ := ret[0].(string)
202 ret1, _ := ret[1].(error)
203 return ret0, ret1
204}
206// CurrentBranch indicates an expected call of CurrentBranch.
207func (mr *MockGitMockRecorder) CurrentBranch() *MockGitCurrentBranchCall {
208 mr.mock.ctrl.T.Helper()
209 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentBranch", reflect.TypeOf((*MockGit)(nil).CurrentBranch))
210 return &MockGitCurrentBranchCall{Call: call}
211}
213// MockGitCurrentBranchCall wrap *gomock.Call
214type MockGitCurrentBranchCall struct {
215 *gomock.Call
216}
218// Return rewrite *gomock.Call.Return
219func (c *MockGitCurrentBranchCall) Return(arg0 string, arg1 error) *MockGitCurrentBranchCall {
220 c.Call = c.Call.Return(arg0, arg1)
221 return c
222}
224// Do rewrite *gomock.Call.Do
225func (c *MockGitCurrentBranchCall) Do(f func() (string, error)) *MockGitCurrentBranchCall {
226 c.Call = c.Call.Do(f)
227 return c
228}
230// DoAndReturn rewrite *gomock.Call.DoAndReturn
231func (c *MockGitCurrentBranchCall) DoAndReturn(f func() (string, error)) *MockGitCurrentBranchCall {
232 c.Call = c.Call.DoAndReturn(f)
233 return c
234}
236// DefaultBranch mocks base method.
237func (m *MockGit) DefaultBranch(remote string) (string, error) {
238 m.ctrl.T.Helper()
239 ret := m.ctrl.Call(m, "DefaultBranch", remote)
240 ret0, _ := ret[0].(string)
241 ret1, _ := ret[1].(error)
242 return ret0, ret1
243}
245// DefaultBranch indicates an expected call of DefaultBranch.
246func (mr *MockGitMockRecorder) DefaultBranch(remote any) *MockGitDefaultBranchCall {
247 mr.mock.ctrl.T.Helper()
248 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultBranch", reflect.TypeOf((*MockGit)(nil).DefaultBranch), remote)
249 return &MockGitDefaultBranchCall{Call: call}
250}
252// MockGitDefaultBranchCall wrap *gomock.Call
253type MockGitDefaultBranchCall struct {
254 *gomock.Call
255}
257// Return rewrite *gomock.Call.Return
258func (c *MockGitDefaultBranchCall) Return(arg0 string, arg1 error) *MockGitDefaultBranchCall {
259 c.Call = c.Call.Return(arg0, arg1)
260 return c
261}
263// Do rewrite *gomock.Call.Do
264func (c *MockGitDefaultBranchCall) Do(f func(string) (string, error)) *MockGitDefaultBranchCall {
265 c.Call = c.Call.Do(f)
266 return c
267}
269// DoAndReturn rewrite *gomock.Call.DoAndReturn
270func (c *MockGitDefaultBranchCall) DoAndReturn(f func(string) (string, error)) *MockGitDefaultBranchCall {
271 c.Call = c.Call.DoAndReturn(f)
272 return c
273}
275// DeleteLocalBranch mocks base method.
276func (m *MockGit) DeleteLocalBranch(branch string) error {
277 m.ctrl.T.Helper()
278 ret := m.ctrl.Call(m, "DeleteLocalBranch", branch)
279 ret0, _ := ret[0].(error)
280 return ret0
281}
283// DeleteLocalBranch indicates an expected call of DeleteLocalBranch.
284func (mr *MockGitMockRecorder) DeleteLocalBranch(branch any) *MockGitDeleteLocalBranchCall {
285 mr.mock.ctrl.T.Helper()
286 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalBranch", reflect.TypeOf((*MockGit)(nil).DeleteLocalBranch), branch)
287 return &MockGitDeleteLocalBranchCall{Call: call}
288}
290// MockGitDeleteLocalBranchCall wrap *gomock.Call
291type MockGitDeleteLocalBranchCall struct {
292 *gomock.Call
293}
295// Return rewrite *gomock.Call.Return
296func (c *MockGitDeleteLocalBranchCall) Return(arg0 error) *MockGitDeleteLocalBranchCall {
297 c.Call = c.Call.Return(arg0)
298 return c
299}
301// Do rewrite *gomock.Call.Do
302func (c *MockGitDeleteLocalBranchCall) Do(f func(string) error) *MockGitDeleteLocalBranchCall {
303 c.Call = c.Call.Do(f)
304 return c
305}
307// DoAndReturn rewrite *gomock.Call.DoAndReturn
308func (c *MockGitDeleteLocalBranchCall) DoAndReturn(f func(string) error) *MockGitDeleteLocalBranchCall {
309 c.Call = c.Call.DoAndReturn(f)
310 return c
311}
313// HasLocalBranch mocks base method.
314func (m *MockGit) HasLocalBranch(branch string) (bool, error) {
315 m.ctrl.T.Helper()
316 ret := m.ctrl.Call(m, "HasLocalBranch", branch)
317 ret0, _ := ret[0].(bool)
318 ret1, _ := ret[1].(error)
319 return ret0, ret1
320}
322// HasLocalBranch indicates an expected call of HasLocalBranch.
323func (mr *MockGitMockRecorder) HasLocalBranch(branch any) *MockGitHasLocalBranchCall {
324 mr.mock.ctrl.T.Helper()
325 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasLocalBranch", reflect.TypeOf((*MockGit)(nil).HasLocalBranch), branch)
326 return &MockGitHasLocalBranchCall{Call: call}
327}
329// MockGitHasLocalBranchCall wrap *gomock.Call
330type MockGitHasLocalBranchCall struct {
331 *gomock.Call
332}
334// Return rewrite *gomock.Call.Return
335func (c *MockGitHasLocalBranchCall) Return(arg0 bool, arg1 error) *MockGitHasLocalBranchCall {
336 c.Call = c.Call.Return(arg0, arg1)
337 return c
338}
340// Do rewrite *gomock.Call.Do
341func (c *MockGitHasLocalBranchCall) Do(f func(string) (bool, error)) *MockGitHasLocalBranchCall {
342 c.Call = c.Call.Do(f)
343 return c
344}
346// DoAndReturn rewrite *gomock.Call.DoAndReturn
347func (c *MockGitHasLocalBranchCall) DoAndReturn(f func(string) (bool, error)) *MockGitHasLocalBranchCall {
348 c.Call = c.Call.DoAndReturn(f)
349 return c
350}
352// LatestCommit mocks base method.
353func (m *MockGit) LatestCommit(ref string) (*git.Commit, error) {
354 m.ctrl.T.Helper()
355 ret := m.ctrl.Call(m, "LatestCommit", ref)
356 ret0, _ := ret[0].(*git.Commit)
357 ret1, _ := ret[1].(error)
358 return ret0, ret1
359}
361// LatestCommit indicates an expected call of LatestCommit.
362func (mr *MockGitMockRecorder) LatestCommit(ref any) *MockGitLatestCommitCall {
363 mr.mock.ctrl.T.Helper()
364 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestCommit", reflect.TypeOf((*MockGit)(nil).LatestCommit), ref)
365 return &MockGitLatestCommitCall{Call: call}
366}
368// MockGitLatestCommitCall wrap *gomock.Call
369type MockGitLatestCommitCall struct {
370 *gomock.Call
371}
373// Return rewrite *gomock.Call.Return
374func (c *MockGitLatestCommitCall) Return(arg0 *git.Commit, arg1 error) *MockGitLatestCommitCall {
375 c.Call = c.Call.Return(arg0, arg1)
376 return c
377}
379// Do rewrite *gomock.Call.Do
380func (c *MockGitLatestCommitCall) Do(f func(string) (*git.Commit, error)) *MockGitLatestCommitCall {
381 c.Call = c.Call.Do(f)
382 return c
383}
385// DoAndReturn rewrite *gomock.Call.DoAndReturn
386func (c *MockGitLatestCommitCall) DoAndReturn(f func(string) (*git.Commit, error)) *MockGitLatestCommitCall {
387 c.Call = c.Call.DoAndReturn(f)
388 return c
389}
391// Push mocks base method.
392func (m *MockGit) Push(remote, ref string) error {
393 m.ctrl.T.Helper()
394 ret := m.ctrl.Call(m, "Push", remote, ref)
395 ret0, _ := ret[0].(error)
396 return ret0
397}
399// Push indicates an expected call of Push.
400func (mr *MockGitMockRecorder) Push(remote, ref any) *MockGitPushCall {
401 mr.mock.ctrl.T.Helper()
402 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockGit)(nil).Push), remote, ref)
403 return &MockGitPushCall{Call: call}
404}
406// MockGitPushCall wrap *gomock.Call
407type MockGitPushCall struct {
408 *gomock.Call
409}
411// Return rewrite *gomock.Call.Return
412func (c *MockGitPushCall) Return(arg0 error) *MockGitPushCall {
413 c.Call = c.Call.Return(arg0)
414 return c
415}
417// Do rewrite *gomock.Call.Do
418func (c *MockGitPushCall) Do(f func(string, string) error) *MockGitPushCall {
419 c.Call = c.Call.Do(f)
420 return c
421}
423// DoAndReturn rewrite *gomock.Call.DoAndReturn
424func (c *MockGitPushCall) DoAndReturn(f func(string, string) error) *MockGitPushCall {
425 c.Call = c.Call.DoAndReturn(f)
426 return c
427}
429// RemoteBranchExists mocks base method.
430func (m *MockGit) RemoteBranchExists(remote, branch string) (bool, error) {
431 m.ctrl.T.Helper()
432 ret := m.ctrl.Call(m, "RemoteBranchExists", remote, branch)
433 ret0, _ := ret[0].(bool)
434 ret1, _ := ret[1].(error)
435 return ret0, ret1
436}
438// RemoteBranchExists indicates an expected call of RemoteBranchExists.
439func (mr *MockGitMockRecorder) RemoteBranchExists(remote, branch any) *MockGitRemoteBranchExistsCall {
440 mr.mock.ctrl.T.Helper()
441 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteBranchExists", reflect.TypeOf((*MockGit)(nil).RemoteBranchExists), remote, branch)
442 return &MockGitRemoteBranchExistsCall{Call: call}
443}
445// MockGitRemoteBranchExistsCall wrap *gomock.Call
446type MockGitRemoteBranchExistsCall struct {
447 *gomock.Call
448}
450// Return rewrite *gomock.Call.Return
451func (c *MockGitRemoteBranchExistsCall) Return(arg0 bool, arg1 error) *MockGitRemoteBranchExistsCall {
452 c.Call = c.Call.Return(arg0, arg1)
453 return c
454}
456// Do rewrite *gomock.Call.Do
457func (c *MockGitRemoteBranchExistsCall) Do(f func(string, string) (bool, error)) *MockGitRemoteBranchExistsCall {
458 c.Call = c.Call.Do(f)
459 return c
460}
462// DoAndReturn rewrite *gomock.Call.DoAndReturn
463func (c *MockGitRemoteBranchExistsCall) DoAndReturn(f func(string, string) (bool, error)) *MockGitRemoteBranchExistsCall {
464 c.Call = c.Call.DoAndReturn(f)
465 return c
466}
468// UncommittedChangeCount mocks base method.
469func (m *MockGit) UncommittedChangeCount() (int, error) {
470 m.ctrl.T.Helper()
471 ret := m.ctrl.Call(m, "UncommittedChangeCount")
472 ret0, _ := ret[0].(int)
473 ret1, _ := ret[1].(error)
474 return ret0, ret1
475}
477// UncommittedChangeCount indicates an expected call of UncommittedChangeCount.
478func (mr *MockGitMockRecorder) UncommittedChangeCount() *MockGitUncommittedChangeCountCall {
479 mr.mock.ctrl.T.Helper()
480 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UncommittedChangeCount", reflect.TypeOf((*MockGit)(nil).UncommittedChangeCount))
481 return &MockGitUncommittedChangeCountCall{Call: call}
482}
484// MockGitUncommittedChangeCountCall wrap *gomock.Call
485type MockGitUncommittedChangeCountCall struct {
486 *gomock.Call
487}
489// Return rewrite *gomock.Call.Return
490func (c *MockGitUncommittedChangeCountCall) Return(arg0 int, arg1 error) *MockGitUncommittedChangeCountCall {
491 c.Call = c.Call.Return(arg0, arg1)
492 return c
493}
495// Do rewrite *gomock.Call.Do
496func (c *MockGitUncommittedChangeCountCall) Do(f func() (int, error)) *MockGitUncommittedChangeCountCall {
497 c.Call = c.Call.Do(f)
498 return c
499}
501// DoAndReturn rewrite *gomock.Call.DoAndReturn
502func (c *MockGitUncommittedChangeCountCall) DoAndReturn(f func() (int, error)) *MockGitUncommittedChangeCountCall {
503 c.Call = c.Call.DoAndReturn(f)
504 return c
505}
507// UserName mocks base method.
508func (m *MockGit) UserName() (string, error) {
509 m.ctrl.T.Helper()
510 ret := m.ctrl.Call(m, "UserName")
511 ret0, _ := ret[0].(string)
512 ret1, _ := ret[1].(error)
513 return ret0, ret1
514}
516// UserName indicates an expected call of UserName.
517func (mr *MockGitMockRecorder) UserName() *MockGitUserNameCall {
518 mr.mock.ctrl.T.Helper()
519 call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserName", reflect.TypeOf((*MockGit)(nil).UserName))
520 return &MockGitUserNameCall{Call: call}
521}
523// MockGitUserNameCall wrap *gomock.Call
524type MockGitUserNameCall struct {
525 *gomock.Call
526}
528// Return rewrite *gomock.Call.Return
529func (c *MockGitUserNameCall) Return(arg0 string, arg1 error) *MockGitUserNameCall {
530 c.Call = c.Call.Return(arg0, arg1)
531 return c
532}
534// Do rewrite *gomock.Call.Do
535func (c *MockGitUserNameCall) Do(f func() (string, error)) *MockGitUserNameCall {
536 c.Call = c.Call.Do(f)
537 return c
538}
540// DoAndReturn rewrite *gomock.Call.DoAndReturn
541func (c *MockGitUserNameCall) DoAndReturn(f func() (string, error)) *MockGitUserNameCall {
542 c.Call = c.Call.DoAndReturn(f)
543 return c
544}
Diagnostics7 git calls · 333 ms
CallStatusSizeTime0333 ms
discover200185 B3 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch 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=4 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 · hit4 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=4273 git.response.cache=HIT git.response.duration_ms=4 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:0200233 B · hit2 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=4 git.response.bytes=233 git.response.cache=HIT git.response.duration_ms=2 git.fetch.filter=tree:0 git.fetch.wants=be3b2f46264fd78e3aeec243c47ee7f44f4b940d 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=233 git.pkt.payload.max=206 git.sideband.band1.bytes=206 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=206 git.pack.trailer=60d385382f0daa4bf5b182241b9c3f6f6404da58Open pack map
fetchtree:0200140 B · hit4 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=320 git.response.bytes=140 git.response.cache=HIT git.response.duration_ms=4 git.fetch.filter=tree:0 git.fetch.wants=3773ed1dc519371f3fc832ba7706b30d49c9b02a 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=140 git.pkt.payload.max=113 git.sideband.band1.bytes=113 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=113 git.pack.trailer=02e50ef5b7c68e8ccf6b7eaacb59ccc5f78b7e35Open pack map
fetch2002.0 KiB320 ms
git.upload-pack fetch http.response.status_code=200 git.response.bytes=2047 git.response.cache=MISS git.response.duration_ms=320 git.fetch.wants=1f3880f6f930e925850ff946b63ab410c9d0bffb 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=2047 git.pkt.payload.max=2020 git.sideband.band1.bytes=2020 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
- a5e259ec7bf5a23e
- Request
- cce05734…
- 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