Function TestPublisherTallymanError

enterprise/coderd/usage/publisher_test.go:563–629

(t *testing.T)

}

func TestPublisherTallymanError(t *testing.T) {
	t.Parallel()
	ctx := testutil.Context(t, testutil.WaitLong)
	log := slogtest.Make(t, nil)
	ctrl := gomock.NewController(t)
	db := dbmock.NewMockStore(ctrl)
	clock := quartz.NewMock(t)
	now := time.Now()
	clock.Set(now)

	deploymentID, licenseJWT := configureMockDeployment(t, db)
	const errorMessage = "tallyman error"
	var calls int
	ingestURL := fakeServer(t, tallymanHandler(t, deploymentID.String(), licenseJWT, func(req usagetypes.TallymanV1IngestRequest) any {
		calls++
		return usagetypes.TallymanV1Response{
			Message: errorMessage,
		}
	}))

	publisher := usage.NewTallymanPublisher(ctx, log, db, coderdenttest.Keys,
		usage.PublisherWithClock(clock),
		usage.PublisherWithIngestURL(ingestURL),
	)
	defer publisher.Close()

	// Start the publisher with a trap.
	tickerTrap := clock.Trap().NewTicker()
	defer tickerTrap.Close()
	startErr := make(chan error)
	go func() {
		err := publisher.Start()
		testutil.RequireSend(ctx, t, startErr, err)
	}()
	tickerCall := tickerTrap.MustWait(ctx)
	tickerCall.MustRelease(ctx)
	require.NoError(t, testutil.RequireReceive(ctx, t, startErr))

	// Mock events to be published.
	events := []database.UsageEvent{
		{
			ID:        uuid.New().String(),
			EventType: string(usagetypes.UsageEventTypeDCManagedAgentsV1),
			EventData: []byte(jsoninate(t, usagetypes.DCManagedAgentsV1{
				Count: 1,
			})),
		},
	}
	db.EXPECT().SelectUsageEventsForPublishing(gomock.Any(), gomock.Any()).Return(events, nil).Times(1)
	db.EXPECT().UpdateUsageEventsPostPublish(gomock.Any(), gomock.Any()).DoAndReturn(
		func(ctx context.Context, params database.UpdateUsageEventsPostPublishParams) error {
			assert.Equal(t, []string{events[0].ID}, params.IDs)
			assert.Contains(t, params.FailureMessages[0], errorMessage)
			assert.Equal(t, []bool{false}, params.SetPublishedAts)
			return nil
		},
	).Times(1)