[CAP-9243] add workflows unit tests (#317)

Add better unit test coverage to workflows logic, targeting the loader and service layers (not cmd).

GitOrigin-RevId: 38d71a277745e07756a911baf41727d51f357184

Author: blue-keleher

pkg/taskrun/taskrun_test.go

@@ -0,0 +1,218 @@
+package taskrun
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	wfclient "github.com/render-oss/cli/pkg/client/workflows"
+	"github.com/render-oss/cli/pkg/pointers"
+)
+
+func TestTaskRunDetailsFormat(t *testing.T) {
+	t.Run("nil input returns nil", func(t *testing.T) {
+		result := TaskRunDetailsFormat(nil)
+		assert.Nil(t, result)
+	})
+
+	t.Run("all fields populated", func(t *testing.T) {
+		startedAt := time.Date(2025, 1, 15, 10, 30, 0, 0, time.UTC)
+		completedAt := time.Date(2025, 1, 15, 10, 35, 0, 0, time.UTC)
+
+		var input wfclient.TaskData
+		require.NoError(t, input.FromTaskData1(map[string]any{"key": "value"}))
+
+		taskRun := &wfclient.TaskRunDetails{
+			Id:          "tr-1",
+			Status:      wfclient.Completed,
+			StartedAt:   &startedAt,
+			CompletedAt: &completedAt,
+			Input:       input,
+			Error:       pointers.From("something went wrong"),
+			Results:     wfclient.TaskRunResult{42},
+		}
+
+		kvs := TaskRunDetailsFormat(taskRun)
+		require.NotNil(t, kvs)
+
+		kvMap := make(map[string]string, len(kvs))
+		for _, kv := range kvs {
+			kvMap[kv.Key] = kv.Value
+		}
+
+		assert.Equal(t, "tr-1", kvMap["ID"])
+		assert.Contains(t, kvMap["Status"], string(wfclient.Completed))
+		assert.Equal(t, startedAt.Format(time.RFC3339), kvMap["Started At"])
+		assert.Equal(t, completedAt.Format(time.RFC3339), kvMap["Completed At"])
+		assert.Contains(t, kvMap["Input"], "key")
+		assert.Equal(t, "something went wrong", kvMap["Error"])
+		assert.Contains(t, kvMap["Results"], "42")
+	})
+
+	t.Run("nil StartedAt and CompletedAt produce empty string values", func(t *testing.T) {
+		var input wfclient.TaskData
+		require.NoError(t, input.FromTaskData0([]any{}))
+
+		taskRun := &wfclient.TaskRunDetails{
+			Id:          "tr-2",
+			Status:      wfclient.Pending,
+			StartedAt:   nil,
+			CompletedAt: nil,
+			Input:       input,
+		}
+
+		kvs := TaskRunDetailsFormat(taskRun)
+		kvMap := make(map[string]string, len(kvs))
+		for _, kv := range kvs {
+			kvMap[kv.Key] = kv.Value
+		}
+
+		assert.Equal(t, "", kvMap["Started At"])
+		assert.Equal(t, "", kvMap["Completed At"])
+	})
+
+	t.Run("error field appended when non-nil", func(t *testing.T) {
+		var input wfclient.TaskData
+		require.NoError(t, input.FromTaskData0([]any{}))
+
+		taskRun := &wfclient.TaskRunDetails{
+			Id:     "tr-3",
+			Status: wfclient.Failed,
+			Input:  input,
+			Error:  pointers.From("task timed out"),
+		}
+
+		kvs := TaskRunDetailsFormat(taskRun)
+		keys := make([]string, 0, len(kvs))
+		for _, kv := range kvs {
+			keys = append(keys, kv.Key)
+		}
+
+		assert.Contains(t, keys, "Error")
+	})
+
+	t.Run("error field omitted when nil", func(t *testing.T) {
+		var input wfclient.TaskData
+		require.NoError(t, input.FromTaskData0([]any{}))
+
+		taskRun := &wfclient.TaskRunDetails{
+			Id:     "tr-4",
+			Status: wfclient.Running,
+			Input:  input,
+			Error:  nil,
+		}
+
+		kvs := TaskRunDetailsFormat(taskRun)
+		keys := make([]string, 0, len(kvs))
+		for _, kv := range kvs {
+			keys = append(keys, kv.Key)
+		}
+
+		assert.NotContains(t, keys, "Error")
+	})
+
+	t.Run("results field appended when non-nil", func(t *testing.T) {
+		var input wfclient.TaskData
+		require.NoError(t, input.FromTaskData0([]any{}))
+
+		taskRun := &wfclient.TaskRunDetails{
+			Id:      "tr-5",
+			Status:  wfclient.Completed,
+			Input:   input,
+			Results: wfclient.TaskRunResult{"result-data"},
+		}
+
+		kvs := TaskRunDetailsFormat(taskRun)
+		keys := make([]string, 0, len(kvs))
+		for _, kv := range kvs {
+			keys = append(keys, kv.Key)
+		}
+
+		assert.Contains(t, keys, "Results")
+	})
+
+	t.Run("results field omitted when nil", func(t *testing.T) {
+		var input wfclient.TaskData
+		require.NoError(t, input.FromTaskData0([]any{}))
+
+		taskRun := &wfclient.TaskRunDetails{
+			Id:      "tr-6",
+			Status:  wfclient.Running,
+			Input:   input,
+			Results: nil,
+		}
+
+		kvs := TaskRunDetailsFormat(taskRun)
+		keys := make([]string, 0, len(kvs))
+		for _, kv := range kvs {
+			keys = append(keys, kv.Key)
+		}
+
+		assert.NotContains(t, keys, "Results")
+	})
+}
+
+func TestRow(t *testing.T) {
+	t.Run("pending run with no dates", func(t *testing.T) {
+		taskRun := &wfclient.TaskRun{
+			Id:          "tr-1",
+			Status:      wfclient.Pending,
+			StartedAt:   nil,
+			CompletedAt: nil,
+		}
+
+		row := Row(taskRun)
+		require.Len(t, row, 5)
+		assert.Equal(t, "tr-1", row[0])
+		assert.Equal(t, "pending", row[1])
+		assert.Equal(t, "", row[2]) // started
+		assert.Equal(t, "", row[3]) // completed
+		assert.Equal(t, "", row[4]) // duration
+	})
+
+	t.Run("running with only StartedAt", func(t *testing.T) {
+		startedAt := time.Date(2025, 1, 15, 10, 30, 0, 0, time.UTC)
+
+		taskRun := &wfclient.TaskRun{
+			Id:          "tr-2",
+			Status:      wfclient.Running,
+			StartedAt:   &startedAt,
+			CompletedAt: nil,
+		}
+
+		row := Row(taskRun)
+		require.Len(t, row, 5)
+		assert.Equal(t, "tr-2", row[0])
+		assert.Equal(t, "running", row[1])
+		assert.Equal(t, startedAt.Format(time.RFC3339), row[2])
+		assert.Equal(t, "", row[3]) // completed
+		assert.Equal(t, "", row[4]) // duration
+	})
+
+	t.Run("completed with both dates", func(t *testing.T) {
+		startedAt := time.Date(2025, 1, 15, 10, 30, 0, 0, time.UTC)
+		completedAt := time.Date(2025, 1, 15, 10, 35, 30, 0, time.UTC)
+
+		taskRun := &wfclient.TaskRun{
+			Id:          "tr-3",
+			Status:      wfclient.Completed,
+			StartedAt:   &startedAt,
+			CompletedAt: &completedAt,
+		}
+
+		row := Row(taskRun)
+		require.Len(t, row, 5)
+		assert.Equal(t, "tr-3", row[0])
+		assert.Equal(t, "completed", row[1])
+		assert.Equal(t, startedAt.Format(time.RFC3339), row[2])
+		assert.Equal(t, completedAt.Format(time.RFC3339), row[3])
+
+		// Duration should be 5m30s
+		duration := completedAt.Sub(startedAt)
+		assert.Equal(t, duration.String(), row[4])
+		assert.True(t, strings.Contains(row[4], "5m30s"), "expected duration to contain 5m30s, got %s", row[4])
+	})
+}

