Function TestManagerTaskBlockBreakerCanBeDisabled

internal/task/manager_test.go:5146–5196

(t *testing.T)

}

func TestManagerTaskBlockBreakerCanBeDisabled(t *testing.T) {
	t.Run(
		"Should keep recurrence accounting but skip escalation when disabled",
		func(t *testing.T) {
			t.Parallel()

			store := newInMemoryManagerStore()
			manager := newTaskManagerForTestWithOptions(t, store, WithBlockRecurrenceLimit(0))
			actor := validActorContext()
			taskRecord, err := manager.CreateTask(context.Background(), CreateTask{
				Scope:       ScopeWorkspace,
				WorkspaceID: "ws-block-breaker-disabled",
				Title:       "Breaker disabled",
			}, actor)
			if err != nil {
				t.Fatalf("CreateTask() error = %v", err)
			}

			for idx := range 3 {
				block, err := manager.BlockTask(context.Background(), BlockRequest{
					TaskID: taskRecord.ID,
					Kind:   BlockKindCapability,
					Reason: fmt.Sprintf("missing capability %d", idx),
				}, actor)
				if err != nil {
					t.Fatalf("BlockTask(%d) error = %v", idx, err)
				}
				if idx < 2 {
					if _, err := manager.ClearTaskBlock(
						context.Background(),
						taskRecord.ID,
						block.ID,
						"capability restored",
						actor,
					); err != nil {
						t.Fatalf("ClearTaskBlock(%d) error = %v", idx, err)
					}
				}
			}
			if got, want := store.blockRecurrences[blockRecurrenceTestKey(taskRecord.ID, BlockKindCapability)].Count, 2; got != want {
				t.Fatalf("recurrence count = %d, want %d", got, want)
			}
			if store.tasks[taskRecord.ID].NeedsAttention != nil {
				t.Fatalf(
					"NeedsAttention = %#v, want disabled breaker to skip escalation",
					store.tasks[taskRecord.ID].NeedsAttention,
				)
			}
		},
	)
}

func TestManagerExpireTaskBlocksDoesNotIncrementRecurrenceOnClear(t *testing.T) {
	t.Run(