@featurevisor/sdk 0.47.5 → 0.47.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@featurevisor/sdk",
-  "version": "0.47.5",
+  "version": "0.47.7",
   "description": "Featurevisor SDK for Node.js and the browser",
   "main": "dist/index.js",
   "module": "lib/index.js",
@@ -49,5 +49,5 @@
     "compare-versions": "^6.0.0-rc.1",
     "murmurhash": "^2.0.1"
   },
-  "gitHead": "150079539789fe0b61fa78dd9337788a4c176cb2"
+  "gitHead": "0995af7e2bea55f101f3b4a6606e471e02ecb021"
 }

package/src/instance.spec.ts

@@ -45,7 +45,7 @@ describe("sdk: instance", function () {
     }, 0);
   });
 
-  it("should resolve onReady method as Promise", function (done) {
+  it("should resolve onReady method as Promise when initialized synchronously", function (done) {
     let readyCount = 0;
 
     const sdk = createInstance({
@@ -71,6 +71,41 @@ describe("sdk: instance", function () {
     }, 0);
   });
 
+  it("should resolve onReady method as Promise, when fetching datafile remotely", function (done) {
+    let readyCount = 0;
+
+    const sdk = createInstance({
+      datafileUrl: "http://localhost:3000/datafile.json",
+      handleDatafileFetch: function () {
+        const content: DatafileContent = {
+          schemaVersion: "1",
+          revision: "1.0",
+          features: [],
+          attributes: [],
+          segments: [],
+        };
+
+        return new Promise(function (resolve) {
+          setTimeout(function () {
+            resolve(content);
+          }, 10);
+        });
+      },
+      onReady: () => {
+        readyCount += 1;
+      },
+    });
+
+    setTimeout(() => {
+      sdk.onReady().then((f) => {
+        expect(f.isReady()).toEqual(true);
+        expect(readyCount).toEqual(1);
+
+        done();
+      });
+    }, 0);
+  });
+
   it("should configure plain bucketBy", function () {
     let capturedBucketKey = "";
 
@@ -393,6 +428,9 @@ describe("sdk: instance", function () {
         test: {
           enabled: true,
           variation: "control",
+          variables: {
+            color: "red",
+          },
         },
       },
       datafileUrl: "http://localhost:3000/datafile.json",
@@ -436,6 +474,11 @@ describe("sdk: instance", function () {
         userId: "123",
       }),
     ).toEqual("control");
+    expect(
+      sdk.getVariable("test", "color", {
+        userId: "123",
+      }),
+    ).toEqual("red");
 
     setTimeout(function () {
       // still control after fetching datafile
@@ -463,6 +506,9 @@ describe("sdk: instance", function () {
         test: {
           enabled: true,
           variation: "control",
+          variables: {
+            color: "red",
+          },
         },
       },
       datafileUrl: "http://localhost:3000/datafile.json",
@@ -506,6 +552,11 @@ describe("sdk: instance", function () {
         userId: "123",
       }),
     ).toEqual("control");
+    expect(
+      sdk.getVariable("test", "color", {
+        userId: "123",
+      }),
+    ).toEqual("red");
 
     setTimeout(function () {
       // treatment after fetching datafile
@@ -765,6 +816,166 @@ describe("sdk: instance", function () {
     expect(deprecatedCount).toEqual(1);
   });
 
+  it("should check if enabled for overridden flags from rules", function () {
+    const sdk = createInstance({
+      datafile: {
+        schemaVersion: "1",
+        revision: "1.0",
+        features: [
+          {
+            key: "test",
+            bucketBy: "userId",
+            traffic: [
+              {
+                key: "2",
+                segments: ["netherlands"],
+                percentage: 100000,
+                enabled: false,
+                allocation: [],
+              },
+              {
+                key: "1",
+                segments: "*",
+                percentage: 100000,
+                allocation: [],
+              },
+            ],
+          },
+        ],
+        attributes: [],
+        segments: [
+          {
+            key: "netherlands",
+            conditions: JSON.stringify([
+              {
+                attribute: "country",
+                operator: "equals",
+                value: "nl",
+              },
+            ]),
+          },
+        ],
+      },
+    });
+
+    expect(sdk.isEnabled("test", { userId: "user-123", country: "de" })).toEqual(true);
+    expect(sdk.isEnabled("test", { userId: "user-123", country: "nl" })).toEqual(false);
+  });
+
+  it("should check if enabled for mutually exclusive features", function () {
+    let bucketValue = 10000;
+
+    const sdk = createInstance({
+      configureBucketValue: function () {
+        return bucketValue;
+      },
+
+      datafile: {
+        schemaVersion: "1",
+        revision: "1.0",
+        features: [
+          {
+            key: "mutex",
+            bucketBy: "userId",
+            ranges: [[0, 50000]],
+            traffic: [{ key: "1", segments: "*", percentage: 50000, allocation: [] }],
+          },
+        ],
+        attributes: [],
+        segments: [],
+      },
+    });
+
+    expect(sdk.isEnabled("test")).toEqual(false);
+    expect(sdk.isEnabled("test", { userId: "123" })).toEqual(false);
+
+    bucketValue = 40000;
+    expect(sdk.isEnabled("mutex", { userId: "123" })).toEqual(true);
+
+    bucketValue = 60000;
+    expect(sdk.isEnabled("mutex", { userId: "123" })).toEqual(false);
+  });
+
+  it("should get variation", function () {
+    const sdk = createInstance({
+      datafile: {
+        schemaVersion: "1",
+        revision: "1.0",
+        features: [
+          {
+            key: "test",
+            bucketBy: "userId",
+            variations: [{ value: "control" }, { value: "treatment" }],
+            force: [
+              {
+                conditions: [{ attribute: "userId", operator: "equals", value: "user-gb" }],
+                enabled: false,
+              },
+              {
+                segments: ["netherlands"],
+                enabled: false,
+              },
+            ],
+            traffic: [
+              {
+                key: "1",
+                segments: "*",
+                percentage: 100000,
+                allocation: [
+                  { variation: "control", range: [0, 0] },
+                  { variation: "treatment", range: [0, 100000] },
+                ],
+              },
+            ],
+          },
+          {
+            key: "testWithNoVariation",
+            bucketBy: "userId",
+            traffic: [
+              {
+                key: "1",
+                segments: "*",
+                percentage: 100000,
+                allocation: [],
+              },
+            ],
+          },
+        ],
+        attributes: [],
+        segments: [
+          {
+            key: "netherlands",
+            conditions: JSON.stringify([
+              {
+                attribute: "country",
+                operator: "equals",
+                value: "nl",
+              },
+            ]),
+          },
+        ],
+      },
+    });
+
+    const context = {
+      userId: "123",
+    };
+
+    expect(sdk.getVariation("test", context)).toEqual("treatment");
+    expect(sdk.getVariation("test", { userId: "user-ch" })).toEqual("treatment");
+
+    // non existing
+    expect(sdk.getVariation("nonExistingFeature", context)).toEqual(undefined);
+
+    // disabled
+    expect(sdk.getVariation("test", { userId: "user-gb" })).toEqual(undefined);
+    expect(sdk.getVariation("test", { userId: "user-gb" })).toEqual(undefined);
+    expect(sdk.getVariation("test", { userId: "123", country: "nl" })).toEqual(undefined);
+
+    // no variation
+    expect(sdk.getVariation("testWithNoVariation", context)).toEqual(undefined);
+  });
+
   it("should get variable", function () {
     const sdk = createInstance({
       datafile: {
@@ -790,6 +1001,11 @@ describe("sdk: instance", function () {
                 type: "integer",
                 defaultValue: 0,
               },
+              {
+                key: "price",
+                type: "double",
+                defaultValue: 9.99,
+              },
               {
                 key: "paymentMethods",
                 type: "array",
@@ -820,25 +1036,101 @@ describe("sdk: instance", function () {
                   {
                     key: "showSidebar",
                     value: true,
+                    overrides: [
+                      {
+                        segments: ["netherlands"],
+                        value: false,
+                      },
+                      {
+                        conditions: [
+                          {
+                            attribute: "country",
+                            operator: "equals",
+                            value: "de",
+                          },
+                        ],
+                        value: false,
+                      },
+                    ],
                   },
                 ],
               },
             ],
+            force: [
+              {
+                conditions: [{ attribute: "userId", operator: "equals", value: "user-ch" }],
+                enabled: true,
+                variation: "control",
+                variables: {
+                  color: "red and white",
+                },
+              },
+              {
+                conditions: [{ attribute: "userId", operator: "equals", value: "user-gb" }],
+                enabled: false,
+              },
+            ],
             traffic: [
+              // belgium
+              {
+                key: "2",
+                segments: ["belgium"],
+                percentage: 100000,
+                allocation: [
+                  { variation: "control", range: [0, 0] },
+                  {
+                    variation: "treatment",
+                    range: [0, 100000],
+                  },
+                ],
+                variation: "control",
+                variables: {
+                  color: "black",
+                },
+              },
+
+              // everyone
               {
                 key: "1",
                 segments: "*",
                 percentage: 100000,
                 allocation: [
                   { variation: "control", range: [0, 0] },
-                  { variation: "treatment", range: [0, 100000] },
+                  {
+                    variation: "treatment",
+                    range: [0, 100000],
+                  },
                 ],
               },
             ],
           },
         ],
-        attributes: [],
-        segments: [],
+        attributes: [
+          { key: "userId", type: "string", capture: true },
+          { key: "country", type: "string" },
+        ],
+        segments: [
+          {
+            key: "netherlands",
+            conditions: JSON.stringify([
+              {
+                attribute: "country",
+                operator: "equals",
+                value: "nl",
+              },
+            ]),
+          },
+          {
+            key: "belgium",
+            conditions: JSON.stringify([
+              {
+                attribute: "country",
+                operator: "equals",
+                value: "be",
+              },
+            ]),
+          },
+        ],
       },
     });
 
@@ -847,16 +1139,40 @@ describe("sdk: instance", function () {
     };
 
     expect(sdk.getVariation("test", context)).toEqual("treatment");
+    expect(
+      sdk.getVariation("test", {
+        ...context,
+        country: "be",
+      }),
+    ).toEqual("control");
+    expect(sdk.getVariation("test", { userId: "user-ch" })).toEqual("control");
 
     expect(sdk.getVariable("test", "color", context)).toEqual("red");
     expect(sdk.getVariableString("test", "color", context)).toEqual("red");
+    expect(sdk.getVariable("test", "color", { ...context, country: "be" })).toEqual("black");
+    expect(sdk.getVariable("test", "color", { userId: "user-ch" })).toEqual("red and white");
 
     expect(sdk.getVariable("test", "showSidebar", context)).toEqual(true);
     expect(sdk.getVariableBoolean("test", "showSidebar", context)).toEqual(true);
+    expect(
+      sdk.getVariableBoolean("test", "showSidebar", {
+        ...context,
+        country: "nl",
+      }),
+    ).toEqual(false);
+    expect(
+      sdk.getVariableBoolean("test", "showSidebar", {
+        ...context,
+        country: "de",
+      }),
+    ).toEqual(false);
 
     expect(sdk.getVariable("test", "count", context)).toEqual(0);
     expect(sdk.getVariableInteger("test", "count", context)).toEqual(0);
 
+    expect(sdk.getVariable("test", "price", context)).toEqual(9.99);
+    expect(sdk.getVariableDouble("test", "price", context)).toEqual(9.99);
+
     expect(sdk.getVariable("test", "paymentMethods", context)).toEqual(["paypal", "creditcard"]);
     expect(sdk.getVariableArray("test", "paymentMethods", context)).toEqual([
       "paypal",
@@ -880,5 +1196,12 @@ describe("sdk: instance", function () {
         nested: "value",
       },
     });
+
+    // non existing
+    expect(sdk.getVariable("test", "nonExisting", context)).toEqual(undefined);
+    expect(sdk.getVariable("nonExistingFeature", "nonExisting", context)).toEqual(undefined);
+
+    // disabled
+    expect(sdk.getVariable("test", "color", { userId: "user-gb" })).toEqual(undefined);
   });
 });