GitLabgitlab-org

cli

main
ply6 git calls45 ms102 KiB5 cachedprotocol v2
905 lines31 KiBRaw
1package api
3import (
4 "context"
5 "crypto/sha256"
6 "errors"
7 "fmt"
8 "io"
9 "net"
10 "net/http"
11 "net/http/httptest"
12 "net/url"
13 "os"
14 "path/filepath"
15 "strings"
16 "sync/atomic"
17 "testing"
18 "time"
20 "github.com/stretchr/testify/assert"
21 "github.com/stretchr/testify/require"
22 "github.com/zalando/go-keyring"
24 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
26 "gitlab.com/gitlab-org/cli/internal/config"
29type roundTripFunc func(*http.Request) (*http.Response, error)
31func (f roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
32 return f(req)
35func TestBuildInfoUserAgent(t *testing.T) {
36 tests := []struct {
37 name string
38 buildInfo BuildInfo
39 expectedUA string
40 }{
41 {
42 name: "without coding agent",
43 buildInfo: BuildInfo{
44 Version: "1.50.0",
45 Platform: "linux",
46 Architecture: "amd64",
47 },
48 expectedUA: "glab/1.50.0 (linux, amd64)",
49 },
50 {
51 name: "with coding agent",
52 buildInfo: BuildInfo{
53 Version: "1.50.0",
54 Platform: "darwin",
55 Architecture: "arm64",
56 CodingAgent: "claude-code",
57 },
58 expectedUA: "glab/1.50.0 (darwin, arm64) Coding-Agent/claude-code",
59 },
60 {
61 name: "empty coding agent omits suffix",
62 buildInfo: BuildInfo{
63 Version: "DEV",
64 Platform: "windows",
65 Architecture: "amd64",
66 CodingAgent: "",
67 },
68 expectedUA: "glab/DEV (windows, amd64)",
69 },
70 }
72 for _, tt := range tests {
73 t.Run(tt.name, func(t *testing.T) {
74 assert.Equal(t, tt.expectedUA, tt.buildInfo.UserAgent())
75 })
76 }
79func TestNewClientFromConfig(t *testing.T) {
80 t.Setenv("GITLAB_TOKEN", "")
81 t.Setenv("GITLAB_ACCESS_TOKEN", "")
82 t.Setenv("OAUTH_TOKEN", "")
83 t.Setenv("GLAB_IS_OAUTH2", "")
84 t.Setenv("JOB_TOKEN", "")
85 t.Setenv("CI_JOB_TOKEN", "")
86 t.Setenv("GITLAB_CI", "")
87 t.Setenv("GLAB_ENABLE_CI_AUTOLOGIN", "")
88 t.Setenv("CI_SERVER_FQDN", "")
89 t.Setenv("CI_SERVER_PROTOCOL", "")
90 t.Setenv("GITLAB_HOST", "")
91 t.Setenv("GITLAB_API_HOST", "")
92 t.Setenv("API_PROTOCOL", "")
94 tests := []struct {
95 name string
96 envVars map[string]string
97 repoHost string
98 expectedAuthKey string
99 expectedAuthVal string
100 expectedBaseURL string
101 }{
102 {
103 // GITLAB_HOST makes the passed-in host the default host, for
104 // which environment credentials resolve.
105 name: "OAuth2 access token",
106 envVars: map[string]string{
107 "GITLAB_TOKEN": "oauth2-access-token",
108 "GLAB_IS_OAUTH2": "true",
109 "GITLAB_HOST": "example.com",
110 },
111 repoHost: "example.com",
112 expectedAuthKey: "Authorization",
113 expectedAuthVal: "Bearer oauth2-access-token",
114 expectedBaseURL: "https://example.com/api/v4/",
115 },
116 {
117 name: "PAT auth",
118 envVars: map[string]string{
119 "GITLAB_TOKEN": "some-pat",
120 "GITLAB_HOST": "example.com",
121 },
122 repoHost: "example.com",
123 expectedAuthKey: gitlab.AccessTokenHeaderName,
124 expectedAuthVal: "some-pat",
125 expectedBaseURL: "https://example.com/api/v4/",
126 },
127 {
128 name: "job token from env without CI",
129 envVars: map[string]string{
130 "JOB_TOKEN": "my-job-token",
131 "GITLAB_HOST": "example.com",
132 },
133 repoHost: "example.com",
134 expectedAuthKey: gitlab.JobTokenHeaderName,
135 expectedAuthVal: "my-job-token",
136 expectedBaseURL: "https://example.com/api/v4/",
137 },
138 {
139 name: "custom protocol from env",
140 envVars: map[string]string{
141 "GITLAB_TOKEN": "my-pat",
142 "GITLAB_HOST": "example.com",
143 "API_PROTOCOL": "http",
144 },
145 repoHost: "example.com",
146 expectedAuthKey: gitlab.AccessTokenHeaderName,
147 expectedAuthVal: "my-pat",
148 expectedBaseURL: "http://example.com/api/v4/",
149 },
150 {
151 // Under CI auto-login the CI server is the default host, so
152 // environment credentials resolve for it.
153 name: "CI auto-login uses CI variables",
154 envVars: map[string]string{
155 "GLAB_ENABLE_CI_AUTOLOGIN": "true",
156 "GITLAB_CI": "true",
157 "CI_JOB_TOKEN": "ci-tok",
158 "CI_SERVER_FQDN": "ci.example.com",
159 },
160 repoHost: "ci.example.com",
161 expectedAuthKey: gitlab.JobTokenHeaderName,
162 expectedAuthVal: "ci-tok",
163 expectedBaseURL: "https://ci.example.com/api/v4/",
164 },
165 {
166 name: "CI auto-login with custom protocol",
167 envVars: map[string]string{
168 "GLAB_ENABLE_CI_AUTOLOGIN": "true",
169 "GITLAB_CI": "true",
170 "CI_JOB_TOKEN": "ci-tok",
171 "CI_SERVER_FQDN": "ci.example.com",
172 "CI_SERVER_PROTOCOL": "http",
173 },
174 repoHost: "ci.example.com",
175 expectedAuthKey: gitlab.JobTokenHeaderName,
176 expectedAuthVal: "ci-tok",
177 expectedBaseURL: "http://ci.example.com/api/v4/",
178 },
179 {
180 name: "CI auto-login PAT takes precedence over job token",
181 envVars: map[string]string{
182 "GLAB_ENABLE_CI_AUTOLOGIN": "true",
183 "GITLAB_CI": "true",
184 "GITLAB_TOKEN": "my-pat",
185 "CI_JOB_TOKEN": "ci-tok",
186 "CI_SERVER_FQDN": "ci.example.com",
187 },
188 repoHost: "ci.example.com",
189 expectedAuthKey: gitlab.AccessTokenHeaderName,
190 expectedAuthVal: "my-pat",
191 expectedBaseURL: "https://ci.example.com/api/v4/",
192 },
193 {
194 name: "CI auto-login disabled falls back to PAT and passed-in host",
195 envVars: map[string]string{
196 "GITLAB_CI": "true",
197 "GLAB_ENABLE_CI_AUTOLOGIN": "false",
198 "GITLAB_TOKEN": "my-pat",
199 "GITLAB_HOST": "manual.example.com",
200 "CI_JOB_TOKEN": "ci-tok",
201 "CI_SERVER_FQDN": "ci.example.com",
202 },
203 repoHost: "manual.example.com",
204 expectedAuthKey: gitlab.AccessTokenHeaderName,
205 expectedAuthVal: "my-pat",
206 expectedBaseURL: "https://manual.example.com/api/v4/",
207 },
208 }
210 for _, tt := range tests {
211 t.Run(tt.name, func(t *testing.T) {
212 for k, v := range tt.envVars {
213 t.Setenv(k, v)
214 }
216 client, err := NewClientFromConfig(
217 tt.repoHost,
218 config.NewBlankConfig(),
219 false,
220 "test-agent",
221 )
222 require.NoError(t, err)
224 key, value, err := client.AuthSource().Header(t.Context())
225 require.NoError(t, err)
226 assert.Equal(t, tt.expectedAuthKey, key)
227 assert.Equal(t, tt.expectedAuthVal, value)
228 assert.Equal(t, tt.expectedBaseURL, client.BaseURL())
229 })
230 }
233// TestNewClientFromConfig_EnvTokenScopedToTrustedHosts pins the fix for
234// https://gitlab.com/gitlab-org/cli/-/work_items/8545: a token from the
235// environment is never sent to a host named only in a command argument.
236func TestNewClientFromConfig_EnvTokenScopedToTrustedHosts(t *testing.T) {
237 for _, k := range []string{
238 "GITLAB_ACCESS_TOKEN", "OAUTH_TOKEN", "GLAB_IS_OAUTH2", "JOB_TOKEN",
239 "CI_JOB_TOKEN", "GITLAB_CI", "GLAB_ENABLE_CI_AUTOLOGIN", "CI_SERVER_FQDN",
240 "GITLAB_HOST", "GITLAB_API_HOST", "API_PROTOCOL",
241 } {
242 t.Setenv(k, "")
243 }
244 t.Setenv("GITLAB_TOKEN", "env-pat")
246 assertAuthHeader := func(t *testing.T, client *Client, expectedValue string) {
247 t.Helper()
248 _, value, err := client.AuthSource().Header(t.Context())
249 require.NoError(t, err)
250 assert.Equal(t, expectedValue, value)
251 }
253 t.Run("withheld from a host that is neither default nor configured", func(t *testing.T) {
254 client, err := NewClientFromConfig("attacker.example.com", config.NewBlankConfig(), false, "test-agent")
255 require.NoError(t, err)
257 // No credential must be attached: the client is unauthenticated.
258 _, _, err = client.AuthSource().Header(t.Context())
259 require.ErrorContains(t, err, "unauthenticated")
260 })
262 t.Run("sent to the default host", func(t *testing.T) {
263 client, err := NewClientFromConfig("gitlab.com", config.NewBlankConfig(), false, "test-agent")
264 require.NoError(t, err)
265 assertAuthHeader(t, client, "env-pat")
266 })
268 t.Run("sent to the default host named by GITLAB_HOST", func(t *testing.T) {
269 t.Setenv("GITLAB_HOST", "gitlab.example.com")
271 client, err := NewClientFromConfig("gitlab.example.com", config.NewBlankConfig(), false, "test-agent")
272 require.NoError(t, err)
273 assertAuthHeader(t, client, "env-pat")
274 })
276 t.Run("sent to the default host named by GITLAB_HOST with a subfolder", func(t *testing.T) {
277 t.Setenv("GITLAB_HOST", "https://gitlab.example.com/gitlab")
279 client, err := NewClientFromConfig("gitlab.example.com/gitlab", config.NewBlankConfig(), false, "test-agent")
280 require.NoError(t, err)
281 assertAuthHeader(t, client, "env-pat")
282 })
284 t.Run("sent to a configured host", func(t *testing.T) {
285 cfg := config.NewFromString("hosts:\n gitlab.example.com:\n user: someone\n")
287 client, err := NewClientFromConfig("gitlab.example.com", cfg, false, "test-agent")
288 require.NoError(t, err)
289 assertAuthHeader(t, client, "env-pat")
290 })
293func TestNewClientFromConfig_AuthContextPrecedence(t *testing.T) {
294 tests := []struct {
295 name string
296 envVars map[string]string
297 expectedAuthKey string
298 expectedAuthValue string
299 expectedRefreshes int64
300 expectConfigUnchanged bool
301 }{
302 {
303 name: "GITLAB_TOKEN PAT overrides stored OAuth",
304 envVars: map[string]string{"GITLAB_TOKEN": "env-pat"},
305 expectedAuthKey: gitlab.AccessTokenHeaderName,
306 expectedAuthValue: "env-pat",
307 expectConfigUnchanged: true,
308 },
309 {
310 name: "GITLAB_ACCESS_TOKEN PAT overrides stored OAuth",
311 envVars: map[string]string{"GITLAB_ACCESS_TOKEN": "env-pat"},
312 expectedAuthKey: gitlab.AccessTokenHeaderName,
313 expectedAuthValue: "env-pat",
314 expectConfigUnchanged: true,
315 },
316 {
317 name: "OAUTH_TOKEN preserves stored OAuth context",
318 envVars: map[string]string{"OAUTH_TOKEN": "environment-oauth-token"},
319 expectedAuthKey: "Authorization",
320 expectedAuthValue: "Bearer refreshed-access-token",
321 expectedRefreshes: 1,
322 },
323 {
324 name: "stored OAuth is preserved without an override",
325 expectedAuthKey: "Authorization",
326 expectedAuthValue: "Bearer refreshed-access-token",
327 expectedRefreshes: 1,
328 },
329 {
330 name: "explicit environment OAuth is preserved",
331 envVars: map[string]string{
332 "GITLAB_TOKEN": "environment-oauth-token",
333 "GLAB_IS_OAUTH2": "true",
334 },
335 expectedAuthKey: "Authorization",
336 expectedAuthValue: "Bearer refreshed-access-token",
337 expectedRefreshes: 1,
338 },
339 }
341 for _, tt := range tests {
342 t.Run(tt.name, func(t *testing.T) {
343 t.Setenv("GITLAB_TOKEN", "")
344 t.Setenv("GITLAB_ACCESS_TOKEN", "")
345 t.Setenv("OAUTH_TOKEN", "")
346 t.Setenv("GLAB_IS_OAUTH2", "")
347 for key, value := range tt.envVars {
348 t.Setenv(key, value)
349 }
351 var refreshRequests atomic.Int64
352 server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
353 refreshRequests.Add(1)
354 w.Header().Set("Content-Type", "application/json")
355 _, _ = io.WriteString(w, `{"access_token":"refreshed-access-token","token_type":"Bearer","refresh_token":"refreshed-refresh-token","expires_in":3600}`)
356 }))
357 t.Cleanup(server.Close)
359 hostname := strings.TrimPrefix(server.URL, "https://")
360 configDir := t.TempDir()
361 cfg := config.NewBlankConfigInDir(configDir)
362 require.NoError(t, cfg.Set(hostname, "api_host", hostname))
363 require.NoError(t, cfg.Set(hostname, "client_id", "test-client-id"))
364 require.NoError(t, cfg.Set(hostname, "skip_tls_verify", "true"))
365 require.NoError(t, cfg.Set(hostname, "is_oauth2", "true"))
366 require.NoError(t, cfg.Set(hostname, "token", "stored-oauth-token"))
367 require.NoError(t, cfg.Set(hostname, "oauth2_refresh_token", "stored-refresh-token"))
368 require.NoError(t, cfg.Set(hostname, "oauth2_expiry_date", time.Now().Add(-time.Hour).Format(time.RFC3339)))
369 require.NoError(t, cfg.Write())
371 configPath := filepath.Join(configDir, "config.yml")
372 configBefore, err := os.ReadFile(configPath)
373 require.NoError(t, err)
375 client, err := NewClientFromConfig(hostname, cfg, false, "test-agent")
376 require.NoError(t, err)
378 key, value, err := client.AuthSource().Header(t.Context())
379 require.NoError(t, err)
380 assert.Equal(t, tt.expectedAuthKey, key)
381 assert.Equal(t, tt.expectedAuthValue, value)
382 assert.Equal(t, tt.expectedRefreshes, refreshRequests.Load())
384 configAfter, err := os.ReadFile(configPath)
385 require.NoError(t, err)
386 if tt.expectConfigUnchanged {
387 assert.Equal(t, sha256.Sum256(configBefore), sha256.Sum256(configAfter))
388 } else {
389 assert.NotEqual(t, sha256.Sum256(configBefore), sha256.Sum256(configAfter))
390 }
391 })
392 }
395func TestNewClientFromConfig_DuoWorkflowID(t *testing.T) {
396 t.Setenv("GITLAB_TOKEN", "test-pat")
397 t.Setenv("DUO_WORKFLOW_WORKFLOW_ID", "")
399 receivedHeaders := make(chan string, 4)
400 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
401 receivedHeaders <- req.Header.Get("X-Gitlab-Duo-Workflow-Id")
402 w.WriteHeader(http.StatusNoContent)
403 }))
404 t.Cleanup(server.Close)
406 hostname := strings.TrimPrefix(server.URL, "http://")
407 baseURL, err := url.Parse(server.URL + "/api")
408 require.NoError(t, err)
410 newConfig := func(customHeaderValue string) config.Config {
411 configYAML := fmt.Sprintf("hosts:\n %q:\n api_protocol: http\n", hostname)
412 if customHeaderValue != "" {
413 configYAML += fmt.Sprintf(" custom_headers:\n - name: X-Gitlab-Duo-Workflow-Id\n value: %q\n", customHeaderValue)
414 }
415 return config.NewFromString(configYAML)
416 }
417 sentDuoWorkflowIDHeader := func(t *testing.T, client *Client, req *http.Request) string {
418 t.Helper()
419 resp, err := client.httpClient.Do(req)
420 require.NoError(t, err)
421 require.NoError(t, resp.Body.Close())
422 return <-receivedHeaders
423 }
425 t.Run("header injected when env var is set", func(t *testing.T) {
426 t.Setenv("DUO_WORKFLOW_WORKFLOW_ID", "workflow-id-xyz")
428 client, err := NewClientFromConfig(hostname, newConfig(""), false, "test-agent")
429 require.NoError(t, err)
431 req, err := NewHTTPRequest(t.Context(), client, "GET", baseURL, nil, []string{}, false)
432 require.NoError(t, err)
433 assert.Equal(t, "workflow-id-xyz", sentDuoWorkflowIDHeader(t, client, req))
434 })
436 t.Run("no header when env var is empty", func(t *testing.T) {
437 t.Setenv("DUO_WORKFLOW_WORKFLOW_ID", "")
439 client, err := NewClientFromConfig(hostname, newConfig(""), false, "test-agent")
440 require.NoError(t, err)
442 req, err := NewHTTPRequest(t.Context(), client, "GET", baseURL, nil, []string{}, false)
443 require.NoError(t, err)
444 assert.Empty(t, sentDuoWorkflowIDHeader(t, client, req))
445 })
447 t.Run("env var overrides X-Gitlab-Duo-Workflow-Id from config headers", func(t *testing.T) {
448 t.Setenv("DUO_WORKFLOW_WORKFLOW_ID", "from-env")
450 client, err := NewClientFromConfig(hostname, newConfig("from-config"), false, "test-agent")
451 require.NoError(t, err)
453 req, err := NewHTTPRequest(t.Context(), client, "GET", baseURL, nil, []string{}, false)
454 require.NoError(t, err)
455 assert.Equal(t, "from-env", sentDuoWorkflowIDHeader(t, client, req))
456 })
458 t.Run("malformed workflow ID is ignored", func(t *testing.T) {
459 t.Setenv("DUO_WORKFLOW_WORKFLOW_ID", "workflow\r\nid")
461 client, err := NewClientFromConfig(hostname, newConfig(""), false, "test-agent")
462 require.NoError(t, err)
464 req, err := NewHTTPRequest(t.Context(), client, "GET", baseURL, nil, []string{}, false)
465 require.NoError(t, err)
466 assert.Empty(t, sentDuoWorkflowIDHeader(t, client, req))
467 })
470func TestNewClientFromConfig_OAuth2NoTokenReturnsError(t *testing.T) {
471 t.Setenv("GITLAB_TOKEN", "")
472 t.Setenv("GLAB_IS_OAUTH2", "true")
473 // Environment credentials and flags only resolve for trusted hosts; make
474 // the host the default one so GLAB_IS_OAUTH2 applies.
475 t.Setenv("GITLAB_HOST", "example.gitlab.com")
477 _, err := NewClientFromConfig(
478 "example.gitlab.com",
479 config.NewBlankConfig(),
480 false,
481 "dummy user agent",
482 )
483 require.ErrorIs(t, err, ErrUnauthenticated)
484 // The message should be actionable rather than the old low-level jargon.
485 assert.EqualError(t, err, "OAuth2 authentication is configured for \"example.gitlab.com\" but no access or refresh token was found (the stored credentials may be missing or incomplete); run `glab auth login --hostname example.gitlab.com` to re-authenticate")
488func TestNewClientFromConfig_SurfacesKeyringReadError(t *testing.T) {
489 t.Setenv("GITLAB_TOKEN", "")
490 keyring.MockInitWithError(errors.New("keyring locked"))
491 t.Cleanup(keyring.MockInit)
493 cfg := config.NewBlankConfig()
494 require.NoError(t, cfg.Set("example.gitlab.com", "use_keyring", "true"))
496 // A failed keyring read must surface as a clear error rather than being
497 // silently treated as an absent (empty) credential.
498 _, err := NewClientFromConfig("example.gitlab.com", cfg, false, "dummy user agent")
499 require.Error(t, err)
500 assert.Contains(t, err.Error(), "keyring")
503func TestNewClientFromConfig_KeyringTokenMissing(t *testing.T) {
504 keyring.MockInit()
505 t.Cleanup(keyring.MockInit)
507 t.Setenv("GITLAB_TOKEN", "")
508 t.Setenv("GITLAB_ACCESS_TOKEN", "")
509 t.Setenv("OAUTH_TOKEN", "")
510 t.Setenv("GLAB_IS_OAUTH2", "")
511 t.Setenv("JOB_TOKEN", "")
512 t.Setenv("CI_JOB_TOKEN", "")
513 t.Setenv("GITLAB_CI", "")
514 t.Setenv("GLAB_ENABLE_CI_AUTOLOGIN", "")
515 t.Setenv("GLAB_USE_KEYRING", "")
516 t.Setenv("USE_KEYRING", "")
518 keyringHost := "---\nhosts:\n gitlab.example.com:\n use_keyring: \"true\"\n"
520 t.Run("returns an actionable error", func(t *testing.T) {
521 _, err := NewClientFromConfig("gitlab.example.com", config.NewFromString(keyringHost), false, "test-agent")
522 require.ErrorIs(t, err, ErrUnauthenticated)
523 assert.Contains(t, err.Error(), "keyring")
524 assert.Contains(t, err.Error(), "re-authenticate")
525 assert.Contains(t, err.Error(), "glab auth login --hostname gitlab.example.com")
526 })
528 t.Run("a token from the environment still wins", func(t *testing.T) {
529 t.Setenv("GITLAB_TOKEN", "env-pat")
531 client, err := NewClientFromConfig("gitlab.example.com", config.NewFromString(keyringHost), false, "test-agent")
532 require.NoError(t, err)
534 key, value, err := client.AuthSource().Header(t.Context())
535 require.NoError(t, err)
536 assert.Equal(t, gitlab.AccessTokenHeaderName, key)
537 assert.Equal(t, "env-pat", value)
538 })
540 t.Run("a job token still authenticates", func(t *testing.T) {
541 t.Setenv("GLAB_ENABLE_CI_AUTOLOGIN", "true")
542 t.Setenv("GITLAB_CI", "true")
543 t.Setenv("CI_JOB_TOKEN", "env-job-token")
545 client, err := NewClientFromConfig("gitlab.example.com", config.NewFromString(keyringHost), false, "test-agent")
546 require.NoError(t, err)
548 key, value, err := client.AuthSource().Header(t.Context())
549 require.NoError(t, err)
550 assert.Equal(t, gitlab.JobTokenHeaderName, key)
551 assert.Equal(t, "env-job-token", value)
552 })
554 t.Run("a host without use_keyring stays unauthenticated", func(t *testing.T) {
555 cfg := config.NewFromString("---\nhosts:\n gitlab.example.com:\n user: someone\n")
557 client, err := NewClientFromConfig("gitlab.example.com", cfg, false, "test-agent")
558 require.NoError(t, err)
560 _, _, err = client.AuthSource().Header(t.Context())
561 require.ErrorContains(t, err, "unauthenticated")
562 })
564 // The keyring is only read when the host itself sets use_keyring, so
565 // GLAB_USE_KEYRING alone must not turn a tokenless host into an error.
566 t.Run("GLAB_USE_KEYRING does not apply to a host without use_keyring", func(t *testing.T) {
567 t.Setenv("GLAB_USE_KEYRING", "true")
568 cfg := config.NewFromString("---\nhosts:\n gitlab.example.com:\n user: someone\n")
570 client, err := NewClientFromConfig("gitlab.example.com", cfg, false, "test-agent")
571 require.NoError(t, err)
573 _, _, err = client.AuthSource().Header(t.Context())
574 require.ErrorContains(t, err, "unauthenticated")
575 })
577 t.Run("a top-level use_keyring does not apply to a host without use_keyring", func(t *testing.T) {
578 cfg := config.NewFromString("---\nuse_keyring: \"true\"\nhosts:\n gitlab.example.com:\n user: someone\n")
580 client, err := NewClientFromConfig("gitlab.example.com", cfg, false, "test-agent")
581 require.NoError(t, err)
583 _, _, err = client.AuthSource().Header(t.Context())
584 require.ErrorContains(t, err, "unauthenticated")
585 })
587 t.Run("a top-level use_keyring keeps the token from the host entry", func(t *testing.T) {
588 cfg := config.NewFromString("---\nuse_keyring: \"true\"\nhosts:\n gitlab.example.com:\n token: config-pat\n")
590 client, err := NewClientFromConfig("gitlab.example.com", cfg, false, "test-agent")
591 require.NoError(t, err)
593 key, value, err := client.AuthSource().Header(t.Context())
594 require.NoError(t, err)
595 assert.Equal(t, gitlab.AccessTokenHeaderName, key)
596 assert.Equal(t, "config-pat", value)
597 })
600func TestNewClientFromConfig_WithoutAuthentication(t *testing.T) {
601 keyring.MockInit()
602 t.Cleanup(keyring.MockInit)
604 t.Setenv("GITLAB_TOKEN", "")
605 t.Setenv("GITLAB_ACCESS_TOKEN", "")
606 t.Setenv("OAUTH_TOKEN", "")
607 t.Setenv("GLAB_IS_OAUTH2", "")
608 t.Setenv("JOB_TOKEN", "")
609 t.Setenv("CI_JOB_TOKEN", "")
610 t.Setenv("GITLAB_CI", "")
611 t.Setenv("GLAB_USE_KEYRING", "")
612 t.Setenv("USE_KEYRING", "")
614 var gotHeader string
615 server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
616 gotHeader = r.Header.Get("X-Test-Header")
617 w.WriteHeader(http.StatusOK)
618 }))
619 t.Cleanup(server.Close)
621 hostname := strings.TrimPrefix(server.URL, "https://")
622 cfg := config.NewFromString(fmt.Sprintf(`
623---
624hosts:
625 %s:
626 use_keyring: "true"
627 is_oauth2: "true"
628 skip_tls_verify: "true"
629 custom_headers:
630 - name: X-Test-Header
631 value: from-config
632`, hostname))
634 client, err := NewClientFromConfig(hostname, cfg, false, "test-agent", WithoutAuthentication())
635 require.NoError(t, err)
637 _, _, err = client.AuthSource().Header(t.Context())
638 require.ErrorContains(t, err, "unauthenticated")
640 req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, server.URL, http.NoBody)
641 require.NoError(t, err)
642 resp, err := client.HTTPClient().Do(req)
643 require.NoError(t, err)
644 require.NoError(t, resp.Body.Close())
645 assert.Equal(t, http.StatusOK, resp.StatusCode)
646 assert.Equal(t, "from-config", gotHeader)
649func TestNewClientFromConfig_WithoutAuthenticationSkipsKeyringRead(t *testing.T) {
650 t.Setenv("GITLAB_TOKEN", "")
651 keyring.MockInitWithError(errors.New("keyring locked"))
652 t.Cleanup(keyring.MockInit)
654 cfg := config.NewBlankConfig()
655 require.NoError(t, cfg.Set("example.gitlab.com", "use_keyring", "true"))
657 client, err := NewClientFromConfig("example.gitlab.com", cfg, false, "dummy user agent", WithoutAuthentication())
658 require.NoError(t, err)
660 _, _, err = client.AuthSource().Header(t.Context())
661 require.ErrorContains(t, err, "unauthenticated")
664// TestNewClientFromConfig_WithoutTokenFromEnvironment pins the option glab
665// uses when it acts on behalf of a process that inherits the user's shell
666// environment, such as the Docker credential helper: the environment must
667// not be able to decide which identity the request is made as.
668func TestNewClientFromConfig_WithoutTokenFromEnvironment(t *testing.T) {
669 t.Setenv("GITLAB_TOKEN", "env-pat")
670 t.Setenv("GITLAB_ACCESS_TOKEN", "")
672 cfg := config.NewFromString(`
673---
674hosts:
675 gitlab.example.com:
676 token: config-pat
677`)
679 t.Run("the environment wins by default", func(t *testing.T) {
680 client, err := NewClientFromConfig("gitlab.example.com", cfg, false, "test-agent")
681 require.NoError(t, err)
683 key, value, err := client.AuthSource().Header(t.Context())
684 require.NoError(t, err)
685 assert.Equal(t, gitlab.AccessTokenHeaderName, key)
686 assert.Equal(t, "env-pat", value)
687 })
689 t.Run("the option restricts resolution to config", func(t *testing.T) {
690 client, err := NewClientFromConfig("gitlab.example.com", cfg, false, "test-agent", WithoutTokenFromEnvironment())
691 require.NoError(t, err)
693 key, value, err := client.AuthSource().Header(t.Context())
694 require.NoError(t, err)
695 assert.Equal(t, gitlab.AccessTokenHeaderName, key)
696 assert.Equal(t, "config-pat", value)
697 })
699 // A host with no stored credential must not silently fall back to the
700 // environment: an unauthenticated client makes the failure visible
701 // instead of acting as whoever GITLAB_TOKEN names.
702 t.Run("a host without a stored token yields an unauthenticated client", func(t *testing.T) {
703 blank := config.NewFromString("---\nhosts:\n other.example.com:\n user: someone\n")
705 client, err := NewClientFromConfig("other.example.com", blank, false, "test-agent", WithoutTokenFromEnvironment())
706 require.NoError(t, err)
708 _, _, err = client.AuthSource().Header(t.Context())
709 require.ErrorContains(t, err, "unauthenticated")
710 })
712 // A stray GLAB_IS_OAUTH2 must not flip a PAT-configured host onto the
713 // OAuth2 auth flow: without this, isOAuth2 would read "true" from the
714 // environment, sending the client down the oauth2AccessTokenOnlyAuthSource
715 // branch (Authorization: Bearer) instead of AccessTokenAuthSource
716 // (PRIVATE-TOKEN), even though the token value itself is correct.
717 t.Run("the option also ignores GLAB_IS_OAUTH2", func(t *testing.T) {
718 t.Setenv("GLAB_IS_OAUTH2", "true")
720 client, err := NewClientFromConfig("gitlab.example.com", cfg, false, "test-agent", WithoutTokenFromEnvironment())
721 require.NoError(t, err)
723 key, value, err := client.AuthSource().Header(t.Context())
724 require.NoError(t, err)
725 assert.Equal(t, gitlab.AccessTokenHeaderName, key)
726 assert.Equal(t, "config-pat", value)
727 })
729 // job_token is deliberately excluded from the option: CI_JOB_TOKEN
730 // authentication must keep working under CI auto-login regardless of
731 // whether the caller asked to ignore the environment for the identity
732 // (token/is_oauth2) lookups.
733 t.Run("the option does not affect job_token", func(t *testing.T) {
734 t.Setenv("GLAB_ENABLE_CI_AUTOLOGIN", "true")
735 t.Setenv("GITLAB_CI", "true")
736 t.Setenv("CI_JOB_TOKEN", "env-job-token")
738 blank := config.NewFromString("---\nhosts:\n other.example.com:\n user: someone\n")
740 client, err := NewClientFromConfig("other.example.com", blank, false, "test-agent", WithoutTokenFromEnvironment())
741 require.NoError(t, err)
743 key, value, err := client.AuthSource().Header(t.Context())
744 require.NoError(t, err)
745 assert.Equal(t, gitlab.JobTokenHeaderName, key)
746 assert.Equal(t, "env-job-token", value)
747 })
750// The access-token-only path has no refresh token, so the stored expiry is the
751// only expiry anything downstream can report.
752func TestNewClientFromConfig_AccessTokenOnlyCarriesStoredExpiry(t *testing.T) {
753 tests := []struct {
754 name string
755 expiryLine string
756 expectedExpiry time.Time
757 }{
758 {
759 name: "RFC3339",
760 expiryLine: ` oauth2_expiry_date: "2099-01-02T03:04:05Z"`,
761 expectedExpiry: time.Date(2099, time.January, 2, 3, 4, 5, 0, time.UTC),
762 },
763 {
764 name: "absent",
765 expiryLine: "",
766 expectedExpiry: time.Time{},
767 },
768 {
769 name: "unparseable is ignored rather than fatal",
770 expiryLine: ` oauth2_expiry_date: "not-a-date"`,
771 },
772 }
774 for _, tt := range tests {
775 t.Run(tt.name, func(t *testing.T) {
776 for _, k := range []string{"GITLAB_TOKEN", "GITLAB_ACCESS_TOKEN", "OAUTH_TOKEN", "GLAB_IS_OAUTH2"} {
777 t.Setenv(k, "")
778 }
780 cfg := config.NewFromString("hosts:\n example.com:\n is_oauth2: \"true\"\n token: an-access-token\n" + tt.expiryLine + "\n")
781 client, err := NewClientFromConfig("example.com", cfg, false, "ua")
782 require.NoError(t, err)
784 cred, err := client.Credential(t.Context())
785 require.NoError(t, err)
786 assert.Equal(t, CredentialOAuth2, cred.Kind)
787 assert.Equal(t, "an-access-token", cred.Token)
788 assert.True(t, tt.expectedExpiry.Equal(cred.Expiry), "want %s, got %s", tt.expectedExpiry, cred.Expiry)
789 assert.Empty(t, cred.RefreshToken, "there is no refresh token in this path")
790 })
791 }
794// forget() leaves is_oauth2 and a lapsed oauth2_expiry_date behind. A fresh
795// token from the environment must not be judged against that stale date.
796func TestNewClientFromConfig_EnvTokenIgnoresStoredExpiry(t *testing.T) {
797 for _, k := range []string{"GITLAB_TOKEN", "GITLAB_ACCESS_TOKEN", "OAUTH_TOKEN", "GLAB_IS_OAUTH2"} {
798 t.Setenv(k, "")
799 }
800 t.Setenv("OAUTH_TOKEN", "env-access-token")
802 cfg := config.NewFromString("hosts:\n example.com:\n is_oauth2: \"true\"\n oauth2_expiry_date: \"2000-01-02T03:04:05Z\"\n")
803 client, err := NewClientFromConfig("example.com", cfg, false, "ua")
804 require.NoError(t, err)
806 key, value, err := client.AuthSource().Header(t.Context())
807 require.NoError(t, err)
808 assert.Equal(t, gitlab.OAuthTokenHeaderName, key)
809 assert.Equal(t, "Bearer env-access-token", value)
811 cred, err := client.Credential(t.Context())
812 require.NoError(t, err)
813 assert.Equal(t, "env-access-token", cred.Token)
814 assert.True(t, cred.Expiry.IsZero(), "the stored expiry is not the environment token's")
817func TestNewClientFromConfig_DoesNotRetryPostOnServerError(t *testing.T) {
818 t.Setenv("GITLAB_TOKEN", "test-pat")
820 var requests atomic.Int32
821 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
822 requests.Add(1)
823 w.WriteHeader(http.StatusBadGateway)
824 }))
825 t.Cleanup(server.Close)
827 hostname := strings.TrimPrefix(server.URL, "http://")
828 cfg := config.NewFromString(fmt.Sprintf("hosts:\n %q:\n api_protocol: http\n", hostname))
829 client, err := NewClientFromConfig(hostname, cfg, false, "test-agent")
830 require.NoError(t, err)
832 _, _, err = client.Lab().Issues.CreateIssue("group/project", &gitlab.CreateIssueOptions{Title: new("title")})
833 require.Error(t, err)
834 assert.Equal(t, int32(1), requests.Load())
837func TestNewClientFromConfig_RetriesPostOnRateLimit(t *testing.T) {
838 t.Setenv("GITLAB_TOKEN", "test-pat")
840 var requests atomic.Int32
841 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
842 if requests.Add(1) == 1 {
843 w.WriteHeader(http.StatusTooManyRequests)
844 return
845 }
846 w.WriteHeader(http.StatusCreated)
847 _, _ = io.WriteString(w, `{"iid": 1}`)
848 }))
849 t.Cleanup(server.Close)
851 hostname := strings.TrimPrefix(server.URL, "http://")
852 cfg := config.NewFromString(fmt.Sprintf("hosts:\n %q:\n api_protocol: http\n", hostname))
853 client, err := NewClientFromConfig(hostname, cfg, false, "test-agent")
854 require.NoError(t, err)
856 _, _, err = client.Lab().Issues.CreateIssue("group/project", &gitlab.CreateIssueOptions{Title: new("title")})
857 require.NoError(t, err)
858 assert.Equal(t, int32(2), requests.Load())
861func TestWithSafeRetries_RetriesPostOnServerError(t *testing.T) {
862 t.Setenv("GITLAB_TOKEN", "test-pat")
864 var requests atomic.Int32
865 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
866 if requests.Add(1) == 1 {
867 w.WriteHeader(http.StatusBadGateway)
868 return
869 }
870 w.WriteHeader(http.StatusCreated)
871 _, _ = io.WriteString(w, `{"iid": 1}`)
872 }))
873 t.Cleanup(server.Close)
875 hostname := strings.TrimPrefix(server.URL, "http://")
876 cfg := config.NewFromString(fmt.Sprintf("hosts:\n %q:\n api_protocol: http\n", hostname))
877 client, err := NewClientFromConfig(hostname, cfg, false, "test-agent")
878 require.NoError(t, err)
880 _, _, err = client.Lab().Issues.CreateIssue("group/project", &gitlab.CreateIssueOptions{Title: new("title")}, WithSafeRetries())
881 require.NoError(t, err)
882 assert.Equal(t, int32(2), requests.Load())
885func TestWithSafeRetries_DoesNotRetryUnknownHost(t *testing.T) {
886 var dials atomic.Int32
887 transport := &http.Transport{
888 DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
889 dials.Add(1)
890 return nil, &net.DNSError{Err: "no such host", Name: "gitlab.invalid", IsNotFound: true}
891 },
892 }
893 client, err := NewClient(
894 func(*http.Client) (gitlab.AuthSource, error) {
895 return gitlab.Unauthenticated{}, nil
896 },
897 WithBaseURL("https://gitlab.invalid/api/v4/"),
898 WithHTTPClient(&http.Client{Transport: transport}),
899 )
900 require.NoError(t, err)
902 _, _, err = client.Lab().Issues.CreateIssue("group/project", &gitlab.CreateIssueOptions{Title: new("title")}, WithSafeRetries())
903 require.Error(t, err)
904 assert.Equal(t, int32(1), dials.Load())
Diagnostics6 git calls · 45 ms
CallStatusSizeTime045 ms
discover200185 B4 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=4
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 KiB · hit4 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=4
git.response.bytes=59849
git.response.cache=HIT
git.response.duration_ms=4
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 · 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:0 · deepen 1020032 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=32926
git.response.cache=HIT
git.response.duration_ms=3
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.1 KiB · hit6 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=6
git.response.bytes=1165
git.response.cache=HIT
git.response.duration_ms=6
git.fetch.filter=tree:0
git.fetch.wants=71c8407e0ff0e0af10f6a041ae330f754b68e7eb
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=1165
git.pkt.payload.max=1138
git.sideband.band1.bytes=1138
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=1138
git.pack.trailer=61886367c69619d8db2b2cf2d7d24dca2016141c
Open pack map
fetch2005.9 KiB · hit32 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=31
git.response.bytes=6016
git.response.cache=HIT
git.response.duration_ms=32
git.fetch.wants=f50ab2820bb8bf6e26857e156285449d21dea7b4
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=6016
git.pkt.payload.max=5989
git.sideband.band1.bytes=5989
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
a5e98b96c9f33191
Request
a89030ef…
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