chore: use testcontainers for crdb

Author: tstirrat15

internal/testserver/datastore/config/postgres-with-timestamps.conf

@@ -0,0 +1,2 @@
+max_connections = 3000
+track_commit_timestamp = 1

internal/testserver/datastore/config/postgres.conf

@@ -0,0 +1 @@
+max_connections = 3000

internal/testserver/datastore/crdb.go

@@ -2,18 +2,14 @@ package datastore
 
 import (
 	"context"
-	"fmt"
 	"testing"
 
-	"github.com/google/uuid"
 	"github.com/stretchr/testify/require"
-	"github.com/testcontainers/testcontainers-go"
 	"github.com/testcontainers/testcontainers-go/modules/cockroachdb"
 
 	crdbmigrations "github.com/authzed/spicedb/internal/datastore/crdb/migrations"
 	"github.com/authzed/spicedb/pkg/datastore"
 	"github.com/authzed/spicedb/pkg/migrate"
-	"github.com/authzed/spicedb/pkg/secrets"
 )
 
 // crdbTester is safe for concurrent use by tests.
@@ -24,73 +20,28 @@ type crdbTester struct {
 var _ RunningEngineForTest = (*crdbTester)(nil)
 
 // RunCRDBForTesting returns a RunningEngineForTest for CRDB
-func RunCRDBForTesting(t testing.TB, bridgeNetworkName string, crdbVersion string) *crdbTester {
-	ctx := context.Background()
-	name := "crds-" + uuid.New().String()
+func RunCRDBForTesting(t testing.TB, crdbVersion string) *crdbTester {
+	ctx := t.Context()
 
-	containerReq := testcontainers.ContainerRequest{
-		Name: name,
-		Cmd:  []string{"--insecure", "--max-offset=50ms"},
-	}
-
-	if bridgeNetworkName != "" {
-		containerReq.Networks = []string{bridgeNetworkName}
-	}
-
-	opts := []testcontainers.ContainerCustomizer{
+	container, err := cockroachdb.Run(ctx, "mirror.gcr.io/cockroachdb/cockroach:v"+crdbVersion, 
 		cockroachdb.WithInsecure(),
-		testcontainers.CustomizeRequest(testcontainers.GenericContainerRequest{
-			ContainerRequest: containerReq,
-		}),
-	}
-
-	container, err := cockroachdb.Run(ctx, "mirror.gcr.io/cockroachdb/cockroach:v"+crdbVersion, opts...)
+)
 	require.NoError(t, err)
 
-	t.Cleanup(func() {
-		require.NoError(t, container.Terminate(ctx))
-	})
-
 	// enable changefeeds
-	code, _, _ := container.Exec(ctx, []string{
+	code, _, err := container.Exec(ctx, []string{
 		"cockroach", "sql",
 		"--insecure",
 		"-e", "SET CLUSTER SETTING kv.rangefeed.enabled = true;",
 	})
-	require.Equal(t, 0, code)
-
-	// create DB
-	dbNameUniquePortion, err := secrets.TokenHex(4)
 	require.NoError(t, err)
-
-	newDBName := "db" + dbNameUniquePortion
-	code, _, _ = container.Exec(ctx, []string{
-		"cockroach", "sql",
-		"--insecure",
-		"-e", "CREATE DATABASE " + newDBName + ";",
-	})
 	require.Equal(t, 0, code)
 
-	hostname := "localhost"
-	creds := "root:fake"
-	port := "26257"
-
-	if bridgeNetworkName != "" {
-		hostname = name
-	} else {
-		mappedPort, err := container.MappedPort(ctx, "26257")
-		require.NoError(t, err)
-		port = mappedPort.Port()
-	}
+	connUri, err := container.ConnectionString(ctx)
+	require.NoError(t, err)
 
 	return &crdbTester{
-		databaseConnectStr: fmt.Sprintf(
-			"postgres://%s@%s:%s/%s?sslmode=disable",
-			creds,
-			hostname,
-			port,
-			newDBName,
-		),
+		databaseConnectStr: connUri,
 	}
 }
 
@@ -101,8 +52,6 @@ func (r *crdbTester) NewDatabase(t testing.TB) string {
 
 // NewDatastore creates a database and runs migrations on it.
 func (r *crdbTester) NewDatastore(t testing.TB, initFunc InitFunc) datastore.Datastore {
-	t.Log("MAINE")
-	t.Log(r.databaseConnectStr)
 	connectStr := r.databaseConnectStr
 
 	migrationDriver, err := crdbmigrations.NewCRDBDriver(connectStr)

internal/testserver/datastore/datastore.go

@@ -48,33 +48,25 @@ type RunningEngineForTestWithEnvVars interface {
 // respectively. Note also that the backing database or service will be shutdown automatically via
 // the Cleanup of the testing object.
 func RunDatastoreEngine(t testing.TB, engine string) RunningEngineForTest {
-	return RunDatastoreEngineWithBridge(t, engine, "")
-}
-
-// RunDatastoreEngineWithBridge runs a datastore engine on a specific bridge. If a bridge is
-// specified, then the hostnames returned by the engines are those to be called from another
-// container on the bridge.
-func RunDatastoreEngineWithBridge(t testing.TB, engine string, bridgeNetworkName string) RunningEngineForTest {
 	switch engine {
 	case "memory":
-		require.Empty(t, bridgeNetworkName, "memory datastore does not support bridge networking")
 		return RunMemoryForTesting(t)
 	case "cockroachdb":
 		ver := os.Getenv("CRDB_TEST_VERSION")
 		if ver == "" {
 			ver = crdbversion.LatestTestedCockroachDBVersion
 		}
-		return RunCRDBForTesting(t, bridgeNetworkName, ver)
+		return RunCRDBForTesting(t, ver)
 	case "postgres":
 		ver := os.Getenv("POSTGRES_TEST_VERSION")
 		if ver == "" {
 			ver = pgversion.LatestTestedPostgresVersion
 		}
-		return RunPostgresForTesting(t, bridgeNetworkName, migrate.Head, ver, false)
+		return RunPostgresForTesting(t, migrate.Head, ver, false)
 	case "mysql":
-		return RunMySQLForTesting(t, bridgeNetworkName)
+		return RunMySQLForTesting(t)
 	case "spanner":
-		return RunSpannerForTesting(t, bridgeNetworkName, migrate.Head)
+		return RunSpannerForTesting(t, migrate.Head)
 	default:
 		t.Fatalf("found missing engine for RunDatastoreEngine: %s", engine)
 		return nil

internal/testserver/datastore/mysql.go

@@ -43,20 +43,20 @@ type MySQLTesterOptions struct {
 
 // RunMySQLForTesting returns a RunningEngineForTest for the mysql driver
 // backed by a MySQL instance with RunningEngineForTest options - no prefix is added, and datastore migration is run.
-func RunMySQLForTesting(t testing.TB, bridgeNetworkName string) RunningEngineForTest {
-	return RunMySQLForTestingWithOptions(t, MySQLTesterOptions{Prefix: "", MigrateForNewDatastore: true}, bridgeNetworkName)
+func RunMySQLForTesting(t testing.TB) RunningEngineForTest {
+	return RunMySQLForTestingWithOptions(t, MySQLTesterOptions{Prefix: "", MigrateForNewDatastore: true})
 }
 
 // RunMySQLForTestingWithOptions returns a RunningEngineForTest for the mysql driver
 // backed by a MySQL instance, while allowing options to be forwarded
-func RunMySQLForTestingWithOptions(t testing.TB, options MySQLTesterOptions, bridgeNetworkName string) RunningEngineForTest {
-	ctx := context.Background()
+func RunMySQLForTestingWithOptions(t testing.TB, options MySQLTesterOptions) RunningEngineForTest {
+	ctx := t.Context()
 	containerImageTag := version.MinimumSupportedMySQLVersion
 
-	name := "mysql-" + uuid.New().String()
+	// TODO: add wait behavior
+	// TODO: simplify
 
 	req := testcontainers.ContainerRequest{
-		Name:         name,
 		Image:        "mirror.gcr.io/library/mysql:" + containerImageTag,
 		ExposedPorts: []string{fmt.Sprintf("%d/tcp", mysqlPort)},
 		Env: map[string]string{
@@ -68,10 +68,6 @@ func RunMySQLForTestingWithOptions(t testing.TB, options MySQLTesterOptions, bri
 			WithStartupTimeout(dockerBootTimeout),
 	}
 
-	if bridgeNetworkName != "" {
-		req.Networks = []string{bridgeNetworkName}
-	}
-
 	container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
 		ContainerRequest: req,
 		Started:          true,
@@ -86,34 +82,12 @@ func RunMySQLForTestingWithOptions(t testing.TB, options MySQLTesterOptions, bri
 	mappedPort, err := container.MappedPort(ctx, "3306")
 	require.NoError(t, err)
 
-	if bridgeNetworkName != "" {
-		builder.hostname = name
-		builder.port = strconv.Itoa(mysqlPort)
-	} else {
-		builder.port = mappedPort.Port()
-	}
+	builder.port = mappedPort.Port()
 
  	dsn := fmt.Sprintf("%s@(localhost:%s)/mysql?parseTime=true", builder.creds, port)
 	builder.db, err = sql.Open("mysql", dsn)
 	require.NoError(t, err)
 
-	// TODO: use require.Eventually here
- 	require.NoError(t, pool.Retry(func() error {
- 		var err error
- 		ctx, cancelPing := context.WithTimeout(context.Background(), dockerBootTimeout)
- 		defer cancelPing()
- 		err = builder.db.PingContext(ctx)
- 		if err != nil {
- 			return err
-		}
-		time.Sleep(500 * time.Millisecond)
-	}))
-
-	t.Cleanup(func() {
-		require.NoError(t, builder.db.Close())
-		require.NoError(t, container.Terminate(ctx))
-	})
-
 	return builder
 }