Skip to content

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

8.8 KB
Raw Blame
package reviewrun

import (
	"context"
	"testing"
	"time"

	metadatapb "github.com/bytebase/omni/metadata"
	"github.com/stretchr/testify/require"
	"google.golang.org/protobuf/encoding/protojson"

	"github.com/bytebase/bytebase/backend/common"
	"github.com/bytebase/bytebase/backend/common/testcontainer"
	storepb "github.com/bytebase/bytebase/backend/generated-go/store"
	"github.com/bytebase/bytebase/backend/store"

	_ "github.com/bytebase/bytebase/backend/plugin/db/pg"
)

// TestRuleExecutorSkipsAnEmptyPolicy pins that review switched off is no
// review: the executor returns no findings without resolving a target, where
// the same issue fails once a rule is on because its target does not exist.
func TestRuleExecutorSkipsAnEmptyPolicy(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	db, stores, _ := testcontainer.NewMetadataDB(t)
	_, err := db.ExecContext(ctx, `
		INSERT INTO workspace (resource_id) VALUES ('ws');
		INSERT INTO principal (name, email, password_hash) VALUES ('creator', '[email protected]', 'unused');
		INSERT INTO project (resource_id, workspace, name) VALUES ('p', 'ws', 'P');
	`)
	require.NoError(t, err)

	plan, err := stores.CreatePlan(ctx, &store.PlanMessage{
		ProjectID: "p",
		Name:      "plan",
		Config: &storepb.PlanConfig{
			Specs: []*storepb.PlanConfig_Spec{{
				Id: "spec-1",
				Config: &storepb.PlanConfig_Spec_ChangeDatabaseConfig{
					ChangeDatabaseConfig: &storepb.PlanConfig_ChangeDatabaseConfig{
						Targets: []string{"instances/missing/databases/app"},
					},
				},
			}},
		},
	}, "[email protected]")
	require.NoError(t, err)
	issue, err := stores.CreateIssue(ctx, &store.IssueMessage{
		ProjectID:    "p",
		CreatorEmail: "[email protected]",
		Title:        "issue",
		Type:         storepb.Issue_DATABASE_CHANGE,
		Payload:      &storepb.Issue{},
		PlanUID:      &plan.UID,
	})
	require.NoError(t, err)

	setRules := func(rules ...storepb.ReviewRuleType) {
		t.Helper()
		payload, err := protojson.Marshal(&storepb.ReviewRulePolicy{Rules: rules})
		require.NoError(t, err)
		_, err = stores.CreatePolicy(ctx, &store.PolicyMessage{
			Workspace:    "ws",
			ResourceType: storepb.Policy_PROJECT,
			Resource:     common.FormatProject("p"),
			Type:         storepb.Policy_REVIEW_RULE,
			Payload:      string(payload),
			Enforce:      true,
		})
		require.NoError(t, err)
	}
	executor := NewRuleExecutor(stores)

	setRules()
	comments, err := executor.RunOnce(ctx, "p", issue.UID)
	require.NoError(t, err)
	require.Empty(t, comments)

	setRules(storepb.ReviewRuleType_SYNTAX)
	_, err = executor.RunOnce(ctx, "p", issue.UID)
	require.Error(t, err)
}

// TestRuleExecutorSkipsAnEngineWithoutAReviewer pins that the rule review
// leaves an engine it has no reviewer for to V1's statement advice: the run
// skips its target and completes with no findings.
func TestRuleExecutorSkipsAnEngineWithoutAReviewer(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	db, stores, _ := testcontainer.NewMetadataDB(t)
	_, err := db.ExecContext(ctx, `
		INSERT INTO workspace (resource_id) VALUES ('ws');
		INSERT INTO principal (name, email, password_hash) VALUES ('creator', '[email protected]', 'unused');
		INSERT INTO project (resource_id, workspace, name) VALUES ('p', 'ws', 'P');
	`)
	require.NoError(t, err)
	payload, err := protojson.Marshal(&storepb.ReviewRulePolicy{Rules: []storepb.ReviewRuleType{storepb.ReviewRuleType_SYNTAX}})
	require.NoError(t, err)
	_, err = stores.CreatePolicy(ctx, &store.PolicyMessage{
		Workspace:    "ws",
		ResourceType: storepb.Policy_PROJECT,
		Resource:     common.FormatProject("p"),
		Type:         storepb.Policy_REVIEW_RULE,
		Payload:      string(payload),
		Enforce:      true,
	})
	require.NoError(t, err)
	sheets, err := stores.CreateSheets(ctx, "p", &store.SheetMessage{Statement: "DELETE FROM t;"})
	require.NoError(t, err)

	runOn := func(instanceID string, engine storepb.Engine) error {
		t.Helper()
		require.False(t, ReviewsEngine(engine))
		_, err := stores.CreateInstance(ctx, &store.InstanceMessage{
			ResourceID: instanceID,
			Workspace:  "ws",
			Metadata: &storepb.Instance{
				Engine:      engine,
				DataSources: []*storepb.DataSource{{Id: "admin", Type: storepb.DataSourceType_ADMIN}},
			},
		})
		require.NoError(t, err)
		_, err = stores.UpsertDatabase(ctx, &store.DatabaseMessage{
			ProjectID:    "p",
			InstanceID:   instanceID,
			DatabaseName: "app",
			Metadata:     &storepb.DatabaseMetadata{},
		})
		require.NoError(t, err)
		plan, err := stores.CreatePlan(ctx, &store.PlanMessage{
			ProjectID: "p",
			Name:      "plan",
			Config: &storepb.PlanConfig{
				Specs: []*storepb.PlanConfig_Spec{{
					Id: "spec-1",
					Config: &storepb.PlanConfig_Spec_ChangeDatabaseConfig{
						ChangeDatabaseConfig: &storepb.PlanConfig_ChangeDatabaseConfig{
							Targets:     []string{"instances/" + instanceID + "/databases/app"},
							SheetSha256: sheets[0].Sha256,
						},
					},
				}},
			},
		}, "[email protected]")
		require.NoError(t, err)
		issue, err := stores.CreateIssue(ctx, &store.IssueMessage{
			ProjectID:    "p",
			CreatorEmail: "[email protected]",
			Title:        "issue",
			Type:         storepb.Issue_DATABASE_CHANGE,
			Payload:      &storepb.Issue{},
			PlanUID:      &plan.UID,
		})
		require.NoError(t, err)
		comments, err := NewRuleExecutor(stores).RunOnce(ctx, "p", issue.UID)
		require.Empty(t, comments)
		return err
	}

	require.NoError(t, runOn("dynamo", storepb.Engine_DYNAMODB))
	require.NoError(t, runOn("clickhouse", storepb.Engine_CLICKHOUSE))
}

