Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

fix(test): wait for the schema dump in TestTenantBackfill (#21831)

Danny Xuc4173003a90f
diff --git a/backend/tests/database.go b/backend/tests/database.go
index eb50880bbf..13534f227c 100644
--- a/backend/tests/database.go
+++ b/backend/tests/database.go
@@ -4,7 +4,9 @@ import (
"context"
"fmt"
"slices"
+ "strings"
"sync"
+ "time"
"connectrpc.com/connect"
"github.com/google/uuid"
@@ -233,3 +235,43 @@ func (ctl *controller) waitDatabaseRegistered(ctx context.Context, instance *v1p
}
return errors.Wrapf(last, "database %s is not registered after %d instance syncs", name, instanceSyncAttempts)
}
+
+// waitSchemaDump returns the database's schema dump once it reports want, a
+// string the change just applied to the database puts in the dump.
+//
+// A completed rollout does not make that dump current. createDatabase registers
+// the database, and the instance sync that registration runs queues an
+// asynchronous schema sync for it; that queued sync can read the database
+// before a later migration and write its dump after the migration's own sync
+// wrote one, and db_schema keeps the last write, so the dump reverts to the
+// pre-migration schema. Syncing once per round makes the dump current and
+// outlasts such a write.
+func (ctl *controller) waitSchemaDump(ctx context.Context, databaseName, want string) (string, error) {
+ ticker := time.NewTicker(pollInterval)
+ defer ticker.Stop()
+ timeout := time.After(30 * time.Second)
+
+ for {
+ if _, err := ctl.databaseServiceClient.SyncDatabase(ctx, connect.NewRequest(&v1pb.SyncDatabaseRequest{
+ Name: databaseName,
+ })); err != nil {
+ return "", err
+ }
+ resp, err := ctl.databaseServiceClient.GetDatabaseSchema(ctx, connect.NewRequest(&v1pb.GetDatabaseSchemaRequest{
+ Name: fmt.Sprintf("%s/schema", databaseName),
+ }))
+ if err != nil {
+ return "", err
+ }
+ dump := resp.Msg.Schema
+ if strings.Contains(dump, want) {
+ return dump, nil
+ }
+
+ select {
+ case <-timeout:
+ return "", errors.Errorf("timeout waiting for the schema dump of %s to report %q, last dump:\n%s", databaseName, want, dump)
+ case <-ticker.C:
+ }
+ }
+}
diff --git a/backend/tests/tenant_test.go b/backend/tests/tenant_test.go
index 3f612fb189..52d8917188 100644
--- a/backend/tests/tenant_test.go
+++ b/backend/tests/tenant_test.go
@@ -100,11 +100,10 @@ func TestTenantBackfill(t *testing.T) {
})
a.NoError(err)
- baselineSchema, err := ctl.databaseServiceClient.GetDatabaseSchema(ctx, connect.NewRequest(&v1pb.GetDatabaseSchemaRequest{
- Name: fmt.Sprintf("%s/databases/%s/schema", prodInstance.Msg.Name, baselineDBName),
- }))
+ baselineDBPath := fmt.Sprintf("%s/databases/%s", prodInstance.Msg.Name, baselineDBName)
+ baselineSchema, err := ctl.waitSchemaDump(ctx, baselineDBPath, `"book"`)
a.NoError(err)
- a.Equal(wantBookSchema, baselineSchema.Msg.Schema)
+ a.Equal(wantBookSchema, baselineSchema)
// Create pending change (ALTER TABLE) - approved but not executed.
sheet2, err := ctl.sheetServiceClient.CreateSheet(ctx, connect.NewRequest(&v1pb.CreateSheetRequest{
@@ -153,9 +152,7 @@ func TestTenantBackfill(t *testing.T) {
// ==================== TENANT ONBOARDING WORKFLOW ====================
// Step 1: Get baseline's current schema.
- baselineCurrentSchema, err := ctl.databaseServiceClient.GetDatabaseSchema(ctx, connect.NewRequest(&v1pb.GetDatabaseSchemaRequest{
- Name: fmt.Sprintf("%s/databases/%s/schema", prodInstance.Msg.Name, baselineDBName),
- }))
+ baselineCurrentSchema, err := ctl.waitSchemaDump(ctx, baselineDBPath, `"book"`)
a.NoError(err)
// Step 2: Create new tenant database.
@@ -166,7 +163,7 @@ func TestTenantBackfill(t *testing.T) {
// Step 3: Initialize new tenant with baseline schema.
initSheet, err := ctl.sheetServiceClient.CreateSheet(ctx, connect.NewRequest(&v1pb.CreateSheetRequest{
Parent: project.Msg.Name,
- Sheet: &v1pb.Sheet{Content: []byte(baselineCurrentSchema.Msg.Schema)},
+ Sheet: &v1pb.Sheet{Content: []byte(baselineCurrentSchema)},
}))
a.NoError(err)
@@ -207,11 +204,9 @@ func TestTenantBackfill(t *testing.T) {
err = ctl.waitRollout(ctx, initIssue.Msg.Name, initRollout.Msg.Name)
a.NoError(err)
- newTenantSchema, err := ctl.databaseServiceClient.GetDatabaseSchema(ctx, connect.NewRequest(&v1pb.GetDatabaseSchemaRequest{
- Name: fmt.Sprintf("%s/databases/%s/schema", prodInstance.Msg.Name, newTenantDBName),
- }))
+ newTenantSchema, err := ctl.waitSchemaDump(ctx, newTenantDBPath, `"book"`)
a.NoError(err)
- a.Equal(baselineCurrentSchema.Msg.Schema, newTenantSchema.Msg.Schema)
+ a.Equal(baselineCurrentSchema, newTenantSchema)
// Step 4: Find pending rollouts for baseline.
plans, err := ctl.planServiceClient.ListPlans(ctx, connect.NewRequest(&v1pb.ListPlansRequest{
@@ -276,18 +271,14 @@ func TestTenantBackfill(t *testing.T) {
err = ctl.waitRollout(ctx, pendingIssue.Msg.Name, pendingRollout.Msg.Name)
a.NoError(err)
- finalBaselineSchema, err := ctl.databaseServiceClient.GetDatabaseSchema(ctx, connect.NewRequest(&v1pb.GetDatabaseSchemaRequest{
- Name: fmt.Sprintf("%s/databases/%s/schema", prodInstance.Msg.Name, baselineDBName),
- }))
+ finalBaselineSchema, err := ctl.waitSchemaDump(ctx, baselineDBPath, "author")
a.NoError(err)
- finalNewTenantSchema, err := ctl.databaseServiceClient.GetDatabaseSchema(ctx, connect.NewRequest(&v1pb.GetDatabaseSchemaRequest{
- Name: fmt.Sprintf("%s/databases/%s/schema", prodInstance.Msg.Name, newTenantDBName),
- }))
+ finalNewTenantSchema, err := ctl.waitSchemaDump(ctx, newTenantDBPath, "author")
a.NoError(err)
- a.Equal(finalBaselineSchema.Msg.Schema, finalNewTenantSchema.Msg.Schema)
- a.Contains(finalNewTenantSchema.Msg.Schema, "author")
+ a.Equal(finalBaselineSchema, finalNewTenantSchema)
+ a.Contains(finalNewTenantSchema, "author")
completedRollout, err := ctl.rolloutServiceClient.GetRollout(ctx, connect.NewRequest(&v1pb.GetRolloutRequest{
Name: pendingRollout.Msg.Name,