update

linglingye001 · linglingye001 · commit 920c12f87516 · 2024-11-06T14:17:23.000+08:00
diff --git a/src/schema/model.ts b/src/schema/model.ts
@@ -12,14 +12,6 @@ export interface FeatureFlag {
    * An ID used to uniquely identify and reference the feature.
    */
   id: string;
-  /**
-   * A description of the feature.
-   */
-  description?: string;
-  /**
-   * A display name for the feature to use for display rather than the ID.
-   */
-  display_name?: string;
   /**
    * A feature is OFF if enabled is false. If enabled is true, then the feature is ON if there are no conditions (null or empty) or if the conditions are satisfied.
    */
diff --git a/src/schema/validator.ts b/src/schema/validator.ts
@@ -13,21 +13,14 @@ export function validateFeatureFlag(featureFlag: any): void {
         throw new TypeError("Feature flag must be an object.");
     }
     if (typeof featureFlag.id !== "string") {
-        throw new TypeError("Feature flag ID must be a string.");
-    }
-    if (featureFlag.description !== undefined && typeof featureFlag.description !== "string") {
-        throw new TypeError("Feature flag description must be a string.");
-    }
-    if (featureFlag.display_name !== undefined && typeof featureFlag.display_name !== "string") {
-        throw new TypeError("Feature flag display name must be a string.");
+        throw new TypeError("Feature flag 'id' must be a string.");
     }
     if (featureFlag.enabled !== undefined && typeof featureFlag.enabled !== "boolean") {
-        throw new TypeError("Feature flag enabled must be a boolean.");
+        throw new TypeError("Feature flag 'enabled' must be a boolean.");
     }
     if (featureFlag.conditions !== undefined) {
         validateFeatureEnablementConditions(featureFlag.conditions);
     }
-    // variants, allocation, and telemetry
     if (featureFlag.variants !== undefined) {
         validateVariants(featureFlag.variants);
     }
@@ -41,7 +34,7 @@ export function validateFeatureFlag(featureFlag: any): void {
 
 function validateFeatureEnablementConditions(conditions: any) {
     if (conditions.requirement_type !== undefined && conditions.requirement_type !== "Any" && conditions.requirement_type !== "All") {
-        throw new TypeError("Feature enablement conditions requirement type must be 'Any' or 'All'.");
+        throw new TypeError("'requirement_type' must be 'Any' or 'All'.");
     }
     if (conditions.client_filters !== undefined) {
         validateClientFilters(conditions.client_filters);
@@ -50,50 +43,48 @@ function validateFeatureEnablementConditions(conditions: any) {
 
 function validateClientFilters(client_filters: any) {
     if (!Array.isArray(client_filters)) {
-        throw new TypeError("Client filter Collection must be an array.");
+        throw new TypeError("'client_filters' must be an array.");
     }
 
     for (const filter of client_filters) {
         if (typeof filter.name !== "string") {
-            throw new TypeError("Client filter name must be a string.");
+            throw new TypeError("Client filter 'name' must be a string.");
         }
         if (filter.parameters !== undefined && typeof filter.parameters !== "object") {
-            throw new TypeError("Client filter parameters must be an object.");
+            throw new TypeError("Client filter 'parameters' must be an object.");
         }
-        // validate parameters here if we have schema of specific filters in the future
     }
 }
 
 function validateVariants(variants: any) {
     if (!Array.isArray(variants)) {
-        throw new TypeError("Variants must be an array.");
+        throw new TypeError("'variants' must be an array.");
     }
 
     for (const variant of variants) {
         if (typeof variant.name !== "string") {
-            throw new TypeError("Variant name must be a string.");
+            throw new TypeError("Variant 'name' must be a string.");
         }
         // skip configuration_value validation as it accepts any type
         if (variant.status_override !== undefined && typeof variant.status_override !== "string") {
-            throw new TypeError("Variant status override must be a string.");
+            throw new TypeError("Variant 'status_override' must be a string.");
         }
         if (variant.status_override !== undefined && variant.status_override !== "None" && variant.status_override !== "Enabled" && variant.status_override !== "Disabled") {
-            throw new TypeError("Variant status override must be 'None', 'Enabled', or 'Disabled'.");
+            throw new TypeError("Variant 'status_override' must be 'None', 'Enabled', or 'Disabled'.");
         }
     }
 }
 
-// #region Allocation
 function validateVariantAllocation(allocation: any) {
     if (typeof allocation !== "object") {
-        throw new TypeError("Variant allocation must be an object.");
+        throw new TypeError("Variant 'allocation' must be an object.");
     }
 
     if (allocation.default_when_disabled !== undefined && typeof allocation.default_when_disabled !== "string") {
-        throw new TypeError("Variant allocation default_when_disabled must be a string.");
+        throw new TypeError("Variant allocation 'default_when_disabled' must be a string.");
     }
     if (allocation.default_when_enabled !== undefined && typeof allocation.default_when_enabled !== "string") {
-        throw new TypeError("Variant allocation default_when_enabled must be a string.");
+        throw new TypeError("Variant allocation 'default_when_enabled' must be a string.");
     }
     if (allocation.user !== undefined) {
         validateUserVariantAllocation(allocation.user);
@@ -105,64 +96,64 @@ function validateVariantAllocation(allocation: any) {
         validatePercentileVariantAllocation(allocation.percentile);
     }
     if (allocation.seed !== undefined && typeof allocation.seed !== "string") {
-        throw new TypeError("Variant allocation seed must be a string.");
+        throw new TypeError("Variant allocation 'seed' must be a string.");
     }
 }
 
 function validateUserVariantAllocation(UserAllocations: any) {
     if (!Array.isArray(UserAllocations)) {
-        throw new TypeError("User allocations must be an array.");
+        throw new TypeError("User allocation 'user' must be an array.");
     }
 
     for (const allocation of UserAllocations) {
         if (typeof allocation.variant !== "string") {
-            throw new TypeError("User allocation variant must be a string.");
+            throw new TypeError("User allocation 'variant' must be a string.");
         }
         if (!Array.isArray(allocation.users)) {
-            throw new TypeError("User allocation users must be an array.");
+            throw new TypeError("User allocation 'users' must be an array.");
         }
         for (const user of allocation.users) {
             if (typeof user !== "string") {
-                throw new TypeError("Elements in User allocation users must be strings.");
+                throw new TypeError("Elements in User allocation 'users' must be strings.");
             }
         }
     }
 }
 
 function validateGroupVariantAllocation(groupAllocations: any) {
     if (!Array.isArray(groupAllocations)) {
-        throw new TypeError("Group allocations must be an array.");
+        throw new TypeError("Group allocation 'group' must be an array.");
     }
 
     for (const allocation of groupAllocations) {
         if (typeof allocation.variant !== "string") {
-            throw new TypeError("Group allocation variant must be a string.");
+            throw new TypeError("Group allocation 'variant' must be a string.");
         }
         if (!Array.isArray(allocation.groups)) {
-            throw new TypeError("Group allocation groups must be an array.");
+            throw new TypeError("Group allocation 'groups' must be an array.");
         }
         for (const group of allocation.groups) {
             if (typeof group !== "string") {
-                throw new TypeError("Elements in Group allocation groups must be strings.");
+                throw new TypeError("Elements in Group allocation 'groups' must be strings.");
             }
         }
     }
 }
 
 function validatePercentileVariantAllocation(percentileAllocations: any) {
     if (!Array.isArray(percentileAllocations)) {
-        throw new TypeError("Percentile allocations must be an array.");
+        throw new TypeError("Percentile allocation 'percentile' must be an array.");
     }
 
     for (const allocation of percentileAllocations) {
         if (typeof allocation.variant !== "string") {
-            throw new TypeError("Percentile allocation variant must be a string.");
+            throw new TypeError("Percentile allocation 'variant' must be a string.");
         }
         if (typeof allocation.from !== "number" || allocation.from < 0 || allocation.from > 100) {
-            throw new TypeError("Percentile allocation from must be a number between 0 and 100.");
+            throw new TypeError("Percentile allocation 'from' must be a number between 0 and 100.");
         }
         if (typeof allocation.to !== "number" || allocation.to < 0 || allocation.to > 100) {
-            throw new TypeError("Percentile allocation to must be a number between 0 and 100.");
+            throw new TypeError("Percentile allocation 'to' must be a number between 0 and 100.");
         }
     }
 }
@@ -171,15 +162,13 @@ function validatePercentileVariantAllocation(percentileAllocations: any) {
 // #region Telemetry
 function validateTelemetryOptions(telemetry: any) {
     if (typeof telemetry !== "object") {
-        throw new TypeError("Telemetry options must be an object.");
+        throw new TypeError("Telemetry option 'telemetry' must be an object.");
     }
-
     if (telemetry.enabled !== undefined && typeof telemetry.enabled !== "boolean") {
-        throw new TypeError("Telemetry enabled must be a boolean.");
+        throw new TypeError("Telemetry 'enabled' must be a boolean.");
     }
     if (telemetry.metadata !== undefined && typeof telemetry.metadata !== "object") {
-        throw new TypeError("Telemetry metadata must be an object.");
+        throw new TypeError("Telemetry 'metadata' must be an object.");
     }
-    // TODO: validate metadata keys (string) and values (string), not sure if we need to do this
 }
 // #endregion
diff --git a/test/featureManager.test.ts b/test/featureManager.test.ts
@@ -72,6 +72,43 @@ describe("feature manager", () => {
         ]);
     });
 
+    it("should evaluate features with conditions", () => {
+        const dataSource = new Map();
+        dataSource.set("feature_management", {
+            feature_flags: [
+                {
+                    "id": "Gamma",
+                    "description": "",
+                    "enabled": true,
+                    "conditions": {
+                        "requirement_type": "invalid type",
+                        "client_filters": [
+                            { "name": "Microsoft.Targeting", "parameters": { "Audience": { "DefaultRolloutPercentage": 50 } } }
+                        ]
+                    }
+                },
+                {
+                    "id": "Delta",
+                    "description": "",
+                    "enabled": true,
+                    "conditions": {
+                        "requirement_type": "Any",
+                        "client_filters": [
+                            { "name": "Microsoft.Targeting", "parameters": "invalid parameter" }
+                        ]
+                    }
+                }
+            ],
+        });
+
+        const provider = new ConfigurationMapFeatureFlagProvider(dataSource);
+        const featureManager = new FeatureManager(provider);
+        return Promise.all([
+            expect(featureManager.isEnabled("Gamma")).eventually.rejectedWith("'requirement_type' must be 'Any' or 'All'."),
+            expect(featureManager.isEnabled("Delta")).eventually.rejectedWith("Client filter 'parameters' must be an object.")
+        ]);
+    });
+
     it("should let the last feature flag win", () => {
         const jsonObject = {
             "feature_management": {
diff --git a/test/noFilters.test.ts b/test/noFilters.test.ts
@@ -61,7 +61,7 @@ describe("feature flags with no filters", () => {
         return Promise.all([
             expect(featureManager.isEnabled("BooleanTrue")).eventually.eq(true),
             expect(featureManager.isEnabled("BooleanFalse")).eventually.eq(false),
-            expect(featureManager.isEnabled("InvalidEnabled")).eventually.rejectedWith("Feature flag enabled must be a boolean."),
+            expect(featureManager.isEnabled("InvalidEnabled")).eventually.rejectedWith("Feature flag 'enabled' must be a boolean."),
             expect(featureManager.isEnabled("Minimal")).eventually.eq(true),
             expect(featureManager.isEnabled("NoEnabled")).eventually.eq(false),
             expect(featureManager.isEnabled("EmptyConditions")).eventually.eq(true)

Original file line number	Diff line number	Diff line change
`@@ -13,21 +13,14 @@ export function validateFeatureFlag(featureFlag: any): void {`
`13`	`13`	`throw new TypeError("Feature flag must be an object.");`
`14`	`14`	`}`
`15`	`15`	`if (typeof featureFlag.id !== "string") {`
`16`		`- throw new TypeError("Feature flag ID must be a string.");`
`17`		`- }`
`18`		`- if (featureFlag.description !== undefined && typeof featureFlag.description !== "string") {`
`19`		`- throw new TypeError("Feature flag description must be a string.");`
`20`		`- }`
`21`		`- if (featureFlag.display_name !== undefined && typeof featureFlag.display_name !== "string") {`
`22`		`- throw new TypeError("Feature flag display name must be a string.");`
	`16`	`+ throw new TypeError("Feature flag 'id' must be a string.");`
`23`	`17`	`}`
`24`	`18`	`if (featureFlag.enabled !== undefined && typeof featureFlag.enabled !== "boolean") {`
`25`		`- throw new TypeError("Feature flag enabled must be a boolean.");`
	`19`	`+ throw new TypeError("Feature flag 'enabled' must be a boolean.");`
`26`	`20`	`}`
`27`	`21`	`if (featureFlag.conditions !== undefined) {`
`28`	`22`	`validateFeatureEnablementConditions(featureFlag.conditions);`
`29`	`23`	`}`
`30`		`- // variants, allocation, and telemetry`
`31`	`24`	`if (featureFlag.variants !== undefined) {`
`32`	`25`	`validateVariants(featureFlag.variants);`
`33`	`26`	`}`
`@@ -41,7 +34,7 @@ export function validateFeatureFlag(featureFlag: any): void {`
`41`	`34`
`42`	`35`	`function validateFeatureEnablementConditions(conditions: any) {`
`43`	`36`	`if (conditions.requirement_type !== undefined && conditions.requirement_type !== "Any" && conditions.requirement_type !== "All") {`
`44`		`- throw new TypeError("Feature enablement conditions requirement type must be 'Any' or 'All'.");`
	`37`	`+ throw new TypeError("'requirement_type' must be 'Any' or 'All'.");`
`45`	`38`	`}`
`46`	`39`	`if (conditions.client_filters !== undefined) {`
`47`	`40`	`validateClientFilters(conditions.client_filters);`
`@@ -50,50 +43,48 @@ function validateFeatureEnablementConditions(conditions: any) {`
`50`	`43`
`51`	`44`	`function validateClientFilters(client_filters: any) {`
`52`	`45`	`if (!Array.isArray(client_filters)) {`
`53`		`- throw new TypeError("Client filter Collection must be an array.");`
	`46`	`+ throw new TypeError("'client_filters' must be an array.");`
`54`	`47`	`}`
`55`	`48`
`56`	`49`	`for (const filter of client_filters) {`
`57`	`50`	`if (typeof filter.name !== "string") {`
`58`		`- throw new TypeError("Client filter name must be a string.");`
	`51`	`+ throw new TypeError("Client filter 'name' must be a string.");`
`59`	`52`	`}`
`60`	`53`	`if (filter.parameters !== undefined && typeof filter.parameters !== "object") {`
`61`		`- throw new TypeError("Client filter parameters must be an object.");`
	`54`	`+ throw new TypeError("Client filter 'parameters' must be an object.");`
`62`	`55`	`}`
`63`		`- // validate parameters here if we have schema of specific filters in the future`
`64`	`56`	`}`
`65`	`57`	`}`
`66`	`58`
`67`	`59`	`function validateVariants(variants: any) {`
`68`	`60`	`if (!Array.isArray(variants)) {`
`69`		`- throw new TypeError("Variants must be an array.");`
	`61`	`+ throw new TypeError("'variants' must be an array.");`
`70`	`62`	`}`
`71`	`63`
`72`	`64`	`for (const variant of variants) {`
`73`	`65`	`if (typeof variant.name !== "string") {`
`74`		`- throw new TypeError("Variant name must be a string.");`
	`66`	`+ throw new TypeError("Variant 'name' must be a string.");`
`75`	`67`	`}`
`76`	`68`	`// skip configuration_value validation as it accepts any type`
`77`	`69`	`if (variant.status_override !== undefined && typeof variant.status_override !== "string") {`
`78`		`- throw new TypeError("Variant status override must be a string.");`
	`70`	`+ throw new TypeError("Variant 'status_override' must be a string.");`
`79`	`71`	`}`
`80`	`72`	`if (variant.status_override !== undefined && variant.status_override !== "None" && variant.status_override !== "Enabled" && variant.status_override !== "Disabled") {`
`81`		`- throw new TypeError("Variant status override must be 'None', 'Enabled', or 'Disabled'.");`
	`73`	`+ throw new TypeError("Variant 'status_override' must be 'None', 'Enabled', or 'Disabled'.");`
`82`	`74`	`}`
`83`	`75`	`}`
`84`	`76`	`}`
`85`	`77`
`86`		`-// #region Allocation`
`87`	`78`	`function validateVariantAllocation(allocation: any) {`
`88`	`79`	`if (typeof allocation !== "object") {`
`89`		`- throw new TypeError("Variant allocation must be an object.");`
	`80`	`+ throw new TypeError("Variant 'allocation' must be an object.");`
`90`	`81`	`}`
`91`	`82`
`92`	`83`	`if (allocation.default_when_disabled !== undefined && typeof allocation.default_when_disabled !== "string") {`
`93`		`- throw new TypeError("Variant allocation default_when_disabled must be a string.");`
	`84`	`+ throw new TypeError("Variant allocation 'default_when_disabled' must be a string.");`
`94`	`85`	`}`
`95`	`86`	`if (allocation.default_when_enabled !== undefined && typeof allocation.default_when_enabled !== "string") {`
`96`		`- throw new TypeError("Variant allocation default_when_enabled must be a string.");`
	`87`	`+ throw new TypeError("Variant allocation 'default_when_enabled' must be a string.");`
`97`	`88`	`}`
`98`	`89`	`if (allocation.user !== undefined) {`
`99`	`90`	`validateUserVariantAllocation(allocation.user);`
`@@ -105,64 +96,64 @@ function validateVariantAllocation(allocation: any) {`
`105`	`96`	`validatePercentileVariantAllocation(allocation.percentile);`
`106`	`97`	`}`
`107`	`98`	`if (allocation.seed !== undefined && typeof allocation.seed !== "string") {`
`108`		`- throw new TypeError("Variant allocation seed must be a string.");`
	`99`	`+ throw new TypeError("Variant allocation 'seed' must be a string.");`
`109`	`100`	`}`
`110`	`101`	`}`
`111`	`102`
`112`	`103`	`function validateUserVariantAllocation(UserAllocations: any) {`
`113`	`104`	`if (!Array.isArray(UserAllocations)) {`
`114`		`- throw new TypeError("User allocations must be an array.");`
	`105`	`+ throw new TypeError("User allocation 'user' must be an array.");`
`115`	`106`	`}`
`116`	`107`
`117`	`108`	`for (const allocation of UserAllocations) {`
`118`	`109`	`if (typeof allocation.variant !== "string") {`
`119`		`- throw new TypeError("User allocation variant must be a string.");`
	`110`	`+ throw new TypeError("User allocation 'variant' must be a string.");`
`120`	`111`	`}`
`121`	`112`	`if (!Array.isArray(allocation.users)) {`
`122`		`- throw new TypeError("User allocation users must be an array.");`
	`113`	`+ throw new TypeError("User allocation 'users' must be an array.");`
`123`	`114`	`}`
`124`	`115`	`for (const user of allocation.users) {`
`125`	`116`	`if (typeof user !== "string") {`
`126`		`- throw new TypeError("Elements in User allocation users must be strings.");`
	`117`	`+ throw new TypeError("Elements in User allocation 'users' must be strings.");`
`127`	`118`	`}`
`128`	`119`	`}`
`129`	`120`	`}`
`130`	`121`	`}`
`131`	`122`
`132`	`123`	`function validateGroupVariantAllocation(groupAllocations: any) {`
`133`	`124`	`if (!Array.isArray(groupAllocations)) {`
`134`		`- throw new TypeError("Group allocations must be an array.");`
	`125`	`+ throw new TypeError("Group allocation 'group' must be an array.");`
`135`	`126`	`}`
`136`	`127`
`137`	`128`	`for (const allocation of groupAllocations) {`
`138`	`129`	`if (typeof allocation.variant !== "string") {`
`139`		`- throw new TypeError("Group allocation variant must be a string.");`
	`130`	`+ throw new TypeError("Group allocation 'variant' must be a string.");`
`140`	`131`	`}`
`141`	`132`	`if (!Array.isArray(allocation.groups)) {`
`142`		`- throw new TypeError("Group allocation groups must be an array.");`
	`133`	`+ throw new TypeError("Group allocation 'groups' must be an array.");`
`143`	`134`	`}`
`144`	`135`	`for (const group of allocation.groups) {`
`145`	`136`	`if (typeof group !== "string") {`
`146`		`- throw new TypeError("Elements in Group allocation groups must be strings.");`
	`137`	`+ throw new TypeError("Elements in Group allocation 'groups' must be strings.");`
`147`	`138`	`}`
`148`	`139`	`}`
`149`	`140`	`}`
`150`	`141`	`}`
`151`	`142`
`152`	`143`	`function validatePercentileVariantAllocation(percentileAllocations: any) {`
`153`	`144`	`if (!Array.isArray(percentileAllocations)) {`
`154`		`- throw new TypeError("Percentile allocations must be an array.");`
	`145`	`+ throw new TypeError("Percentile allocation 'percentile' must be an array.");`
`155`	`146`	`}`
`156`	`147`
`157`	`148`	`for (const allocation of percentileAllocations) {`
`158`	`149`	`if (typeof allocation.variant !== "string") {`
`159`		`- throw new TypeError("Percentile allocation variant must be a string.");`
	`150`	`+ throw new TypeError("Percentile allocation 'variant' must be a string.");`
`160`	`151`	`}`
`161`	`152`	`if (typeof allocation.from !== "number" \|\| allocation.from < 0 \|\| allocation.from > 100) {`
`162`		`- throw new TypeError("Percentile allocation from must be a number between 0 and 100.");`
	`153`	`+ throw new TypeError("Percentile allocation 'from' must be a number between 0 and 100.");`
`163`	`154`	`}`
`164`	`155`	`if (typeof allocation.to !== "number" \|\| allocation.to < 0 \|\| allocation.to > 100) {`
`165`		`- throw new TypeError("Percentile allocation to must be a number between 0 and 100.");`
	`156`	`+ throw new TypeError("Percentile allocation 'to' must be a number between 0 and 100.");`
`166`	`157`	`}`
`167`	`158`	`}`
`168`	`159`	`}`
`@@ -171,15 +162,13 @@ function validatePercentileVariantAllocation(percentileAllocations: any) {`
`171`	`162`	`// #region Telemetry`
`172`	`163`	`function validateTelemetryOptions(telemetry: any) {`
`173`	`164`	`if (typeof telemetry !== "object") {`
`174`		`- throw new TypeError("Telemetry options must be an object.");`
	`165`	`+ throw new TypeError("Telemetry option 'telemetry' must be an object.");`
`175`	`166`	`}`
`176`		`-`
`177`	`167`	`if (telemetry.enabled !== undefined && typeof telemetry.enabled !== "boolean") {`
`178`		`- throw new TypeError("Telemetry enabled must be a boolean.");`
	`168`	`+ throw new TypeError("Telemetry 'enabled' must be a boolean.");`
`179`	`169`	`}`
`180`	`170`	`if (telemetry.metadata !== undefined && typeof telemetry.metadata !== "object") {`
`181`		`- throw new TypeError("Telemetry metadata must be an object.");`
	`171`	`+ throw new TypeError("Telemetry 'metadata' must be an object.");`
`182`	`172`	`}`
`183`		`- // TODO: validate metadata keys (string) and values (string), not sure if we need to do this`
`184`	`173`	`}`
`185`	`174`	`// #endregion`