sergio/takana

1--- a/pipeline/backend/local/local_test.go
2+++ b/pipeline/backend/local/local_test.go
3@@ -19,14 +19,14 @@
4 import (
5 	"context"
6 	"fmt"
7-	"io"
8+//	"io"
9 	"os"
10-	"os/exec"
11+//	"os/exec"
12 	"path/filepath"
13 	"runtime"
14-	"slices"
15+//	"slices"
16 	"strings"
17-	"sync"
18+//	"sync"
19 	"sync/atomic"
20 	"testing"
21 	"time"
22@@ -163,206 +163,206 @@
23 		}
24 	})
25 }
26-
27-func TestRunStep(t *testing.T) {
28-	if runtime.GOOS != "linux" {
29-		t.Skip("skipping on non linux due to shell availability and symlink capability")
30-	}
31-
32-	// we lookup shell tools we use first and create the PATH var based on that
33-	shBinary, err := exec.LookPath("sh")
34-	require.NoError(t, err)
35-	path := []string{filepath.Dir(shBinary)}
36-	echoBinary, err := exec.LookPath("echo")
37-	require.NoError(t, err)
38-	if echoPath := filepath.Dir(echoBinary); !slices.Contains(path, echoPath) {
39-		path = append(path, echoPath)
40-	}
41-	// we make a symlinc to have a posix but non default shell
42-	altShellDir := t.TempDir()
43-	altShellPath := filepath.Join(altShellDir, "altsh")
44-	require.NoError(t, os.Symlink(shBinary, altShellPath))
45-	path = append(path, altShellDir)
46-
47-	prepairEnv(t)
48-	//nolint:usetesting // reason: we use prepairEnv()
49-	os.Setenv("PATH", strings.Join(path, ":"))
50-
51-	backend, _ := New().(*local)
52-	backend.tempDir = t.TempDir()
53-	backend.isolatedHome = true
54-	ctx := t.Context()
55-	taskUUID := "test-run-tasks"
56-
57-	// Setup workflow
58-	require.NoError(t, backend.SetupWorkflow(ctx, &types.Config{}, taskUUID))
59-
60-	t.Run("type commands", func(t *testing.T) {
61-		step := &types.Step{
62-			UUID:     "step-1",
63-			Name:     "test-step",
64-			Type:     types.StepTypeCommands,
65-			Image:    "sh",
66-			Commands: []string{"echo hello", "env"},
67-			Environment: map[string]string{
68-				"TEST_VAR": "test_value",
69-			},
70-		}
71-
72-		t.Run("start successful", func(t *testing.T) {
73-			err = backend.StartStep(ctx, step, taskUUID)
74-			require.NoError(t, err)
75-
76-			// Verify command was started
77-			state, err := backend.getWorkflowState(taskUUID)
78-			require.NoError(t, err)
79-			stepStateWraped, contains := state.stepState.Load(step.UUID)
80-			assert.True(t, contains)
81-			stepState, _ := stepStateWraped.(*stepState)
82-			assert.NotNil(t, stepState.cmd)
83-
84-			var outputData []byte
85-			outputDataMutex := sync.Mutex{}
86-			go t.Run("TailStep", func(t *testing.T) {
87-				outputDataMutex.Lock()
88-				go outputDataMutex.Unlock()
89-				output, err := backend.TailStep(ctx, step, taskUUID)
90-				require.NoError(t, err)
91-				assert.NotNil(t, output)
92-
93-				// Read output
94-				outputData, err = io.ReadAll(output)
95-				require.NoError(t, err)
96-			})
97-
98-			// Wait for step to finish
99-			t.Run("TestWaitStep", func(t *testing.T) {
100-				time.Sleep(time.Second / 5) // needed to prevent race condition on outputData
101-				state, err := backend.WaitStep(ctx, step, taskUUID)
102-				require.NoError(t, err)
103-				assert.True(t, state.Exited)
104-				assert.Equal(t, 0, state.ExitCode)
105-			})
106-
107-			// Verify output
108-			outputDataMutex.Lock()
109-			go outputDataMutex.Unlock()
110-			outputLines := strings.Split(strings.TrimSpace(string(outputData)), "\n")
111-			require.Truef(t, len(outputLines) > 3, "output of lines must be bigger than 3 at least but we got: %#v", outputLines)
112-			// we first test output without environments
113-			wantBeforeEnvs := []string{
114-				"+ echo hello",
115-				"hello",
116-				"+ env",
117-			}
118-			gotBeforeEnvs := outputLines[:len(wantBeforeEnvs)]
119-			assert.Equal(t, wantBeforeEnvs, gotBeforeEnvs)
120-			// we filter out nixos specific stuff catched up in env output
121-			gotEnvs := slices.DeleteFunc(outputLines[len(wantBeforeEnvs):], func(s string) bool {
122-				return strings.HasPrefix(s, "_=") || strings.HasPrefix(s, "SHLVL=")
123-			})
124-			assert.ElementsMatch(t, []string{
125-				"PWD=" + state.baseDir + "/workspace",
126-				"USERPROFILE=" + state.baseDir + "/home",
127-				"TEST_VAR=test_value",
128-				"HOME=" + state.baseDir + "/home",
129-				"CI_WORKSPACE=" + state.baseDir + "/workspace",
130-				"PATH=" + strings.Join(path, ":"),
131-			}, gotEnvs)
132-
133-			t.Run("TestDestroyStep", func(t *testing.T) {
134-				err := backend.DestroyStep(ctx, step, taskUUID)
135-				require.NoError(t, err)
136-			})
137-		})
138-	})
139-
140-	t.Run("run command in alternate unix shell", func(t *testing.T) {
141-		step := &types.Step{
142-			UUID:     "step-altshell",
143-			Name:     "altshell",
144-			Type:     types.StepTypeCommands,
145-			Image:    "altsh",
146-			Commands: []string{"echo success"},
147-		}
148-
149-		err = backend.StartStep(ctx, step, taskUUID)
150-		require.NoError(t, err)
151-
152-		state, err := backend.WaitStep(ctx, step, taskUUID)
153-		require.NoError(t, err)
154-		assert.True(t, state.Exited)
155-		assert.Equal(t, 0, state.ExitCode)
156-	})
157-
158-	t.Run("command should fail", func(t *testing.T) {
159-		step := &types.Step{
160-			UUID:     "step-fail",
161-			Name:     "fail-step",
162-			Type:     types.StepTypeCommands,
163-			Image:    "sh",
164-			Commands: []string{"exit 1"},
165-		}
166-
167-		err = backend.StartStep(ctx, step, taskUUID)
168-		require.NoError(t, err)
169-
170-		state, err := backend.WaitStep(ctx, step, taskUUID)
171-		require.NoError(t, err)
172-		assert.True(t, state.Exited)
173-		assert.Equal(t, 1, state.ExitCode)
174-	})
175-
176-	t.Run("WaitStep", func(t *testing.T) {
177-		t.Run("step not found", func(t *testing.T) {
178-			step := &types.Step{
179-				UUID: "nonexistent-step",
180-				Name: "missing",
181-			}
182-
183-			_, err = backend.WaitStep(ctx, step, taskUUID)
184-			assert.Error(t, err)
185-			assert.Contains(t, err.Error(), "not found")
186-		})
187-	})
188-
189-	t.Run("type plugin", func(t *testing.T) {
190-		step := &types.Step{
191-			UUID:        "step-plugin-1",
192-			Name:        "test-plugin",
193-			Type:        types.StepTypePlugin,
194-			Image:       "echo", // Use a binary that exists
195-			Environment: map[string]string{},
196-		}
197-
198-		t.Run("start", func(t *testing.T) {
199-			err = backend.StartStep(ctx, step, taskUUID)
200-			require.NoError(t, err)
201-
202-			// Verify command was started
203-			state, err := backend.getStepState(taskUUID, step.UUID)
204-			require.NoError(t, err)
205-			assert.NotEqualf(t, 0, state.cmd.Process.Pid, "expect an pid of the process")
206-		})
207-	})
208-
209-	t.Run("type unsupported", func(t *testing.T) {
210-		step := &types.Step{
211-			UUID: "step-unsupported",
212-			Name: "test-unsupported",
213-			Type: "unsupported-type",
214-		}
215-
216-		t.Run("start", func(t *testing.T) {
217-			err = backend.StartStep(ctx, step, taskUUID)
218-			assert.ErrorIs(t, err, ErrUnsupportedStepType)
219-		})
220-	})
221-
222-	// Cleanup
223-	assert.NoError(t, backend.DestroyWorkflow(ctx, &types.Config{}, taskUUID))
224-}
225-
226+//
227+//func TestRunStep(t *testing.T) {
228+//	if runtime.GOOS != "linux" {
229+//		t.Skip("skipping on non linux due to shell availability and symlink capability")
230+//	}
231+//
232+//	// we lookup shell tools we use first and create the PATH var based on that
233+//	shBinary, err := exec.LookPath("sh")
234+//	require.NoError(t, err)
235+//	path := []string{filepath.Dir(shBinary)}
236+//	echoBinary, err := exec.LookPath("echo")
237+//	require.NoError(t, err)
238+//	if echoPath := filepath.Dir(echoBinary); !slices.Contains(path, echoPath) {
239+//		path = append(path, echoPath)
240+//	}
241+//	// we make a symlinc to have a posix but non default shell
242+//	altShellDir := t.TempDir()
243+//	altShellPath := filepath.Join(altShellDir, "altsh")
244+//	require.NoError(t, os.Symlink(shBinary, altShellPath))
245+//	path = append(path, altShellDir)
246+//
247+//	prepairEnv(t)
248+//	//nolint:usetesting // reason: we use prepairEnv()
249+//	os.Setenv("PATH", strings.Join(path, ":"))
250+//
251+//	backend, _ := New().(*local)
252+//	backend.tempDir = t.TempDir()
253+//	backend.isolatedHome = true
254+//	ctx := t.Context()
255+//	taskUUID := "test-run-tasks"
256+//
257+//	// Setup workflow
258+//	require.NoError(t, backend.SetupWorkflow(ctx, &types.Config{}, taskUUID))
259+//
260+//	t.Run("type commands", func(t *testing.T) {
261+//		step := &types.Step{
262+//			UUID:     "step-1",
263+//			Name:     "test-step",
264+//			Type:     types.StepTypeCommands,
265+//			Image:    "sh",
266+//			Commands: []string{"echo hello", "env"},
267+//			Environment: map[string]string{
268+//				"TEST_VAR": "test_value",
269+//			},
270+//		}
271+//
272+//		t.Run("start successful", func(t *testing.T) {
273+//			err = backend.StartStep(ctx, step, taskUUID)
274+//			require.NoError(t, err)
275+//
276+//			// Verify command was started
277+//			state, err := backend.getWorkflowState(taskUUID)
278+//			require.NoError(t, err)
279+//			stepStateWraped, contains := state.stepState.Load(step.UUID)
280+//			assert.True(t, contains)
281+//			stepState, _ := stepStateWraped.(*stepState)
282+//			assert.NotNil(t, stepState.cmd)
283+//
284+//			var outputData []byte
285+//			outputDataMutex := sync.Mutex{}
286+//			go t.Run("TailStep", func(t *testing.T) {
287+//				outputDataMutex.Lock()
288+//				go outputDataMutex.Unlock()
289+//				output, err := backend.TailStep(ctx, step, taskUUID)
290+//				require.NoError(t, err)
291+//				assert.NotNil(t, output)
292+//
293+//				// Read output
294+//				outputData, err = io.ReadAll(output)
295+//				require.NoError(t, err)
296+//			})
297+//
298+//			// Wait for step to finish
299+//			t.Run("TestWaitStep", func(t *testing.T) {
300+//				time.Sleep(time.Second / 5) // needed to prevent race condition on outputData
301+//				state, err := backend.WaitStep(ctx, step, taskUUID)
302+//				require.NoError(t, err)
303+//				assert.True(t, state.Exited)
304+//				assert.Equal(t, 0, state.ExitCode)
305+//			})
306+//
307+//			// Verify output
308+//			outputDataMutex.Lock()
309+//			go outputDataMutex.Unlock()
310+//			outputLines := strings.Split(strings.TrimSpace(string(outputData)), "\n")
311+//			require.Truef(t, len(outputLines) > 3, "output of lines must be bigger than 3 at least but we got: %#v", outputLines)
312+//			// we first test output without environments
313+//			wantBeforeEnvs := []string{
314+//				"+ echo hello",
315+//				"hello",
316+//				"+ env",
317+//			}
318+//			gotBeforeEnvs := outputLines[:len(wantBeforeEnvs)]
319+//			assert.Equal(t, wantBeforeEnvs, gotBeforeEnvs)
320+//			// we filter out nixos specific stuff catched up in env output
321+//			gotEnvs := slices.DeleteFunc(outputLines[len(wantBeforeEnvs):], func(s string) bool {
322+//				return strings.HasPrefix(s, "_=") || strings.HasPrefix(s, "SHLVL=")
323+//			})
324+//			assert.ElementsMatch(t, []string{
325+//				"PWD=" + state.baseDir + "/workspace",
326+//				"USERPROFILE=" + state.baseDir + "/home",
327+//				"TEST_VAR=test_value",
328+//				"HOME=" + state.baseDir + "/home",
329+//				"CI_WORKSPACE=" + state.baseDir + "/workspace",
330+//				"PATH=" + strings.Join(path, ":"),
331+//			}, gotEnvs)
332+//
333+//			t.Run("TestDestroyStep", func(t *testing.T) {
334+//				err := backend.DestroyStep(ctx, step, taskUUID)
335+//				require.NoError(t, err)
336+//			})
337+//		})
338+//	})
339+//
340+//	t.Run("run command in alternate unix shell", func(t *testing.T) {
341+//		step := &types.Step{
342+//			UUID:     "step-altshell",
343+//			Name:     "altshell",
344+//			Type:     types.StepTypeCommands,
345+//			Image:    "altsh",
346+//			Commands: []string{"echo success"},
347+//		}
348+//
349+//		err = backend.StartStep(ctx, step, taskUUID)
350+//		require.NoError(t, err)
351+//
352+//		state, err := backend.WaitStep(ctx, step, taskUUID)
353+//		require.NoError(t, err)
354+//		assert.True(t, state.Exited)
355+//		assert.Equal(t, 0, state.ExitCode)
356+//	})
357+//
358+//	t.Run("command should fail", func(t *testing.T) {
359+//		step := &types.Step{
360+//			UUID:     "step-fail",
361+//			Name:     "fail-step",
362+//			Type:     types.StepTypeCommands,
363+//			Image:    "sh",
364+//			Commands: []string{"exit 1"},
365+//		}
366+//
367+//		err = backend.StartStep(ctx, step, taskUUID)
368+//		require.NoError(t, err)
369+//
370+//		state, err := backend.WaitStep(ctx, step, taskUUID)
371+//		require.NoError(t, err)
372+//		assert.True(t, state.Exited)
373+//		assert.Equal(t, 1, state.ExitCode)
374+//	})
375+//
376+//	t.Run("WaitStep", func(t *testing.T) {
377+//		t.Run("step not found", func(t *testing.T) {
378+//			step := &types.Step{
379+//				UUID: "nonexistent-step",
380+//				Name: "missing",
381+//			}
382+//
383+//			_, err = backend.WaitStep(ctx, step, taskUUID)
384+//			assert.Error(t, err)
385+//			assert.Contains(t, err.Error(), "not found")
386+//		})
387+//	})
388+//
389+//	t.Run("type plugin", func(t *testing.T) {
390+//		step := &types.Step{
391+//			UUID:        "step-plugin-1",
392+//			Name:        "test-plugin",
393+//			Type:        types.StepTypePlugin,
394+//			Image:       "echo", // Use a binary that exists
395+//			Environment: map[string]string{},
396+//		}
397+//
398+//		t.Run("start", func(t *testing.T) {
399+//			err = backend.StartStep(ctx, step, taskUUID)
400+//			require.NoError(t, err)
401+//
402+//			// Verify command was started
403+//			state, err := backend.getStepState(taskUUID, step.UUID)
404+//			require.NoError(t, err)
405+//			assert.NotEqualf(t, 0, state.cmd.Process.Pid, "expect an pid of the process")
406+//		})
407+//	})
408+//
409+//	t.Run("type unsupported", func(t *testing.T) {
410+//		step := &types.Step{
411+//			UUID: "step-unsupported",
412+//			Name: "test-unsupported",
413+//			Type: "unsupported-type",
414+//		}
415+//
416+//		t.Run("start", func(t *testing.T) {
417+//			err = backend.StartStep(ctx, step, taskUUID)
418+//			assert.ErrorIs(t, err, ErrUnsupportedStepType)
419+//		})
420+//	})
421+//
422+//	// Cleanup
423+//	assert.NoError(t, backend.DestroyWorkflow(ctx, &types.Config{}, taskUUID))
424+//}
425+//
426 func TestStateManagement(t *testing.T) {
427 	backend, _ := New().(*local)
428