@featurevisor/core 2.17.0 → 2.19.0

package/src/linter/featureSchema.spec.ts

@@ -610,6 +610,34 @@ describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable
         "maxLength",
       );
     });
+
+    it("accepts plain-key partial object overrides for structured object schemas", () => {
+      expectParseSuccess(
+        baseFeature({
+          variablesSchema: {
+            config: {
+              type: "object",
+              properties: {
+                theme: { type: "string" },
+                compact: { type: "boolean" },
+              },
+              required: ["theme", "compact"],
+              defaultValue: { theme: "light", compact: true },
+            },
+          },
+          variations: [
+            { value: "control", weight: 50 },
+            {
+              value: "treatment",
+              weight: 50,
+              variableOverrides: {
+                config: [{ segments: "*", value: { theme: "dark" } }],
+              },
+            },
+          ],
+        }),
+      );
+    });
   });
 
   describe("rules: variables", () => {
@@ -701,6 +729,175 @@ describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable
     });
   });
 
+  describe("rules: variableOverrides", () => {
+    it("accepts rule variableOverrides with values matching variablesSchema", () => {
+      expectParseSuccess(
+        baseFeature({
+          variablesSchema: {
+            config: {
+              type: "object",
+              properties: {
+                title: { type: "string" },
+                nested: {
+                  type: "object",
+                  properties: {
+                    count: { type: "integer" },
+                  },
+                },
+              },
+              defaultValue: {
+                title: "default",
+                nested: { count: 0 },
+              },
+            },
+          },
+          rules: {
+            staging: [
+              {
+                key: "r1",
+                segments: "*",
+                percentage: 100,
+                variableOverrides: {
+                  config: [
+                    {
+                      segments: "countries/germany",
+                      value: {
+                        "nested.count": 5,
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+            production: [{ key: "r1", segments: "*", percentage: 100 }],
+          },
+        }),
+      );
+    });
+
+    it("rejects rule variableOverrides for unknown variable key", () => {
+      expectParseFailure(
+        baseFeature({
+          variablesSchema: {
+            config: { type: "string", defaultValue: "x" },
+          },
+          rules: {
+            staging: [
+              {
+                key: "r1",
+                segments: "*",
+                percentage: 100,
+                variableOverrides: {
+                  unknown: [{ segments: "*", value: "x" }],
+                },
+              },
+            ],
+            production: [{ key: "r1", segments: "*", percentage: 100 }],
+          },
+        }),
+        "not defined in",
+      );
+    });
+
+    it("rejects mutation notation in rule variableOverrides key", () => {
+      expectParseFailure(
+        baseFeature({
+          variablesSchema: {
+            config: {
+              type: "object",
+              properties: { title: { type: "string" } },
+              defaultValue: { title: "x" },
+            },
+          },
+          rules: {
+            staging: [
+              {
+                key: "r1",
+                segments: "*",
+                percentage: 100,
+                variableOverrides: {
+                  "config.title": [{ segments: "*", value: "y" }],
+                },
+              },
+            ],
+            production: [{ key: "r1", segments: "*", percentage: 100 }],
+          },
+        }),
+        "must be a declared variable key",
+      );
+    });
+
+    it("rejects rule variableOverride path not present in schema", () => {
+      expectParseFailure(
+        baseFeature({
+          variablesSchema: {
+            config: {
+              type: "object",
+              properties: { title: { type: "string" } },
+              defaultValue: { title: "x" },
+            },
+          },
+          rules: {
+            staging: [
+              {
+                key: "r1",
+                segments: "*",
+                percentage: 100,
+                variableOverrides: {
+                  config: [
+                    {
+                      segments: "*",
+                      value: {
+                        "nested.missing": "x",
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+            production: [{ key: "r1", segments: "*", percentage: 100 }],
+          },
+        }),
+        "invalid for variable",
+      );
+    });
+
+    it("rejects non-null payload for :remove in rule variableOverrides", () => {
+      expectParseFailure(
+        baseFeature({
+          variablesSchema: {
+            config: {
+              type: "object",
+              properties: { title: { type: "string" }, optional: { type: "string" } },
+              defaultValue: { title: "x", optional: "y" },
+            },
+          },
+          rules: {
+            staging: [
+              {
+                key: "r1",
+                segments: "*",
+                percentage: 100,
+                variableOverrides: {
+                  config: [
+                    {
+                      conditions: [{ attribute: "country", operator: "equals", value: "de" }],
+                      value: {
+                        "optional:remove": "not-null",
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+            production: [{ key: "r1", segments: "*", percentage: 100 }],
+          },
+        }),
+        "must use `null` as value",
+      );
+    });
+  });
+
   describe("force: variables", () => {
     it("accepts force variables that match variablesSchema", () => {
       expectParseSuccess(
@@ -852,6 +1049,89 @@ describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable
       );
     });
 
+    it("accepts object variable with additionalProperties only and arbitrary keys", () => {
+      expectParseSuccess(
+        baseFeature({
+          variablesSchema: {
+            labels: {
+              type: "object",
+              additionalProperties: { type: "string" },
+              defaultValue: { title: "Welcome", subtitle: "Hello" },
+            },
+          },
+        }),
+      );
+    });
+
+    it("accepts object variable with properties and additionalProperties together", () => {
+      expectParseSuccess(
+        baseFeature({
+          variablesSchema: {
+            metadata: {
+              type: "object",
+              properties: {
+                fixed: { type: "integer" },
+              },
+              additionalProperties: { type: "string" },
+              required: ["fixed"],
+              defaultValue: { fixed: 1, dynamicKey: "value" },
+            },
+          },
+        }),
+      );
+    });
+
+    it("rejects object variable when unknown key is present and additionalProperties is not defined", () => {
+      expectParseFailure(
+        baseFeature({
+          variablesSchema: {
+            settings: {
+              type: "object",
+              properties: {
+                theme: { type: "string" },
+              },
+              defaultValue: { theme: "light", subtitle: "hello" },
+            },
+          },
+        }),
+        "Unknown property",
+      );
+    });
+
+    it("accepts object variable with additionalProperties that references reusable schema", () => {
+      expectParseSuccess(
+        baseFeature({
+          variablesSchema: {
+            linksByLocale: {
+              type: "object",
+              additionalProperties: { schema: "link" },
+              defaultValue: {
+                en: { title: "Home", url: "/" },
+                de: { title: "Start", url: "/de" },
+              },
+            },
+          },
+        }),
+      );
+    });
+
+    it("rejects object variable when additionalProperties value does not match schema", () => {
+      expectParseFailure(
+        baseFeature({
+          variablesSchema: {
+            linksByLocale: {
+              type: "object",
+              additionalProperties: { schema: "link" },
+              defaultValue: {
+                en: { title: "Home" },
+              },
+            },
+          },
+        }),
+        "Missing required property",
+      );
+    });
+
     it("rejects inline object variable when defaultValue is missing required property", () => {
       expectParseFailure(
         baseFeature({
@@ -1417,5 +1697,40 @@ describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable
         },
       );
     });
+
+    it("additionalProperties type mismatch: error path includes dynamic object key", () => {
+      expectErrorSurfaces(
+        baseFeature({
+          variablesSchema: {
+            labels: {
+              type: "object",
+              additionalProperties: { type: "string" },
+              defaultValue: {
+                title: 123,
+              },
+            },
+          },
+        }),
+        {
+          pathContains: ["variablesSchema", "labels", "defaultValue", "title"],
+          messageContains: "type string",
+        },
+      );
+    });
+
+    it("rejects variable schema with schema reference mixed with inline additionalProperties", () => {
+      expectParseFailure(
+        baseFeature({
+          variablesSchema: {
+            myLink: {
+              schema: "link",
+              additionalProperties: { type: "string" },
+              defaultValue: { title: "Home", url: "/" },
+            },
+          },
+        }),
+        "additionalProperties",
+      );
+    });
   });
 });