GitLabgitlab-org

cli

main
ply8 git calls422 ms101 KiB5 cachedprotocol v2
339 lines13 KiBRaw
1//go:build !integration
3package pkgcmd
5import (
6 "errors"
7 "net/http"
8 "testing"
10 "github.com/stretchr/testify/assert"
11 "github.com/stretchr/testify/require"
12 "go.uber.org/mock/gomock"
14 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
15 gitlabtesting "gitlab.com/gitlab-org/api/client-go/v3/testing"
17 "gitlab.com/gitlab-org/cli/internal/cmdutils"
18 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
21// runPackage drives the command against a real REST checker backed by client,
22// so the test exercises the p.Type -> ecosystem mapping, the request shape,
23// and the exit-code contract rather than the GLAB_DF_FAKE_* seam. It returns
24// stdout and stderr separately so the allow-to-stdout / blocked-to-stderr
25// contract can be asserted.
26func runPackage(t *testing.T, client *gitlab.Client, purlArg string) (string, string, error) {
27 t.Helper()
28 t.Chdir(t.TempDir())
29 run := cmdtest.SetupCmdForTest(
30 t,
31 NewCmd,
32 false,
33 cmdtest.WithBaseRepo("g", "p", "gitlab.com"),
34 cmdtest.WithGitLabClient(client),
35 )
36 out, err := run(purlArg)
37 if out == nil {
38 return "", "", err
39 }
40 return out.OutBuf.String(), out.ErrBuf.String(), err
43// mockClient returns a client whose EvaluatePackage is set up by setup. When
44// setup is nil the API must not be called (the command should fail before the
45// request, e.g. on an invalid PURL).
46func mockClient(t *testing.T, setup func(tc *gitlabtesting.TestClient)) *gitlab.Client {
47 t.Helper()
48 tc := gitlabtesting.NewTestClient(t)
49 if setup != nil {
50 setup(tc)
51 }
52 return tc.Client
55func TestPackageHelpTextHasNoFormatError(t *testing.T) {
56 ios, _, _, _ := cmdtest.TestIOStreams()
57 cmd := NewCmd(cmdtest.NewTestFactory(ios))
58 assert.NotContains(t, cmd.Long, "%!", "Long help must not contain a fmt format-verb error")
59 assert.NotContains(t, cmd.Long, "EXTRA", "Long help must not contain leftover fmt EXTRA args")
60 assert.Contains(t, cmd.Long, "Exit codes:")
63func TestPackageInvalidPURL(t *testing.T) {
64 _, _, err := runPackage(t, mockClient(t, nil), "not-a-purl")
65 require.Error(t, err)
66 assert.Contains(t, err.Error(), "invalid PURL")
69func TestPackageUnsupportedType(t *testing.T) {
70 _, _, err := runPackage(t, mockClient(t, nil), "pkg:cocoapods/Alamofire@5.9.0")
71 require.Error(t, err)
72 assert.Contains(t, err.Error(), "not supported")
75// TestPackageVersionlessPURLRejected proves a PURL with no version fails
76// locally with a clear error and never reaches the API, which would reject a
77// blank version with 400. mockClient sets no EvaluatePackage expectation, so
78// any call fails the test.
79func TestPackageVersionlessPURLRejected(t *testing.T) {
80 _, _, err := runPackage(t, mockClient(t, nil), "pkg:npm/left-pad")
81 require.Error(t, err)
82 assert.Contains(t, err.Error(), "must include a version")
85// requireExitCodeOne fails unless err is an *cmdutils.ExitError carrying the
86// generic-failure exit code 1 (the contract for a misconfiguration or
87// transport error) and returns it so the caller can assert its Details.
88func requireExitCodeOne(t *testing.T, err error) *cmdutils.ExitError {
89 t.Helper()
90 require.Error(t, err)
91 var xerr *cmdutils.ExitError
92 require.ErrorAs(t, err, &xerr)
93 assert.Equal(t, 1, xerr.Code)
94 return xerr
97// TestPackageBaseRepoErrorExitsOne covers the branch where the git remote
98// cannot be resolved to a project: it must surface as exit 1, not a block.
99func TestPackageBaseRepoErrorExitsOne(t *testing.T) {
100 t.Chdir(t.TempDir())
101 executor := cmdtest.NewMockExecutor(gomock.NewController(t))
102 executor.EXPECT().LookPath("git").Return("", errors.New("not found"))
103 run := cmdtest.SetupCmdForTest(t, NewCmd, false,
104 cmdtest.WithExecutor(executor),
105 cmdtest.WithBaseRepoError(errors.New("no GitLab remote found")))
106 _, err := run("pkg:npm/left-pad@1.3.0")
107 xerr := requireExitCodeOne(t, err)
108 assert.Contains(t, xerr.Details, "failed to resolve GitLab project")
109 assert.EqualError(t, err, "no GitLab remote found. git is required")
112func TestPackageBaseRepoErrorWithGitInstalledHasNoGitHint(t *testing.T) {
113 t.Chdir(t.TempDir())
114 executor := cmdtest.NewMockExecutor(gomock.NewController(t))
115 executor.EXPECT().LookPath("git").Return("/usr/bin/git", nil)
116 run := cmdtest.SetupCmdForTest(t, NewCmd, false,
117 cmdtest.WithExecutor(executor),
118 cmdtest.WithBaseRepoError(errors.New("no GitLab remote found")))
119 _, err := run("pkg:npm/left-pad@1.3.0")
120 xerr := requireExitCodeOne(t, err)
121 assert.NotContains(t, xerr.Error(), "git is required")
124// TestPackageGitLabClientErrorExitsOne covers the branch where the API client
125// cannot be built (e.g. missing or invalid token): it must surface as exit 1.
126func TestPackageGitLabClientErrorExitsOne(t *testing.T) {
127 t.Chdir(t.TempDir())
128 run := cmdtest.SetupCmdForTest(t, NewCmd, false,
129 cmdtest.WithBaseRepo("g", "p", "gitlab.com"),
130 cmdtest.WithGitLabClientError(errors.New("no token configured")))
131 _, err := run("pkg:npm/left-pad@1.3.0")
132 xerr := requireExitCodeOne(t, err)
133 assert.Contains(t, xerr.Details, "failed to create a GitLab API client")
136// TestPackageCheckerInitErrorExitsOne covers the branch where policy.New
137// refuses to build a checker: under GITLAB_CI it rejects the GLAB_DF_FAKE_*
138// fake so a pipeline variable cannot disable the firewall. That must surface
139// as exit 1, not a block.
140func TestPackageCheckerInitErrorExitsOne(t *testing.T) {
141 t.Setenv("GITLAB_CI", "true")
142 t.Setenv("GLAB_DF_FAKE_DEFAULT", "allow")
143 _, _, err := runPackage(t, mockClient(t, nil), "pkg:npm/left-pad@1.3.0")
144 xerr := requireExitCodeOne(t, err)
145 assert.Contains(t, xerr.Details, "failed to initialize the Dependency Firewall policy checker")
148// TestPackageSendsMappedRequest asserts the command forwards the resolved
149// project, the PURL type mapped to the API ecosystem enum, and the download
150// operation — the wiring the GLAB_DF_FAKE_* path never exercises.
151func TestPackageSendsMappedRequest(t *testing.T) {
152 client := mockClient(t, func(tc *gitlabtesting.TestClient) {
153 tc.MockSecurityDependencyFirewall.EXPECT().
154 EvaluatePackage("g/p", &gitlab.EvaluatePackageOptions{
155 Ecosystem: gitlab.DependencyFirewallEcosystemMaven,
156 Name: "org.slf4j:slf4j-api",
157 Version: "2.0.13",
158 }, gomock.Any()).
159 Return(&gitlab.PackageEvaluation{Outcome: gitlab.DependencyFirewallOutcomeAllowed}, nil, nil)
160 })
162 _, _, err := runPackage(t, client, "pkg:maven/org.slf4j/slf4j-api@2.0.13")
163 require.NoError(t, err)
166func TestPackageSendsMappedNuGetRequest(t *testing.T) {
167 client := mockClient(t, func(tc *gitlabtesting.TestClient) {
168 tc.MockSecurityDependencyFirewall.EXPECT().
169 EvaluatePackage("g/p", &gitlab.EvaluatePackageOptions{
170 Ecosystem: gitlab.DependencyFirewallEcosystemNuGet,
171 Name: "Newtonsoft.Json",
172 Version: "13.0.1",
173 }, gomock.Any()).
174 Return(&gitlab.PackageEvaluation{Outcome: gitlab.DependencyFirewallOutcomeAllowed}, nil, nil)
175 })
177 _, _, err := runPackage(t, client, "pkg:nuget/Newtonsoft.Json@13.0.1")
178 require.NoError(t, err)
181func TestPackageSendsMappedCargoRequest(t *testing.T) {
182 client := mockClient(t, func(tc *gitlabtesting.TestClient) {
183 tc.MockSecurityDependencyFirewall.EXPECT().
184 EvaluatePackage("g/p", &gitlab.EvaluatePackageOptions{
185 Ecosystem: gitlab.DependencyFirewallEcosystemCargo,
186 Name: "serde",
187 Version: "1.0.197",
188 }, gomock.Any()).
189 Return(&gitlab.PackageEvaluation{Outcome: gitlab.DependencyFirewallOutcomeAllowed}, nil, nil)
190 })
192 _, _, err := runPackage(t, client, "pkg:cargo/serde@1.0.197")
193 require.NoError(t, err)
196func TestPackageSendsMappedGolangRequest(t *testing.T) {
197 client := mockClient(t, func(tc *gitlabtesting.TestClient) {
198 tc.MockSecurityDependencyFirewall.EXPECT().
199 EvaluatePackage("g/p", &gitlab.EvaluatePackageOptions{
200 Ecosystem: gitlab.DependencyFirewallEcosystemGolang,
201 Name: "github.com/BurntSushi/toml",
202 Version: "v1.4.0",
203 }, gomock.Any()).
204 Return(&gitlab.PackageEvaluation{Outcome: gitlab.DependencyFirewallOutcomeAllowed}, nil, nil)
205 })
207 _, _, err := runPackage(t, client, "pkg:golang/github.com/BurntSushi/toml@v1.4.0")
208 require.NoError(t, err)
211func TestPackageAllowReportsAllowed(t *testing.T) {
212 client := mockClient(t, func(tc *gitlabtesting.TestClient) {
213 tc.MockSecurityDependencyFirewall.EXPECT().
214 EvaluatePackage("g/p", gomock.Any(), gomock.Any()).
215 Return(&gitlab.PackageEvaluation{Outcome: gitlab.DependencyFirewallOutcomeAllowed}, nil, nil)
216 })
218 stdout, _, err := runPackage(t, client, "pkg:npm/left-pad@1.3.0")
219 require.NoError(t, err)
220 assert.Contains(t, stdout, "left-pad@1.3.0")
221 assert.Contains(t, stdout, "allowed by the Dependency Firewall")
222 assert.NotContains(t, stdout, "no Dependency Firewall activity recorded",
223 "an allow must not also print the empty-summary line")
226// TestPackageAllowSanitizesCraftedPURL proves the direct allow-output path does
227// not let a crafted PURL inject a newline or control sequence into the
228// terminal: purl.Parse percent-decodes the version, and the command must
229// flatten it before printing.
230func TestPackageAllowSanitizesCraftedPURL(t *testing.T) {
231 client := mockClient(t, func(tc *gitlabtesting.TestClient) {
232 tc.MockSecurityDependencyFirewall.EXPECT().
233 EvaluatePackage("g/p", gomock.Any(), gomock.Any()).
234 Return(&gitlab.PackageEvaluation{Outcome: gitlab.DependencyFirewallOutcomeAllowed}, nil, nil)
235 })
237 stdout, _, err := runPackage(t, client, "pkg:npm/left-pad@1.3.0%0a%0aFAKE-INJECTED-LINE")
238 require.NoError(t, err)
239 assert.NotContains(t, stdout, "\n\nFAKE-INJECTED-LINE",
240 "a crafted version must not inject raw newlines into the output")
241 assert.Contains(t, stdout, "left-pad@1.3.0 FAKE-INJECTED-LINE",
242 "the crafted characters are flattened onto the single output line")
245func TestPackageWarnExitsZero(t *testing.T) {
246 client := mockClient(t, func(tc *gitlabtesting.TestClient) {
247 tc.MockSecurityDependencyFirewall.EXPECT().
248 EvaluatePackage("g/p", gomock.Any(), gomock.Any()).
249 Return(&gitlab.PackageEvaluation{
250 Outcome: gitlab.DependencyFirewallOutcomeWarned,
251 Reason: new("known-malware policy"),
252 }, nil, nil)
253 })
255 stdout, _, err := runPackage(t, client, "pkg:npm/left-pad@1.3.0")
256 require.NoError(t, err)
257 assert.Contains(t, stdout, "left-pad")
258 assert.Contains(t, stdout, "1 package warning")
261func TestPackageBlockedExitsThree(t *testing.T) {
262 client := mockClient(t, func(tc *gitlabtesting.TestClient) {
263 tc.MockSecurityDependencyFirewall.EXPECT().
264 EvaluatePackage("g/p", gomock.Any(), gomock.Any()).
265 Return(&gitlab.PackageEvaluation{
266 Outcome: gitlab.DependencyFirewallOutcomeBlocked,
267 Reason: new("blocked by policy"),
268 }, nil, nil)
269 })
271 _, stderr, err := runPackage(t, client, "pkg:npm/left-pad@1.3.0")
272 require.Error(t, err)
274 var xerr *cmdutils.ExitError
275 require.ErrorAs(t, err, &xerr, "expected *cmdutils.ExitError, got %T", err)
276 assert.Equal(t, 3, xerr.Code)
278 assert.Contains(t, stderr, "left-pad")
279 assert.Contains(t, stderr, "1 package blocked")
282// TestPackageNotEvaluatingFailsOpen covers a project the firewall is not
283// evaluating (404): the command allows the package and exits 0 rather than
284// treating the absence of a policy as a block.
285func TestPackageNotEvaluatingFailsOpen(t *testing.T) {
286 client := mockClient(t, func(tc *gitlabtesting.TestClient) {
287 tc.MockSecurityDependencyFirewall.EXPECT().
288 EvaluatePackage("g/p", gomock.Any(), gomock.Any()).
289 Return(nil, nil, &gitlab.ErrorResponse{StatusCode: http.StatusNotFound})
290 })
292 stdout, _, err := runPackage(t, client, "pkg:npm/left-pad@1.3.0")
293 require.NoError(t, err)
294 assert.Contains(t, stdout, "not evaluating this project")
297// TestPackageTransportErrorExitsOne is the case CachingChecker used to erase:
298// a transport failure must surface as the documented exit 1, not a false
299// exit-3 block.
300func TestPackageTransportErrorExitsOne(t *testing.T) {
301 client := mockClient(t, func(tc *gitlabtesting.TestClient) {
302 tc.MockSecurityDependencyFirewall.EXPECT().
303 EvaluatePackage("g/p", gomock.Any(), gomock.Any()).
304 Return(nil, nil, errors.New("dial tcp: connection refused"))
305 })
307 _, _, err := runPackage(t, client, "pkg:npm/left-pad@1.3.0")
308 require.Error(t, err)
310 var xerr *cmdutils.ExitError
311 require.ErrorAs(t, err, &xerr)
312 assert.Equal(t, 1, xerr.Code, "a transport error is a misconfiguration/transport failure, not a block")
313 assert.Contains(t, err.Error(), "connection refused")
316// TestPackagePyPINormalizesNameForVerdict checks the PEP 503 normalization the
317// command relies on: an input the parser must rewrite (Flask_Login ->
318// flask-login) has to reach the API in normalized form for a policy keyed to
319// the normalized name to match.
320func TestPackagePyPINormalizesNameForVerdict(t *testing.T) {
321 client := mockClient(t, func(tc *gitlabtesting.TestClient) {
322 tc.MockSecurityDependencyFirewall.EXPECT().
323 EvaluatePackage("g/p", &gitlab.EvaluatePackageOptions{
324 Ecosystem: gitlab.DependencyFirewallEcosystemPyPI,
325 Name: "flask-login",
326 Version: "1.0",
327 }, gomock.Any()).
328 Return(&gitlab.PackageEvaluation{
329 Outcome: gitlab.DependencyFirewallOutcomeBlocked,
330 Reason: new("blocked by policy"),
331 }, nil, nil)
332 })
334 _, _, err := runPackage(t, client, "pkg:pypi/Flask_Login@1.0")
335 require.Error(t, err)
336 var xerr *cmdutils.ExitError
337 require.ErrorAs(t, err, &xerr)
338 assert.Equal(t, 3, xerr.Code)
Diagnostics8 git calls · 422 ms
CallStatusSizeTime0422 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=3
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 · 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.8 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=1857
git.response.cache=HIT
git.response.duration_ms=3
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:0200650 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=650
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=cdbc4acb219224e81172d025f80739e1e383a784
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=650
git.pkt.payload.max=623
git.sideband.band1.bytes=623
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=623
git.pack.trailer=aabedefb11d4348efc4e1168413c6ec52cbf90d2
Open pack map
fetchtree:0200139 B · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=407
git.response.bytes=139
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=405066cbafa2fe3c3f417c7d5b0b4fa08af7e0c6
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=139
git.pkt.payload.max=112
git.sideband.band1.bytes=112
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=112
git.pack.trailer=6d4a07360b8e3402b6d00337f32d3ed2e0ba42e3
Open pack map
fetch2003.2 KiB408 ms
git.upload-pack fetch
http.response.status_code=200
git.response.bytes=3239
git.response.cache=MISS
git.response.duration_ms=408
git.fetch.wants=16a25aa483e91d7058ce5fc63c132126a8c18145
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=3239
git.pkt.payload.max=3212
git.sideband.band1.bytes=3212
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
a5e2972f78a42407
Request
6437ca45…
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