Function TestRunner_Run

scaletest/taskstatus/run_internal_test.go:164–283

(t *testing.T)

}

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

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

	mClock := quartz.NewMock(t)
	fClient := newFakeClient(t)
	fUpdater := newFakeAppStatusUpdater(t)
	templateID := uuid.UUID{5, 6, 7, 8}
	workspaceName := "test-workspace"
	appSlug := "test-app"

	reg := prometheus.NewRegistry()
	metrics := NewMetrics(reg, "test")

	connectedWaitGroup := &sync.WaitGroup{}
	connectedWaitGroup.Add(1)
	startReporting := make(chan struct{})

	cfg := Config{
		TemplateID:           templateID,
		WorkspaceName:        workspaceName,
		AppSlug:              appSlug,
		ConnectedWaitGroup:   connectedWaitGroup,
		StartReporting:       startReporting,
		ReportStatusPeriod:   10 * time.Second,
		ReportStatusDuration: 35 * time.Second,
		Metrics:              metrics,
		MetricLabelValues:    []string{"test"},
	}
	runner := &Runner{
		client:      fClient,
		updater:     fUpdater,
		cfg:         cfg,
		clock:       mClock,
		randFloat64: func() float64 { return 0.5 }, // not random in tests
		reportTimes: make(map[int]time.Time),
	}

	reportTickerTrap := mClock.Trap().NewTimer("reportTaskStatus")
	defer reportTickerTrap.Close()
	sinceTrap := mClock.Trap().Since("watchWorkspaceUpdates")
	defer sinceTrap.Close()
	buildTickerTrap := mClock.Trap().TickerFunc("createExternalWorkspace")
	defer buildTickerTrap.Close()

	// Run the runner in a goroutine
	runErr := make(chan error, 1)
	go func() {
		runErr <- runner.Run(ctx, "test-runner", testutil.NewTestLogWriter(t))
	}()

	// complete the build
	buildTickerTrap.MustWait(ctx).MustRelease(ctx)
	w := mClock.Advance(30 * time.Second)
	testutil.RequireSend(ctx, t, fClient.workspaceByOwnerAndNameStatus, codersdk.ProvisionerJobSucceeded)
	w.MustWait(ctx)