fix filter parameter handling

Author: linglingye001

src/featureManagement/featureFlagConverter.ts

@@ -15,68 +15,69 @@ export function convertToMicrosoftSchema(featureFlag: FeatureFlag): any {
         enabled: featureFlag.enabled
     };
 
-    if (featureFlag.description !== undefined) {
+    if (featureFlag.description != null) {
         result.description = featureFlag.description;
     }
 
     // conditions: filters -> client_filters, requirementType -> requirement_type
     const conditions: any = {
         client_filters: (featureFlag.conditions?.filters ?? []).map(filter => {
             const clientFilter: any = { name: filter.name };
-            if (filter.parameters !== undefined) {
-                clientFilter.parameters = filter.parameters;
+            if (filter.parameters != null) {
+                clientFilter.parameters = Object.fromEntries(
+                    Object.entries(filter.parameters).map(([name, value]) => [name, JSON.parse(value)]));
             }
             return clientFilter;
         })
     };
-    if (featureFlag.conditions?.requirementType !== undefined) {
+    if (featureFlag.conditions?.requirementType != null) {
         conditions.requirement_type = featureFlag.conditions.requirementType;
     }
     result.conditions = conditions;
 
     // variants: value -> configuration_value, statusOverride -> status_override
-    if (featureFlag.variants !== undefined) {
+    if (featureFlag.variants != null) {
         result.variants = featureFlag.variants.map(variant => {
             const result_variant: any = { name: variant.name };
             if (variant.value !== undefined) {
                 result_variant.configuration_value = variant.value;
             }
-            if (variant.statusOverride !== undefined) {
+            if (variant.statusOverride != null) {
                 result_variant.status_override = variant.statusOverride;
             }
             return result_variant;
         });
     }
 
     // allocation: camelCase -> snake_case
-    if (featureFlag.allocation !== undefined) {
+    if (featureFlag.allocation != null) {
         const allocation: any = {};
         const sourceAllocation = featureFlag.allocation;
-        if (sourceAllocation.defaultWhenDisabled !== undefined) {
+        if (sourceAllocation.defaultWhenDisabled != null) {
             allocation.default_when_disabled = sourceAllocation.defaultWhenDisabled;
         }
-        if (sourceAllocation.defaultWhenEnabled !== undefined) {
+        if (sourceAllocation.defaultWhenEnabled != null) {
             allocation.default_when_enabled = sourceAllocation.defaultWhenEnabled;
         }
-        if (sourceAllocation.percentile !== undefined) {
+        if (sourceAllocation.percentile != null) {
             allocation.percentile = sourceAllocation.percentile.map(p => ({ variant: p.variant, from: p.from, to: p.to }));
         }
-        if (sourceAllocation.user !== undefined) {
+        if (sourceAllocation.user != null) {
             allocation.user = sourceAllocation.user.map(u => ({ variant: u.variant, users: u.users }));
         }
-        if (sourceAllocation.group !== undefined) {
+        if (sourceAllocation.group != null) {
             allocation.group = sourceAllocation.group.map(g => ({ variant: g.variant, groups: g.groups }));
         }
-        if (sourceAllocation.seed !== undefined) {
+        if (sourceAllocation.seed != null) {
             allocation.seed = sourceAllocation.seed;
         }
         result.allocation = allocation;
     }
 
     // telemetry: metadata is (re)populated later by the provider with ETag/FeatureFlagReference/AllocationId
-    if (featureFlag.telemetry !== undefined) {
+    if (featureFlag.telemetry != null) {
         const telemetry: any = { enabled: featureFlag.telemetry.enabled };
-        if (featureFlag.telemetry.metadata !== undefined) {
+        if (featureFlag.telemetry.metadata != null) {
             telemetry.metadata = featureFlag.telemetry.metadata;
         }
         result.telemetry = telemetry;

test/featureFlag.test.ts

@@ -524,6 +524,65 @@ describe("enhanced feature flags", function () {
         expect(featureFlags.find(ff => ff.id === "NewBeta").enabled).equals(false);
     });
 
+    it("should load an enhanced feature flag with null optional fields", async () => {
+        mockAppConfigurationClientListConfigurationSettings([[]], undefined, [[
+            createMockedEnhancedFeatureFlag("Minimal", {
+                description: null,
+                conditions: null,
+                variants: null,
+                allocation: null,
+                telemetry: null
+            })
+        ]]);
+
+        const settings = await load(createMockedConnectionString(), {
+            featureFlagOptions: { enabled: true }
+        });
+
+        const featureFlag = (settings.get<any>("feature_management").feature_flags as any[])
+            .find(ff => ff.id === "Minimal");
+        expect(featureFlag).not.undefined;
+        expect(featureFlag.conditions.client_filters).deep.equals([]);
+        expect(featureFlag).not.have.property("description");
+        expect(featureFlag).not.have.property("variants");
+        expect(featureFlag).not.have.property("allocation");
+        expect(featureFlag).not.have.property("telemetry");
+    });
+
+    it("should parse enhanced feature flag filter parameters", async () => {
+        const audience = {
+            Users: ["test@contoso.com"],
+            Groups: [{ Name: "contoso.com", RolloutPercentage: 50 }],
+            DefaultRolloutPercentage: 0
+        };
+        mockAppConfigurationClientListConfigurationSettings([[]], undefined, [[
+            createMockedEnhancedFeatureFlag("Targeted", {
+                conditions: {
+                    requirementType: "Any",
+                    filters: [{
+                        name: "Microsoft.Targeting",
+                        parameters: {
+                            Audience: JSON.stringify(audience),
+                            PlainText: "not-json",
+                            Percentage: "50"
+                        }
+                    }]
+                }
+            })
+        ]]);
+
+        const settings = await load(createMockedConnectionString(), {
+            featureFlagOptions: { enabled: true }
+        });
+
+        const featureFlag = (settings.get<any>("feature_management").feature_flags as any[])
+            .find(ff => ff.id === "Targeted");
+        const parameters = featureFlag.conditions.client_filters[0].parameters;
+        expect(parameters.Audience).deep.equals(audience);
+        expect(parameters.PlainText).equals("not-json");
+        expect(parameters.Percentage).equals(50);
+    });
+
     it("should let an enhanced feature flag supersede a feature flag with the same name", async () => {
         // "Shared" is enabled and "ClassicOnly" exists; the dedicated endpoint returns "Shared" disabled
         const featureFlagSettings = [