Function TestLaunchHeartbeat

coderd/x/chatd/chatdebug/model_internal_test.go:1214–1379

(t *testing.T)

func float64Ptr(v float64) *float64 { return &v }

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

	t.Run("fires_touch_step_on_tick", func(t *testing.T) {
		t.Parallel()

		ctrl := gomock.NewController(t)
		db := dbmock.NewMockStore(ctrl)
		mClock := quartz.NewMock(t)

		// Use a small stale threshold so the heartbeat interval is
		// short enough to test easily (threshold/2 = 5s, clamped ≥1s).
		svc := NewService(db, testutil.Logger(t), nil,
			WithClock(mClock),
			WithStaleThreshold(10*time.Second),
		)

		stepID := uuid.New()
		runID := uuid.New()
		chatID := uuid.New()

		done := make(chan struct{})
		defer close(done)

		// Trap the ticker creation so we can control it.
		tickerTrap := mClock.Trap().NewTicker("chatdebug", "heartbeat")
		defer tickerTrap.Close()

		ctx := testutil.Context(t, testutil.WaitShort)

		// Expect atomic TouchStep calls via TouchChatDebugStepAndRun.
		touchCalled := make(chan struct{}, 5)
		db.EXPECT().
			TouchChatDebugStepAndRun(gomock.Any(), gomock.Any()).
			DoAndReturn(func(_ context.Context, params database.TouchChatDebugStepAndRunParams) error {
				require.Equal(t, stepID, params.StepID)
				require.Equal(t, runID, params.RunID)
				require.Equal(t, chatID, params.ChatID)
				select {
				case touchCalled <- struct{}{}:
				default:
				}
				return nil
			}).
			AnyTimes()

		launchHeartbeat(ctx, svc, stepID, runID, chatID, done)

		// Wait for the ticker to be created.
		tickerTrap.MustWait(ctx).MustRelease(ctx)

		// Advance the clock past one heartbeat interval (5s for a
		// 10s stale threshold) and verify TouchStep fires.
		mClock.Advance(5 * time.Second).MustWait(ctx)

		select {
		case <-touchCalled:
		case <-ctx.Done():