@featurevisor/core 1.1.0 → 1.2.0

package/lib/tester/testSegment.js

@@ -39,6 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.testSegment = void 0;
 var sdk_1 = require("@featurevisor/sdk");
 var cliFormat_1 = require("./cliFormat");
+var matrix_1 = require("./matrix");
 function testSegment(datasource, test, patterns) {
     return __awaiter(this, void 0, void 0, function () {
         var hasError, segmentKey, segmentExists, parsedSegment, conditions;
@@ -61,17 +62,19 @@ function testSegment(datasource, test, patterns) {
                     parsedSegment = _a.sent();
                     conditions = parsedSegment.conditions;
                     test.assertions.forEach(function (assertion, aIndex) {
-                        var description = "  Assertion #".concat(aIndex + 1, ": ").concat(assertion.description || "#".concat(aIndex + 1));
-                        if (patterns.assertionPattern && !patterns.assertionPattern.test(description)) {
-                            return;
-                        }
-                        console.log(description);
-                        var expected = assertion.expectedToMatch;
-                        var actual = (0, sdk_1.allConditionsAreMatched)(conditions, assertion.context);
-                        if (actual !== expected) {
-                            hasError = true;
-                            console.error(cliFormat_1.CLI_FORMAT_RED, "    Segment failed: expected \"".concat(expected, "\", got \"").concat(actual, "\""));
-                        }
+                        var assertions = (0, matrix_1.getSegmentAssertionsFromMatrix)(aIndex, assertion);
+                        assertions.forEach(function (assertion) {
+                            if (patterns.assertionPattern && !patterns.assertionPattern.test(assertion.description)) {
+                                return;
+                            }
+                            console.log(assertion.description);
+                            var expected = assertion.expectedToMatch;
+                            var actual = (0, sdk_1.allConditionsAreMatched)(conditions, assertion.context);
+                            if (actual !== expected) {
+                                hasError = true;
+                                console.error(cliFormat_1.CLI_FORMAT_RED, "    Segment failed: expected \"".concat(expected, "\", got \"").concat(actual, "\""));
+                            }
+                        });
                     });
                     return [2 /*return*/, hasError];
             }

package/lib/tester/testSegment.js.map

@@ -1 +1 @@
-{"version":3,"file":"testSegment.js","sourceRoot":"","sources":["../../src/tester/testSegment.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,yCAA4D;AAI5D,yCAA8D;AAE9D,SAAsB,WAAW,CAC/B,UAAsB,EACtB,IAAiB,EACjB,QAAQ;;;;;;oBAEJ,QAAQ,GAAG,KAAK,CAAC;oBAEf,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC;oBAEhC,OAAO,CAAC,GAAG,CAAC,2BAAe,EAAE,sBAAc,UAAU,QAAI,CAAC,CAAC;oBAErC,qBAAM,UAAU,CAAC,aAAa,CAAC,UAAU,CAAC,EAAA;;oBAA1D,aAAa,GAAG,SAA0C;oBAEhE,IAAI,CAAC,aAAa,EAAE;wBAClB,OAAO,CAAC,KAAK,CAAC,0BAAc,EAAE,oCAA6B,UAAU,CAAE,CAAC,CAAC;wBACzE,QAAQ,GAAG,IAAI,CAAC;wBAEhB,sBAAO,QAAQ,EAAC;qBACjB;oBAEqB,qBAAM,UAAU,CAAC,WAAW,CAAC,UAAU,CAAC,EAAA;;oBAAxD,aAAa,GAAG,SAAwC;oBACxD,UAAU,GAAG,aAAa,CAAC,UAAqC,CAAC;oBAEvE,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,UAAU,SAAS,EAAE,MAAM;wBACjD,IAAM,WAAW,GAAG,uBAAgB,MAAM,GAAG,CAAC,eAAK,SAAS,CAAC,WAAW,IAAI,WAAI,MAAM,GAAG,CAAC,CAAE,CAAE,CAAC;wBAE/F,IAAI,QAAQ,CAAC,gBAAgB,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE;4BAC7E,OAAO;yBACR;wBAED,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;wBAEzB,IAAM,QAAQ,GAAG,SAAS,CAAC,eAAe,CAAC;wBAC3C,IAAM,MAAM,GAAG,IAAA,6BAAuB,EAAC,UAAU,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;wBAEtE,IAAI,MAAM,KAAK,QAAQ,EAAE;4BACvB,QAAQ,GAAG,IAAI,CAAC;4BAEhB,OAAO,CAAC,KAAK,CAAC,0BAAc,EAAE,yCAAiC,QAAQ,uBAAW,MAAM,OAAG,CAAC,CAAC;yBAC9F;oBACH,CAAC,CAAC,CAAC;oBAEH,sBAAO,QAAQ,EAAC;;;;CACjB;AA3CD,kCA2CC"}
+{"version":3,"file":"testSegment.js","sourceRoot":"","sources":["../../src/tester/testSegment.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,yCAA4D;AAI5D,yCAA8D;AAC9D,mCAA0D;AAE1D,SAAsB,WAAW,CAC/B,UAAsB,EACtB,IAAiB,EACjB,QAAQ;;;;;;oBAEJ,QAAQ,GAAG,KAAK,CAAC;oBAEf,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC;oBAEhC,OAAO,CAAC,GAAG,CAAC,2BAAe,EAAE,sBAAc,UAAU,QAAI,CAAC,CAAC;oBAErC,qBAAM,UAAU,CAAC,aAAa,CAAC,UAAU,CAAC,EAAA;;oBAA1D,aAAa,GAAG,SAA0C;oBAEhE,IAAI,CAAC,aAAa,EAAE;wBAClB,OAAO,CAAC,KAAK,CAAC,0BAAc,EAAE,oCAA6B,UAAU,CAAE,CAAC,CAAC;wBACzE,QAAQ,GAAG,IAAI,CAAC;wBAEhB,sBAAO,QAAQ,EAAC;qBACjB;oBAEqB,qBAAM,UAAU,CAAC,WAAW,CAAC,UAAU,CAAC,EAAA;;oBAAxD,aAAa,GAAG,SAAwC;oBACxD,UAAU,GAAG,aAAa,CAAC,UAAqC,CAAC;oBAEvE,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,UAAU,SAAS,EAAE,MAAM;wBACjD,IAAM,UAAU,GAAG,IAAA,uCAA8B,EAAC,MAAM,EAAE,SAAS,CAAC,CAAC;wBAErE,UAAU,CAAC,OAAO,CAAC,UAAU,SAAS;4BACpC,IAAI,QAAQ,CAAC,gBAAgB,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE;gCACvF,OAAO;6BACR;4BAED,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;4BAEnC,IAAM,QAAQ,GAAG,SAAS,CAAC,eAAe,CAAC;4BAC3C,IAAM,MAAM,GAAG,IAAA,6BAAuB,EAAC,UAAU,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;4BAEtE,IAAI,MAAM,KAAK,QAAQ,EAAE;gCACvB,QAAQ,GAAG,IAAI,CAAC;gCAEhB,OAAO,CAAC,KAAK,CACX,0BAAc,EACd,yCAAiC,QAAQ,uBAAW,MAAM,OAAG,CAC9D,CAAC;6BACH;wBACH,CAAC,CAAC,CAAC;oBACL,CAAC,CAAC,CAAC;oBAEH,sBAAO,QAAQ,EAAC;;;;CACjB;AAhDD,kCAgDC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@featurevisor/core",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Core package of Featurevisor for Node.js usage",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -44,9 +44,9 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@featurevisor/sdk": "^1.0.2",
-    "@featurevisor/site": "1.0.0",
-    "@featurevisor/types": "1.0.0",
+    "@featurevisor/sdk": "^1.2.0",
+    "@featurevisor/site": "^1.2.0",
+    "@featurevisor/types": "^1.2.0",
     "axios": "^1.3.4",
     "joi": "^17.8.3",
     "js-yaml": "^4.1.0",
@@ -57,5 +57,5 @@
     "@types/js-yaml": "^4.0.5",
     "@types/tar": "^6.1.4"
   },
-  "gitHead": "08807fe55241e7ead179ecdbb135fa5ff57461ab"
+  "gitHead": "e733c84d2fcdc6205df5ae75e5bbf73753141646"
 }

package/src/linter/testSchema.ts

@@ -13,6 +13,7 @@ export function getTestsJoiSchema(
       .required(),
     assertions: Joi.array().items(
       Joi.object({
+        matrix: Joi.object().optional(), // @TODO: make it stricter
         description: Joi.string().optional(),
         context: Joi.object(),
         expectedToMatch: Joi.boolean(),
@@ -26,10 +27,28 @@ export function getTestsJoiSchema(
       .required(),
     assertions: Joi.array().items(
       Joi.object({
+        matrix: Joi.object().optional(), // @TODO: make it stricter
         description: Joi.string().optional(),
-        at: Joi.number().precision(3).min(0).max(100).required(),
+        at: Joi.alternatives().try(
+          Joi.number().precision(3).min(0).max(100).required(),
+
+          // because of supporting matrix
+          Joi.string().required(),
+        ),
         environment: Joi.string()
-          .valid(...projectConfig.environments)
+          .custom((value, helpers) => {
+            if (value.indexOf("${{") === 0) {
+              // allow unknown strings for matrix
+              return value;
+            }
+
+            // otherwise only known environments should be passed
+            if (projectConfig.environments.includes(value)) {
+              return value;
+            }
+
+            return helpers.error("any.invalid");
+          })
           .required(),
         context: Joi.object().required(),
         expectedToBeEnabled: Joi.boolean().required(),

package/src/tester/matrix.spec.ts

@@ -0,0 +1,49 @@
+import { getMatrixCombinations } from "./matrix";
+
+describe("core :: tester :: matrix", function () {
+  test("should empty array when no keys are available", function () {
+    const matrix = {};
+    const combinations = getMatrixCombinations(matrix);
+
+    expect(combinations).toEqual([]);
+  });
+
+  test("should get combinations from matrix with two keys", function () {
+    const matrix = {
+      a: [1, 2],
+      b: ["x", "y"],
+    };
+    const combinations = getMatrixCombinations(matrix);
+
+    expect(combinations).toEqual([
+      { a: 1, b: "x" },
+      { a: 1, b: "y" },
+
+      { a: 2, b: "x" },
+      { a: 2, b: "y" },
+    ]);
+  });
+
+  test("should get combinations from matrix with three keys", function () {
+    const matrix = {
+      a: [1, 2],
+      b: ["x", "y"],
+      c: [true, false],
+    };
+    const combinations = getMatrixCombinations(matrix);
+
+    expect(combinations).toEqual([
+      { a: 1, b: "x", c: true },
+      { a: 1, b: "x", c: false },
+
+      { a: 1, b: "y", c: true },
+      { a: 1, b: "y", c: false },
+
+      { a: 2, b: "x", c: true },
+      { a: 2, b: "x", c: false },
+
+      { a: 2, b: "y", c: true },
+      { a: 2, b: "y", c: false },
+    ]);
+  });
+});

package/src/tester/matrix.ts

@@ -0,0 +1,185 @@
+import { AssertionMatrix, FeatureAssertion, SegmentAssertion } from "@featurevisor/types";
+
+function generateCombinations(
+  keys: string[],
+  matrix: AssertionMatrix,
+  idx: number,
+  prev: any,
+  combinations: any[],
+) {
+  const key = keys[idx];
+  const values = matrix[key];
+
+  for (let i = 0; i < values.length; i++) {
+    const combination = { ...prev, [key]: values[i] };
+
+    if (idx === keys.length - 1) {
+      combinations.push(combination);
+    } else {
+      generateCombinations(keys, matrix, idx + 1, combination, combinations);
+    }
+  }
+}
+
+export function getMatrixCombinations(matrix: AssertionMatrix) {
+  const keys = Object.keys(matrix);
+
+  if (!keys.length) {
+    return [];
+  }
+
+  const combinations: any[] = [];
+  generateCombinations(keys, matrix, 0, {}, combinations);
+
+  return combinations;
+}
+
+export function applyCombinationToValue(value: any, combination: any) {
+  if (typeof value === "string") {
+    const variableKeysInValue = value.match(/\${{(.+?)}}/g);
+
+    // no variables found
+    if (!variableKeysInValue) {
+      return value;
+    }
+
+    // only 1 variable found, so we can insert the value directly
+    if (variableKeysInValue.length === 1 && value.startsWith("${{") && value.endsWith("}}")) {
+      const key = value.replace("${{", "").replace("}}", "").trim();
+
+      return combination[key];
+    }
+
+    // multiple variables found, so we can replace each as a whole string
+    return value.replace(/\${{(.+?)}}/g, (_, key) => combination[key.trim()]);
+  }
+
+  return value;
+}
+
+/**
+ * Features
+ */
+export function applyCombinationToFeatureAssertion(
+  combination: any,
+  assertion: FeatureAssertion,
+): FeatureAssertion {
+  const flattenedAssertion = { ...assertion };
+
+  // environment
+  flattenedAssertion.environment = applyCombinationToValue(
+    flattenedAssertion.environment,
+    combination,
+  );
+
+  // context
+  flattenedAssertion.context = Object.keys(flattenedAssertion.context).reduce((acc, key) => {
+    acc[key] = applyCombinationToValue(flattenedAssertion.context[key], combination);
+
+    return acc;
+  }, {});
+
+  // at
+  flattenedAssertion.at = applyCombinationToValue(flattenedAssertion.at, combination);
+  if (typeof flattenedAssertion.at === "string") {
+    flattenedAssertion.at =
+      (flattenedAssertion.at as string).indexOf(".") > -1
+        ? parseFloat(flattenedAssertion.at)
+        : parseInt(flattenedAssertion.at, 10);
+  }
+
+  // description
+  if (flattenedAssertion.description) {
+    flattenedAssertion.description = applyCombinationToValue(
+      flattenedAssertion.description,
+      combination,
+    );
+  }
+
+  return flattenedAssertion;
+}
+
+export function getFeatureAssertionsFromMatrix(
+  aIndex,
+  assertionWithMatrix: FeatureAssertion,
+): FeatureAssertion[] {
+  if (!assertionWithMatrix.matrix) {
+    const assertion = { ...assertionWithMatrix };
+    assertion.description = `  Assertion #${aIndex + 1}: (${assertion.environment}) ${
+      assertion.description || `at ${assertion.at}%`
+    }`;
+
+    return [assertion];
+  }
+
+  const assertions: FeatureAssertion[] = [];
+  const combinations = getMatrixCombinations(assertionWithMatrix.matrix);
+
+  for (let cIndex = 0; cIndex < combinations.length; cIndex++) {
+    const combination = combinations[cIndex];
+    const assertion = applyCombinationToFeatureAssertion(combination, assertionWithMatrix);
+    assertion.description = `  Assertion #${aIndex + 1}: (${assertion.environment}) ${
+      assertion.description || `at ${assertion.at}%`
+    }`;
+
+    assertions.push(assertion);
+  }
+
+  return assertions;
+}
+
+/**
+ * Segments
+ */
+export function applyCombinationToSegmentAssertion(
+  combination: any,
+  assertion: SegmentAssertion,
+): SegmentAssertion {
+  const flattenedAssertion = { ...assertion };
+
+  // context
+  flattenedAssertion.context = Object.keys(flattenedAssertion.context).reduce((acc, key) => {
+    acc[key] = applyCombinationToValue(flattenedAssertion.context[key], combination);
+
+    return acc;
+  }, {});
+
+  // description
+  if (flattenedAssertion.description) {
+    flattenedAssertion.description = applyCombinationToValue(
+      flattenedAssertion.description,
+      combination,
+    );
+  }
+
+  return flattenedAssertion;
+}
+
+export function getSegmentAssertionsFromMatrix(
+  aIndex,
+  assertionWithMatrix: SegmentAssertion,
+): SegmentAssertion[] {
+  if (!assertionWithMatrix.matrix) {
+    const assertion = { ...assertionWithMatrix };
+    assertion.description = `  Assertion #${aIndex + 1}: ${
+      assertion.description || `#${aIndex + 1}`
+    }`;
+
+    return [assertion];
+  }
+
+  const assertions: SegmentAssertion[] = [];
+  const combinations = getMatrixCombinations(assertionWithMatrix.matrix);
+
+  for (let cIndex = 0; cIndex < combinations.length; cIndex++) {
+    const combination = combinations[cIndex];
+    const assertion = applyCombinationToSegmentAssertion(combination, assertionWithMatrix);
+    assertion.description = `  Assertion #${aIndex + 1}: ${
+      assertion.description || `#${aIndex + 1}`
+    }`;
+
+    assertions.push(assertion);
+  }
+
+  return assertions;
+}

package/src/tester/testFeature.ts

@@ -9,6 +9,7 @@ import { SCHEMA_VERSION } from "../config";
 import { checkIfArraysAreEqual } from "./checkIfArraysAreEqual";
 import { checkIfObjectsAreEqual } from "./checkIfObjectsAreEqual";
 import { CLI_FORMAT_BOLD, CLI_FORMAT_RED } from "./cliFormat";
+import { getFeatureAssertionsFromMatrix } from "./matrix";
 
 export async function testFeature(
   datasource: Datasource,
@@ -23,149 +24,155 @@ export async function testFeature(
   console.log(CLI_FORMAT_BOLD, `  Feature "${featureKey}":`);
 
   for (let aIndex = 0; aIndex < test.assertions.length; aIndex++) {
-    const assertion = test.assertions[aIndex];
-    const description = `  Assertion #${aIndex + 1}: (${assertion.environment}) ${
-      assertion.description || `at ${assertion.at}%`
-    }`;
+    const assertions = getFeatureAssertionsFromMatrix(aIndex, test.assertions[aIndex]);
 
-    if (patterns.assertionPattern && !patterns.assertionPattern.test(description)) {
-      continue;
-    }
-
-    console.log(description);
-
-    const requiredChain = await datasource.getRequiredFeaturesChain(test.feature);
-    const featuresToInclude = Array.from(requiredChain);
-
-    const existingState = await datasource.readState(assertion.environment);
-    const datafileContent = await buildDatafile(
-      projectConfig,
-      datasource,
-      {
-        schemaVersion: SCHEMA_VERSION,
-        revision: "testing",
-        environment: assertion.environment,
-        features: featuresToInclude,
-      },
-      existingState,
-    );
-
-    if (options.showDatafile) {
-      console.log("");
-      console.log(JSON.stringify(datafileContent, null, 2));
-      console.log("");
-    }
+    for (let bIndex = 0; bIndex < assertions.length; bIndex++) {
+      const assertion = assertions[bIndex];
 
-    const sdk = createInstance({
-      datafile: datafileContent,
-      configureBucketValue: () => {
-        return assertion.at * (MAX_BUCKETED_NUMBER / 100);
-      },
-    });
-
-    if (options.verbose) {
-      sdk.setLogLevels(["debug", "info", "warn", "error"]);
-    }
+      if (patterns.assertionPattern && !patterns.assertionPattern.test(assertion.description)) {
+        continue;
+      }
 
-    // isEnabled
-    if ("expectedToBeEnabled" in assertion) {
-      const isEnabled = sdk.isEnabled(featureKey, assertion.context);
+      console.log(assertion.description);
+
+      const requiredChain = await datasource.getRequiredFeaturesChain(test.feature);
+      const featuresToInclude = Array.from(requiredChain);
+
+      const existingState = await datasource.readState(assertion.environment);
+      const datafileContent = await buildDatafile(
+        projectConfig,
+        datasource,
+        {
+          schemaVersion: SCHEMA_VERSION,
+          revision: "testing",
+          environment: assertion.environment,
+          features: featuresToInclude,
+        },
+        existingState,
+      );
+
+      if (options.showDatafile) {
+        console.log("");
+        console.log(JSON.stringify(datafileContent, null, 2));
+        console.log("");
+      }
 
-      if (isEnabled !== assertion.expectedToBeEnabled) {
-        hasError = true;
+      const sdk = createInstance({
+        datafile: datafileContent,
+        configureBucketValue: () => {
+          return assertion.at * (MAX_BUCKETED_NUMBER / 100);
+        },
+      });
 
-        console.error(
-          CLI_FORMAT_RED,
-          `    isEnabled failed: expected "${assertion.expectedToBeEnabled}", received "${isEnabled}"`,
-        );
+      if (options.verbose) {
+        sdk.setLogLevels(["debug", "info", "warn", "error"]);
       }
-    }
 
-    // variation
-    if ("expectedVariation" in assertion) {
-      const variation = sdk.getVariation(featureKey, assertion.context);
+      // isEnabled
+      if ("expectedToBeEnabled" in assertion) {
+        const isEnabled = sdk.isEnabled(featureKey, assertion.context);
 
-      if (variation !== assertion.expectedVariation) {
-        hasError = true;
+        if (isEnabled !== assertion.expectedToBeEnabled) {
+          hasError = true;
 
-        console.error(
-          CLI_FORMAT_RED,
-          `    Variation failed: expected "${assertion.expectedVariation}", received "${variation}"`,
-        );
+          console.error(
+            CLI_FORMAT_RED,
+            `    isEnabled failed: expected "${assertion.expectedToBeEnabled}", received "${isEnabled}"`,
+          );
+        }
       }
-    }
 
-    // variables
-    const feature = await datasource.readFeature(featureKey);
+      // variation
+      if ("expectedVariation" in assertion) {
+        const variation = sdk.getVariation(featureKey, assertion.context);
 
-    if (!feature) {
-      hasError = true;
+        if (variation !== assertion.expectedVariation) {
+          hasError = true;
 
-      console.error(CLI_FORMAT_RED, `    Feature "${featureKey}" failed: feature not found`);
+          console.error(
+            CLI_FORMAT_RED,
+            `    Variation failed: expected "${assertion.expectedVariation}", received "${variation}"`,
+          );
+        }
+      }
 
-      continue;
-    }
+      // variables
+      const feature = await datasource.readFeature(featureKey);
 
-    if (typeof assertion.expectedVariables === "object") {
-      Object.keys(assertion.expectedVariables).forEach(function (variableKey) {
-        const expectedValue =
-          assertion.expectedVariables && assertion.expectedVariables[variableKey];
-        const actualValue = sdk.getVariable(featureKey, variableKey, assertion.context);
+      if (!feature) {
+        hasError = true;
 
-        let passed;
+        console.error(CLI_FORMAT_RED, `    Feature "${featureKey}" failed: feature not found`);
 
-        const variableSchema = feature.variablesSchema?.find((v) => v.key === variableKey);
+        continue;
+      }
 
-        if (!variableSchema) {
-          hasError = true;
+      if (typeof assertion.expectedVariables === "object") {
+        Object.keys(assertion.expectedVariables).forEach(function (variableKey) {
+          const expectedValue =
+            assertion.expectedVariables && assertion.expectedVariables[variableKey];
+          const actualValue = sdk.getVariable(featureKey, variableKey, assertion.context);
 
-          console.error(
-            CLI_FORMAT_RED,
-            `    Variable "${variableKey}" failed: variable schema not found in feature`,
-          );
+          let passed;
 
-          return;
-        }
+          const variableSchema = feature.variablesSchema?.find((v) => v.key === variableKey);
 
-        if (variableSchema.type === "json") {
-          // JSON type
-          const parsedExpectedValue =
-            typeof expectedValue === "string" ? JSON.parse(expectedValue as string) : expectedValue;
+          if (!variableSchema) {
+            hasError = true;
 
-          if (Array.isArray(actualValue)) {
-            passed = checkIfArraysAreEqual(parsedExpectedValue, actualValue);
-          } else if (typeof actualValue === "object") {
-            passed = checkIfObjectsAreEqual(parsedExpectedValue, actualValue);
-          } else {
-            passed = JSON.stringify(parsedExpectedValue) === JSON.stringify(actualValue);
-          }
+            console.error(
+              CLI_FORMAT_RED,
+              `    Variable "${variableKey}" failed: variable schema not found in feature`,
+            );
 
-          if (!passed) {
-            console.error(CLI_FORMAT_RED, `    Variable "${variableKey}" failed:`);
-            console.error(CLI_FORMAT_RED, `      expected: ${JSON.stringify(parsedExpectedValue)}`);
-            console.error(CLI_FORMAT_RED, `      received: ${JSON.stringify(actualValue)}`);
+            return;
           }
-        } else {
-          // other types
-          if (typeof expectedValue === "object") {
-            passed = checkIfObjectsAreEqual(expectedValue, actualValue);
-          } else if (Array.isArray(expectedValue)) {
-            passed = checkIfArraysAreEqual(expectedValue, actualValue);
+
+          if (variableSchema.type === "json") {
+            // JSON type
+            const parsedExpectedValue =
+              typeof expectedValue === "string"
+                ? JSON.parse(expectedValue as string)
+                : expectedValue;
+
+            if (Array.isArray(actualValue)) {
+              passed = checkIfArraysAreEqual(parsedExpectedValue, actualValue);
+            } else if (typeof actualValue === "object") {
+              passed = checkIfObjectsAreEqual(parsedExpectedValue, actualValue);
+            } else {
+              passed = JSON.stringify(parsedExpectedValue) === JSON.stringify(actualValue);
+            }
+
+            if (!passed) {
+              console.error(CLI_FORMAT_RED, `    Variable "${variableKey}" failed:`);
+              console.error(
+                CLI_FORMAT_RED,
+                `      expected: ${JSON.stringify(parsedExpectedValue)}`,
+              );
+              console.error(CLI_FORMAT_RED, `      received: ${JSON.stringify(actualValue)}`);
+            }
           } else {
-            passed = expectedValue === actualValue;
+            // other types
+            if (typeof expectedValue === "object") {
+              passed = checkIfObjectsAreEqual(expectedValue, actualValue);
+            } else if (Array.isArray(expectedValue)) {
+              passed = checkIfArraysAreEqual(expectedValue, actualValue);
+            } else {
+              passed = expectedValue === actualValue;
+            }
+
+            if (!passed) {
+              console.error(CLI_FORMAT_RED, `    Variable "${variableKey}" failed:`);
+              console.error(CLI_FORMAT_RED, `      expected: ${JSON.stringify(expectedValue)}`);
+              console.error(CLI_FORMAT_RED, `      received: ${JSON.stringify(actualValue)}`);
+            }
           }
 
           if (!passed) {
-            console.error(CLI_FORMAT_RED, `    Variable "${variableKey}" failed:`);
-            console.error(CLI_FORMAT_RED, `      expected: ${JSON.stringify(expectedValue)}`);
-            console.error(CLI_FORMAT_RED, `      received: ${JSON.stringify(actualValue)}`);
+            hasError = true;
           }
-        }
-
-        if (!passed) {
-          hasError = true;
-        }
-      });
+        });
+      }
     }
   }
 

package/src/tester/testSegment.ts

@@ -4,6 +4,7 @@ import { allConditionsAreMatched } from "@featurevisor/sdk";
 import { Datasource } from "../datasource";
 
 import { CLI_FORMAT_BOLD, CLI_FORMAT_RED } from "./cliFormat";
+import { getSegmentAssertionsFromMatrix } from "./matrix";
 
 export async function testSegment(
   datasource: Datasource,
@@ -29,22 +30,27 @@ export async function testSegment(
   const conditions = parsedSegment.conditions as Condition | Condition[];
 
   test.assertions.forEach(function (assertion, aIndex) {
-    const description = `  Assertion #${aIndex + 1}: ${assertion.description || `#${aIndex + 1}`}`;
+    const assertions = getSegmentAssertionsFromMatrix(aIndex, assertion);
 
-    if (patterns.assertionPattern && !patterns.assertionPattern.test(description)) {
-      return;
-    }
+    assertions.forEach(function (assertion) {
+      if (patterns.assertionPattern && !patterns.assertionPattern.test(assertion.description)) {
+        return;
+      }
 
-    console.log(description);
+      console.log(assertion.description);
 
-    const expected = assertion.expectedToMatch;
-    const actual = allConditionsAreMatched(conditions, assertion.context);
+      const expected = assertion.expectedToMatch;
+      const actual = allConditionsAreMatched(conditions, assertion.context);
 
-    if (actual !== expected) {
-      hasError = true;
+      if (actual !== expected) {
+        hasError = true;
 
-      console.error(CLI_FORMAT_RED, `    Segment failed: expected "${expected}", got "${actual}"`);
-    }
+        console.error(
+          CLI_FORMAT_RED,
+          `    Segment failed: expected "${expected}", got "${actual}"`,
+        );
+      }
+    });
   });
 
   return hasError;