Function runTestCase

pkg/util/services/basic_service_test.go:188–250

(t *testing.T, tc testCase)

}

func runTestCase(t *testing.T, tc testCase) {
	s := newServ(servConf{
		startSleep:            time.Second,
		startRetVal:           tc.startRetVal,
		startReturnContextErr: tc.startReturnContextErr,
		runSleep:              time.Second,
		runRetVal:             tc.runRetVal,
		runReturnContextErr:   tc.runReturnContextErr,
		stopRetVal:            tc.stopRetVal,
	})

	sl := newServiceListener()
	require.NoError(t, sl.StartAsync(context.Background()))
	require.NoError(t, sl.AwaitRunning(context.Background()))

	s.AddListener(sl)

	require.Equal(t, New, s.State())

	ctx, servCancel := context.WithCancel(context.Background())
	defer servCancel() // make sure to call cancel at least once

	require.NoError(t, s.StartAsync(ctx), "StartAsync")
	require.Error(t, s.StartAsync(ctx), "second StartAsync") // must always return error
	if tc.cancelAfterStartAsync {
		servCancel()
	}
	if tc.stopAfterStartAsync {
		s.StopAsync()
	}

	awaitCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	awaitRunningErr := s.AwaitRunning(awaitCtx)

	if len(tc.awaitRunningError) == 0 {
		require.NoError(t, awaitRunningErr, "AwaitRunning")
	} else {
		require.Contains(t, tc.awaitRunningError, awaitRunningErr, "AwaitRunning")
	}

	if tc.cancelAfterAwaitRunning {
		servCancel()
	}
	if tc.stopAfterAwaitRunning {
		s.StopAsync()
	}

	awaitCtx, cancel = context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	require.Equal(t, tc.awaitTerminatedError, s.AwaitTerminated(awaitCtx), "AwaitTerminated")
	require.Equal(t, tc.failureCase, s.FailureCase(), "FailureCase")

	// get log, and compare against expected
	// we can only get log once listener is finished, otherwise we risk race conditions