Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat(policy): wire the REVIEW_RULE policy through the service and store
rebelice30daddecefd4
diff --git a/backend/api/v1/org_policy_service.go b/backend/api/v1/org_policy_service.goindex 677539c571..e381c33f4f 100644--- a/backend/api/v1/org_policy_service.go+++ b/backend/api/v1/org_policy_service.go@@ -29,6 +29,7 @@ var (storepb.Policy_QUERY_DATA: {storepb.Policy_WORKSPACE, storepb.Policy_PROJECT},storepb.Policy_MASKING_RULE: {storepb.Policy_WORKSPACE},storepb.Policy_MASKING_EXEMPTION: {storepb.Policy_PROJECT},+ storepb.Policy_REVIEW_RULE: {storepb.Policy_WORKSPACE, storepb.Policy_PROJECT},})@@ -58,15 +59,25 @@ func (s *OrgPolicyService) GetPolicy(ctx context.Context, req *connect.Request[vpolicy, parent, err := s.findPolicyMessage(ctx, req.Msg.Name)if err != nil {connectErr := connect.CodeOf(err)- // For ROLLOUT_POLICY, return default policy if not found+ // Some policy types have a default that stands in for a missing row.if connectErr == connect.CodeNotFound {policyType, extractErr := extractPolicyTypeFromName(req.Msg.Name)- if extractErr == nil && policyType == storepb.Policy_ROLLOUT {- defaultPolicy, defaultErr := s.getDefaultRolloutPolicy(parent)- if defaultErr != nil {- return nil, defaultErr+ if extractErr == nil {+ switch policyType {+ case storepb.Policy_ROLLOUT:+ defaultPolicy, defaultErr := s.getDefaultRolloutPolicy(parent)+ if defaultErr != nil {+ return nil, defaultErr+ }+ policy = defaultPolicy+ case storepb.Policy_REVIEW_RULE:+ defaultPolicy, defaultErr := getDefaultReviewRulePolicy(parent)+ if defaultErr != nil {+ return nil, defaultErr+ }+ policy = defaultPolicy+ default:}- policy = defaultPolicy}} else {return nil, err@@ -226,7 +237,8 @@ func (s *OrgPolicyService) UpdatePolicy(ctx context.Context, req *connect.Reques"tag_policy","data_source_query_policy","export_data_policy",- "query_data_policy":+ "query_data_policy",+ "review_rule_policy":if !pathMatchType(path, policy.Type) {return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("invalid path %s for policy type %s", path, policy.Type.String()))}@@ -270,6 +282,8 @@ func pathMatchType(path string, policyType storepb.Policy_Type) bool {return path == "tag_policy"case storepb.Policy_QUERY_DATA:return path == "query_data_policy"+ case storepb.Policy_REVIEW_RULE:+ return path == "review_rule_policy"default:return false}@@ -345,6 +359,33 @@ func (*OrgPolicyService) getDefaultRolloutPolicy(parent string) (*store.PolicyMereturn policy, nil}+// getDefaultReviewRulePolicy returns the review rule policy that stands in for+// a missing row: every rule on. It is the same default the store applies when+// neither the project nor the workspace has a policy.+func getDefaultReviewRulePolicy(parent string) (*store.PolicyMessage, error) {+ resourceType, resource, err := common.GetPolicyResourceTypeAndResource(parent)+ if err != nil {+ return nil, connect.NewError(connect.CodeInvalidArgument, err)+ }++ payloadBytes, err := protojson.Marshal(store.GetDefaultReviewRulePolicy())+ if err != nil {+ return nil, errors.Wrap(err, "failed to marshal review rule policy")+ }++ policy := &store.PolicyMessage{+ ResourceType: resourceType,+ Type: storepb.Policy_REVIEW_RULE,+ InheritFromParent: false,+ Enforce: true,+ Payload: string(payloadBytes),+ }+ if v := resource; v != nil {+ policy.Resource = *v+ }+ return policy, nil+}+// findPolicyMessage finds the policy and the parent name by the policy name.func (s *OrgPolicyService) findPolicyMessage(ctx context.Context, policyName string) (*store.PolicyMessage, string, error) {tokens := strings.Split(policyName, common.PolicyNamePrefix)@@ -543,11 +584,41 @@ func validatePolicyPayload(policyType storepb.Policy_Type, policy *v1pb.Policy)}}}+ case storepb.Policy_REVIEW_RULE:+ reviewRulePolicy, ok := policy.Policy.(*v1pb.Policy_ReviewRulePolicy)+ if !ok {+ return connect.NewError(connect.CodeInvalidArgument, errors.Errorf("unmatched policy type %v and policy %v", policyType, policy.Policy))+ }+ if reviewRulePolicy.ReviewRulePolicy == nil {+ return connect.NewError(connect.CodeInvalidArgument, errors.New("review rule policy must be set"))+ }+ if err := validateReviewRules(reviewRulePolicy.ReviewRulePolicy.Rules); err != nil {+ return connect.NewError(connect.CodeInvalidArgument, err)+ }default:}return nil}+// validateReviewRules rejects unspecified, unknown, and repeated rules. The+// list is a switch, so every entry must name one rule the server knows.+func validateReviewRules(rules []v1pb.ReviewRuleType) error {+ seen := make(map[v1pb.ReviewRuleType]bool, len(rules))+ for _, rule := range rules {+ if rule == v1pb.ReviewRuleType_REVIEW_RULE_TYPE_UNSPECIFIED {+ return errors.New("review rule must be specified")+ }+ if _, ok := v1pb.ReviewRuleType_name[int32(rule)]; !ok {+ return errors.Errorf("unknown review rule %d", rule)+ }+ if seen[rule] {+ return errors.Errorf("review rule %s is listed twice", rule)+ }+ seen[rule] = true+ }+ return nil+}+func (s *OrgPolicyService) convertPolicyPayloadToString(ctx context.Context, policy *v1pb.Policy) (string, error) {switch policy.Type {case v1pb.PolicyType_ROLLOUT_POLICY:@@ -582,6 +653,13 @@ func (s *OrgPolicyService) convertPolicyPayloadToString(ctx context.Context, polreturn "", errors.Wrap(err, "failed to marshal policy")}return string(payloadBytes), nil+ case v1pb.PolicyType_REVIEW_RULE:+ payload := convertToStorePBReviewRulePolicy(policy.GetReviewRulePolicy())+ payloadBytes, err := protojson.Marshal(payload)+ if err != nil {+ return "", errors.Wrap(err, "failed to marshal review rule policy")+ }+ return string(payloadBytes), nilcase v1pb.PolicyType_MASKING_RULE:if err := s.licenseService.IsFeatureEnabled(ctx, common.GetWorkspaceIDFromContext(ctx), v1pb.PlanFeature_FEATURE_DATA_MASKING); err != nil {return "", connect.NewError(connect.CodePermissionDenied, err)@@ -650,6 +728,12 @@ func convertToPolicy(policyMessage *store.PolicyMessage) (*v1pb.Policy, error) {return nil, err}policy.Policy = payload+ case storepb.Policy_REVIEW_RULE:+ payload, err := convertToV1PBReviewRulePolicy(policyMessage.Payload)+ if err != nil {+ return nil, err+ }+ policy.Policy = payloadcase storepb.Policy_MASKING_RULE:maskingRulePolicy := &storepb.MaskingRulePolicy{}if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(policyMessage.Payload), maskingRulePolicy); err != nil {diff --git a/backend/api/v1/org_policy_service_converter.go b/backend/api/v1/org_policy_service_converter.goindex 70c7b1d31f..759d8aa193 100644--- a/backend/api/v1/org_policy_service_converter.go+++ b/backend/api/v1/org_policy_service_converter.go@@ -187,6 +187,30 @@ func convertToQueryDataPolicyPayload(policy *v1pb.QueryDataPolicy) *storepb.Quer}}+func convertToV1PBReviewRulePolicy(payloadStr string) (*v1pb.Policy_ReviewRulePolicy, error) {+ payload := &storepb.ReviewRulePolicy{}+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(payloadStr), payload); err != nil {+ return nil, errors.Wrapf(err, "failed to unmarshal review rule policy payload")+ }+ rules := make([]v1pb.ReviewRuleType, 0, len(payload.Rules))+ for _, rule := range payload.Rules {+ rules = append(rules, v1pb.ReviewRuleType(rule))+ }+ return &v1pb.Policy_ReviewRulePolicy{+ ReviewRulePolicy: &v1pb.ReviewRulePolicy{Rules: rules},+ }, nil+}++// convertToStorePBReviewRulePolicy casts each rule across the two mirrored+// enums; TestReviewRuleTypeEnumsMirror holds their numbering together.+func convertToStorePBReviewRulePolicy(policy *v1pb.ReviewRulePolicy) *storepb.ReviewRulePolicy {+ rules := make([]storepb.ReviewRuleType, 0, len(policy.GetRules()))+ for _, rule := range policy.GetRules() {+ rules = append(rules, storepb.ReviewRuleType(rule))+ }+ return &storepb.ReviewRulePolicy{Rules: rules}+}+func convertToStorePBMskingRulePolicy(policy *v1pb.MaskingRulePolicy) *storepb.MaskingRulePolicy {var rules []*storepb.MaskingRulePolicy_MaskingRulefor _, rule := range policy.Rules {@@ -298,6 +322,8 @@ func convertV1PBToStorePBPolicyType(pType v1pb.PolicyType) (storepb.Policy_Type,return storepb.Policy_MASKING_EXEMPTION, nilcase v1pb.PolicyType_DATA_QUERY:return storepb.Policy_QUERY_DATA, nil+ case v1pb.PolicyType_REVIEW_RULE:+ return storepb.Policy_REVIEW_RULE, nildefault:}return storepb.Policy_TYPE_UNSPECIFIED, errors.Errorf("invalid policy type %v", pType)@@ -315,6 +341,8 @@ func convertStorePBToV1PBPolicyType(pType storepb.Policy_Type) v1pb.PolicyType {return v1pb.PolicyType_MASKING_EXEMPTIONcase storepb.Policy_QUERY_DATA:return v1pb.PolicyType_DATA_QUERY+ case storepb.Policy_REVIEW_RULE:+ return v1pb.PolicyType_REVIEW_RULEdefault:}return v1pb.PolicyType_POLICY_TYPE_UNSPECIFIEDdiff --git a/backend/api/v1/org_policy_service_review_rule_test.go b/backend/api/v1/org_policy_service_review_rule_test.gonew file mode 100644index 0000000000..a94335ee57--- /dev/null+++ b/backend/api/v1/org_policy_service_review_rule_test.go@@ -0,0 +1,123 @@+package v1++import (+ "testing"++ "github.com/stretchr/testify/require"+ "google.golang.org/protobuf/encoding/protojson"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+ "github.com/bytebase/bytebase/backend/store"+)++// TestReviewRuleTypeEnumsMirror holds bytebase.v1.ReviewRuleType and+// bytebase.store.ReviewRuleType to the same numbering, which is what lets the+// converters cast between them.+func TestReviewRuleTypeEnumsMirror(t *testing.T) {+ t.Parallel()+ require.Equal(t, len(v1pb.ReviewRuleType_name), len(storepb.ReviewRuleType_name))+ for number, name := range v1pb.ReviewRuleType_name {+ require.Equal(t, name, storepb.ReviewRuleType_name[number], "value %d", number)+ }+}++func TestReviewRulePolicyConverterRoundTrip(t *testing.T) {+ t.Parallel()+ in := &v1pb.ReviewRulePolicy{Rules: []v1pb.ReviewRuleType{+ v1pb.ReviewRuleType_SYNTAX,+ v1pb.ReviewRuleType_DISALLOW_DROP_OBJECT,+ v1pb.ReviewRuleType_REQUIRE_PRIMARY_KEY,+ }}++ payload := convertToStorePBReviewRulePolicy(in)+ require.Equal(t, []storepb.ReviewRuleType{+ storepb.ReviewRuleType_SYNTAX,+ storepb.ReviewRuleType_DISALLOW_DROP_OBJECT,+ storepb.ReviewRuleType_REQUIRE_PRIMARY_KEY,+ }, payload.Rules)++ payloadBytes, err := protojson.Marshal(payload)+ require.NoError(t, err)+ out, err := convertToV1PBReviewRulePolicy(string(payloadBytes))+ require.NoError(t, err)+ require.Equal(t, in.Rules, out.ReviewRulePolicy.Rules)++ empty := convertToStorePBReviewRulePolicy(nil)+ require.Empty(t, empty.Rules)+}++func TestReviewRulePolicyTypeConversion(t *testing.T) {+ t.Parallel()+ storeType, err := convertV1PBToStorePBPolicyType(v1pb.PolicyType_REVIEW_RULE)+ require.NoError(t, err)+ require.Equal(t, storepb.Policy_REVIEW_RULE, storeType)+ require.Equal(t, v1pb.PolicyType_REVIEW_RULE, convertStorePBToV1PBPolicyType(storepb.Policy_REVIEW_RULE))+}++func TestReviewRulePolicyResourceTypes(t *testing.T) {+ t.Parallel()+ require.NoError(t, validatePolicyType(storepb.Policy_REVIEW_RULE, storepb.Policy_WORKSPACE))+ require.NoError(t, validatePolicyType(storepb.Policy_REVIEW_RULE, storepb.Policy_PROJECT))+ require.Error(t, validatePolicyType(storepb.Policy_REVIEW_RULE, storepb.Policy_ENVIRONMENT))+}++func TestReviewRulePolicyPathMatchType(t *testing.T) {+ t.Parallel()+ require.True(t, pathMatchType("review_rule_policy", storepb.Policy_REVIEW_RULE))+ require.False(t, pathMatchType("query_data_policy", storepb.Policy_REVIEW_RULE))+ require.False(t, pathMatchType("review_rule_policy", storepb.Policy_QUERY_DATA))+}++func TestValidateReviewRulePolicyPayload(t *testing.T) {+ t.Parallel()+ reviewRule := func(rules ...v1pb.ReviewRuleType) *v1pb.Policy {+ return &v1pb.Policy{Policy: &v1pb.Policy_ReviewRulePolicy{+ ReviewRulePolicy: &v1pb.ReviewRulePolicy{Rules: rules},+ }}+ }+ for _, tc := range []struct {+ name string+ policy *v1pb.Policy+ ok bool+ }{+ {"empty list switches every rule off", reviewRule(), true},+ {"known rules", reviewRule(v1pb.ReviewRuleType_SYNTAX, v1pb.ReviewRuleType_REQUIRE_WHERE), true},+ {"unspecified", reviewRule(v1pb.ReviewRuleType_REVIEW_RULE_TYPE_UNSPECIFIED), false},+ {"unknown value", reviewRule(v1pb.ReviewRuleType(9999)), false},+ {"repeated rule", reviewRule(v1pb.ReviewRuleType_SYNTAX, v1pb.ReviewRuleType_SYNTAX), false},+ {"other payload", &v1pb.Policy{Policy: &v1pb.Policy_QueryDataPolicy{QueryDataPolicy: &v1pb.QueryDataPolicy{}}}, false},+ {"nil payload", &v1pb.Policy{Policy: &v1pb.Policy_ReviewRulePolicy{}}, false},+ } {+ t.Run(tc.name, func(t *testing.T) {+ t.Parallel()+ err := validatePolicyPayload(storepb.Policy_REVIEW_RULE, tc.policy)+ if tc.ok {+ require.NoError(t, err)+ } else {+ require.Error(t, err)+ }+ })+ }+}++// TestDefaultReviewRulePolicy pins that the stand-in for a missing row is+// every rule, and that it survives the store-to-v1 conversion.+func TestDefaultReviewRulePolicy(t *testing.T) {+ t.Parallel()+ message, err := getDefaultReviewRulePolicy("projects/p1")+ require.NoError(t, err)+ require.Equal(t, storepb.Policy_PROJECT, message.ResourceType)+ require.Equal(t, "projects/p1", message.Resource)+ require.Equal(t, storepb.Policy_REVIEW_RULE, message.Type)+ require.True(t, message.Enforce)++ policy, err := convertToPolicy(message)+ require.NoError(t, err)+ require.Equal(t, "projects/p1/policies/review_rule", policy.Name)+ require.Equal(t, v1pb.PolicyType_REVIEW_RULE, policy.Type)+ got := policy.GetReviewRulePolicy().Rules+ require.Len(t, got, len(v1pb.ReviewRuleType_name)-1)+ require.NotContains(t, got, v1pb.ReviewRuleType_REVIEW_RULE_TYPE_UNSPECIFIED)+ require.Equal(t, len(store.GetDefaultReviewRulePolicy().Rules), len(got))+}diff --git a/backend/migrator/migration/LATEST.sql b/backend/migrator/migration/LATEST.sqlindex 72153c998e..799a7ad28c 100644--- a/backend/migrator/migration/LATEST.sql+++ b/backend/migrator/migration/LATEST.sql@@ -116,7 +116,7 @@ CREATE TABLE policy (resource_type text NOT NULL,-- resource: resource name in format like "environments/{environment}", "projects/{project}", etc.resource TEXT NOT NULL,- -- type: ROLLOUT, MASKING_EXCEPTION, QUERY_DATA, MASKING_RULE, IAM, TAG+ -- type: ROLLOUT, MASKING_EXCEPTION, QUERY_DATA, MASKING_RULE, IAM, TAG, REVIEW_RULE-- Enum: Policy.Type (proto/store/store/policy.proto)type text NOT NULL,-- Stored as different types based on policy type (proto/store/store/policy.proto):@@ -126,6 +126,7 @@ CREATE TABLE policy (-- MASKING_RULE: MaskingRulePolicy-- IAM: IamPolicy-- TAG: TagPolicy+ -- REVIEW_RULE: ReviewRulePolicy (the standard review rules switched on; nearest policy wins)payload jsonb NOT NULL DEFAULT '{}',inherit_from_parent boolean NOT NULL DEFAULT TRUE,PRIMARY KEY (workspace, resource_type, resource, type)diff --git a/backend/store/policy.go b/backend/store/policy.goindex 165c4a8ffa..c3cfa6f337 100644--- a/backend/store/policy.go+++ b/backend/store/policy.go@@ -462,6 +462,67 @@ func (s *Store) getQueryDataPolicy(ctx context.Context, workspaceID string, resoreturn p, nil}+// GetDefaultReviewRulePolicy returns the review rule policy in force when+// neither the project nor the workspace has one: every standard rule on, in+// declaration order.+func GetDefaultReviewRulePolicy() *storepb.ReviewRulePolicy {+ values := storepb.ReviewRuleType(0).Descriptor().Values()+ rules := make([]storepb.ReviewRuleType, 0, values.Len())+ for i := 0; i < values.Len(); i++ {+ rule := storepb.ReviewRuleType(values.Get(i).Number())+ if rule == storepb.ReviewRuleType_REVIEW_RULE_TYPE_UNSPECIFIED {+ continue+ }+ rules = append(rules, rule)+ }+ return &storepb.ReviewRulePolicy{Rules: rules}+}++// GetEffectiveReviewRulePolicy returns the standard review rules on for a+// project. The nearest policy wins: the project's own policy applies as is, a+// project without one uses the workspace policy, and with neither every rule+// is on. A policy that is not enforced counts as absent.+func (s *Store) GetEffectiveReviewRulePolicy(ctx context.Context, workspaceID string, projectID string) (*storepb.ReviewRulePolicy, error) {+ for _, level := range []struct {+ resourceType storepb.Policy_Resource+ resource string+ }{+ {storepb.Policy_PROJECT, common.FormatProject(projectID)},+ {storepb.Policy_WORKSPACE, common.FormatWorkspace(workspaceID)},+ } {+ policy, err := s.getReviewRulePolicy(ctx, workspaceID, level.resourceType, level.resource)+ if err != nil {+ return nil, err+ }+ if policy != nil {+ return policy, nil+ }+ }+ return GetDefaultReviewRulePolicy(), nil+}++// getReviewRulePolicy returns nil when the resource has no enforced review+// rule policy.+func (s *Store) getReviewRulePolicy(ctx context.Context, workspaceID string, resourceType storepb.Policy_Resource, resource string) (*storepb.ReviewRulePolicy, error) {+ policy, err := s.GetPolicy(ctx, &FindPolicyMessage{+ Workspace: workspaceID,+ ResourceType: &resourceType,+ Resource: &resource,+ Type: new(storepb.Policy_REVIEW_RULE),+ })+ if err != nil {+ return nil, errors.Wrapf(err, "failed to get review rule policy for %s", resource)+ }+ if policy == nil || !policy.Enforce {+ return nil, nil+ }+ p := &storepb.ReviewRulePolicy{}+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(policy.Payload), p); err != nil {+ return nil, errors.Wrapf(err, "failed to unmarshal review rule policy for %s", resource)+ }+ return p, nil+}+type reviewConfigResource struct {resourceType storepb.Policy_Resourceresource stringdiff --git a/backend/store/policy_review_rule_test.go b/backend/store/policy_review_rule_test.gonew file mode 100644index 0000000000..fac824efaa--- /dev/null+++ b/backend/store/policy_review_rule_test.go@@ -0,0 +1,92 @@+package store_test++import (+ "context"+ "testing"++ "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"+)++// TestGetEffectiveReviewRulePolicy pins the nearest-wins resolution: the+// project's own policy applies as is, a project without one uses the+// workspace's, and with neither every rule is on. A policy that is not+// enforced counts as absent.+func TestGetEffectiveReviewRulePolicy(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 project (resource_id, workspace, name) VALUES ('p', 'ws', 'P');+ `)+ require.NoError(t, err)++ payload := func(rules ...storepb.ReviewRuleType) string {+ b, err := protojson.Marshal(&storepb.ReviewRulePolicy{Rules: rules})+ require.NoError(t, err)+ return string(b)+ }+ upsert := func(resourceType storepb.Policy_Resource, resource string, enforce bool, rules ...storepb.ReviewRuleType) {+ _, err := stores.CreatePolicy(ctx, &store.PolicyMessage{+ Workspace: "ws",+ ResourceType: resourceType,+ Resource: resource,+ Type: storepb.Policy_REVIEW_RULE,+ Payload: payload(rules...),+ Enforce: enforce,+ })+ require.NoError(t, err)+ }+ effective := func() []storepb.ReviewRuleType {+ p, err := stores.GetEffectiveReviewRulePolicy(ctx, "ws", "p")+ require.NoError(t, err)+ return p.Rules+ }+ every := store.GetDefaultReviewRulePolicy().Rules+ require.Len(t, every, len(storepb.ReviewRuleType_name)-1)++ // Neither level has a policy: every rule.+ require.Equal(t, every, effective())++ // Workspace only.+ upsert(storepb.Policy_WORKSPACE, common.FormatWorkspace("ws"), true, storepb.ReviewRuleType_SYNTAX, storepb.ReviewRuleType_REQUIRE_WHERE)+ require.Equal(t, []storepb.ReviewRuleType{storepb.ReviewRuleType_SYNTAX, storepb.ReviewRuleType_REQUIRE_WHERE}, effective())++ // The project's own policy replaces the workspace's, no union.+ upsert(storepb.Policy_PROJECT, common.FormatProject("p"), true, storepb.ReviewRuleType_DISALLOW_TRUNCATE)+ require.Equal(t, []storepb.ReviewRuleType{storepb.ReviewRuleType_DISALLOW_TRUNCATE}, effective())++ // An empty project list is a policy too: everything off.+ upsert(storepb.Policy_PROJECT, common.FormatProject("p"), true)+ require.Empty(t, effective())++ // A project policy that is not enforced counts as absent.+ upsert(storepb.Policy_PROJECT, common.FormatProject("p"), false, storepb.ReviewRuleType_DISALLOW_TRUNCATE)+ require.Equal(t, []storepb.ReviewRuleType{storepb.ReviewRuleType_SYNTAX, storepb.ReviewRuleType_REQUIRE_WHERE}, effective())++ // Same for the workspace: back to every rule.+ upsert(storepb.Policy_WORKSPACE, common.FormatWorkspace("ws"), false, storepb.ReviewRuleType_SYNTAX)+ require.Equal(t, every, effective())++ // Another workspace's policy never leaks in.+ _, err = db.ExecContext(ctx, `INSERT INTO workspace (resource_id) VALUES ('other');`)+ require.NoError(t, err)+ _, err = stores.CreatePolicy(ctx, &store.PolicyMessage{+ Workspace: "other",+ ResourceType: storepb.Policy_WORKSPACE,+ Resource: common.FormatWorkspace("other"),+ Type: storepb.Policy_REVIEW_RULE,+ Payload: payload(storepb.ReviewRuleType_SYNTAX),+ Enforce: true,+ })+ require.NoError(t, err)+ require.Equal(t, every, effective())+}diff --git a/backend/tests/review_rule_policy_test.go b/backend/tests/review_rule_policy_test.gonew file mode 100644index 0000000000..3a65eada74--- /dev/null+++ b/backend/tests/review_rule_policy_test.go@@ -0,0 +1,132 @@+package tests++import (+ "context"+ "testing"++ "connectrpc.com/connect"+ "github.com/stretchr/testify/require"+ "google.golang.org/protobuf/types/known/fieldmaskpb"++ "github.com/bytebase/bytebase/backend/common"+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+)++// TestReviewRulePolicy walks the REVIEW_RULE policy through the org policy+// service at both levels: the all-rules default on a missing row, create,+// get, list, update, validation, and delete.+func TestReviewRulePolicy(t *testing.T) {+ t.Parallel()+ a := require.New(t)+ ctx := context.Background()+ ctl, ctx := startWorkspace(ctx, t)++ projectPolicyName := ctl.project.Name + "/policies/review_rule"+ rules := func(policy *v1pb.Policy) []v1pb.ReviewRuleType {+ return policy.GetReviewRulePolicy().GetRules()+ }+ reviewRule := func(list ...v1pb.ReviewRuleType) *v1pb.Policy {+ return &v1pb.Policy{+ Type: v1pb.PolicyType_REVIEW_RULE,+ Policy: &v1pb.Policy_ReviewRulePolicy{ReviewRulePolicy: &v1pb.ReviewRulePolicy{Rules: list}},+ }+ }++ // No row: the default is every rule, not NotFound.+ got, err := ctl.orgPolicyServiceClient.GetPolicy(ctx, connect.NewRequest(&v1pb.GetPolicyRequest{Name: projectPolicyName}))+ a.NoError(err)+ a.Equal(projectPolicyName, got.Msg.Name)+ a.Equal(v1pb.PolicyType_REVIEW_RULE, got.Msg.Type)+ a.Equal(v1pb.PolicyResourceType_PROJECT, got.Msg.ResourceType)+ a.Len(rules(got.Msg), len(v1pb.ReviewRuleType_name)-1)++ // Create on the project.+ created, err := ctl.orgPolicyServiceClient.CreatePolicy(ctx, connect.NewRequest(&v1pb.CreatePolicyRequest{+ Parent: ctl.project.Name,+ Policy: reviewRule(v1pb.ReviewRuleType_SYNTAX, v1pb.ReviewRuleType_DISALLOW_DROP_OBJECT),+ }))+ a.NoError(err)+ a.Equal(projectPolicyName, created.Msg.Name)+ a.Equal([]v1pb.ReviewRuleType{v1pb.ReviewRuleType_SYNTAX, v1pb.ReviewRuleType_DISALLOW_DROP_OBJECT}, rules(created.Msg))++ got, err = ctl.orgPolicyServiceClient.GetPolicy(ctx, connect.NewRequest(&v1pb.GetPolicyRequest{Name: projectPolicyName}))+ a.NoError(err)+ a.Equal(rules(created.Msg), rules(got.Msg))++ // List with the type filter finds it.+ listed, err := ctl.orgPolicyServiceClient.ListPolicies(ctx, connect.NewRequest(&v1pb.ListPoliciesRequest{+ Parent: ctl.project.Name,+ PolicyType: v1pb.PolicyType_REVIEW_RULE.Enum(),+ }))+ a.NoError(err)+ a.Len(listed.Msg.Policies, 1)+ a.Equal(projectPolicyName, listed.Msg.Policies[0].Name)++ // Update through the review_rule_policy mask path.+ updatedPolicy := reviewRule(v1pb.ReviewRuleType_REQUIRE_WHERE)+ updatedPolicy.Name = projectPolicyName+ updated, err := ctl.orgPolicyServiceClient.UpdatePolicy(ctx, connect.NewRequest(&v1pb.UpdatePolicyRequest{+ Policy: updatedPolicy,+ UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"review_rule_policy"}},+ }))+ a.NoError(err)+ a.Equal([]v1pb.ReviewRuleType{v1pb.ReviewRuleType_REQUIRE_WHERE}, rules(updated.Msg))++ // Validation: unspecified and repeated rules are refused on update and create.+ for _, bad := range [][]v1pb.ReviewRuleType{+ {v1pb.ReviewRuleType_REVIEW_RULE_TYPE_UNSPECIFIED},+ {v1pb.ReviewRuleType_SYNTAX, v1pb.ReviewRuleType_SYNTAX},+ } {+ badPolicy := reviewRule(bad...)+ badPolicy.Name = projectPolicyName+ _, err = ctl.orgPolicyServiceClient.UpdatePolicy(ctx, connect.NewRequest(&v1pb.UpdatePolicyRequest{+ Policy: badPolicy,+ UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"review_rule_policy"}},+ }))+ a.Equal(connect.CodeInvalidArgument, connect.CodeOf(err))+ }++ // The policy does not attach to an environment.+ _, err = ctl.orgPolicyServiceClient.CreatePolicy(ctx, connect.NewRequest(&v1pb.CreatePolicyRequest{+ Parent: "environments/prod",+ Policy: reviewRule(v1pb.ReviewRuleType_SYNTAX),+ }))+ a.Equal(connect.CodeInvalidArgument, connect.CodeOf(err))++ // Workspace level.+ stores := getStore(t, ctl.server)+ workspaceID, err := stores.GetWorkspaceID(ctx)+ a.NoError(err)+ workspacePolicyName := common.FormatWorkspace(workspaceID) + "/policies/review_rule"+ got, err = ctl.orgPolicyServiceClient.GetPolicy(ctx, connect.NewRequest(&v1pb.GetPolicyRequest{Name: workspacePolicyName}))+ a.NoError(err)+ a.Equal(v1pb.PolicyResourceType_WORKSPACE, got.Msg.ResourceType)+ a.Len(rules(got.Msg), len(v1pb.ReviewRuleType_name)-1)+ created, err = ctl.orgPolicyServiceClient.CreatePolicy(ctx, connect.NewRequest(&v1pb.CreatePolicyRequest{+ Parent: common.FormatWorkspace(workspaceID),+ Policy: reviewRule(v1pb.ReviewRuleType_DISALLOW_TRUNCATE),+ }))+ a.NoError(err)+ a.Equal(workspacePolicyName, created.Msg.Name)++ // The effective set is the nearest policy: the project's while it has one,+ // the workspace's after the project's is deleted.+ projectID, err := common.GetProjectID(ctl.project.Name)+ a.NoError(err)+ effective, err := stores.GetEffectiveReviewRulePolicy(ctx, workspaceID, projectID)+ a.NoError(err)+ a.Equal("REQUIRE_WHERE", effective.Rules[0].String())+ a.Len(effective.Rules, 1)++ _, err = ctl.orgPolicyServiceClient.DeletePolicy(ctx, connect.NewRequest(&v1pb.DeletePolicyRequest{Name: projectPolicyName}))+ a.NoError(err)+ effective, err = stores.GetEffectiveReviewRulePolicy(ctx, workspaceID, projectID)+ a.NoError(err)+ a.Equal("DISALLOW_TRUNCATE", effective.Rules[0].String())+ a.Len(effective.Rules, 1)++ // Deleted: back to the default.+ got, err = ctl.orgPolicyServiceClient.GetPolicy(ctx, connect.NewRequest(&v1pb.GetPolicyRequest{Name: projectPolicyName}))+ a.NoError(err)+ a.Len(rules(got.Msg), len(v1pb.ReviewRuleType_name)-1)+}