Function TestManagerEnqueueRunRejectsConcurrentOpenRun

internal/task/manager_test.go:4089–4186

(t *testing.T)

}

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

	tests := []struct {
		name     string
		openRun  func(context.Context, *testing.T, *Service, Run, ActorContext) Run
		wantOpen RunStatus
	}{
		{
			name: "queued",
			openRun: func(_ context.Context, _ *testing.T, _ *Service, run Run, _ ActorContext) Run {
				return run
			},
			wantOpen: TaskRunStatusQueued,
		},
		{
			name: "running",
			openRun: func(ctx context.Context, t *testing.T, manager *Service, run Run, actor ActorContext) Run {
				t.Helper()
				claimed, err := manager.ClaimRun(ctx, run.ID, ClaimRun{}, actor)
				if err != nil {
					t.Fatalf("ClaimRun() error = %v", err)
				}
				running, err := manager.StartRun(ctx, claimed.ID, StartRun{}, actor)
				if err != nil {
					t.Fatalf("StartRun() error = %v", err)
				}
				return *running
			},
			wantOpen: TaskRunStatusRunning,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			ctx := context.Background()
			store := newInMemoryManagerStore()
			manager := newTaskManagerForTestWithOptions(
				t,
				store,
				WithSessionExecutor(testSessionExecutor{}),
			)
			actor := validActorContext()

			taskRecord, err := manager.CreateTask(ctx, CreateTask{
				Scope: ScopeGlobal,
				Title: "Concurrent run guard",
			}, actor)
			if err != nil {
				t.Fatalf("CreateTask() error = %v", err)
			}

			firstRun, err := manager.EnqueueRun(ctx, EnqueueRun{
				TaskID:         taskRecord.ID,
				IdempotencyKey: "same-logical-run",
			}, actor)