test: improve unit test coverage for internal/task to A level

Author: snowdream

internal/task/engine_more_test.go

@@ -5,31 +5,22 @@ package task
 
 import (
 	"context"
-	"errors"
 	"testing"
-)
-
-type errorRunner struct{}
 
-func (e *errorRunner) CanExecute(dir, task string) bool { return false }
-func (e *errorRunner) Run(ctx context.Context, dir, task string, args, env []string) error {
-	return nil
-}
-func (e *errorRunner) ListTasks(dir string) ([]string, error) { return nil, errors.New("err") }
-func (e *errorRunner) Name() string                           { return "errorRunner" }
+	"github.com/stretchr/testify/require"
+)
 
-func TestEngine_Execute_NotFound(t *testing.T) {
-	eng := NewEngine()
-	err := eng.Execute(context.Background(), ".", "nonexistent_task_12345", nil, nil)
-	if err == nil {
-		t.Errorf("expected error for nonexistent task")
-	}
+func TestEngine_ListTasks_Empty(t *testing.T) {
+	engine := NewEngine()
+	// No runners registered
+	tasks := engine.ListTasks("/tmp")
+	require.Empty(t, tasks)
 }
 
-func TestEngine_ListTasks_Error(t *testing.T) {
-	eng := NewEngine()
-	eng.runners = append(eng.runners, &errorRunner{})
-
-	// Error from runner should be ignored
-	eng.ListTasks(".")
+func TestEngine_Execute_Error(t *testing.T) {
+	engine := NewEngine()
+	// No runners registered
+	err := engine.Execute(context.Background(), "/tmp", "test", nil, nil)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "no suitable task runner found")
 }

internal/task/native_more_test.go

@@ -5,47 +5,64 @@ package task
 
 import (
 	"context"
+	"os"
 	"testing"
 
 	"github.com/snowdreamtech/unirtm/internal/config"
+	"github.com/stretchr/testify/require"
 )
 
-func TestNativeRunner_runTaskWithGraph(t *testing.T) {
-	r := &NativeRunner{
-		tasks: map[string]config.Task{
-			"t1":      {Depends: []string{"t2"}},
-			"t2":      {Depends: []string{"t3"}},
-			"t3":      {Run: config.StringArray{"echo t3"}},
-			"cycle1":  {Depends: []string{"cycle2"}},
-			"cycle2":  {Depends: []string{"cycle1"}},
-			"bad_dep": {Depends: []string{"nonexistent"}},
-		},
-		settings: config.Settings{TaskOutput: "interleaved"},
+func TestNativeRunner_runTaskWithGraph_Cycle(t *testing.T) {
+	tasks := map[string]config.Task{
+		"A": {Run: config.StringArray{"echo A"}, Depends: []string{"B"}},
+		"B": {Run: config.StringArray{"echo B"}, Depends: []string{"A"}},
 	}
+	runner := NewNativeRunner(tasks, config.Settings{})
 
-	ctx := context.Background()
+	err := runner.Run(context.Background(), "/tmp", "A", nil, nil)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "circular dependency")
+}
 
-	// success
-	err := r.Run(ctx, ".", "t1", nil, nil)
-	if err != nil {
-		t.Errorf("expected no error running t1")
+func TestNativeRunner_runTaskWithGraph_MissingDep(t *testing.T) {
+	tasks := map[string]config.Task{
+		"A": {Run: config.StringArray{"echo A"}, Depends: []string{"B"}},
 	}
+	runner := NewNativeRunner(tasks, config.Settings{})
+
+	err := runner.Run(context.Background(), "/tmp", "A", nil, nil)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "dependency")
+}
 
-	// cycle
-	err = r.Run(ctx, ".", "cycle1", nil, nil)
-	if err == nil {
-		t.Errorf("expected error for circular dependency")
+func TestPrefixWriter_Write(t *testing.T) {
+	pw := &prefixWriter{
+		prefix: "PREFIX",
+		w:      os.Stdout,
 	}
 
-	// task not found
-	err = r.Run(ctx, ".", "nonexistent", nil, nil)
-	if err == nil {
-		t.Errorf("expected error for nonexistent task")
+	n, err := pw.Write([]byte("hello\nworld\n"))
+	require.NoError(t, err)
+	require.Equal(t, 12, n)
+}
+
+func TestNativeRunner_runTaskWithGraph_Normal(t *testing.T) {
+	tasks := map[string]config.Task{
+		"A": {Run: config.StringArray{"echo A"}, Env: map[string]interface{}{"FOO": "BAR"}, Timeout: 5, Output: "interleaved"},
 	}
+	runner := NewNativeRunner(tasks, config.Settings{})
+
+	err := runner.Run(context.Background(), "/tmp", "A", []string{"arg1"}, []string{"ENV1=1"})
+	require.NoError(t, err)
+}
 
-	// dependency not found
-	err = r.Run(ctx, ".", "bad_dep", nil, nil)
-	if err == nil {
-		t.Errorf("expected error for missing dependency")
+func TestNativeRunner_runTaskWithGraph_InvalidScript(t *testing.T) {
+	tasks := map[string]config.Task{
+		"A": {Run: config.StringArray{"echo \"unclosed quote"}, Output: "prefix"},
 	}
+	runner := NewNativeRunner(tasks, config.Settings{})
+
+	err := runner.Run(context.Background(), "/tmp", "A", nil, nil)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "failed to parse task script")
 }