@featurevisor/core 2.26.1 → 3.0.1

package/src/builder/{buildScopedSegments.spec.ts → applyContextToSegments.spec.ts}

@@ -1,14 +1,14 @@
 import type { DatafileContent } from "@featurevisor/types";
 
 import {
-  buildScopedSegments,
+  applyContextToSegments,
   removeRedundantGroupSegments,
-  buildScopedGroupSegments,
-} from "./buildScopedSegments";
-import { DatafileReader, createLogger } from "@featurevisor/sdk";
+  applyContextToGroupSegments,
+} from "./applyContextToSegments";
+import { createFeaturevisor } from "@featurevisor/sdk";
 
-describe("core: buildScopedSegments", function () {
-  describe("buildScopedSegments", function () {
+describe("core: applyContextToSegments", function () {
+  describe("applyContextToSegments", function () {
     const datafileWithSegments: DatafileContent = {
       schemaVersion: "2",
       revision: "unknown",
@@ -45,43 +45,43 @@ describe("core: buildScopedSegments", function () {
       features: {},
     };
 
-    const datafileReaderWithSegments = new DatafileReader({
+    const featurevisorWithSegments = createFeaturevisor({
       datafile: datafileWithSegments,
-      logger: createLogger({ level: "fatal" }),
+      logLevel: "fatal",
     });
 
-    test("buildScopedSegments is a function", function () {
-      expect(buildScopedSegments).toBeInstanceOf(Function);
+    test("applyContextToSegments is a function", function () {
+      expect(applyContextToSegments).toBeInstanceOf(Function);
     });
 
     test("simple cases", function () {
       // "*" remains "*"
-      expect(buildScopedSegments(datafileReaderWithSegments, "*", {})).toEqual("*");
+      expect(applyContextToSegments(featurevisorWithSegments, "*", {})).toEqual("*");
 
       // Plain segment that matches
       expect(
-        buildScopedSegments(datafileReaderWithSegments, "web", {
+        applyContextToSegments(featurevisorWithSegments, "web", {
           platform: "web",
         }),
       ).toEqual("*");
 
       // Plain segment that doesn't match
       expect(
-        buildScopedSegments(datafileReaderWithSegments, "web", {
+        applyContextToSegments(featurevisorWithSegments, "web", {
           platform: "mobile",
         }),
       ).toEqual("web");
 
       // Array of segments - partial match (redundant "*" removed)
       expect(
-        buildScopedSegments(datafileReaderWithSegments, ["web", "chrome"], {
+        applyContextToSegments(featurevisorWithSegments, ["web", "chrome"], {
           platform: "web",
         }),
       ).toEqual(["chrome"]);
 
       // Array of segments - full match (all "*" becomes "*")
       expect(
-        buildScopedSegments(datafileReaderWithSegments, ["web", "chrome"], {
+        applyContextToSegments(featurevisorWithSegments, ["web", "chrome"], {
           platform: "web",
           browser: "chrome",
         }),
@@ -89,7 +89,7 @@ describe("core: buildScopedSegments", function () {
 
       // Array of segments - no match
       expect(
-        buildScopedSegments(datafileReaderWithSegments, ["web", "chrome"], {
+        applyContextToSegments(featurevisorWithSegments, ["web", "chrome"], {
           platform: "mobile",
           browser: "safari",
         }),
@@ -99,8 +99,8 @@ describe("core: buildScopedSegments", function () {
     test("AND group segments", function () {
       // AND with all matching segments (all "*" becomes "*")
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             and: ["web", "chrome"],
           },
@@ -113,8 +113,8 @@ describe("core: buildScopedSegments", function () {
 
       // AND with partial match (redundant "*" removed)
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             and: ["web", "chrome"],
           },
@@ -128,8 +128,8 @@ describe("core: buildScopedSegments", function () {
 
       // AND with no matches
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             and: ["web", "chrome"],
           },
@@ -144,8 +144,8 @@ describe("core: buildScopedSegments", function () {
 
       // AND with "*" in it (all "*" becomes "*")
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             and: ["*", "chrome"],
           },
@@ -159,8 +159,8 @@ describe("core: buildScopedSegments", function () {
     test("OR group segments", function () {
       // OR with all matching segments (all "*" becomes "*")
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             or: ["web", "chrome"],
           },
@@ -173,8 +173,8 @@ describe("core: buildScopedSegments", function () {
 
       // OR with partial match (redundant "*" removed, but OR structure remains)
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             or: ["web", "chrome"],
           },
@@ -188,8 +188,8 @@ describe("core: buildScopedSegments", function () {
 
       // OR with no matches
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             or: ["web", "mobile"],
           },
@@ -203,10 +203,10 @@ describe("core: buildScopedSegments", function () {
     });
 
     test("NOT group segments", function () {
-      // NOT with matching segment (all "*" becomes "*")
+      // NOT with matching segment remains an always-false expression
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             not: ["web"],
           },
@@ -214,12 +214,14 @@ describe("core: buildScopedSegments", function () {
             platform: "web",
           },
         ),
-      ).toEqual("*");
+      ).toEqual({
+        not: ["*"],
+      });
 
       // NOT with non-matching segment
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             not: ["web"],
           },
@@ -231,10 +233,10 @@ describe("core: buildScopedSegments", function () {
         not: ["web"],
       });
 
-      // NOT with multiple segments (all "*" becomes "*")
+      // NOT with multiple matching segments remains an always-false expression
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             not: ["web", "chrome"],
           },
@@ -243,14 +245,16 @@ describe("core: buildScopedSegments", function () {
             browser: "chrome",
           },
         ),
-      ).toEqual("*");
+      ).toEqual({
+        not: ["*"],
+      });
     });
 
     test("nested AND group segments", function () {
       // Nested AND with all matching (all "*" becomes "*")
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             and: [
               "web",
@@ -269,8 +273,8 @@ describe("core: buildScopedSegments", function () {
 
       // Nested AND with partial match (redundant "*" removed)
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             and: [
               "web",
@@ -296,8 +300,8 @@ describe("core: buildScopedSegments", function () {
     test("nested OR group segments", function () {
       // Nested OR with outer match (redundant "*" removed, but inner OR remains)
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             or: [
               "web",
@@ -320,8 +324,8 @@ describe("core: buildScopedSegments", function () {
 
       // Nested OR with inner match (redundant "*" removed, but outer OR remains)
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             or: [
               "web",
@@ -345,10 +349,10 @@ describe("core: buildScopedSegments", function () {
     });
 
     test("nested NOT group segments", function () {
-      // Nested NOT (all "*" becomes "*")
+      // Nested NOT preserves non-broadening false expressions
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             not: [
               "web",
@@ -362,14 +366,20 @@ describe("core: buildScopedSegments", function () {
             browser: "chrome",
           },
         ),
-      ).toEqual("*");
+      ).toEqual({
+        not: [
+          {
+            not: ["*"],
+          },
+        ],
+      });
     });
 
     test("mixed nested group segments", function () {
       // AND with nested OR (redundant "*" removed, but OR structure remains if not all match)
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             and: [
               "web",
@@ -393,8 +403,8 @@ describe("core: buildScopedSegments", function () {
 
       // OR with nested AND (redundant "*" removed, but OR structure remains if not all match)
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             or: [
               "web",
@@ -414,8 +424,8 @@ describe("core: buildScopedSegments", function () {
 
       // AND with nested NOT (redundant "*" removed)
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             and: [
               "web",
@@ -438,8 +448,8 @@ describe("core: buildScopedSegments", function () {
 
       // Complex nested structure (redundant "*" removed)
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             and: [
               "web",
@@ -471,8 +481,8 @@ describe("core: buildScopedSegments", function () {
     test("arrays with nested group segments", function () {
       // Array with AND group segment (redundant "*" removed)
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           [
             "web",
             {
@@ -489,8 +499,8 @@ describe("core: buildScopedSegments", function () {
 
       // Array with OR group segment (redundant "*" removed, but OR structure remains if not all match)
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           [
             "web",
             {
@@ -512,7 +522,7 @@ describe("core: buildScopedSegments", function () {
     test("segments with complex conditions", function () {
       // Segment with AND conditions in its definition
       expect(
-        buildScopedSegments(datafileReaderWithSegments, "premium", {
+        applyContextToSegments(featurevisorWithSegments, "premium", {
           tier: "premium",
           status: "active",
         }),
@@ -520,7 +530,7 @@ describe("core: buildScopedSegments", function () {
 
       // Segment with AND conditions that doesn't match
       expect(
-        buildScopedSegments(datafileReaderWithSegments, "premium", {
+        applyContextToSegments(featurevisorWithSegments, "premium", {
           tier: "premium",
           status: "inactive",
         }),
@@ -529,22 +539,22 @@ describe("core: buildScopedSegments", function () {
 
     test("edge cases", function () {
       // Empty context
-      expect(buildScopedSegments(datafileReaderWithSegments, "web", {})).toEqual("web");
+      expect(applyContextToSegments(featurevisorWithSegments, "web", {})).toEqual("web");
 
       // Empty array (all "*" becomes "*")
-      expect(buildScopedSegments(datafileReaderWithSegments, [], {})).toEqual("*");
+      expect(applyContextToSegments(featurevisorWithSegments, [], {})).toEqual("*");
 
       // "*" in array with matching segment (all "*" becomes "*")
       expect(
-        buildScopedSegments(datafileReaderWithSegments, ["*", "web"], {
+        applyContextToSegments(featurevisorWithSegments, ["*", "web"], {
           platform: "web",
         }),
       ).toEqual("*");
 
       // AND with empty array (all "*" becomes "*")
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             and: [],
           },
@@ -554,8 +564,8 @@ describe("core: buildScopedSegments", function () {
 
       // OR with empty array (all "*" becomes "*")
       expect(
-        buildScopedSegments(
-          datafileReaderWithSegments,
+        applyContextToSegments(
+          featurevisorWithSegments,
           {
             or: [],
           },
@@ -629,7 +639,9 @@ describe("core: buildScopedSegments", function () {
 
     test("NOT group segments", function () {
       // All "*" in NOT
-      expect(removeRedundantGroupSegments({ not: ["*", "*", "*"] })).toEqual("*");
+      expect(removeRedundantGroupSegments({ not: ["*", "*", "*"] })).toEqual({
+        not: ["*"],
+      });
 
       // Mixed with "*" in NOT
       expect(
@@ -726,7 +738,13 @@ describe("core: buildScopedSegments", function () {
         removeRedundantGroupSegments({
           not: ["*", { not: ["*", "*", "*"] }, "*"],
         }),
-      ).toEqual("*");
+      ).toEqual({
+        not: [
+          {
+            not: ["*"],
+          },
+        ],
+      });
 
       // Nested NOT with mixed group segments
       expect(
@@ -898,7 +916,7 @@ describe("core: buildScopedSegments", function () {
     });
   });
 
-  describe("buildScopedGroupSegments", function () {
+  describe("applyContextToGroupSegments", function () {
     const datafileWithSegments: DatafileContent = {
       schemaVersion: "2",
       revision: "unknown",
@@ -935,43 +953,43 @@ describe("core: buildScopedSegments", function () {
       features: {},
     };
 
-    const datafileReaderWithSegments = new DatafileReader({
+    const featurevisorWithSegments = createFeaturevisor({
       datafile: datafileWithSegments,
-      logger: createLogger({ level: "fatal" }),
+      logLevel: "fatal",
     });
 
-    test("buildScopedGroupSegments is a function", function () {
-      expect(buildScopedGroupSegments).toBeInstanceOf(Function);
+    test("applyContextToGroupSegments is a function", function () {
+      expect(applyContextToGroupSegments).toBeInstanceOf(Function);
     });
 
     test("simple cases", function () {
       // "*" remains "*"
-      expect(buildScopedGroupSegments(datafileReaderWithSegments, "*", {})).toEqual("*");
+      expect(applyContextToGroupSegments(featurevisorWithSegments, "*", {})).toEqual("*");
 
       // Plain segment that matches
       expect(
-        buildScopedGroupSegments(datafileReaderWithSegments, "web", {
+        applyContextToGroupSegments(featurevisorWithSegments, "web", {
           platform: "web",
         }),
       ).toEqual("*");
 
       // Plain segment that doesn't match
       expect(
-        buildScopedGroupSegments(datafileReaderWithSegments, "web", {
+        applyContextToGroupSegments(featurevisorWithSegments, "web", {
           platform: "mobile",
         }),
       ).toEqual("web");
 
       // Array of segments - partial match
       expect(
-        buildScopedGroupSegments(datafileReaderWithSegments, ["web", "chrome"], {
+        applyContextToGroupSegments(featurevisorWithSegments, ["web", "chrome"], {
           platform: "web",
         }),
       ).toEqual(["*", "chrome"]);
 
       // Array of segments - full match (all "*" - will be cleaned by removeRedundantGroupSegments later)
       expect(
-        buildScopedGroupSegments(datafileReaderWithSegments, ["web", "chrome"], {
+        applyContextToGroupSegments(featurevisorWithSegments, ["web", "chrome"], {
           platform: "web",
           browser: "chrome",
         }),
@@ -979,7 +997,7 @@ describe("core: buildScopedSegments", function () {
 
       // Array of segments - no match
       expect(
-        buildScopedGroupSegments(datafileReaderWithSegments, ["web", "chrome"], {
+        applyContextToGroupSegments(featurevisorWithSegments, ["web", "chrome"], {
           platform: "mobile",
           browser: "safari",
         }),
@@ -989,8 +1007,8 @@ describe("core: buildScopedSegments", function () {
     test("AND group segments", function () {
       // AND with all matching segments (all "*" becomes "*")
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             and: ["web", "chrome"],
           },
@@ -1005,8 +1023,8 @@ describe("core: buildScopedSegments", function () {
 
       // AND with partial match
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             and: ["web", "chrome"],
           },
@@ -1020,8 +1038,8 @@ describe("core: buildScopedSegments", function () {
 
       // AND with no matches
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             and: ["web", "chrome"],
           },
@@ -1036,8 +1054,8 @@ describe("core: buildScopedSegments", function () {
 
       // AND with "*" in it
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             and: ["*", "chrome"],
           },
@@ -1053,8 +1071,8 @@ describe("core: buildScopedSegments", function () {
     test("OR group segments", function () {
       // OR with all matching segments (all "*" becomes "*")
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             or: ["web", "chrome"],
           },
@@ -1069,8 +1087,8 @@ describe("core: buildScopedSegments", function () {
 
       // OR with partial match
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             or: ["web", "chrome"],
           },
@@ -1084,8 +1102,8 @@ describe("core: buildScopedSegments", function () {
 
       // OR with no matches
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             or: ["web", "mobile"],
           },
@@ -1101,8 +1119,8 @@ describe("core: buildScopedSegments", function () {
     test("NOT group segments", function () {
       // NOT with matching segment
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             not: ["web"],
           },
@@ -1116,8 +1134,8 @@ describe("core: buildScopedSegments", function () {
 
       // NOT with non-matching segment
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             not: ["web"],
           },
@@ -1131,8 +1149,8 @@ describe("core: buildScopedSegments", function () {
 
       // NOT with multiple segments (all "*" becomes "*")
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             not: ["web", "chrome"],
           },
@@ -1149,8 +1167,8 @@ describe("core: buildScopedSegments", function () {
     test("nested AND group segments", function () {
       // Nested AND with all matching (all "*" becomes "*")
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             and: [
               "web",
@@ -1176,8 +1194,8 @@ describe("core: buildScopedSegments", function () {
 
       // Nested AND with partial match
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             and: [
               "web",
@@ -1204,8 +1222,8 @@ describe("core: buildScopedSegments", function () {
     test("nested OR group segments", function () {
       // Nested OR with all matching
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             or: [
               "web",
@@ -1230,8 +1248,8 @@ describe("core: buildScopedSegments", function () {
 
       // Nested OR with partial match
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             or: [
               "web",
@@ -1257,8 +1275,8 @@ describe("core: buildScopedSegments", function () {
     test("complex nested structures", function () {
       // Complex nested with AND, OR, NOT
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             and: [
               "web",
@@ -1291,7 +1309,7 @@ describe("core: buildScopedSegments", function () {
     test("segments with complex conditions", function () {
       // Segment with AND conditions in its definition
       expect(
-        buildScopedGroupSegments(datafileReaderWithSegments, "premium", {
+        applyContextToGroupSegments(featurevisorWithSegments, "premium", {
           tier: "premium",
           status: "active",
         }),
@@ -1299,7 +1317,7 @@ describe("core: buildScopedSegments", function () {
 
       // Segment with AND conditions that doesn't match
       expect(
-        buildScopedGroupSegments(datafileReaderWithSegments, "premium", {
+        applyContextToGroupSegments(featurevisorWithSegments, "premium", {
           tier: "premium",
           status: "inactive",
         }),
@@ -1308,21 +1326,23 @@ describe("core: buildScopedSegments", function () {
 
     test("removeSegments parameter", function () {
       // Simple segment in removeSegments
-      expect(buildScopedGroupSegments(datafileReaderWithSegments, "web", {}, ["web"])).toEqual("*");
+      expect(applyContextToGroupSegments(featurevisorWithSegments, "web", {}, ["web"])).toEqual(
+        "*",
+      );
 
       // Segment not in removeSegments
-      expect(buildScopedGroupSegments(datafileReaderWithSegments, "web", {}, ["mobile"])).toEqual(
+      expect(applyContextToGroupSegments(featurevisorWithSegments, "web", {}, ["mobile"])).toEqual(
         "web",
       );
 
       // Array with one segment in removeSegments
       expect(
-        buildScopedGroupSegments(datafileReaderWithSegments, ["web", "chrome"], {}, ["web"]),
+        applyContextToGroupSegments(featurevisorWithSegments, ["web", "chrome"], {}, ["web"]),
       ).toEqual(["*", "chrome"]);
 
       // Array with all segments in removeSegments
       expect(
-        buildScopedGroupSegments(datafileReaderWithSegments, ["web", "chrome"], {}, [
+        applyContextToGroupSegments(featurevisorWithSegments, ["web", "chrome"], {}, [
           "web",
           "chrome",
         ]),
@@ -1330,8 +1350,8 @@ describe("core: buildScopedSegments", function () {
 
       // Array with multiple segments, some in removeSegments
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           ["web", "chrome", "mobile", "safari"],
           {},
           ["web", "mobile"],
@@ -1340,8 +1360,8 @@ describe("core: buildScopedSegments", function () {
 
       // AND group segment with removeSegments
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             and: ["web", "chrome"],
           },
@@ -1354,8 +1374,8 @@ describe("core: buildScopedSegments", function () {
 
       // AND group segment with all segments in removeSegments
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             and: ["web", "chrome"],
           },
@@ -1368,8 +1388,8 @@ describe("core: buildScopedSegments", function () {
 
       // OR group segment with removeSegments
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             or: ["web", "chrome"],
           },
@@ -1382,8 +1402,8 @@ describe("core: buildScopedSegments", function () {
 
       // OR group segment with all segments in removeSegments
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             or: ["web", "chrome"],
           },
@@ -1396,8 +1416,8 @@ describe("core: buildScopedSegments", function () {
 
       // NOT group segment with removeSegments
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             not: ["web", "chrome"],
           },
@@ -1410,8 +1430,8 @@ describe("core: buildScopedSegments", function () {
 
       // NOT group segment with all segments in removeSegments
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             not: ["web", "chrome"],
           },
@@ -1424,8 +1444,8 @@ describe("core: buildScopedSegments", function () {
 
       // Nested AND with removeSegments
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             and: [
               "web",
@@ -1448,8 +1468,8 @@ describe("core: buildScopedSegments", function () {
 
       // Nested OR with removeSegments
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             or: [
               "web",
@@ -1472,8 +1492,8 @@ describe("core: buildScopedSegments", function () {
 
       // Mixed nested structure with removeSegments
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             and: [
               "web",
@@ -1502,8 +1522,8 @@ describe("core: buildScopedSegments", function () {
 
       // removeSegments combined with matching context
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           ["web", "chrome"],
           {
             platform: "web",
@@ -1514,8 +1534,8 @@ describe("core: buildScopedSegments", function () {
 
       // removeSegments with segment that would match context
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           ["web", "chrome"],
           {
             platform: "web",
@@ -1527,8 +1547,8 @@ describe("core: buildScopedSegments", function () {
 
       // Complex: removeSegments, context matching, and nested structures
       expect(
-        buildScopedGroupSegments(
-          datafileReaderWithSegments,
+        applyContextToGroupSegments(
+          featurevisorWithSegments,
           {
             and: [
               "web",
@@ -1555,18 +1575,18 @@ describe("core: buildScopedSegments", function () {
       });
 
       // Empty removeSegments array (should behave like no removeSegments)
-      expect(buildScopedGroupSegments(datafileReaderWithSegments, "web", {}, [])).toEqual("web");
+      expect(applyContextToGroupSegments(featurevisorWithSegments, "web", {}, [])).toEqual("web");
 
       // removeSegments with segment that doesn't exist in datafile
       expect(
-        buildScopedGroupSegments(datafileReaderWithSegments, ["web", "nonexistent"], {}, [
+        applyContextToGroupSegments(featurevisorWithSegments, ["web", "nonexistent"], {}, [
           "nonexistent",
         ]),
       ).toEqual(["web", "*"]);
 
       // removeSegments with "*" in array (should still work)
       expect(
-        buildScopedGroupSegments(datafileReaderWithSegments, ["*", "web", "chrome"], {}, ["web"]),
+        applyContextToGroupSegments(featurevisorWithSegments, ["*", "web", "chrome"], {}, ["web"]),
       ).toEqual(["*", "*", "chrome"]);
     });
   });