GitLabgitlab-org

cli

main
ply8 git calls208 ms101 KiB5 cachedprotocol v2
710 lines21 KiBRaw
1//go:build !integration
3package credentialhelper
5import (
6 "bytes"
7 "context"
8 "encoding/json"
9 "errors"
10 "fmt"
11 "testing"
12 "time"
14 "github.com/MakeNowJust/heredoc/v2"
15 "github.com/stretchr/testify/assert"
16 "github.com/stretchr/testify/require"
17 "github.com/zalando/go-keyring"
18 "go.uber.org/mock/gomock"
19 "golang.org/x/oauth2"
21 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
23 "gitlab.com/gitlab-org/cli/internal/api"
24 "gitlab.com/gitlab-org/cli/internal/cmdutils"
25 "gitlab.com/gitlab-org/cli/internal/config"
26 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
29func (errorResponseType) UnmarshalJSON(b []byte) error {
30 if !bytes.Equal(b, []byte(`"error"`)) {
31 return fmt.Errorf("error response type value must be '`error`' but was '%s'", b)
32 }
34 return nil
37func (successResponseType) UnmarshalJSON(b []byte) error {
38 if !bytes.Equal(b, []byte(`"success"`)) {
39 return fmt.Errorf("success response type value must be '`success`' but was '%s'", b)
40 }
42 return nil
45func TestCredentialHelper_PAT(t *testing.T) {
46 t.Parallel()
48 exec := cmdtest.SetupCmdForTest(
49 t,
50 NewCmd,
51 false,
52 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
53 cmdtest.WithApiClient(cmdtest.NewTestAuthSourceApiClient(t, nil, gitlab.AccessTokenAuthSource{Token: "any-pat"}, "gitlab.example.com")),
54 )
56 out, err := exec("")
58 require.NoError(t, err)
60 var resp response
61 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
62 assert.Equal(t, "https://gitlab.example.com", resp.InstanceURL)
63 assert.Equal(t, "pat", resp.Token.Type)
64 assert.Equal(t, "any-pat", resp.Token.Token)
65 assert.True(t, resp.Token.ExpiryTimestamp.IsZero())
68func TestCredentialHelper_JobToken(t *testing.T) {
69 t.Parallel()
71 exec := cmdtest.SetupCmdForTest(
72 t,
73 NewCmd,
74 false,
75 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
76 cmdtest.WithApiClient(cmdtest.NewTestAuthSourceApiClient(t, nil, gitlab.JobTokenAuthSource{Token: "CI_JOB_TOKEN_12345"}, "gitlab.example.com")),
77 )
79 out, err := exec("")
81 require.NoError(t, err)
83 var resp response
84 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
85 assert.Equal(t, "https://gitlab.example.com", resp.InstanceURL)
86 assert.Equal(t, "job-token", resp.Token.Type)
87 assert.Equal(t, "CI_JOB_TOKEN_12345", resp.Token.Token)
88 assert.True(t, resp.Token.ExpiryTimestamp.IsZero())
89 assert.JSONEq(t,
90 `{"type":"success","instance_url":"https://gitlab.example.com","token":{"type":"job-token","token":"CI_JOB_TOKEN_12345"}}`,
91 out.OutBuf.String(),
92 )
95func TestCredentialHelper_OAuth2AccessTokenOnly(t *testing.T) {
96 t.Parallel()
98 exec := cmdtest.SetupCmdForTest(
99 t,
100 NewCmd,
101 false,
102 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
103 cmdtest.WithApiClient(accessTokenOnlyClient(t, "")),
104 )
106 out, err := exec("")
108 require.NoError(t, err)
110 var resp response
111 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
112 assert.Equal(t, "https://gitlab.example.com", resp.InstanceURL)
113 assert.Equal(t, "oauth2", resp.Token.Type)
114 assert.Equal(t, "bare-access-token", resp.Token.Token)
115 assert.True(t, resp.Token.ExpiryTimestamp.IsZero())
117 // The struct cannot show that a zero expiry is dropped from the wire form.
118 assert.JSONEq(t,
119 `{"type":"success","instance_url":"https://gitlab.example.com","token":{"type":"oauth2","token":"bare-access-token"}}`,
120 out.OutBuf.String(),
121 )
124func TestCredentialHelper_UnsupportedAuthSource(t *testing.T) {
125 t.Parallel()
127 exec := cmdtest.SetupCmdForTest(
128 t,
129 NewCmd,
130 false,
131 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
132 cmdtest.WithApiClient(cmdtest.NewTestAuthSourceApiClient(t, nil, staticHeaderAuthSource{name: "X-Custom-Auth", value: "whatever"}, "gitlab.example.com")),
133 )
135 out, err := exec("")
137 require.NoError(t, err)
139 var resp errorResponse
140 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
141 assert.Equal(t, "unsupported_auth_source", resp.Code)
142 assert.Equal(t, "gitlab.example.com", resp.Host)
143 assert.Equal(t, "unable to determine token", resp.Message)
146// accessTokenOnlyClient builds a client the way NewClientFromConfig does for a
147// host with is_oauth2 set and no refresh token, so the test covers the real
148// construction rather than a hand-made auth source.
149func accessTokenOnlyClient(t *testing.T, expiryDate string) *api.Client {
150 t.Helper()
152 cfg := "hosts:\n gitlab.example.com:\n is_oauth2: \"true\"\n token: bare-access-token\n"
153 if expiryDate != "" {
154 cfg += " oauth2_expiry_date: \"" + expiryDate + "\"\n"
155 }
157 client, err := api.NewClientFromConfig("gitlab.example.com", config.NewFromString(cfg), false, "test", api.WithoutTokenFromEnvironment())
158 require.NoError(t, err)
159 return client
162// staticHeaderAuthSource stands in for an auth source this command does not
163// know about.
164type staticHeaderAuthSource struct {
165 name string
166 value string
169func (staticHeaderAuthSource) Init(context.Context, *gitlab.Client) error { return nil }
171func (s staticHeaderAuthSource) Header(context.Context) (string, string, error) {
172 return s.name, s.value, nil
175func TestCredentialHelper_OAuth2(t *testing.T) {
176 t.Parallel()
178 expiryTime := time.Now().Add(1 * time.Hour).UTC().Truncate(time.Second)
180 ctrl := gomock.NewController(t)
181 mockTokenSource := NewMockTokenSource(ctrl)
182 mockTokenSource.EXPECT().Token().Return(&oauth2.Token{
183 AccessToken: "oauth2-access-token",
184 Expiry: expiryTime,
185 }, nil)
187 exec := cmdtest.SetupCmdForTest(
188 t,
189 NewCmd,
190 false,
191 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
192 cmdtest.WithConfig(config.NewFromString(heredoc.Doc(`
193 hosts:
194 gitlab.example.com:
195 is_oauth2: "true"
196 token: old-token
197 `))),
198 cmdtest.WithApiClient(cmdtest.NewTestAuthSourceApiClient(t, nil, gitlab.OAuthTokenSource{TokenSource: mockTokenSource}, "gitlab.example.com")),
199 )
201 out, err := exec("")
203 require.NoError(t, err)
205 var resp response
206 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
207 assert.Equal(t, "https://gitlab.example.com", resp.InstanceURL)
208 assert.Equal(t, "oauth2", resp.Token.Type)
209 assert.Equal(t, "oauth2-access-token", resp.Token.Token)
210 assert.Equal(t, expiryTime.UTC(), resp.Token.ExpiryTimestamp.UTC().Truncate(time.Second))
213func TestCredentialHelper_OAuth2_RefreshError(t *testing.T) {
214 t.Parallel()
216 ctrl := gomock.NewController(t)
217 mockTokenSource := NewMockTokenSource(ctrl)
218 mockTokenSource.EXPECT().Token().Return(nil, errors.New("token refresh failed"))
220 exec := cmdtest.SetupCmdForTest(
221 t,
222 NewCmd,
223 false,
224 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
225 cmdtest.WithConfig(config.NewFromString(heredoc.Doc(`
226 hosts:
227 gitlab.example.com:
228 is_oauth2: "true"
229 `))),
230 cmdtest.WithApiClient(cmdtest.NewTestAuthSourceApiClient(t, nil, gitlab.OAuthTokenSource{TokenSource: mockTokenSource}, "gitlab.example.com")),
231 )
233 out, err := exec("")
235 require.NoError(t, err)
237 var resp errorResponse
238 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
239 assert.Equal(t, "refresh_failed", resp.Code)
240 assert.Equal(t, "gitlab.example.com", resp.Host)
241 assert.Empty(t, resp.OAuthError)
242 assert.Contains(t, resp.Message, "gitlab.example.com", "the host must be named")
243 assert.Contains(t, resp.Message, "failed to refresh the OAuth2 token")
244 assert.Contains(t, resp.Message, "token refresh failed", "the underlying cause must survive")
247func TestCredentialHelper_OAuth2_RefreshRetrieveError(t *testing.T) {
248 t.Parallel()
250 ctrl := gomock.NewController(t)
251 mockTokenSource := NewMockTokenSource(ctrl)
252 mockTokenSource.EXPECT().Token().Return(nil, &oauth2.RetrieveError{
253 ErrorCode: "invalid_grant",
254 ErrorDescription: "The provided authorization grant is invalid, expired, or revoked.",
255 })
257 exec := cmdtest.SetupCmdForTest(
258 t,
259 NewCmd,
260 false,
261 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
262 cmdtest.WithApiClient(cmdtest.NewTestAuthSourceApiClient(t, nil, gitlab.OAuthTokenSource{TokenSource: mockTokenSource}, "gitlab.example.com")),
263 )
265 out, err := exec("")
267 require.NoError(t, err)
269 var resp errorResponse
270 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
271 assert.Equal(t, "refresh_failed", resp.Code)
272 assert.Equal(t, "gitlab.example.com", resp.Host)
273 assert.Equal(t, "invalid_grant", resp.OAuthError)
274 assert.Contains(t, resp.Message, "failed to refresh the OAuth2 token")
277func TestCredentialHelper_BaseRepoError(t *testing.T) {
278 t.Parallel()
280 exec := cmdtest.SetupCmdForTest(
281 t,
282 NewCmd,
283 false,
284 cmdtest.WithBaseRepoError(errors.New("not a git repository")),
285 cmdtest.WithApiClient(cmdtest.NewTestAuthSourceApiClient(t, nil, gitlab.AccessTokenAuthSource{Token: "any-pat"}, "gitlab.example.com")),
286 )
288 out, err := exec("")
290 require.NoError(t, err)
292 var resp response
293 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
294 assert.Equal(t, "https://gitlab.example.com", resp.InstanceURL)
295 assert.Equal(t, "pat", resp.Token.Type)
296 assert.Equal(t, "any-pat", resp.Token.Token)
297 assert.True(t, resp.Token.ExpiryTimestamp.IsZero())
300func TestCredentialHelper_BaseRepoError_NotAuthenticated(t *testing.T) {
301 t.Parallel()
303 exec := cmdtest.SetupCmdForTest(
304 t,
305 NewCmd,
306 false,
307 cmdtest.WithBaseRepoError(errors.New("not a git repository")),
308 cmdtest.WithDefaultHostname("gitlab.example.com:8443"),
309 cmdtest.WithApiClientFunc(func(repoHost string) (*api.Client, error) {
310 assert.Equal(t, "gitlab.example.com:8443", repoHost)
311 return cmdtest.NewTestAuthSourceApiClient(t, nil, gitlab.Unauthenticated{}, repoHost), nil
312 }),
313 )
315 out, err := exec("")
317 require.NoError(t, err)
319 var resp errorResponse
320 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
321 assert.Equal(t, "not_authenticated", resp.Code)
322 assert.Equal(t, "gitlab.example.com:8443", resp.Host)
323 assert.Equal(t, "glab is not authenticated. Use glab auth login to authenticate", resp.Message)
326func TestCredentialHelper_BaseRepoError_RefreshError(t *testing.T) {
327 t.Parallel()
329 ctrl := gomock.NewController(t)
330 mockTokenSource := NewMockTokenSource(ctrl)
331 mockTokenSource.EXPECT().Token().Return(nil, errors.New("token refresh failed"))
333 exec := cmdtest.SetupCmdForTest(
334 t,
335 NewCmd,
336 false,
337 cmdtest.WithBaseRepoError(errors.New("not a git repository")),
338 cmdtest.WithDefaultHostname("gitlab.example.com"),
339 cmdtest.WithApiClient(cmdtest.NewTestAuthSourceApiClient(t, nil, gitlab.OAuthTokenSource{TokenSource: mockTokenSource}, "gitlab.example.com")),
340 )
342 out, err := exec("")
344 require.NoError(t, err)
346 var resp errorResponse
347 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
348 assert.Equal(t, "refresh_failed", resp.Code)
349 assert.Equal(t, "gitlab.example.com", resp.Host)
350 assert.Contains(t, resp.Message, `failed to read the credentials for "gitlab.example.com": `)
353func TestCredentialHelper_BaseRepoError_APIHost(t *testing.T) {
354 clearTokenEnv(t)
356 cfg := config.NewFromString(heredoc.Doc(`
357 hosts:
358 gitlab.example.com:
359 api_host: api.gitlab.example.com
360 `))
362 exec := cmdtest.SetupCmdForTest(
363 t,
364 NewCmd,
365 false,
366 cmdtest.WithBaseRepoError(errors.New("not a git repository")),
367 cmdtest.WithDefaultHostname("gitlab.example.com"),
368 cmdtest.WithApiClientFunc(func(repoHost string) (*api.Client, error) {
369 // Same fallback as DefaultFactory.ApiClient.
370 if repoHost == "" {
371 repoHost = "gitlab.example.com"
372 }
373 return api.NewClientFromConfig(repoHost, cfg, false, "test")
374 }),
375 )
377 out, err := exec("")
379 require.NoError(t, err)
381 var resp errorResponse
382 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
383 assert.Equal(t, "not_authenticated", resp.Code)
384 assert.Equal(t, "gitlab.example.com", resp.Host)
387func TestCredentialHelper_ApiClientUnauthenticated(t *testing.T) {
388 t.Parallel()
390 exec := cmdtest.SetupCmdForTest(
391 t,
392 NewCmd,
393 false,
394 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
395 cmdtest.WithApiClient(cmdtest.NewTestAuthSourceApiClient(t, nil, gitlab.Unauthenticated{}, "gitlab.example.com")),
396 )
398 out, err := exec("")
400 require.NoError(t, err)
402 var resp errorResponse
403 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
404 assert.Equal(t, "not_authenticated", resp.Code)
405 assert.Equal(t, "gitlab.example.com", resp.Host)
406 assert.Equal(t, "glab is not authenticated. Use glab auth login to authenticate", resp.Message)
409func TestCredentialHelper_NoToken(t *testing.T) {
410 t.Parallel()
412 exec := cmdtest.SetupCmdForTest(
413 t,
414 NewCmd,
415 false,
416 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
417 )
419 out, err := exec("")
421 require.NoError(t, err)
423 var resp errorResponse
424 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
425 assert.Equal(t, "unsupported_auth_source", resp.Code)
426 assert.Equal(t, "gitlab.example.com", resp.Host)
427 assert.Equal(t, "unable to determine token", resp.Message)
430func TestCredentialHelper_RepoOverride(t *testing.T) {
431 t.Parallel()
433 exec := cmdtest.SetupCmdForTest(
434 t,
435 NewCmd,
436 false,
437 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
438 cmdtest.WithApiClient(cmdtest.NewTestAuthSourceApiClient(t, nil, gitlab.AccessTokenAuthSource{Token: "example-token"}, "gitlab.example.com")),
439 )
441 out, err := exec("--repo gitlab.example.com/owner/repo")
443 require.NoError(t, err)
445 var resp response
446 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
447 assert.Equal(t, "https://gitlab.example.com", resp.InstanceURL)
448 assert.Equal(t, "pat", resp.Token.Type)
449 assert.Equal(t, "example-token", resp.Token.Token)
452func TestCredentialHelper_InvalidRepoOverride(t *testing.T) {
453 t.Parallel()
455 exec := cmdtest.SetupCmdForTest(
456 t,
457 NewCmd,
458 false,
459 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
460 )
462 out, err := exec("--repo invalid")
464 require.ErrorIs(t, err, cmdutils.SilentError)
466 var resp errorResponse
467 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
468 assert.Equal(t, "invalid_repo_override", resp.Code)
469 assert.Empty(t, resp.Host)
470 assert.Equal(t, `expected the "[HOST/]OWNER/[NAMESPACE/]REPO" format, got "invalid"`, resp.Message)
471 assert.JSONEq(t,
472 `{"type":"error","code":"invalid_repo_override","message":"expected the \"[HOST/]OWNER/[NAMESPACE/]REPO\" format, got \"invalid\""}`,
473 out.OutBuf.String(),
474 )
477func clearTokenEnv(t *testing.T) {
478 t.Helper()
480 for _, name := range []string{
481 "GITLAB_TOKEN", "GITLAB_ACCESS_TOKEN", "OAUTH_TOKEN", "GLAB_IS_OAUTH2",
482 "JOB_TOKEN", "CI_JOB_TOKEN", "GITLAB_CI", "GLAB_ENABLE_CI_AUTOLOGIN",
483 "GLAB_USE_KEYRING", "USE_KEYRING",
484 } {
485 t.Setenv(name, "")
486 }
489func TestCredentialHelper_NotAuthenticated_OAuth2NoToken(t *testing.T) {
490 clearTokenEnv(t)
492 cfg := config.NewFromString(heredoc.Doc(`
493 hosts:
494 gitlab.example.com:
495 is_oauth2: "true"
496 `))
498 exec := cmdtest.SetupCmdForTest(
499 t,
500 NewCmd,
501 false,
502 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
503 cmdtest.WithApiClientFunc(func(repoHost string) (*api.Client, error) {
504 return api.NewClientFromConfig(repoHost, cfg, false, "test")
505 }),
506 )
508 out, err := exec("")
510 require.NoError(t, err)
512 var resp errorResponse
513 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
514 assert.Equal(t, "not_authenticated", resp.Code)
515 assert.Equal(t, "gitlab.example.com", resp.Host)
516 assert.Equal(t, "OAuth2 authentication is configured for \"gitlab.example.com\" but no access or refresh token was found (the stored credentials may be missing or incomplete); run `glab auth login --hostname gitlab.example.com` to re-authenticate", resp.Message)
519func TestCredentialHelper_NotAuthenticated_KeyringTokenMissing(t *testing.T) {
520 clearTokenEnv(t)
521 keyring.MockInit()
522 t.Cleanup(keyring.MockInit)
524 cfg := config.NewFromString(heredoc.Doc(`
525 hosts:
526 gitlab.example.com:
527 use_keyring: "true"
528 `))
530 exec := cmdtest.SetupCmdForTest(
531 t,
532 NewCmd,
533 false,
534 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
535 cmdtest.WithApiClientFunc(func(repoHost string) (*api.Client, error) {
536 return api.NewClientFromConfig(repoHost, cfg, false, "test")
537 }),
538 )
540 out, err := exec("")
542 require.NoError(t, err)
544 var resp errorResponse
545 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
546 assert.Equal(t, "not_authenticated", resp.Code)
547 assert.Equal(t, "gitlab.example.com", resp.Host)
548 assert.Equal(t, "the token for \"gitlab.example.com\" is missing from the operating system keyring; run `glab auth login --hostname gitlab.example.com` to re-authenticate", resp.Message)
551func TestCredentialHelper_KeyringUnavailable_ApiClient(t *testing.T) {
552 t.Setenv("GITLAB_TOKEN", "")
553 keyring.MockInitWithError(errors.New("keyring locked"))
554 t.Cleanup(keyring.MockInit)
556 cfg := config.NewBlankConfig()
557 require.NoError(t, cfg.Set("gitlab.example.com", "use_keyring", "true"))
559 exec := cmdtest.SetupCmdForTest(
560 t,
561 NewCmd,
562 false,
563 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
564 cmdtest.WithApiClientFunc(func(repoHost string) (*api.Client, error) {
565 return api.NewClientFromConfig(repoHost, cfg, false, "test")
566 }),
567 )
569 out, err := exec("")
571 require.NoError(t, err)
573 var resp errorResponse
574 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
575 assert.Equal(t, "keyring_unavailable", resp.Code)
576 assert.Equal(t, "gitlab.example.com", resp.Host)
577 assert.Equal(t, `failed to read the access token for "gitlab.example.com": failed to read "token" from the operating system keyring for host "gitlab.example.com": keyring locked`, resp.Message)
580func TestCredentialHelper_KeyringUnavailable_OAuth2Refresh(t *testing.T) {
581 keyring.MockInitWithError(errors.New("keyring locked"))
582 t.Cleanup(keyring.MockInit)
584 probeErr := config.CredentialWriteProbe(config.NewFromString(heredoc.Doc(`
585 hosts:
586 gitlab.example.com:
587 use_keyring: "true"
588 `)), "gitlab.example.com")
589 require.Error(t, probeErr)
591 ctrl := gomock.NewController(t)
592 mockTokenSource := NewMockTokenSource(ctrl)
593 mockTokenSource.EXPECT().Token().Return(nil, fmt.Errorf("not refreshing the OAuth token for %q, because the refreshed credentials could not be saved: %w", "gitlab.example.com", probeErr))
595 exec := cmdtest.SetupCmdForTest(
596 t,
597 NewCmd,
598 false,
599 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
600 cmdtest.WithApiClient(cmdtest.NewTestAuthSourceApiClient(t, nil, gitlab.OAuthTokenSource{TokenSource: mockTokenSource}, "gitlab.example.com")),
601 )
603 out, err := exec("")
605 require.NoError(t, err)
607 var resp errorResponse
608 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
609 assert.Equal(t, "keyring_unavailable", resp.Code)
610 assert.Equal(t, "gitlab.example.com", resp.Host)
611 assert.Equal(t, `failed to read the credentials for "gitlab.example.com": failed to refresh the OAuth2 token: not refreshing the OAuth token for "gitlab.example.com", because the refreshed credentials could not be saved: host "gitlab.example.com" stores credentials in the operating system keyring, but the keyring is not accepting writes: keyring locked`, resp.Message)
614func TestCredentialHelper_UnknownError(t *testing.T) {
615 t.Parallel()
617 t.Run("with resolved host", func(t *testing.T) {
618 t.Parallel()
620 exec := cmdtest.SetupCmdForTest(
621 t,
622 NewCmd,
623 false,
624 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
625 cmdtest.WithApiClientFunc(func(repoHost string) (*api.Client, error) {
626 return nil, errors.New("failed to initialize client")
627 }),
628 )
630 out, err := exec("")
632 require.NoError(t, err)
634 var resp errorResponse
635 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
636 assert.Equal(t, "unknown", resp.Code)
637 assert.Equal(t, "gitlab.example.com", resp.Host)
638 assert.Equal(t, "failed to initialize client", resp.Message)
639 })
641 t.Run("with default host", func(t *testing.T) {
642 t.Parallel()
644 exec := cmdtest.SetupCmdForTest(
645 t,
646 NewCmd,
647 false,
648 cmdtest.WithBaseRepoError(errors.New("not a git repository")),
649 cmdtest.WithDefaultHostname("gitlab.example.com"),
650 cmdtest.WithApiClientFunc(func(repoHost string) (*api.Client, error) {
651 return nil, errors.New("failed to initialize client")
652 }),
653 )
655 out, err := exec("")
657 require.NoError(t, err)
659 var resp errorResponse
660 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
661 assert.Equal(t, "unknown", resp.Code)
662 assert.Equal(t, "gitlab.example.com", resp.Host)
663 assert.Equal(t, "failed to initialize client", resp.Message)
664 })
667// PasswordCredentialsAuthSource embeds a nil gitlab.AuthSource until Init, so
668// its Header dereferences nil.
669func TestCredentialHelper_UninitialisedAuthSource(t *testing.T) {
670 t.Parallel()
672 exec := cmdtest.SetupCmdForTest(
673 t,
674 NewCmd,
675 false,
676 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
677 cmdtest.WithApiClient(cmdtest.NewTestAuthSourceApiClient(t, nil, &gitlab.PasswordCredentialsAuthSource{Password: "a-password"}, "gitlab.example.com")),
678 )
680 out, err := exec("")
682 require.NoError(t, err)
684 var resp errorResponse
685 require.NoError(t, json.Unmarshal(out.OutBuf.Bytes(), &resp))
686 assert.Equal(t, "unsupported_auth_source", resp.Code)
687 assert.Equal(t, "gitlab.example.com", resp.Host)
688 assert.Equal(t, "unable to determine token", resp.Message)
691func TestCredentialHelper_OAuth2AccessTokenOnlyReportsStoredExpiry(t *testing.T) {
692 t.Parallel()
694 expiry := time.Date(2099, time.January, 2, 3, 4, 5, 0, time.UTC)
695 exec := cmdtest.SetupCmdForTest(
696 t,
697 NewCmd,
698 false,
699 cmdtest.WithBaseRepo("OWNER", "REPO", "gitlab.example.com"),
700 cmdtest.WithApiClient(accessTokenOnlyClient(t, expiry.Format(time.RFC3339))),
701 )
703 out, err := exec("")
705 require.NoError(t, err)
706 assert.JSONEq(t,
707 `{"type":"success","instance_url":"https://gitlab.example.com","token":{"type":"oauth2","token":"bare-access-token","expiry_timestamp":"2099-01-02T03:04:05Z"}}`,
708 out.OutBuf.String(),
709 )
Diagnostics8 git calls · 208 ms
CallStatusSizeTime0208 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 KiB3 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=3
git.response.bytes=59849
git.response.cache=UPDATING
git.response.duration_ms=3
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
fetchcombine:blob:none+tree:2 · deepen 12004.2 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=4273
git.response.cache=HIT
git.response.duration_ms=2
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:0 · deepen 1020032 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=32926
git.response.cache=HIT
git.response.duration_ms=4
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=44
Open pack map
fetchtree:02001.8 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=1857
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=dce174ff8c632a19d17eea99c8a9b7c37fb2b592
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=1857
git.pkt.payload.max=1830
git.sideband.band1.bytes=1830
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=1830
git.pack.trailer=fb03183b7909876778f740d196d7516811003517
Open pack map
fetchtree:0200358 B · 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=358
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=5d783fac547a70b19ca138c47d067b44febb52da
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=358
git.pkt.payload.max=331
git.sideband.band1.bytes=331
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=331
git.pack.trailer=22a484e5ecad6d6e62b224e8a7f90cf5ff085938
Open pack map
fetchtree:0200210 B · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=196
git.response.bytes=210
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=fdc25df6aed20e918abcba0c5926ee346b0b6156
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=210
git.pkt.payload.max=183
git.sideband.band1.bytes=183
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=183
git.pack.trailer=de1eb375f226089570c36c780ef053302b0a08a9
Open pack map
fetch2003.4 KiB197 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=3457
git.response.cache=MISS
git.response.duration_ms=197
git.fetch.wants=c8afe1073833edd528d1b667fbd0b996f7d01875
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=3457
git.pkt.payload.max=3430
git.sideband.band1.bytes=3430
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
a5e2fa503b8690c0
Request
cf983d0b…
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