Function TestRunner_Run_BuildFailed

scaletest/taskstatus/run_internal_test.go:513–597

(t *testing.T)

}

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

	testCtx := testutil.Context(t, testutil.WaitShort)
	runCtx, cancel := context.WithCancel(testCtx)
	defer cancel()

	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),
	}

	buildTickerTrap := mClock.Trap().TickerFunc("createExternalWorkspace")
	defer buildTickerTrap.Close()
	// Run the runner in a goroutine
	runErr := make(chan error, 1)
	go func() {
		runErr <- runner.Run(runCtx, "test-runner", testutil.NewTestLogWriter(t))
	}()

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

	connectedWaitGroup.Wait()

	// Wait for the runner to complete