Function TestManagerTaskBlockBreakerEscalatesAtLimit

internal/task/manager_test.go:4909–5040

(t *testing.T)

}

func TestManagerTaskBlockBreakerEscalatesAtLimit(t *testing.T) {
	t.Run(
		"Should escalate at the recurrence limit exactly once while already escalated",
		func(t *testing.T) {
			t.Parallel()

			store := newInMemoryManagerStore()
			needsAttentionHooks := 0
			manager := newTaskManagerForTestWithOptions(
				t,
				store,
				WithTaskRunHooks(recordingTaskRunHooks{
					needsAttention: func(
						_ context.Context,
						payload hookspkg.TaskNeedsAttentionPayload,
					) (hookspkg.TaskNeedsAttentionPayload, error) {
						needsAttentionHooks++
						return payload, nil
					},
				}),
			)
			actor := validActorContext()
			taskRecord, err := manager.CreateTask(context.Background(), CreateTask{
				Scope:       ScopeWorkspace,
				WorkspaceID: "ws-block-breaker",
				Title:       "Breaker target",
			}, actor)
			if err != nil {
				t.Fatalf("CreateTask() error = %v", err)
			}

			first, err := manager.BlockTask(context.Background(), BlockRequest{
				TaskID: taskRecord.ID,
				Kind:   BlockKindNeedsInput,
				Reason: "waiting for creator",
			}, actor)
			if err != nil {
				t.Fatalf("BlockTask(first) error = %v", err)
			}
			if got, want := store.blockRecurrences[blockRecurrenceTestKey(taskRecord.ID, BlockKindNeedsInput)].Count, 0; got != want {
				t.Fatalf("first recurrence count = %d, want %d", got, want)
			}
			if _, err := manager.ClearTaskBlock(
				context.Background(),
				taskRecord.ID,
				first.ID,
				"resolved once",
				actor,
			); err != nil {
				t.Fatalf("ClearTaskBlock(first) error = %v", err)
			}

			second, err := manager.BlockTask(context.Background(), BlockRequest{
				TaskID: taskRecord.ID,
				Kind:   BlockKindNeedsInput,
				Reason: "waiting again",
			}, actor)
			if err != nil {