Function TestManagerTaskBlockStatusDerivation

internal/task/manager_test.go:4367–4549

(t *testing.T)

}

func TestManagerTaskBlockStatusDerivation(t *testing.T) {
	t.Parallel()

	t.Run("Should derive blocked when a task holds any open block", func(t *testing.T) {
		t.Parallel()

		store := newInMemoryManagerStore()
		manager := newTaskManagerForTest(t, store)
		actor := validActorContext()
		taskRecord, err := manager.CreateTask(context.Background(), CreateTask{
			Scope:       ScopeWorkspace,
			WorkspaceID: "ws-blocked",
			Title:       "Blocked by runtime condition",
		}, actor)
		if err != nil {
			t.Fatalf("CreateTask() error = %v", err)
		}

		store.blocks[taskRecord.ID] = map[string]TaskBlock{
			"block-open": {
				ID:          "block-open",
				WorkspaceID: taskRecord.WorkspaceID,
				TaskID:      taskRecord.ID,
				Kind:        BlockKindNeedsInput,
				Reason:      "creator input required",
				CreatedBy:   ActorIdentity{Kind: ActorKindAgentSession, Ref: "sess-worker"},
				CreatedAt:   time.Date(2026, 4, 14, 14, 55, 0, 0, time.UTC),
			},
		}

		reconciled, err := manager.reconcileTaskCascade(context.Background(), taskRecord.ID)
		if err != nil {
			t.Fatalf("reconcileTaskCascade() error = %v", err)
		}
		if got, want := reconciled.Status, TaskStatusBlocked; got != want {
			t.Fatalf("reconciled.Status = %q, want %q", got, want)
		}
		if got, want := store.tasks[taskRecord.ID].Status, TaskStatusBlocked; got != want {
			t.Fatalf("stored task status = %q, want %q", got, want)
		}
	})

	t.Run(
		"Should treat a block expiring at derivation time as cleared without a sweep",
		func(t *testing.T) {
			t.Parallel()

			store := newInMemoryManagerStore()
			manager := newTaskManagerForTest(t, store)
			actor := validActorContext()
			taskRecord, err := manager.CreateTask(context.Background(), CreateTask{
				Scope:       ScopeWorkspace,
				WorkspaceID: "ws-expired",
				Title:       "Expired transient block",
			}, actor)
			if err != nil {
				t.Fatalf("CreateTask() error = %v", err)
			}