pkg/tui/views/workflows/loader.go

@@ -16,18 +16,40 @@ import (
 	"github.com/render-oss/cli/pkg/workflowversion"
 )
 
-type WorkflowLoaderDeps interface {
-	TaskRepo() *tasks.Repo
-	WorkflowService() *workflow.Service
-	WorkflowVersionRepo() *version.Repo
-	WorkflowRepo() *workflow.Repo
+// taskRepo defines the task operations the loader needs (unexported; used for testability).
+type taskRepo interface {
+	RunTask(ctx context.Context, taskID string, input *workflows.TaskData) (*workflows.TaskRun, error)
+	GetTask(ctx context.Context, id string) (*workflows.Task, error)
+	ListTasks(ctx context.Context, params *client.ListTasksParams) (client.Cursor, []*workflows.Task, error)
+	ListTaskRuns(ctx context.Context, params *client.ListTaskRunsParams) (client.Cursor, []*workflows.TaskRun, error)
+	GetTaskRunDetails(ctx context.Context, taskRunID string) (*workflows.TaskRunDetails, error)
 }
 
+// versionRepo defines the version operations the loader needs (unexported; used for testability).
+type versionRepo interface {
+	ListVersions(ctx context.Context, workflowID string, params *client.ListWorkflowVersionsParams) (client.Cursor, []*wfclient.WorkflowVersion, error)
+	GetVersion(ctx context.Context, workflowVersionID string) (*wfclient.WorkflowVersion, error)
+	TriggerRelease(ctx context.Context, workflowID string, input version.TriggerReleaseInput) error
+}
+
+// workflowRepo defines the workflow operations the loader needs (unexported; used for testability).
+type workflowRepoIface interface {
+	GetWorkflow(ctx context.Context, id string) (*wfclient.Workflow, error)
+}
+
+const (
+	defaultVersionPollInterval        = 5 * time.Second
+	defaultVersionReleasePollInterval = time.Second
+)
+
 type WorkflowLoader struct {
-	taskRepo            *tasks.Repo
+	taskRepo            taskRepo
 	workflowService     *workflow.Service
-	workflowVersionRepo *version.Repo
-	workflowRepo        *workflow.Repo
+	workflowVersionRepo versionRepo
+	workflowRepo        workflowRepoIface
+
+	versionPollInterval        *time.Duration
+	versionReleasePollInterval *time.Duration
 }
 
 func NewWorkflowLoader(taskRepo *tasks.Repo, workflowService *workflow.Service, workflowVersionRepo *version.Repo, workflowRepo *workflow.Repo) *WorkflowLoader {
@@ -117,7 +139,11 @@ func (w *WorkflowLoader) ReleaseVersion(ctx context.Context, input VersionReleas
 
 func (w *WorkflowLoader) WaitForVersion(ctx context.Context, workflowID, workflowVersionID string) (*wfclient.WorkflowVersion, error) {
 	timeoutTimer := time.NewTimer(versionTimeout)
-	ticker := time.NewTicker(5 * time.Second)
+	pollInterval := defaultVersionPollInterval
+	if w.versionPollInterval != nil {
+		pollInterval = *w.versionPollInterval
+	}
+	ticker := time.NewTicker(pollInterval)
 	defer ticker.Stop()
 
 	// Check immediately before waiting for the first tick
@@ -148,7 +174,11 @@ func (w *WorkflowLoader) WaitForVersion(ctx context.Context, workflowID, workflo
 
 func (w *WorkflowLoader) WaitForVersionRelease(ctx context.Context, workflowID string) (*wfclient.WorkflowVersion, error) {
 	timeoutTimer := time.NewTimer(versionReleaseTimeout)
-	ticker := time.NewTicker(time.Second)
+	releasePollInterval := defaultVersionReleasePollInterval
+	if w.versionReleasePollInterval != nil {
+		releasePollInterval = *w.versionReleasePollInterval
+	}
+	ticker := time.NewTicker(releasePollInterval)
 	defer ticker.Stop()
 
 	// Check immediately before waiting for the first tick