GitLabgitlab-org
cli
main
1//go:build !integration
3package bootstrap
5import (
6 "bytes"
7 "errors"
8 "fmt"
9 "io"
10 "testing"
12 "github.com/google/shlex"
13 "github.com/stretchr/testify/assert"
14 "go.uber.org/mock/gomock"
16 gitlab "gitlab.com/gitlab-org/api/client-go/v3"
18 "gitlab.com/gitlab-org/cli/internal/iostreams"
19 "gitlab.com/gitlab-org/cli/internal/testing/cmdtest"
20)
22func TestAgentBootstrap_FailsToGetDefaultBranchForDefaultManifestBranch(t *testing.T) {
23 // GIVEN
24 exec, api, _, stderr, _, _ := setupCmdExec(t)
26 actualErr := errors.New("dummy error")
28 api.EXPECT().GetDefaultBranch().Return("", actualErr)
29 stderr.EXPECT().Write(ContainsBytes([]byte(actualErr.Error())))
31 // WHEN
32 err := exec("test-agent-name")
34 // THEN
35 assert.ErrorIs(t, err, actualErr)
36}
38func TestAgentBootstrap_HappyPath_AgentNotRegisteredYet(t *testing.T) {
39 // GIVEN
40 exec, api, _, stderr, kubectlWrapper, fluxWrapper := setupCmdExec(t)
42 defaultKASAddress := "wss://kas.gitlab.example.com"
43 defaultBranch := "main"
44 agentName := "test-agent-name"
45 agentTokenValue := "glagent-test-token"
46 agent := &gitlab.Agent{ID: 1, Name: agentName}
47 agentToken := &gitlab.AgentToken{ID: 42, Token: agentTokenValue}
48 helmRepositoryFile := file{path: "gitlab-helm-repository.yaml", content: []byte("any")}
49 helmReleaseFile := file{path: "gitlab-agent-helm-release.yaml", content: []byte("any")}
51 // Agent environment configuration
52 defaultEnvironmentName := "flux-system/gitlab-agent"
53 defaultKubernetesNamespace := "gitlab-agent"
54 defaultFluxResourcePath := "helm.toolkit.fluxcd.io/v2beta1/namespaces/flux-system/helmreleases/gitlab-agent"
56 // Flux environment configuration
57 fluxEnvironmentName := "flux-system/flux-system"
58 fluxKubernetesNamespace := "flux-system"
59 fluxFluxResourcePath := "kustomize.toolkit.fluxcd.io/v1/namespaces/flux-system/kustomizations/flux-system"
61 gomock.InOrder(
62 api.EXPECT().GetDefaultBranch().Return(defaultBranch, nil),
63 stderr.EXPECT().Write([]byte("Registering Agent ... ")),
64 api.EXPECT().GetAgentByName(agentName).Return(nil, agentNotFoundErr),
65 api.EXPECT().RegisterAgent(agentName).Return(agent, nil),
66 stderr.EXPECT().Write([]byte("[OK]\n")),
67 stderr.EXPECT().Write([]byte("Configuring Agent ... ")),
68 api.EXPECT().ConfigureAgent(agent, defaultBranch).Return(nil),
69 stderr.EXPECT().Write([]byte("[OK]\n")),
70 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for Agent ... ")),
71 api.EXPECT().ConfigureEnvironment(agent.ID, defaultEnvironmentName, defaultKubernetesNamespace, defaultFluxResourcePath).Return(nil),
72 stderr.EXPECT().Write([]byte("[OK]\n")),
73 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for FluxCD ... ")),
74 api.EXPECT().ConfigureEnvironment(agent.ID, fluxEnvironmentName, fluxKubernetesNamespace, fluxFluxResourcePath).Return(nil),
75 stderr.EXPECT().Write([]byte("[OK]\n")),
76 stderr.EXPECT().Write([]byte("Creating Agent Token ... ")),
77 api.EXPECT().CreateAgentToken(agent.ID).Return(agentToken, nil),
78 stderr.EXPECT().Write([]byte("[OK]\n")),
79 stderr.EXPECT().Write([]byte("Creating Kubernetes Secret with Agent Token ... ")),
80 kubectlWrapper.EXPECT().createAgentTokenSecret(int64(42), agentTokenValue).Return(nil),
81 stderr.EXPECT().Write([]byte("[OK]\n")),
82 stderr.EXPECT().Write([]byte("Creating Flux Helm Resources ... ")),
83 fluxWrapper.EXPECT().createHelmRepositoryManifest().Return(helmRepositoryFile, nil),
84 api.EXPECT().GetKASAddress().Return(defaultKASAddress, nil),
85 fluxWrapper.EXPECT().createHelmReleaseManifest(defaultKASAddress).Return(helmReleaseFile, nil),
86 stderr.EXPECT().Write([]byte("[OK]\n")),
87 stderr.EXPECT().Write([]byte("Syncing Flux Helm Resources ... ")),
88 api.EXPECT().SyncFile(helmRepositoryFile, defaultBranch).Return(nil),
89 api.EXPECT().SyncFile(helmReleaseFile, defaultBranch).Return(nil),
90 stderr.EXPECT().Write([]byte("[OK]\n")),
91 stderr.EXPECT().Write([]byte("Reconciling Flux Helm Resources ... ")),
92 stderr.EXPECT().Write([]byte("Output from flux command:\n")),
93 fluxWrapper.EXPECT().reconcile().Return(nil),
94 stderr.EXPECT().Write([]byte("Successfully bootstrapped the GitLab Agent\n")),
95 )
97 // WHEN
98 err := exec(agentName)
100 // THEN
101 assert.NoError(t, err)
102}
104func TestAgentBootstrap_HappyPath_AgentAlreadyRegistered(t *testing.T) {
105 // GIVEN
106 exec, api, _, stderr, kubectlWrapper, fluxWrapper := setupCmdExec(t)
108 defaultKASAddress := "wss://kas.gitlab.example.com"
109 defaultBranch := "main"
110 agentName := "test-agent-name"
111 agentTokenValue := "glagent-test-token"
112 agent := &gitlab.Agent{ID: 1, Name: agentName}
113 agentToken := &gitlab.AgentToken{ID: 42, Token: agentTokenValue}
114 helmRepositoryFile := file{path: "gitlab-helm-repository.yaml", content: []byte("any")}
115 helmReleaseFile := file{path: "gitlab-agent-helm-release.yaml", content: []byte("any")}
117 // Agent environment configuration
118 defaultEnvironmentName := "flux-system/gitlab-agent"
119 defaultKubernetesNamespace := "gitlab-agent"
120 defaultFluxResourcePath := "helm.toolkit.fluxcd.io/v2beta1/namespaces/flux-system/helmreleases/gitlab-agent"
122 // Flux environment configuration
123 fluxEnvironmentName := "flux-system/flux-system"
124 fluxKubernetesNamespace := "flux-system"
125 fluxFluxResourcePath := "kustomize.toolkit.fluxcd.io/v1/namespaces/flux-system/kustomizations/flux-system"
127 gomock.InOrder(
128 api.EXPECT().GetDefaultBranch().Return(defaultBranch, nil),
129 stderr.EXPECT().Write([]byte("Registering Agent ... ")),
130 api.EXPECT().GetAgentByName(agentName).Return(agent, nil),
131 stderr.EXPECT().Write([]byte("[OK]\n")),
132 stderr.EXPECT().Write([]byte("Configuring Agent ... ")),
133 api.EXPECT().ConfigureAgent(agent, defaultBranch).Return(nil),
134 stderr.EXPECT().Write([]byte("[OK]\n")),
135 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for Agent ... ")),
136 api.EXPECT().ConfigureEnvironment(agent.ID, defaultEnvironmentName, defaultKubernetesNamespace, defaultFluxResourcePath).Return(nil),
137 stderr.EXPECT().Write([]byte("[OK]\n")),
138 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for FluxCD ... ")),
139 api.EXPECT().ConfigureEnvironment(agent.ID, fluxEnvironmentName, fluxKubernetesNamespace, fluxFluxResourcePath).Return(nil),
140 stderr.EXPECT().Write([]byte("[OK]\n")),
141 stderr.EXPECT().Write([]byte("Creating Agent Token ... ")),
142 api.EXPECT().CreateAgentToken(agent.ID).Return(agentToken, nil),
143 stderr.EXPECT().Write([]byte("[OK]\n")),
144 stderr.EXPECT().Write([]byte("Creating Kubernetes Secret with Agent Token ... ")),
145 kubectlWrapper.EXPECT().createAgentTokenSecret(int64(42), agentTokenValue).Return(nil),
146 stderr.EXPECT().Write([]byte("[OK]\n")),
147 stderr.EXPECT().Write([]byte("Creating Flux Helm Resources ... ")),
148 fluxWrapper.EXPECT().createHelmRepositoryManifest().Return(helmRepositoryFile, nil),
149 api.EXPECT().GetKASAddress().Return(defaultKASAddress, nil),
150 fluxWrapper.EXPECT().createHelmReleaseManifest(defaultKASAddress).Return(helmReleaseFile, nil),
151 stderr.EXPECT().Write([]byte("[OK]\n")),
152 stderr.EXPECT().Write([]byte("Syncing Flux Helm Resources ... ")),
153 api.EXPECT().SyncFile(helmRepositoryFile, defaultBranch).Return(nil),
154 api.EXPECT().SyncFile(helmReleaseFile, defaultBranch).Return(nil),
155 stderr.EXPECT().Write([]byte("[OK]\n")),
156 stderr.EXPECT().Write([]byte("Reconciling Flux Helm Resources ... ")),
157 stderr.EXPECT().Write([]byte("Output from flux command:\n")),
158 fluxWrapper.EXPECT().reconcile().Return(nil),
159 stderr.EXPECT().Write([]byte("Successfully bootstrapped the GitLab Agent\n")),
160 )
162 // WHEN
163 err := exec(agentName)
165 // THEN
166 assert.NoError(t, err)
167}
169func TestAgentBootstrap_HappyPath_NoEnvironmentCreation(t *testing.T) {
170 // GIVEN
171 exec, api, _, stderr, kubectlWrapper, fluxWrapper := setupCmdExec(t)
173 defaultKASAddress := "wss://kas.gitlab.example.com"
174 defaultBranch := "main"
175 agentName := "test-agent-name"
176 agentTokenValue := "glagent-test-token"
177 agent := &gitlab.Agent{ID: 1, Name: agentName}
178 agentToken := &gitlab.AgentToken{ID: 42, Token: agentTokenValue}
179 helmRepositoryFile := file{path: "gitlab-helm-repository.yaml", content: []byte("any")}
180 helmReleaseFile := file{path: "gitlab-agent-helm-release.yaml", content: []byte("any")}
182 // Flux environment configuration
183 fluxEnvironmentName := "flux-system/flux-system"
184 fluxKubernetesNamespace := "flux-system"
185 fluxFluxResourcePath := "kustomize.toolkit.fluxcd.io/v1/namespaces/flux-system/kustomizations/flux-system"
187 gomock.InOrder(
188 api.EXPECT().GetDefaultBranch().Return(defaultBranch, nil),
189 stderr.EXPECT().Write([]byte("Registering Agent ... ")),
190 api.EXPECT().GetAgentByName(agentName).Return(nil, agentNotFoundErr),
191 api.EXPECT().RegisterAgent(agentName).Return(agent, nil),
192 stderr.EXPECT().Write([]byte("[OK]\n")),
193 stderr.EXPECT().Write([]byte("Configuring Agent ... ")),
194 api.EXPECT().ConfigureAgent(agent, defaultBranch).Return(nil),
195 stderr.EXPECT().Write([]byte("[OK]\n")),
196 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for Agent ... ")),
197 stderr.EXPECT().Write([]byte("[SKIPPED]\n")),
198 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for FluxCD ... ")),
199 api.EXPECT().ConfigureEnvironment(agent.ID, fluxEnvironmentName, fluxKubernetesNamespace, fluxFluxResourcePath).Return(nil),
200 stderr.EXPECT().Write([]byte("[OK]\n")),
201 stderr.EXPECT().Write([]byte("Creating Agent Token ... ")),
202 api.EXPECT().CreateAgentToken(agent.ID).Return(agentToken, nil),
203 stderr.EXPECT().Write([]byte("[OK]\n")),
204 stderr.EXPECT().Write([]byte("Creating Kubernetes Secret with Agent Token ... ")),
205 kubectlWrapper.EXPECT().createAgentTokenSecret(int64(42), agentTokenValue).Return(nil),
206 stderr.EXPECT().Write([]byte("[OK]\n")),
207 stderr.EXPECT().Write([]byte("Creating Flux Helm Resources ... ")),
208 fluxWrapper.EXPECT().createHelmRepositoryManifest().Return(helmRepositoryFile, nil),
209 api.EXPECT().GetKASAddress().Return(defaultKASAddress, nil),
210 fluxWrapper.EXPECT().createHelmReleaseManifest(defaultKASAddress).Return(helmReleaseFile, nil),
211 stderr.EXPECT().Write([]byte("[OK]\n")),
212 stderr.EXPECT().Write([]byte("Syncing Flux Helm Resources ... ")),
213 api.EXPECT().SyncFile(helmRepositoryFile, defaultBranch).Return(nil),
214 api.EXPECT().SyncFile(helmReleaseFile, defaultBranch).Return(nil),
215 stderr.EXPECT().Write([]byte("[OK]\n")),
216 stderr.EXPECT().Write([]byte("Reconciling Flux Helm Resources ... ")),
217 stderr.EXPECT().Write([]byte("Output from flux command:\n")),
218 fluxWrapper.EXPECT().reconcile().Return(nil),
219 stderr.EXPECT().Write([]byte("Successfully bootstrapped the GitLab Agent\n")),
220 )
222 // WHEN
223 err := exec(fmt.Sprintf("%s --create-environment=false", agentName))
225 // THEN
226 assert.NoError(t, err)
227}
229func TestAgentBootstrap_HappyPath_CustomEnvironmentValues(t *testing.T) {
230 // GIVEN
231 exec, api, _, stderr, kubectlWrapper, fluxWrapper := setupCmdExec(t)
233 defaultKASAddress := "wss://kas.gitlab.example.com"
234 defaultBranch := "main"
235 agentName := "test-agent-name"
236 agentTokenValue := "glagent-test-token"
237 agent := &gitlab.Agent{ID: 1, Name: agentName}
238 agentToken := &gitlab.AgentToken{ID: 42, Token: agentTokenValue}
239 helmRepositoryFile := file{path: "gitlab-helm-repository.yaml", content: []byte("any")}
240 helmReleaseFile := file{path: "gitlab-agent-helm-release.yaml", content: []byte("any")}
241 customEnvironmentName := "custom-name"
242 customKubernetesNamespace := "custom-namespace"
243 customFluxResourcePath := "custom-flux-resource-path"
245 // Flux environment configuration
246 fluxEnvironmentName := "flux-system/flux-system"
247 fluxKubernetesNamespace := "flux-system"
248 fluxFluxResourcePath := "kustomize.toolkit.fluxcd.io/v1/namespaces/flux-system/kustomizations/flux-system"
250 gomock.InOrder(
251 api.EXPECT().GetDefaultBranch().Return(defaultBranch, nil),
252 stderr.EXPECT().Write([]byte("Registering Agent ... ")),
253 api.EXPECT().GetAgentByName(agentName).Return(nil, agentNotFoundErr),
254 api.EXPECT().RegisterAgent(agentName).Return(agent, nil),
255 stderr.EXPECT().Write([]byte("[OK]\n")),
256 stderr.EXPECT().Write([]byte("Configuring Agent ... ")),
257 api.EXPECT().ConfigureAgent(agent, defaultBranch).Return(nil),
258 stderr.EXPECT().Write([]byte("[OK]\n")),
259 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for Agent ... ")),
260 api.EXPECT().ConfigureEnvironment(agent.ID, customEnvironmentName, customKubernetesNamespace, customFluxResourcePath).Return(nil),
261 stderr.EXPECT().Write([]byte("[OK]\n")),
262 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for FluxCD ... ")),
263 api.EXPECT().ConfigureEnvironment(agent.ID, fluxEnvironmentName, fluxKubernetesNamespace, fluxFluxResourcePath).Return(nil),
264 stderr.EXPECT().Write([]byte("[OK]\n")),
265 stderr.EXPECT().Write([]byte("Creating Agent Token ... ")),
266 api.EXPECT().CreateAgentToken(agent.ID).Return(agentToken, nil),
267 stderr.EXPECT().Write([]byte("[OK]\n")),
268 stderr.EXPECT().Write([]byte("Creating Kubernetes Secret with Agent Token ... ")),
269 kubectlWrapper.EXPECT().createAgentTokenSecret(int64(42), agentTokenValue).Return(nil),
270 stderr.EXPECT().Write([]byte("[OK]\n")),
271 stderr.EXPECT().Write([]byte("Creating Flux Helm Resources ... ")),
272 fluxWrapper.EXPECT().createHelmRepositoryManifest().Return(helmRepositoryFile, nil),
273 api.EXPECT().GetKASAddress().Return(defaultKASAddress, nil),
274 fluxWrapper.EXPECT().createHelmReleaseManifest(defaultKASAddress).Return(helmReleaseFile, nil),
275 stderr.EXPECT().Write([]byte("[OK]\n")),
276 stderr.EXPECT().Write([]byte("Syncing Flux Helm Resources ... ")),
277 api.EXPECT().SyncFile(helmRepositoryFile, defaultBranch).Return(nil),
278 api.EXPECT().SyncFile(helmReleaseFile, defaultBranch).Return(nil),
279 stderr.EXPECT().Write([]byte("[OK]\n")),
280 stderr.EXPECT().Write([]byte("Reconciling Flux Helm Resources ... ")),
281 stderr.EXPECT().Write([]byte("Output from flux command:\n")),
282 fluxWrapper.EXPECT().reconcile().Return(nil),
283 stderr.EXPECT().Write([]byte("Successfully bootstrapped the GitLab Agent\n")),
284 )
286 // WHEN
287 err := exec(fmt.Sprintf(
288 "%s --environment-name=%s --environment-namespace=%s --environment-flux-resource-path=%s",
289 agentName,
290 customEnvironmentName,
291 customKubernetesNamespace,
292 customFluxResourcePath,
293 ))
295 // THEN
296 assert.NoError(t, err)
297}
299func TestAgentBootstrap_HappyPath_NoReconcile(t *testing.T) {
300 // GIVEN
301 exec, api, _, stderr, kubectlWrapper, fluxWrapper := setupCmdExec(t)
303 defaultKASAddress := "wss://kas.gitlab.example.com"
304 defaultBranch := "main"
305 agentName := "test-agent-name"
306 agentTokenValue := "glagent-test-token"
307 agent := &gitlab.Agent{ID: 1, Name: agentName}
308 agentToken := &gitlab.AgentToken{ID: 42, Token: agentTokenValue}
309 helmRepositoryFile := file{path: "gitlab-helm-repository.yaml", content: []byte("any")}
310 helmReleaseFile := file{path: "gitlab-agent-helm-release.yaml", content: []byte("any")}
311 defaultEnvironmentName := "flux-system/gitlab-agent"
312 defaultKubernetesNamespace := "gitlab-agent"
313 defaultFluxResourcePath := "helm.toolkit.fluxcd.io/v2beta1/namespaces/flux-system/helmreleases/gitlab-agent"
315 // Flux environment configuration
316 fluxEnvironmentName := "flux-system/flux-system"
317 fluxKubernetesNamespace := "flux-system"
318 fluxFluxResourcePath := "kustomize.toolkit.fluxcd.io/v1/namespaces/flux-system/kustomizations/flux-system"
320 gomock.InOrder(
321 api.EXPECT().GetDefaultBranch().Return(defaultBranch, nil),
322 stderr.EXPECT().Write([]byte("Registering Agent ... ")),
323 api.EXPECT().GetAgentByName(agentName).Return(nil, agentNotFoundErr),
324 api.EXPECT().RegisterAgent(agentName).Return(agent, nil),
325 stderr.EXPECT().Write([]byte("[OK]\n")),
326 stderr.EXPECT().Write([]byte("Configuring Agent ... ")),
327 api.EXPECT().ConfigureAgent(agent, defaultBranch).Return(nil),
328 stderr.EXPECT().Write([]byte("[OK]\n")),
329 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for Agent ... ")),
330 api.EXPECT().ConfigureEnvironment(agent.ID, defaultEnvironmentName, defaultKubernetesNamespace, defaultFluxResourcePath).Return(nil),
331 stderr.EXPECT().Write([]byte("[OK]\n")),
332 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for FluxCD ... ")),
333 api.EXPECT().ConfigureEnvironment(agent.ID, fluxEnvironmentName, fluxKubernetesNamespace, fluxFluxResourcePath).Return(nil),
334 stderr.EXPECT().Write([]byte("[OK]\n")),
335 stderr.EXPECT().Write([]byte("Creating Agent Token ... ")),
336 api.EXPECT().CreateAgentToken(agent.ID).Return(agentToken, nil),
337 stderr.EXPECT().Write([]byte("[OK]\n")),
338 stderr.EXPECT().Write([]byte("Creating Kubernetes Secret with Agent Token ... ")),
339 kubectlWrapper.EXPECT().createAgentTokenSecret(int64(42), agentTokenValue).Return(nil),
340 stderr.EXPECT().Write([]byte("[OK]\n")),
341 stderr.EXPECT().Write([]byte("Creating Flux Helm Resources ... ")),
342 fluxWrapper.EXPECT().createHelmRepositoryManifest().Return(helmRepositoryFile, nil),
343 api.EXPECT().GetKASAddress().Return(defaultKASAddress, nil),
344 fluxWrapper.EXPECT().createHelmReleaseManifest(defaultKASAddress).Return(helmReleaseFile, nil),
345 stderr.EXPECT().Write([]byte("[OK]\n")),
346 stderr.EXPECT().Write([]byte("Syncing Flux Helm Resources ... ")),
347 api.EXPECT().SyncFile(helmRepositoryFile, defaultBranch).Return(nil),
348 api.EXPECT().SyncFile(helmReleaseFile, defaultBranch).Return(nil),
349 stderr.EXPECT().Write([]byte("[OK]\n")),
350 stderr.EXPECT().Write([]byte("Reconciling Flux Helm Resources ... ")),
351 stderr.EXPECT().Write([]byte("[SKIPPED]\n")),
352 stderr.EXPECT().Write([]byte("Successfully bootstrapped the GitLab Agent\n")),
353 )
355 // WHEN
356 err := exec(fmt.Sprintf("%s --no-reconcile", agentName))
358 // THEN
359 assert.NoError(t, err)
360}
362func TestAgentBootstrap_HappyPath_CustomFluxHelmManifestFileNames(t *testing.T) {
363 // GIVEN
364 exec, api, _, stderr, kubectlWrapper, fluxWrapper := setupCmdExec(t)
366 defaultKASAddress := "wss://kas.gitlab.example.com"
367 defaultBranch := "main"
368 agentName := "test-agent-name"
369 agentTokenValue := "glagent-test-token"
370 agent := &gitlab.Agent{ID: 1, Name: agentName}
371 agentToken := &gitlab.AgentToken{ID: 42, Token: agentTokenValue}
372 helmRepositoryFile := file{path: "test-1.yaml", content: []byte("any")}
373 helmReleaseFile := file{path: "test-2.yaml", content: []byte("any")}
374 defaultEnvironmentName := "flux-system/gitlab-agent"
375 defaultKubernetesNamespace := "gitlab-agent"
376 defaultFluxResourcePath := "helm.toolkit.fluxcd.io/v2beta1/namespaces/flux-system/helmreleases/gitlab-agent"
378 // Flux environment configuration
379 fluxEnvironmentName := "flux-system/flux-system"
380 fluxKubernetesNamespace := "flux-system"
381 fluxFluxResourcePath := "kustomize.toolkit.fluxcd.io/v1/namespaces/flux-system/kustomizations/flux-system"
383 gomock.InOrder(
384 api.EXPECT().GetDefaultBranch().Return(defaultBranch, nil),
385 stderr.EXPECT().Write([]byte("Registering Agent ... ")),
386 api.EXPECT().GetAgentByName(agentName).Return(nil, agentNotFoundErr),
387 api.EXPECT().RegisterAgent(agentName).Return(agent, nil),
388 stderr.EXPECT().Write([]byte("[OK]\n")),
389 stderr.EXPECT().Write([]byte("Configuring Agent ... ")),
390 api.EXPECT().ConfigureAgent(agent, defaultBranch).Return(nil),
391 stderr.EXPECT().Write([]byte("[OK]\n")),
392 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for Agent ... ")),
393 api.EXPECT().ConfigureEnvironment(agent.ID, defaultEnvironmentName, defaultKubernetesNamespace, defaultFluxResourcePath).Return(nil),
394 stderr.EXPECT().Write([]byte("[OK]\n")),
395 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for FluxCD ... ")),
396 api.EXPECT().ConfigureEnvironment(agent.ID, fluxEnvironmentName, fluxKubernetesNamespace, fluxFluxResourcePath).Return(nil),
397 stderr.EXPECT().Write([]byte("[OK]\n")),
398 stderr.EXPECT().Write([]byte("Creating Agent Token ... ")),
399 api.EXPECT().CreateAgentToken(agent.ID).Return(agentToken, nil),
400 stderr.EXPECT().Write([]byte("[OK]\n")),
401 stderr.EXPECT().Write([]byte("Creating Kubernetes Secret with Agent Token ... ")),
402 kubectlWrapper.EXPECT().createAgentTokenSecret(int64(42), agentTokenValue).Return(nil),
403 stderr.EXPECT().Write([]byte("[OK]\n")),
404 stderr.EXPECT().Write([]byte("Creating Flux Helm Resources ... ")),
405 fluxWrapper.EXPECT().createHelmRepositoryManifest().Return(helmRepositoryFile, nil),
406 api.EXPECT().GetKASAddress().Return(defaultKASAddress, nil),
407 fluxWrapper.EXPECT().createHelmReleaseManifest(defaultKASAddress).Return(helmReleaseFile, nil),
408 stderr.EXPECT().Write([]byte("[OK]\n")),
409 stderr.EXPECT().Write([]byte("Syncing Flux Helm Resources ... ")),
410 api.EXPECT().SyncFile(helmRepositoryFile, defaultBranch).Return(nil),
411 api.EXPECT().SyncFile(helmReleaseFile, defaultBranch).Return(nil),
412 stderr.EXPECT().Write([]byte("[OK]\n")),
413 stderr.EXPECT().Write([]byte("Reconciling Flux Helm Resources ... ")),
414 stderr.EXPECT().Write([]byte("Output from flux command:\n")),
415 fluxWrapper.EXPECT().reconcile().Return(nil),
416 stderr.EXPECT().Write([]byte("Successfully bootstrapped the GitLab Agent\n")),
417 )
419 // WHEN
420 err := exec(fmt.Sprintf(
421 "%s --helm-repository-filepath=%s --helm-release-filepath=%s",
422 agentName,
423 helmRepositoryFile.path,
424 helmReleaseFile.path,
425 ))
427 // THEN
428 assert.NoError(t, err)
429}
431func TestAgentBootstrap_Error_GetAgentByName(t *testing.T) {
432 // GIVEN
433 exec, api, _, stderr, _, _ := setupCmdExec(t)
435 defaultBranch := "main"
436 agentName := "test-agent-name"
438 actualErr := errors.New("dummy error")
440 gomock.InOrder(
441 api.EXPECT().GetDefaultBranch().Return(defaultBranch, nil),
442 stderr.EXPECT().Write([]byte("Registering Agent ... ")),
443 api.EXPECT().GetAgentByName(agentName).Return(nil, actualErr),
444 stderr.EXPECT().Write([]byte("[FAILED]\n")),
445 stderr.EXPECT().Write(ContainsBytes([]byte(actualErr.Error()))),
446 )
448 // WHEN
449 err := exec(agentName)
451 // THEN
452 assert.ErrorIs(t, err, actualErr)
453}
455func TestAgentBootstrap_Error_RegisterAgent(t *testing.T) {
456 // GIVEN
457 exec, api, _, stderr, _, _ := setupCmdExec(t)
459 defaultBranch := "main"
460 agentName := "test-agent-name"
462 actualErr := errors.New("dummy error")
464 gomock.InOrder(
465 api.EXPECT().GetDefaultBranch().Return(defaultBranch, nil),
466 stderr.EXPECT().Write([]byte("Registering Agent ... ")),
467 api.EXPECT().GetAgentByName(agentName).Return(nil, agentNotFoundErr),
468 api.EXPECT().RegisterAgent(agentName).Return(nil, actualErr),
469 stderr.EXPECT().Write([]byte("[FAILED]\n")),
470 stderr.EXPECT().Write(ContainsBytes([]byte(actualErr.Error()))),
471 )
473 // WHEN
474 err := exec(agentName)
476 // THEN
477 assert.ErrorIs(t, err, actualErr)
478}
480func TestAgentBootstrap_Error_ConfigureAgent(t *testing.T) {
481 // GIVEN
482 exec, api, _, stderr, _, _ := setupCmdExec(t)
484 defaultBranch := "main"
485 agentName := "test-agent-name"
486 agent := &gitlab.Agent{ID: 1, Name: agentName}
488 actualErr := errors.New("dummy error")
490 gomock.InOrder(
491 api.EXPECT().GetDefaultBranch().Return(defaultBranch, nil),
492 stderr.EXPECT().Write([]byte("Registering Agent ... ")),
493 api.EXPECT().GetAgentByName(agentName).Return(agent, nil),
494 stderr.EXPECT().Write([]byte("[OK]\n")),
495 stderr.EXPECT().Write([]byte("Configuring Agent ... ")),
496 api.EXPECT().ConfigureAgent(agent, defaultBranch).Return(actualErr),
497 stderr.EXPECT().Write([]byte("[FAILED]\n")),
498 stderr.EXPECT().Write(ContainsBytes([]byte(actualErr.Error()))),
499 )
501 // WHEN
502 err := exec(agentName)
504 // THEN
505 assert.ErrorIs(t, err, actualErr)
506}
508func TestAgentBootstrap_Error_ConfigureEnvironment(t *testing.T) {
509 // GIVEN
510 exec, api, _, stderr, _, _ := setupCmdExec(t)
512 defaultBranch := "main"
513 agentName := "test-agent-name"
514 agent := &gitlab.Agent{ID: 1, Name: agentName}
515 defaultEnvironmentName := "flux-system/gitlab-agent"
516 defaultKubernetesNamespace := "gitlab-agent"
517 defaultFluxResourcePath := "helm.toolkit.fluxcd.io/v2beta1/namespaces/flux-system/helmreleases/gitlab-agent"
519 actualErr := errors.New("dummy error")
521 gomock.InOrder(
522 api.EXPECT().GetDefaultBranch().Return(defaultBranch, nil),
523 stderr.EXPECT().Write([]byte("Registering Agent ... ")),
524 api.EXPECT().GetAgentByName(agentName).Return(agent, nil),
525 stderr.EXPECT().Write([]byte("[OK]\n")),
526 stderr.EXPECT().Write([]byte("Configuring Agent ... ")),
527 api.EXPECT().ConfigureAgent(agent, defaultBranch).Return(nil),
528 stderr.EXPECT().Write([]byte("[OK]\n")),
529 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for Agent ... ")),
530 api.EXPECT().ConfigureEnvironment(agent.ID, defaultEnvironmentName, defaultKubernetesNamespace, defaultFluxResourcePath).Return(actualErr),
531 stderr.EXPECT().Write([]byte("[FAILED]\n")),
532 stderr.EXPECT().Write(ContainsBytes([]byte(actualErr.Error()))),
533 )
535 // WHEN
536 err := exec(agentName)
538 // THEN
539 assert.ErrorIs(t, err, actualErr)
540}
542func TestAgentBootstrap_Error_CreateAgentToken(t *testing.T) {
543 // GIVEN
544 exec, api, _, stderr, _, _ := setupCmdExec(t)
546 defaultBranch := "main"
547 agentName := "test-agent-name"
548 agent := &gitlab.Agent{ID: 1, Name: agentName}
549 defaultEnvironmentName := "flux-system/gitlab-agent"
550 defaultKubernetesNamespace := "gitlab-agent"
551 defaultFluxResourcePath := "helm.toolkit.fluxcd.io/v2beta1/namespaces/flux-system/helmreleases/gitlab-agent"
553 // Flux environment configuration
554 fluxEnvironmentName := "flux-system/flux-system"
555 fluxKubernetesNamespace := "flux-system"
556 fluxFluxResourcePath := "kustomize.toolkit.fluxcd.io/v1/namespaces/flux-system/kustomizations/flux-system"
558 actualErr := errors.New("dummy error")
560 gomock.InOrder(
561 api.EXPECT().GetDefaultBranch().Return(defaultBranch, nil),
562 stderr.EXPECT().Write([]byte("Registering Agent ... ")),
563 api.EXPECT().GetAgentByName(agentName).Return(agent, nil),
564 stderr.EXPECT().Write([]byte("[OK]\n")),
565 stderr.EXPECT().Write([]byte("Configuring Agent ... ")),
566 api.EXPECT().ConfigureAgent(agent, defaultBranch).Return(nil),
567 stderr.EXPECT().Write([]byte("[OK]\n")),
568 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for Agent ... ")),
569 api.EXPECT().ConfigureEnvironment(agent.ID, defaultEnvironmentName, defaultKubernetesNamespace, defaultFluxResourcePath).Return(nil),
570 stderr.EXPECT().Write([]byte("[OK]\n")),
571 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for FluxCD ... ")),
572 api.EXPECT().ConfigureEnvironment(agent.ID, fluxEnvironmentName, fluxKubernetesNamespace, fluxFluxResourcePath).Return(nil),
573 stderr.EXPECT().Write([]byte("[OK]\n")),
574 stderr.EXPECT().Write([]byte("Creating Agent Token ... ")),
575 api.EXPECT().CreateAgentToken(agent.ID).Return(nil, actualErr),
576 stderr.EXPECT().Write([]byte("[FAILED]\n")),
577 stderr.EXPECT().Write(ContainsBytes([]byte(actualErr.Error()))),
578 )
580 // WHEN
581 err := exec(agentName)
583 // THEN
584 assert.ErrorIs(t, err, actualErr)
585}
587func TestAgentBootstrap_Error_createAgentTokenSecret(t *testing.T) {
588 // GIVEN
589 exec, api, _, stderr, kubectlWrapper, _ := setupCmdExec(t)
591 defaultBranch := "main"
592 agentName := "test-agent-name"
593 agentTokenValue := "glagent-test-token"
594 agent := &gitlab.Agent{ID: 1, Name: agentName}
595 agentToken := &gitlab.AgentToken{ID: 42, Token: agentTokenValue}
596 defaultEnvironmentName := "flux-system/gitlab-agent"
597 defaultKubernetesNamespace := "gitlab-agent"
598 defaultFluxResourcePath := "helm.toolkit.fluxcd.io/v2beta1/namespaces/flux-system/helmreleases/gitlab-agent"
600 // Flux environment configuration
601 fluxEnvironmentName := "flux-system/flux-system"
602 fluxKubernetesNamespace := "flux-system"
603 fluxFluxResourcePath := "kustomize.toolkit.fluxcd.io/v1/namespaces/flux-system/kustomizations/flux-system"
605 actualErr := errors.New("dummy error")
607 gomock.InOrder(
608 api.EXPECT().GetDefaultBranch().Return(defaultBranch, nil),
609 stderr.EXPECT().Write([]byte("Registering Agent ... ")),
610 api.EXPECT().GetAgentByName(agentName).Return(agent, nil),
611 stderr.EXPECT().Write([]byte("[OK]\n")),
612 stderr.EXPECT().Write([]byte("Configuring Agent ... ")),
613 api.EXPECT().ConfigureAgent(agent, defaultBranch).Return(nil),
614 stderr.EXPECT().Write([]byte("[OK]\n")),
615 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for Agent ... ")),
616 api.EXPECT().ConfigureEnvironment(agent.ID, defaultEnvironmentName, defaultKubernetesNamespace, defaultFluxResourcePath).Return(nil),
617 stderr.EXPECT().Write([]byte("[OK]\n")),
618 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for FluxCD ... ")),
619 api.EXPECT().ConfigureEnvironment(agent.ID, fluxEnvironmentName, fluxKubernetesNamespace, fluxFluxResourcePath).Return(nil),
620 stderr.EXPECT().Write([]byte("[OK]\n")),
621 stderr.EXPECT().Write([]byte("Creating Agent Token ... ")),
622 api.EXPECT().CreateAgentToken(agent.ID).Return(agentToken, nil),
623 stderr.EXPECT().Write([]byte("[OK]\n")),
624 stderr.EXPECT().Write([]byte("Creating Kubernetes Secret with Agent Token ... ")),
625 kubectlWrapper.EXPECT().createAgentTokenSecret(int64(42), agentTokenValue).Return(actualErr),
626 stderr.EXPECT().Write([]byte("[FAILED]\n")),
627 stderr.EXPECT().Write(ContainsBytes([]byte(actualErr.Error()))),
628 )
630 // WHEN
631 err := exec(agentName)
633 // THEN
634 assert.ErrorIs(t, err, actualErr)
635}
637func TestAgentBootstrap_Error_createHelmRepositoryManifest(t *testing.T) {
638 // GIVEN
639 exec, api, _, stderr, kubectlWrapper, fluxWrapper := setupCmdExec(t)
641 defaultBranch := "main"
642 agentName := "test-agent-name"
643 agentTokenValue := "glagent-test-token"
644 agent := &gitlab.Agent{ID: 1, Name: agentName}
645 agentToken := &gitlab.AgentToken{ID: 42, Token: agentTokenValue}
646 defaultEnvironmentName := "flux-system/gitlab-agent"
647 defaultKubernetesNamespace := "gitlab-agent"
648 defaultFluxResourcePath := "helm.toolkit.fluxcd.io/v2beta1/namespaces/flux-system/helmreleases/gitlab-agent"
650 // Flux environment configuration
651 fluxEnvironmentName := "flux-system/flux-system"
652 fluxKubernetesNamespace := "flux-system"
653 fluxFluxResourcePath := "kustomize.toolkit.fluxcd.io/v1/namespaces/flux-system/kustomizations/flux-system"
655 actualErr := errors.New("dummy error")
657 gomock.InOrder(
658 api.EXPECT().GetDefaultBranch().Return(defaultBranch, nil),
659 stderr.EXPECT().Write([]byte("Registering Agent ... ")),
660 api.EXPECT().GetAgentByName(agentName).Return(agent, nil),
661 stderr.EXPECT().Write([]byte("[OK]\n")),
662 stderr.EXPECT().Write([]byte("Configuring Agent ... ")),
663 api.EXPECT().ConfigureAgent(agent, defaultBranch).Return(nil),
664 stderr.EXPECT().Write([]byte("[OK]\n")),
665 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for Agent ... ")),
666 api.EXPECT().ConfigureEnvironment(agent.ID, defaultEnvironmentName, defaultKubernetesNamespace, defaultFluxResourcePath).Return(nil),
667 stderr.EXPECT().Write([]byte("[OK]\n")),
668 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for FluxCD ... ")),
669 api.EXPECT().ConfigureEnvironment(agent.ID, fluxEnvironmentName, fluxKubernetesNamespace, fluxFluxResourcePath).Return(nil),
670 stderr.EXPECT().Write([]byte("[OK]\n")),
671 stderr.EXPECT().Write([]byte("Creating Agent Token ... ")),
672 api.EXPECT().CreateAgentToken(agent.ID).Return(agentToken, nil),
673 stderr.EXPECT().Write([]byte("[OK]\n")),
674 stderr.EXPECT().Write([]byte("Creating Kubernetes Secret with Agent Token ... ")),
675 kubectlWrapper.EXPECT().createAgentTokenSecret(int64(42), agentTokenValue).Return(nil),
676 stderr.EXPECT().Write([]byte("[OK]\n")),
677 stderr.EXPECT().Write([]byte("Creating Flux Helm Resources ... ")),
678 fluxWrapper.EXPECT().createHelmRepositoryManifest().Return(file{}, actualErr),
679 stderr.EXPECT().Write([]byte("[FAILED]\n")),
680 stderr.EXPECT().Write(ContainsBytes([]byte(actualErr.Error()))),
681 )
683 // WHEN
684 err := exec(agentName)
686 // THEN
687 assert.ErrorIs(t, err, actualErr)
688}
690func TestAgentBootstrap_Error_SyncFile_HelmRepositoryFile(t *testing.T) {
691 // GIVEN
692 exec, api, _, stderr, kubectlWrapper, fluxWrapper := setupCmdExec(t)
694 defaultKASAddress := "wss://kas.gitlab.example.com"
695 defaultBranch := "main"
696 agentName := "test-agent-name"
697 agentTokenValue := "glagent-test-token"
698 agent := &gitlab.Agent{ID: 1, Name: agentName}
699 agentToken := &gitlab.AgentToken{ID: 42, Token: agentTokenValue}
700 helmRepositoryFile := file{path: "gitlab-helm-repository.yaml", content: []byte("any")}
701 helmReleaseFile := file{path: "gitlab-agent-helm-release.yaml", content: []byte("any")}
702 defaultEnvironmentName := "flux-system/gitlab-agent"
703 defaultKubernetesNamespace := "gitlab-agent"
704 defaultFluxResourcePath := "helm.toolkit.fluxcd.io/v2beta1/namespaces/flux-system/helmreleases/gitlab-agent"
706 // Flux environment configuration
707 fluxEnvironmentName := "flux-system/flux-system"
708 fluxKubernetesNamespace := "flux-system"
709 fluxFluxResourcePath := "kustomize.toolkit.fluxcd.io/v1/namespaces/flux-system/kustomizations/flux-system"
711 actualErr := errors.New("dummy error")
713 gomock.InOrder(
714 api.EXPECT().GetDefaultBranch().Return(defaultBranch, nil),
715 stderr.EXPECT().Write([]byte("Registering Agent ... ")),
716 api.EXPECT().GetAgentByName(agentName).Return(agent, nil),
717 stderr.EXPECT().Write([]byte("[OK]\n")),
718 stderr.EXPECT().Write([]byte("Configuring Agent ... ")),
719 api.EXPECT().ConfigureAgent(agent, defaultBranch).Return(nil),
720 stderr.EXPECT().Write([]byte("[OK]\n")),
721 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for Agent ... ")),
722 api.EXPECT().ConfigureEnvironment(agent.ID, defaultEnvironmentName, defaultKubernetesNamespace, defaultFluxResourcePath).Return(nil),
723 stderr.EXPECT().Write([]byte("[OK]\n")),
724 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for FluxCD ... ")),
725 api.EXPECT().ConfigureEnvironment(agent.ID, fluxEnvironmentName, fluxKubernetesNamespace, fluxFluxResourcePath).Return(nil),
726 stderr.EXPECT().Write([]byte("[OK]\n")),
727 stderr.EXPECT().Write([]byte("Creating Agent Token ... ")),
728 api.EXPECT().CreateAgentToken(agent.ID).Return(agentToken, nil),
729 stderr.EXPECT().Write([]byte("[OK]\n")),
730 stderr.EXPECT().Write([]byte("Creating Kubernetes Secret with Agent Token ... ")),
731 kubectlWrapper.EXPECT().createAgentTokenSecret(int64(42), agentTokenValue).Return(nil),
732 stderr.EXPECT().Write([]byte("[OK]\n")),
733 stderr.EXPECT().Write([]byte("Creating Flux Helm Resources ... ")),
734 fluxWrapper.EXPECT().createHelmRepositoryManifest().Return(helmRepositoryFile, nil),
735 api.EXPECT().GetKASAddress().Return(defaultKASAddress, nil),
736 fluxWrapper.EXPECT().createHelmReleaseManifest(defaultKASAddress).Return(helmReleaseFile, nil),
737 stderr.EXPECT().Write([]byte("[OK]\n")),
738 stderr.EXPECT().Write([]byte("Syncing Flux Helm Resources ... ")),
739 api.EXPECT().SyncFile(helmRepositoryFile, defaultBranch).Return(actualErr),
740 stderr.EXPECT().Write([]byte("[FAILED]\n")),
741 stderr.EXPECT().Write(ContainsBytes([]byte(actualErr.Error()))),
742 )
744 // WHEN
745 err := exec(agentName)
747 // THEN
748 assert.ErrorIs(t, err, actualErr)
749}
751func TestAgentBootstrap_Error_SyncFile_HelmReleaseFile(t *testing.T) {
752 // GIVEN
753 exec, api, _, stderr, kubectlWrapper, fluxWrapper := setupCmdExec(t)
755 defaultKASAddress := "wss://kas.gitlab.example.com"
756 defaultBranch := "main"
757 agentName := "test-agent-name"
758 agentTokenValue := "glagent-test-token"
759 agent := &gitlab.Agent{ID: 1, Name: agentName}
760 agentToken := &gitlab.AgentToken{ID: 42, Token: agentTokenValue}
761 helmRepositoryFile := file{path: "gitlab-helm-repository.yaml", content: []byte("any")}
762 helmReleaseFile := file{path: "gitlab-agent-helm-release.yaml", content: []byte("any")}
763 defaultEnvironmentName := "flux-system/gitlab-agent"
764 defaultKubernetesNamespace := "gitlab-agent"
765 defaultFluxResourcePath := "helm.toolkit.fluxcd.io/v2beta1/namespaces/flux-system/helmreleases/gitlab-agent"
767 // Flux environment configuration
768 fluxEnvironmentName := "flux-system/flux-system"
769 fluxKubernetesNamespace := "flux-system"
770 fluxFluxResourcePath := "kustomize.toolkit.fluxcd.io/v1/namespaces/flux-system/kustomizations/flux-system"
772 actualErr := errors.New("dummy error")
774 gomock.InOrder(
775 api.EXPECT().GetDefaultBranch().Return(defaultBranch, nil),
776 stderr.EXPECT().Write([]byte("Registering Agent ... ")),
777 api.EXPECT().GetAgentByName(agentName).Return(agent, nil),
778 stderr.EXPECT().Write([]byte("[OK]\n")),
779 stderr.EXPECT().Write([]byte("Configuring Agent ... ")),
780 api.EXPECT().ConfigureAgent(agent, defaultBranch).Return(nil),
781 stderr.EXPECT().Write([]byte("[OK]\n")),
782 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for Agent ... ")),
783 api.EXPECT().ConfigureEnvironment(agent.ID, defaultEnvironmentName, defaultKubernetesNamespace, defaultFluxResourcePath).Return(nil),
784 stderr.EXPECT().Write([]byte("[OK]\n")),
785 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for FluxCD ... ")),
786 api.EXPECT().ConfigureEnvironment(agent.ID, fluxEnvironmentName, fluxKubernetesNamespace, fluxFluxResourcePath).Return(nil),
787 stderr.EXPECT().Write([]byte("[OK]\n")),
788 stderr.EXPECT().Write([]byte("Creating Agent Token ... ")),
789 api.EXPECT().CreateAgentToken(agent.ID).Return(agentToken, nil),
790 stderr.EXPECT().Write([]byte("[OK]\n")),
791 stderr.EXPECT().Write([]byte("Creating Kubernetes Secret with Agent Token ... ")),
792 kubectlWrapper.EXPECT().createAgentTokenSecret(int64(42), agentTokenValue).Return(nil),
793 stderr.EXPECT().Write([]byte("[OK]\n")),
794 stderr.EXPECT().Write([]byte("Creating Flux Helm Resources ... ")),
795 fluxWrapper.EXPECT().createHelmRepositoryManifest().Return(helmRepositoryFile, nil),
796 api.EXPECT().GetKASAddress().Return(defaultKASAddress, nil),
797 fluxWrapper.EXPECT().createHelmReleaseManifest(defaultKASAddress).Return(helmReleaseFile, nil),
798 stderr.EXPECT().Write([]byte("[OK]\n")),
799 stderr.EXPECT().Write([]byte("Syncing Flux Helm Resources ... ")),
800 api.EXPECT().SyncFile(helmRepositoryFile, defaultBranch).Return(nil),
801 api.EXPECT().SyncFile(helmReleaseFile, defaultBranch).Return(actualErr),
802 stderr.EXPECT().Write([]byte("[FAILED]\n")),
803 stderr.EXPECT().Write(ContainsBytes([]byte(actualErr.Error()))),
804 )
806 // WHEN
807 err := exec(agentName)
809 // THEN
810 assert.ErrorIs(t, err, actualErr)
811}
813func TestAgentBootstrap_Error_reconcile(t *testing.T) {
814 // GIVEN
815 exec, api, _, stderr, kubectlWrapper, fluxWrapper := setupCmdExec(t)
817 defaultKASAddress := "wss://kas.gitlab.example.com"
818 defaultBranch := "main"
819 agentName := "test-agent-name"
820 agentTokenValue := "glagent-test-token"
821 agent := &gitlab.Agent{ID: 1, Name: agentName}
822 agentToken := &gitlab.AgentToken{ID: 42, Token: agentTokenValue}
823 helmRepositoryFile := file{path: "gitlab-helm-repository.yaml", content: []byte("any")}
824 helmReleaseFile := file{path: "gitlab-agent-helm-release.yaml", content: []byte("any")}
825 defaultEnvironmentName := "flux-system/gitlab-agent"
826 defaultKubernetesNamespace := "gitlab-agent"
827 defaultFluxResourcePath := "helm.toolkit.fluxcd.io/v2beta1/namespaces/flux-system/helmreleases/gitlab-agent"
829 // Flux environment configuration
830 fluxEnvironmentName := "flux-system/flux-system"
831 fluxKubernetesNamespace := "flux-system"
832 fluxFluxResourcePath := "kustomize.toolkit.fluxcd.io/v1/namespaces/flux-system/kustomizations/flux-system"
834 actualErr := errors.New("dummy error")
836 gomock.InOrder(
837 api.EXPECT().GetDefaultBranch().Return(defaultBranch, nil),
838 stderr.EXPECT().Write([]byte("Registering Agent ... ")),
839 api.EXPECT().GetAgentByName(agentName).Return(agent, nil),
840 stderr.EXPECT().Write([]byte("[OK]\n")),
841 stderr.EXPECT().Write([]byte("Configuring Agent ... ")),
842 api.EXPECT().ConfigureAgent(agent, defaultBranch).Return(nil),
843 stderr.EXPECT().Write([]byte("[OK]\n")),
844 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for Agent ... ")),
845 api.EXPECT().ConfigureEnvironment(agent.ID, defaultEnvironmentName, defaultKubernetesNamespace, defaultFluxResourcePath).Return(nil),
846 stderr.EXPECT().Write([]byte("[OK]\n")),
847 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for FluxCD ... ")),
848 api.EXPECT().ConfigureEnvironment(agent.ID, fluxEnvironmentName, fluxKubernetesNamespace, fluxFluxResourcePath).Return(nil),
849 stderr.EXPECT().Write([]byte("[OK]\n")),
850 stderr.EXPECT().Write([]byte("Creating Agent Token ... ")),
851 api.EXPECT().CreateAgentToken(agent.ID).Return(agentToken, nil),
852 stderr.EXPECT().Write([]byte("[OK]\n")),
853 stderr.EXPECT().Write([]byte("Creating Kubernetes Secret with Agent Token ... ")),
854 kubectlWrapper.EXPECT().createAgentTokenSecret(int64(42), agentTokenValue).Return(nil),
855 stderr.EXPECT().Write([]byte("[OK]\n")),
856 stderr.EXPECT().Write([]byte("Creating Flux Helm Resources ... ")),
857 fluxWrapper.EXPECT().createHelmRepositoryManifest().Return(helmRepositoryFile, nil),
858 api.EXPECT().GetKASAddress().Return(defaultKASAddress, nil),
859 fluxWrapper.EXPECT().createHelmReleaseManifest(defaultKASAddress).Return(helmReleaseFile, nil),
860 stderr.EXPECT().Write([]byte("[OK]\n")),
861 stderr.EXPECT().Write([]byte("Syncing Flux Helm Resources ... ")),
862 api.EXPECT().SyncFile(helmRepositoryFile, defaultBranch).Return(nil),
863 api.EXPECT().SyncFile(helmReleaseFile, defaultBranch).Return(nil),
864 stderr.EXPECT().Write([]byte("[OK]\n")),
865 stderr.EXPECT().Write([]byte("Reconciling Flux Helm Resources ... ")),
866 stderr.EXPECT().Write([]byte("Output from flux command:\n")),
867 fluxWrapper.EXPECT().reconcile().Return(actualErr),
868 stderr.EXPECT().Write(ContainsBytes([]byte(actualErr.Error()))),
869 )
871 // WHEN
872 err := exec(agentName)
874 // THEN
875 assert.ErrorIs(t, err, actualErr)
876}
878func TestAgentBootstrap_HappyPath_WithoutFlux(t *testing.T) {
879 // GIVEN
880 exec, api, _, stderr, kubectlWrapper, fluxWrapper := setupCmdExec(t)
882 defaultKASAddress := "wss://kas.gitlab.example.com"
883 defaultBranch := "main"
884 agentName := "test-agent-name"
885 agentTokenValue := "glagent-test-token"
886 agent := &gitlab.Agent{ID: 1, Name: agentName}
887 agentToken := &gitlab.AgentToken{ID: 42, Token: agentTokenValue}
888 helmRepositoryFile := file{path: "gitlab-helm-repository.yaml", content: []byte("any")}
889 helmReleaseFile := file{path: "gitlab-agent-helm-release.yaml", content: []byte("any")}
890 defaultEnvironmentName := "flux-system/gitlab-agent"
891 defaultKubernetesNamespace := "gitlab-agent"
892 defaultFluxResourcePath := "helm.toolkit.fluxcd.io/v2beta1/namespaces/flux-system/helmreleases/gitlab-agent"
894 gomock.InOrder(
895 api.EXPECT().GetDefaultBranch().Return(defaultBranch, nil),
896 stderr.EXPECT().Write([]byte("Registering Agent ... ")),
897 api.EXPECT().GetAgentByName(agentName).Return(agent, nil),
898 stderr.EXPECT().Write([]byte("[OK]\n")),
899 stderr.EXPECT().Write([]byte("Configuring Agent ... ")),
900 api.EXPECT().ConfigureAgent(agent, defaultBranch).Return(nil),
901 stderr.EXPECT().Write([]byte("[OK]\n")),
902 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for Agent ... ")),
903 api.EXPECT().ConfigureEnvironment(agent.ID, defaultEnvironmentName, defaultKubernetesNamespace, defaultFluxResourcePath).Return(nil),
904 stderr.EXPECT().Write([]byte("[OK]\n")),
905 stderr.EXPECT().Write([]byte("Configuring Environment with Dashboard for FluxCD ... ")),
906 stderr.EXPECT().Write([]byte("[SKIPPED]\n")),
907 stderr.EXPECT().Write([]byte("Creating Agent Token ... ")),
908 api.EXPECT().CreateAgentToken(agent.ID).Return(agentToken, nil),
909 stderr.EXPECT().Write([]byte("[OK]\n")),
910 stderr.EXPECT().Write([]byte("Creating Kubernetes Secret with Agent Token ... ")),
911 kubectlWrapper.EXPECT().createAgentTokenSecret(int64(42), agentTokenValue).Return(nil),
912 stderr.EXPECT().Write([]byte("[OK]\n")),
913 stderr.EXPECT().Write([]byte("Creating Flux Helm Resources ... ")),
914 fluxWrapper.EXPECT().createHelmRepositoryManifest().Return(helmRepositoryFile, nil),
915 api.EXPECT().GetKASAddress().Return(defaultKASAddress, nil),
916 fluxWrapper.EXPECT().createHelmReleaseManifest(defaultKASAddress).Return(helmReleaseFile, nil),
917 stderr.EXPECT().Write([]byte("[OK]\n")),
918 stderr.EXPECT().Write([]byte("Syncing Flux Helm Resources ... ")),
919 api.EXPECT().SyncFile(helmRepositoryFile, defaultBranch).Return(nil),
920 api.EXPECT().SyncFile(helmReleaseFile, defaultBranch).Return(nil),
921 stderr.EXPECT().Write([]byte("[OK]\n")),
922 stderr.EXPECT().Write([]byte("Reconciling Flux Helm Resources ... ")),
923 stderr.EXPECT().Write([]byte("Output from flux command:\n")),
924 fluxWrapper.EXPECT().reconcile().Return(nil),
925 stderr.EXPECT().Write([]byte("Successfully bootstrapped the GitLab Agent\n")),
926 )
928 // WHEN
929 err := exec(agentName + " --create-flux-environment=false")
931 // THEN
932 assert.NoError(t, err)
933}
935type execFunc func(cli string) error
937//nolint:unparam,gocritic // returns the mocks it wires; a struct would churn 19 call sites for a result count
938func setupCmdExec(t *testing.T) (execFunc, *MockAPI, *MockWriter, *MockWriter, *MockKubectlWrapper, *MockFluxWrapper) {
939 t.Helper()
941 ctrl := gomock.NewController(t)
942 mockAPI := NewMockAPI(ctrl)
943 mockStdout := NewMockWriter(ctrl)
944 mockStderr := NewMockWriter(ctrl)
945 mockKubectlWrapper := NewMockKubectlWrapper(ctrl)
946 mockFluxWrapper := NewMockFluxWrapper(ctrl)
947 mockCmd := NewMockCmd(ctrl)
949 cmd := NewCmdAgentBootstrap(
950 cmdtest.NewTestFactory(
951 &iostreams.IOStreams{
952 In: io.NopCloser(&bytes.Buffer{}),
953 StdOut: mockStdout,
954 StdErr: mockStderr,
955 IsaTTY: true,
956 IsInTTY: true,
957 IsErrTTY: true,
958 },
959 ),
960 func() error { return nil },
961 func(*gitlab.Client, any, *commitAuthor) API { return mockAPI },
962 func(_ Cmd, _, _, _ string) KubectlWrapper { return mockKubectlWrapper },
963 func(_ Cmd, _, _, _, _, _, _, _, _, _, _ string, _, _ []string, _, _, _ string) FluxWrapper {
964 return mockFluxWrapper
965 },
966 func(_, _ io.Writer, _ []string) Cmd { return mockCmd },
967 )
969 cmd.SetIn(&bytes.Buffer{})
970 cmd.SetOut(mockStdout)
971 cmd.SetErr(mockStderr)
973 // Set on root cmd, thus we also need to set it here.
974 // cmd.SilenceErrors = true
975 cmd.SilenceUsage = true
977 exec := func(cli string) error {
978 argv, err := shlex.Split(cli)
979 if err != nil {
980 return err
981 }
983 cmd.SetArgs(argv)
984 _, err = cmd.ExecuteC()
985 return err
986 }
988 return exec, mockAPI, mockStdout, mockStderr, mockKubectlWrapper, mockFluxWrapper
989}
991func ContainsBytes(b []byte) gomock.Matcher {
992 return &containsBytesMatcher{b: b}
993}
995type containsBytesMatcher struct {
996 b []byte
997 actualB []byte
998}
1000func (m containsBytesMatcher) Matches(arg any) bool {
1001 b, ok := arg.([]byte)
1002 if !ok {
1003 return false
1004 }
1005 m.actualB = b
1006 return bytes.Contains(m.actualB, m.b)
1007}
1009func (m containsBytesMatcher) String() string {
1010 return fmt.Sprintf("does not contain: %q, got %q", m.b, m.actualB)
1011}
Diagnostics9 git calls · 260 ms
CallStatusSizeTime0260 ms
discover200185 B3 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs 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 KiB · hit3 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=HIT 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
fetchtree:0 · deepen 1020032 KiB · hit1 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=1 git.response.bytes=32926 git.response.cache=HIT git.response.duration_ms=1 git.fetch.filter=tree:0 git.fetch.wants=0dd7574dce9e385c5c30540e6c15657adc6bdce9 git.fetch.haves.count=0 git.fetch.deepen=10 git.fetch.thin_pack=false git.fetch.ofs_delta=true git.protocol.version=2 git.pkt.frames=22 git.pkt.data=20 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=32926 git.pkt.payload.max=32046 git.sideband.band1.bytes=32046 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=80 git.pack.bytes=32046 git.pack.ofs_delta=36 git.pack.ref_delta=0 git.pack.chain.max=2 git.pack.trailer=cb0bad5d7ffc514895d8b21c4dd470327f90bc91 git.pack.full=44Open pack map
fetchcombine:blob:none+tree:2 · deepen 12004.2 KiB · 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:02001.8 KiB · hit4 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=4 git.response.bytes=1857 git.response.cache=HIT git.response.duration_ms=4 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:0200200 B · hit1 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=1 git.response.bytes=200 git.response.cache=HIT git.response.duration_ms=1 git.fetch.filter=tree:0 git.fetch.wants=9988d47506dcbe3004b8b72cbdb9d66d6d75cda4 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=200 git.pkt.payload.max=173 git.sideband.band1.bytes=173 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=173 git.pack.trailer=948ee807a1ee817af67f2df94421a202e82325f9Open pack map
fetchtree:0200405 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=405 git.response.cache=HIT git.response.duration_ms=2 git.fetch.filter=tree:0 git.fetch.wants=d271680e941992259de0ff84d4a04bcbba55f531 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=405 git.pkt.payload.max=378 git.sideband.band1.bytes=378 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=378 git.pack.trailer=adfacba5ff1f4fcf28dcaac12e2874f6d48a7934Open pack map
fetchtree:0200414 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=414 git.response.cache=HIT git.response.duration_ms=2 git.fetch.filter=tree:0 git.fetch.wants=3c487cc16dcfeca6d024165580948fbb3a622e23 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=414 git.pkt.payload.max=387 git.sideband.band1.bytes=387 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=1 git.pack.bytes=387 git.pack.trailer=a621ec095c3ac7a33563831f77c04827c9c343d3Open pack map
fetch2002.8 KiB246 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=246 git.response.bytes=2827 git.response.cache=MISS git.response.duration_ms=246 git.fetch.wants=2acb016e4a98e76ce6c0b87ddba6af3174236d7f 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=2827 git.pkt.payload.max=2800 git.sideband.band1.bytes=2800 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
- a5eb08afcf0421ca
- Request
- 2357414e…
- 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