@featurevisor/sdk 0.47.4 → 0.47.6

package/lib/logger.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@featurevisor/sdk",
-  "version": "0.47.4",
+  "version": "0.47.6",
   "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": "a0a4cfe96b9223e7bfca022425c851c451b52b89"
+  "gitHead": "e7b6c3a8596d1df292b9c6857baf767e0839a245"
 }

package/src/instance.spec.ts

@@ -393,6 +393,9 @@ describe("sdk: instance", function () {
         test: {
           enabled: true,
           variation: "control",
+          variables: {
+            color: "red",
+          },
         },
       },
       datafileUrl: "http://localhost:3000/datafile.json",
@@ -436,6 +439,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 +471,9 @@ describe("sdk: instance", function () {
         test: {
           enabled: true,
           variation: "control",
+          variables: {
+            color: "red",
+          },
         },
       },
       datafileUrl: "http://localhost:3000/datafile.json",
@@ -506,6 +517,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 +781,105 @@ describe("sdk: instance", function () {
     expect(deprecatedCount).toEqual(1);
   });
 
+  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] },
+                ],
+              },
+            ],
+          },
+        ],
+        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);
+  });
+
   it("should get variable", function () {
     const sdk = createInstance({
       datafile: {
@@ -790,6 +905,11 @@ describe("sdk: instance", function () {
                 type: "integer",
                 defaultValue: 0,
               },
+              {
+                key: "price",
+                type: "double",
+                defaultValue: 9.99,
+              },
               {
                 key: "paymentMethods",
                 type: "array",
@@ -820,25 +940,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 +1043,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 +1100,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);
   });
 });

package/src/logger.spec.ts

@@ -0,0 +1,154 @@
+/* eslint-disable no-global-assign */
+
+import { createLogger } from "./logger";
+
+describe("logger", () => {
+  it("should log", () => {
+    const logger = createLogger({
+      levels: ["debug", "info", "warn", "error"],
+      handler: jest.fn(),
+    });
+
+    logger.debug("debug");
+    logger.info("info");
+    logger.warn("warn");
+    logger.error("error");
+
+    expect(logger).toBeDefined();
+    expect(logger.debug).toBeDefined();
+    expect(logger.info).toBeDefined();
+    expect(logger.warn).toBeDefined();
+    expect(logger.error).toBeDefined();
+    expect(logger.setLevels).toBeDefined();
+    expect(logger.log).toBeDefined();
+    expect(logger.log).toBeInstanceOf(Function);
+    expect(logger.debug).toBeInstanceOf(Function);
+    expect(logger.info).toBeInstanceOf(Function);
+    expect(logger.warn).toBeInstanceOf(Function);
+    expect(logger.error).toBeInstanceOf(Function);
+    expect(logger.setLevels).toBeInstanceOf(Function);
+  });
+
+  it("should log with custom levels", () => {
+    const logger = createLogger({
+      levels: ["debug", "info"],
+      handler: jest.fn(),
+    });
+
+    logger.debug("debug");
+    logger.info("info");
+    logger.warn("warn");
+    logger.error("error");
+
+    expect(logger).toBeDefined();
+    expect(logger.debug).toBeDefined();
+    expect(logger.info).toBeDefined();
+    expect(logger.warn).toBeDefined();
+    expect(logger.error).toBeDefined();
+    expect(logger.setLevels).toBeDefined();
+    expect(logger.log).toBeDefined();
+    expect(logger.log).toBeInstanceOf(Function);
+    expect(logger.debug).toBeInstanceOf(Function);
+    expect(logger.info).toBeInstanceOf(Function);
+    expect(logger.warn).toBeInstanceOf(Function);
+    expect(logger.error).toBeInstanceOf(Function);
+    expect(logger.setLevels).toBeInstanceOf(Function);
+  });
+
+  it("should log with default handler", () => {
+    const logs: any[] = [];
+
+    const realConsole = console;
+    const customConsole = {
+      log: (...args) => logs.push(args),
+      info: (...args) => logs.push(args),
+      warn: (...args) => logs.push(args),
+      error: (...args) => logs.push(args),
+    };
+
+    console = customConsole as unknown as Console; // eslint-ignore-line
+
+    const logger = createLogger({});
+
+    logger.setLevels(["debug", "info", "warn", "error"]);
+
+    logger.debug("debug");
+    logger.info("info");
+    logger.warn("warn");
+    logger.error("error");
+
+    expect(logger).toBeDefined();
+    expect(logger.debug).toBeDefined();
+    expect(logger.info).toBeDefined();
+    expect(logger.warn).toBeDefined();
+    expect(logger.error).toBeDefined();
+    expect(logger.setLevels).toBeDefined();
+    expect(logger.log).toBeDefined();
+    expect(logger.log).toBeInstanceOf(Function);
+    expect(logger.debug).toBeInstanceOf(Function);
+    expect(logger.info).toBeInstanceOf(Function);
+    expect(logger.warn).toBeInstanceOf(Function);
+    expect(logger.error).toBeInstanceOf(Function);
+    expect(logger.setLevels).toBeInstanceOf(Function);
+
+    expect(logs.length).toBe(4);
+
+    console = realConsole; // eslint-ignore-line
+  });
+
+  it("should log with custom handler", () => {
+    const handler = jest.fn();
+    const logger = createLogger({
+      levels: ["debug", "info", "warn", "error"],
+      handler,
+    });
+
+    logger.debug("debug");
+    logger.info("info");
+    logger.warn("warn");
+    logger.error("error");
+
+    expect(logger).toBeDefined();
+    expect(logger.debug).toBeDefined();
+    expect(logger.info).toBeDefined();
+    expect(logger.warn).toBeDefined();
+    expect(logger.error).toBeDefined();
+    expect(logger.setLevels).toBeDefined();
+    expect(logger.log).toBeDefined();
+    expect(logger.log).toBeInstanceOf(Function);
+    expect(logger.debug).toBeInstanceOf(Function);
+    expect(logger.info).toBeInstanceOf(Function);
+    expect(logger.warn).toBeInstanceOf(Function);
+    expect(logger.error).toBeInstanceOf(Function);
+    expect(logger.setLevels).toBeInstanceOf(Function);
+    expect(handler).toHaveBeenCalledTimes(4);
+  });
+
+  it("should log with custom levels and handler", () => {
+    const handler = jest.fn();
+    const logger = createLogger({
+      levels: ["debug", "info"],
+      handler,
+    });
+
+    logger.debug("debug");
+    logger.info("info");
+    logger.warn("warn");
+    logger.error("error");
+
+    expect(logger).toBeDefined();
+    expect(logger.debug).toBeDefined();
+    expect(logger.info).toBeDefined();
+    expect(logger.warn).toBeDefined();
+    expect(logger.error).toBeDefined();
+    expect(logger.setLevels).toBeDefined();
+    expect(logger.log).toBeDefined();
+    expect(logger.log).toBeInstanceOf(Function);
+    expect(logger.debug).toBeInstanceOf(Function);
+    expect(logger.info).toBeInstanceOf(Function);
+    expect(logger.warn).toBeInstanceOf(Function);
+    expect(logger.error).toBeInstanceOf(Function);
+    expect(logger.setLevels).toBeInstanceOf(Function);
+    expect(handler).toHaveBeenCalledTimes(2);
+  });
+});