Skip to content

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

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.go
index 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[v
policy, 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.PolicyMe
return 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, pol
return "", 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), nil
case 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 = payload
case 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.go
index 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_MaskingRule
for _, rule := range policy.Rules {
@@ -298,6 +322,8 @@ func convertV1PBToStorePBPolicyType(pType v1pb.PolicyType) (storepb.Policy_Type,
return storepb.Policy_MASKING_EXEMPTION, nil
case v1pb.PolicyType_DATA_QUERY:
return storepb.Policy_QUERY_DATA, nil
+ case v1pb.PolicyType_REVIEW_RULE:
+ return storepb.Policy_REVIEW_RULE, nil
default:
}
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_EXEMPTION
case storepb.Policy_QUERY_DATA:
return v1pb.PolicyType_DATA_QUERY
+ case storepb.Policy_REVIEW_RULE:
+ return v1pb.PolicyType_REVIEW_RULE
default:
}
return v1pb.PolicyType_POLICY_TYPE_UNSPECIFIED
diff --git a/backend/api/v1/org_policy_service_review_rule_test.go b/backend/api/v1/org_policy_service_review_rule_test.go
new file mode 100644
index 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.sql
index 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.go
index 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, reso
return 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_Resource
resource string
diff --git a/backend/store/policy_review_rule_test.go b/backend/store/policy_review_rule_test.go
new file mode 100644
index 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.go
new file mode 100644
index 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)
+}