Function ExerciseClient

riverdriver/riverdrivertest/driver_client_test.go:202–768

ExerciseClient exercises a client using a generic driver using a minimal set of test cases to verify that the driver works end to end.

(ctx context.Context, t *testing.T,
	driverWithSchema func(ctx context.Context, t *testing.T) (riverdriver.Driver[TTx], string),
)

// ExerciseClient exercises a client using a generic driver using a minimal set
// of test cases to verify that the driver works end to end.
func ExerciseClient[TTx any](ctx context.Context, t *testing.T,
	driverWithSchema func(ctx context.Context, t *testing.T) (riverdriver.Driver[TTx], string),
) {
	t.Helper()

	type testBundle struct {
		config *river.Config
		driver riverdriver.Driver[TTx]
		exec   riverdriver.Executor
		schema string
	}

	// Alternate setup returning only client Config rather than a full Client.
	setupConfig := func(t *testing.T) (*river.Config, *testBundle) {
		t.Helper()

		var (
			driver, schema = driverWithSchema(ctx, t)
			config         = newTestConfig(t, schema)
		)

		return config, &testBundle{
			config: config,
			driver: driver,
			exec:   driver.GetExecutor(),
			schema: schema,
		}
	}

	setup := func(t *testing.T) (*river.Client[TTx], *testBundle) {
		t.Helper()

		config, bundle := setupConfig(t)

		client, err := river.NewClient(bundle.driver, config)
		require.NoError(t, err)

		return client, bundle
	}

	beginTx := func(ctx context.Context, t *testing.T, bundle *testBundle) (TTx, riverdriver.ExecutorTx) {
		t.Helper()

		execTx, err := bundle.driver.GetExecutor().Begin(ctx)
		require.NoError(t, err)

		// Ignore error on cleanup so we can roll back early in tests where desirable.
		t.Cleanup(func() { _ = execTx.Rollback(ctx) })

		return bundle.driver.UnwrapTx(execTx), execTx
	}

	t.Run("StartInsertAndWork", func(t *testing.T) {
		t.Parallel()

		client, bundle := setup(t)

		type JobArgs struct {