test(flag-evaluation): enhance tests for SET and NOT_SET operators

- Added tests to verify behavior of `SET` and `NOT_SET` operators when field values are missing or empty strings.
- Improved clarity and organization of test cases for better readability and maintainability.

Author: pavkam

packages/flag-evaluation/test/index.test.ts

@@ -311,123 +311,125 @@ describe("evaluate feature targeting integration ", () => {
     });
   });
 
-  it("should not report missing context fields for `SET` operator when field doesn't exist", () => {
-    const res = evaluateFeatureRules({
-      featureKey: "test_feature",
-      rules: [
-        {
-          value: true,
-          filter: {
-            type: "context",
-            field: "user.name",
-            operator: "SET",
-            values: [],
+  describe("SET and NOT_SET operators", () => {
+    it("should handle `SET` operator with missing field value", () => {
+      const res = evaluateFeatureRules({
+        featureKey: "test_feature",
+        rules: [
+          {
+            value: true,
+            filter: {
+              type: "context",
+              field: "user.name",
+              operator: "SET",
+              values: [],
+            },
           },
-        },
-      ],
-      context: {},
-    });
-
-    expect(res).toEqual({
-      featureKey: "test_feature",
-      value: undefined,
-      context: {},
-      ruleEvaluationResults: [false],
-      reason: "no matched rules",
-      missingContextFields: [],
-    });
-  });
-
-  it("should not report missing context fields for `NOT_SET` operator when field doesn't exist", () => {
-    const res = evaluateFeatureRules({
-      featureKey: "test_feature",
-      rules: [
-        {
-          value: true,
-          filter: {
-            type: "context",
-            field: "user.name",
-            operator: "NOT_SET",
-            values: [],
+        ],
+        context: {},
+      });
+
+      expect(res).toEqual({
+        featureKey: "test_feature",
+        value: undefined,
+        context: {},
+        ruleEvaluationResults: [false],
+        reason: "no matched rules",
+        missingContextFields: [],
+      });
+    });
+
+    it("should handle `NOT_SET` operator with missing field value", () => {
+      const res = evaluateFeatureRules({
+        featureKey: "test_feature",
+        rules: [
+          {
+            value: true,
+            filter: {
+              type: "context",
+              field: "user.name",
+              operator: "NOT_SET",
+              values: [],
+            },
           },
-        },
-      ],
-      context: {},
-    });
+        ],
+        context: {},
+      });
 
-    expect(res).toEqual({
-      featureKey: "test_feature",
-      value: true,
-      context: {},
-      ruleEvaluationResults: [true],
-      reason: "rule #0 matched",
-      missingContextFields: [],
+      expect(res).toEqual({
+        featureKey: "test_feature",
+        value: true,
+        context: {},
+        ruleEvaluationResults: [true],
+        reason: "rule #0 matched",
+        missingContextFields: [],
+      });
     });
-  });
 
-  it("should handle `SET` operator with empty string field value", () => {
-    const res = evaluateFeatureRules({
-      featureKey: "test_feature",
-      rules: [
-        {
-          value: true,
-          filter: {
-            type: "context",
-            field: "user.name",
-            operator: "SET",
-            values: [],
+    it("should handle `SET` operator with empty string field value", () => {
+      const res = evaluateFeatureRules({
+        featureKey: "test_feature",
+        rules: [
+          {
+            value: true,
+            filter: {
+              type: "context",
+              field: "user.name",
+              operator: "SET",
+              values: [],
+            },
+          },
+        ],
+        context: {
+          user: {
+            name: "",
           },
         },
-      ],
-      context: {
-        user: {
-          name: "",
-        },
-      },
-    });
+      });
 
-    expect(res).toEqual({
-      featureKey: "test_feature",
-      value: undefined,
-      context: {
-        "user.name": "",
-      },
-      ruleEvaluationResults: [false],
-      reason: "no matched rules",
-      missingContextFields: [],
+      expect(res).toEqual({
+        featureKey: "test_feature",
+        value: undefined,
+        context: {
+          "user.name": "",
+        },
+        ruleEvaluationResults: [false],
+        reason: "no matched rules",
+        missingContextFields: [],
+      });
     });
-  });
 
-  it("should handle `NOT_SET` operator with empty string field value", () => {
-    const res = evaluateFeatureRules({
-      featureKey: "test_feature",
-      rules: [
-        {
-          value: true,
-          filter: {
-            type: "context",
-            field: "user.name",
-            operator: "NOT_SET",
-            values: [],
+    it("should handle `NOT_SET` operator with empty string field value", () => {
+      const res = evaluateFeatureRules({
+        featureKey: "test_feature",
+        rules: [
+          {
+            value: true,
+            filter: {
+              type: "context",
+              field: "user.name",
+              operator: "NOT_SET",
+              values: [],
+            },
+          },
+        ],
+        context: {
+          user: {
+            name: "",
           },
         },
-      ],
-      context: {
-        user: {
-          name: "",
-        },
-      },
-    });
+      });
 
-    expect(res).toEqual({
-      featureKey: "test_feature",
-      value: true,
-      context: {
-        "user.name": "",
-      },
-      ruleEvaluationResults: [true],
-      reason: "rule #0 matched",
-      missingContextFields: [],
+      expect(res).toEqual({
+        featureKey: "test_feature",
+        value: true,
+        context: {
+          "user.name": "",
+        },
+        ruleEvaluationResults: [true],
+        reason: "rule #0 matched",
+        missingContextFields: [],
+      });
     });
   });