// TestRuleExecutorPassesTheSyncedDefaultSchema pins that SQL Server's walk
// judges an unqualified name in the default schema the sync read: with it,
// CREATE TABLE of a name the schema holds is a finding; without it, the walk
// cannot place the name.
func TestRuleExecutorPassesTheSyncedDefaultSchema(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	db, stores, _ := testcontainer.NewMetadataDB(t)
	_, err := db.ExecContext(ctx, `
		INSERT INTO workspace (resource_id) VALUES ('ws');
		INSERT INTO principal (name, email, password_hash) VALUES ('creator', '[email protected]', 'unused');
		INSERT INTO project (resource_id, workspace, name) VALUES ('p', 'ws', 'P');
	`)
	require.NoError(t, err)
	payload, err := protojson.Marshal(&storepb.ReviewRulePolicy{Rules: []storepb.ReviewRuleType{storepb.ReviewRuleType_SYNTAX, storepb.ReviewRuleType_WALK_THROUGH}})
	require.NoError(t, err)
	_, err = stores.CreatePolicy(ctx, &store.PolicyMessage{
		Workspace:    "ws",
		ResourceType: storepb.Policy_PROJECT,
		Resource:     common.FormatProject("p"),
		Type:         storepb.Policy_REVIEW_RULE,
		Payload:      string(payload),
		Enforce:      true,
	})
	require.NoError(t, err)
	sheets, err := stores.CreateSheets(ctx, "p", &store.SheetMessage{Statement: "CREATE TABLE t (a int);"})
	require.NoError(t, err)

	review := func(instanceID, defaultSchema string) []string {
		t.Helper()
		_, err := stores.CreateInstance(ctx, &store.InstanceMessage{
			ResourceID: instanceID,
			Workspace:  "ws",
			Metadata: &storepb.Instance{
				Engine:      storepb.Engine_MSSQL,
				DataSources: []*storepb.DataSource{{Id: "admin", Type: storepb.DataSourceType_ADMIN}},
			},
		})
		require.NoError(t, err)
		_, err = stores.UpsertDatabase(ctx, &store.DatabaseMessage{
			ProjectID:    "p",
			InstanceID:   instanceID,
			DatabaseName: "app",
			Metadata:     &storepb.DatabaseMetadata{},
		})
		require.NoError(t, err)
		_, err = stores.UpsertDBSchema(ctx, instanceID, "app", &metadatapb.DatabaseSchemaMetadata{
			Name:          "app",
			DefaultSchema: defaultSchema,
			Schemas: []*metadatapb.SchemaMetadata{{
				Name:   "dbo",
				Tables: []*metadatapb.TableMetadata{{Name: "t", Columns: []*metadatapb.ColumnMetadata{{Name: "a"}}}},
			}},
		}, nil, time.Now())
		require.NoError(t, err)
		plan, err := stores.CreatePlan(ctx, &store.PlanMessage{
			ProjectID: "p",
			Name:      "plan",
			Config: &storepb.PlanConfig{
				Specs: []*storepb.PlanConfig_Spec{{
					Id: "spec-1",
					Config: &storepb.PlanConfig_Spec_ChangeDatabaseConfig{
						ChangeDatabaseConfig: &storepb.PlanConfig_ChangeDatabaseConfig{
							Targets:     []string{"instances/" + instanceID + "/databases/app"},
							SheetSha256: sheets[0].Sha256,
						},
					},
				}},
			},
		}, "[email protected]")
		require.NoError(t, err)
		issue, err := stores.CreateIssue(ctx, &store.IssueMessage{
			ProjectID:    "p",
			CreatorEmail: "[email protected]",
			Title:        "issue",
			Type:         storepb.Issue_DATABASE_CHANGE,
			Payload:      &storepb.Issue{},
			PlanUID:      &plan.UID,
		})
		require.NoError(t, err)
		comments, err := NewRuleExecutor(stores).RunOnce(ctx, "p", issue.UID)
		require.NoError(t, err)
		var messages []string
		for _, comment := range comments {
			messages = append(messages, comment.Payload.GetComment())
		}
		return messages
	}

	require.Equal(t, []string{"Table `t` already exists."}, review("synced", "dbo"))
	require.Empty(t, review("unsynced", ""))
}