Function TestWorker_NoTokenBackoff

coderd/x/gitsync/worker_test.go:1176–1228

(t *testing.T)

}

func TestWorker_NoTokenBackoff(t *testing.T) {
	t.Parallel()
	ctx := testutil.Context(t, testutil.WaitShort)

	chatID := uuid.New()
	ownerID := uuid.New()

	var mu sync.Mutex
	var backoffArgs []database.BackoffChatDiffStatusParams
	tickDone := make(chan struct{})

	mClock := quartz.NewMock(t)

	ctrl := gomock.NewController(t)
	store := dbmock.NewMockStore(ctrl)

	store.EXPECT().AcquireStaleChatDiffStatuses(gomock.Any(), gomock.Any()).
		Return([]database.AcquireStaleChatDiffStatusesRow{
			makeAcquiredRowWithBranch(chatID, ownerID, "feature"),
		}, nil)
	store.EXPECT().BackoffChatDiffStatus(gomock.Any(), gomock.Any()).
		DoAndReturn(func(_ context.Context, arg database.BackoffChatDiffStatusParams) error {
			mu.Lock()
			backoffArgs = append(backoffArgs, arg)
			mu.Unlock()
			close(tickDone)
			return nil
		})

	// Token resolver returns empty token → ErrNoTokenAvailable.
	// Provider methods should never be called.
	prov := &mockProvider{}
	providers := func(context.Context, string) gitprovider.Provider { return prov }
	tokens := func(context.Context, uuid.UUID, string) (*string, error) {
		return ptr.Ref(""), nil
	}

	logger := slogtest.Make(t, &slogtest.Options{IgnoreErrors: true})
	refresher := gitsync.NewRefresher(providers, tokens, logger, mClock)
	worker := gitsync.NewWorker(store, refresher, nil, mClock, logger)

	tickOnce(ctx, t, mClock, worker, tickDone)

	mu.Lock()
	defer mu.Unlock()
	require.Len(t, backoffArgs, 1)
	assert.Equal(t, chatID, backoffArgs[0].ChatID)

	// The backoff should use NoTokenBackoff (10min), not
	// DiffStatusTTL (2min).
	expectedStaleAt := mClock.Now().UTC().Add(gitsync.NoTokenBackoff)
	assert.WithinDuration(t, expectedStaleAt, backoffArgs[0].StaleAt, time.Second)
}