GitLabgitlab-org
cli
main
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"
19)
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
41}
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
53}
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:")
61}
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")
67}
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")
73}
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")
83}
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
95}
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")
110}
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")
122}
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")
134}
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")
146}
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)
164}
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)
179}
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)
194}
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)
209}
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")
224}
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")
243}
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")
259}
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")
280}
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")
295}
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")
314}
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)
339}
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=44Open 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=fb03183b7909876778f740d196d7516811003517Open 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=aabedefb11d4348efc4e1168413c6ec52cbf90d2Open 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=6d4a07360b8e3402b6d00337f32d3ed2e0ba42e3Open 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