@featurevisor/core 1.35.3 → 2.0.1

package/src/list/index.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   ParsedFeature,
   Segment,
   Attribute,
@@ -10,7 +10,7 @@ import {
 
 import { Dependencies } from "../dependencies";
 import { Plugin } from "../cli";
-import { getFeatureAssertionsFromMatrix, getSegmentAssertionsFromMatrix } from "../tester";
+import { getFeatureAssertionsFromMatrix, getSegmentAssertionsFromMatrix } from "./matrix";
 
 async function getEntitiesWithTests(
   deps: Dependencies,
@@ -39,7 +39,7 @@ async function getEntitiesWithTests(
   };
 }
 
-async function listEntities<T>(deps: Dependencies, entityType): Promise<T[]> {
+export async function listEntities<T>(deps: Dependencies, entityType): Promise<T[]> {
   const { datasource, options } = deps;
 
   const result: T[] = [];
@@ -111,16 +111,10 @@ async function listEntities<T>(deps: Dependencies, entityType): Promise<T[]> {
       }
 
       // --disabledIn=<environment>
-      if (
-        options.disabledIn &&
-        parsedFeature.environments &&
-        parsedFeature.environments[options.disabledIn]
-      ) {
-        const disabledInEnvironment = parsedFeature.environments[options.disabledIn].rules.every(
-          (rule) => {
-            return rule.percentage === 0;
-          },
-        );
+      if (options.disabledIn && parsedFeature.rules && parsedFeature.rules[options.disabledIn]) {
+        const disabledInEnvironment = parsedFeature.rules[options.disabledIn].every((rule) => {
+          return rule.percentage === 0;
+        });
 
         if (!disabledInEnvironment) {
           continue;
@@ -128,16 +122,10 @@ async function listEntities<T>(deps: Dependencies, entityType): Promise<T[]> {
       }
 
       // --enabledIn=<environment>
-      if (
-        options.enabledIn &&
-        parsedFeature.environments &&
-        parsedFeature.environments[options.enabledIn]
-      ) {
-        const enabledInEnvironment = parsedFeature.environments[options.enabledIn].rules.some(
-          (rule) => {
-            return rule.percentage > 0;
-          },
-        );
+      if (options.enabledIn && parsedFeature.rules && parsedFeature.rules[options.enabledIn]) {
+        const enabledInEnvironment = parsedFeature.rules[options.enabledIn].some((rule) => {
+          return rule.percentage > 0;
+        });
 
         if (!enabledInEnvironment) {
           continue;
@@ -168,12 +156,7 @@ async function listEntities<T>(deps: Dependencies, entityType): Promise<T[]> {
           ? options.variable
           : [options.variable];
 
-        let variablesInFeature: string[] = [];
-        if (Array.isArray(parsedFeature.variablesSchema)) {
-          variablesInFeature = parsedFeature.variablesSchema.map((variable) => variable.key);
-        } else if (parsedFeature.variablesSchema) {
-          variablesInFeature = Object.keys(parsedFeature.variablesSchema);
-        }
+        let variablesInFeature: string[] = Object.keys(parsedFeature.variablesSchema || {});
 
         const hasVariables = lookForVariables.every((variable) =>
           variablesInFeature.includes(variable),
@@ -338,6 +321,11 @@ async function listEntities<T>(deps: Dependencies, entityType): Promise<T[]> {
       const testEntityType = (test as TestSegment).segment ? "segment" : "feature";
       let testAssertions = test.assertions;
 
+      // --entityType=<type>
+      if (options.entityType && options.entityType !== testEntityType) {
+        continue;
+      }
+
       // --apply-matrix
       if (options.applyMatrix) {
         if (testEntityType === "feature") {
@@ -428,7 +416,7 @@ function printResult({ result, entityType, options }) {
 }
 
 export async function listProject(deps: Dependencies) {
-  const { rootDirectoryPath, projectConfig, datasource, options } = deps;
+  const { options } = deps;
 
   // features
   if (options.features) {

package/src/{tester → list}/matrix.ts

@@ -1,4 +1,4 @@
-import { AssertionMatrix, FeatureAssertion, SegmentAssertion } from "@featurevisor/types";
+import type { AssertionMatrix, FeatureAssertion, SegmentAssertion } from "@featurevisor/types";
 
 function generateCombinations(
   keys: string[],
@@ -73,8 +73,8 @@ export function applyCombinationToFeatureAssertion(
   );
 
   // context
-  flattenedAssertion.context = Object.keys(flattenedAssertion.context).reduce((acc, key) => {
-    acc[key] = applyCombinationToValue(flattenedAssertion.context[key], combination);
+  flattenedAssertion.context = Object.keys(flattenedAssertion.context || {}).reduce((acc, key) => {
+    acc[key] = applyCombinationToValue(flattenedAssertion.context?.[key], combination);
 
     return acc;
   }, {});
@@ -105,9 +105,20 @@ export function getFeatureAssertionsFromMatrix(
 ): FeatureAssertion[] {
   if (!assertionWithMatrix.matrix) {
     const assertion = { ...assertionWithMatrix };
-    assertion.description = `Assertion #${aIndex + 1}:${assertion.environment ? ` (${assertion.environment})` : ""} ${
-      assertion.description || `at ${assertion.at}%`
-    }`;
+
+    let suffix;
+
+    if (assertion.environment) {
+      suffix = ` (${assertion.environment})`;
+    }
+
+    if (assertion.description) {
+      suffix = `: ${assertion.description}`;
+    } else {
+      suffix = `: at ${assertion.at}%`;
+    }
+
+    assertion.description = `Assertion #${aIndex + 1}${suffix}`;
 
     return [assertion];
   }
@@ -118,9 +129,20 @@ export function getFeatureAssertionsFromMatrix(
   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.environment})` : ""} ${
-      assertion.description || `at ${assertion.at}%`
-    }`;
+
+    let suffix;
+
+    if (assertion.environment) {
+      suffix = ` (${assertion.environment})`;
+    }
+
+    if (assertion.description) {
+      suffix = `: ${assertion.description}`;
+    } else {
+      suffix = `: at ${assertion.at}%`;
+    }
+
+    assertion.description = `Assertion #${aIndex + 1}${suffix}`;
 
     assertions.push(assertion);
   }
@@ -161,8 +183,8 @@ export function getSegmentAssertionsFromMatrix(
 ): SegmentAssertion[] {
   if (!assertionWithMatrix.matrix) {
     const assertion = { ...assertionWithMatrix };
-    assertion.description = `Assertion #${aIndex + 1}: ${
-      assertion.description || `#${aIndex + 1}`
+    assertion.description = `Assertion #${aIndex + 1}${
+      assertion.description ? `: ${assertion.description}` : ""
     }`;
 
     return [assertion];

package/src/site/exportSite.ts

@@ -1,8 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
 
-import * as mkdirp from "mkdirp";
-
 import { generateHistory } from "./generateHistory";
 import { getRepoDetails } from "./getRepoDetails";
 import { generateSiteSearchIndex } from "./generateSiteSearchIndex";
@@ -13,7 +11,7 @@ export async function exportSite(deps: Dependencies) {
 
   const hasError = false;
 
-  mkdirp.sync(projectConfig.siteExportDirectoryPath);
+  fs.mkdirSync(projectConfig.siteExportDirectoryPath, { recursive: true });
 
   const sitePackagePath = path.dirname(require.resolve("@featurevisor/site/package.json"));
 
@@ -35,7 +33,7 @@ export async function exportSite(deps: Dependencies) {
 
   // copy datafiles
   fs.cpSync(
-    projectConfig.outputDirectoryPath,
+    projectConfig.datafilesDirectoryPath,
     path.join(projectConfig.siteExportDirectoryPath, "datafiles"),
     { recursive: true },
   );

package/src/site/generateHistory.ts

@@ -1,7 +1,7 @@
 import * as path from "path";
 import * as fs from "fs";
 
-import { HistoryEntry } from "@featurevisor/types";
+import type { HistoryEntry } from "@featurevisor/types";
 import { Dependencies } from "../dependencies";
 
 export async function generateHistory(deps: Dependencies): Promise<HistoryEntry[]> {

package/src/site/generateSiteSearchIndex.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   HistoryEntry,
   SearchIndex,
   AttributeKey,
@@ -87,13 +87,15 @@ export async function generateSiteSearchIndex(
 
     if (Array.isArray(parsed.variations)) {
       parsed.variations.forEach((variation) => {
-        if (!variation.variables) {
+        if (!variation.variableOverrides) {
           return;
         }
 
-        variation.variables.forEach((v) => {
-          if (v.overrides) {
-            v.overrides.forEach((o) => {
+        Object.keys(variation.variableOverrides).forEach((variableKey) => {
+          const overrides = variation.variableOverrides?.[variableKey];
+
+          if (overrides) {
+            overrides.forEach((o) => {
               if (o.conditions) {
                 extractAttributeKeysFromConditions(o.conditions).forEach((attributeKey) => {
                   if (!attributesUsedInFeatures[attributeKey]) {
@@ -119,12 +121,28 @@ export async function generateSiteSearchIndex(
       });
     }
 
-    // with environments
-    if (parsed.environments) {
-      Object.keys(parsed.environments).forEach((environmentKey) => {
-        const env = parsed.environments[environmentKey];
+    // rules
+    if (parsed.rules) {
+      if (!Array.isArray(parsed.rules)) {
+        // with environments
+        Object.keys(parsed.rules).forEach((environmentKey) => {
+          const rules = parsed.rules?.[environmentKey];
+
+          rules.forEach((rule) => {
+            if (rule.segments && rule.segments !== "*") {
+              extractSegmentKeysFromGroupSegments(rule.segments).forEach((segmentKey) => {
+                if (!segmentsUsedInFeatures[segmentKey]) {
+                  segmentsUsedInFeatures[segmentKey] = new Set();
+                }
 
-        env.rules.forEach((rule) => {
+                segmentsUsedInFeatures[segmentKey].add(entityName);
+              });
+            }
+          });
+        });
+      } else {
+        // no environments
+        parsed.rules.forEach((rule) => {
           if (rule.segments && rule.segments !== "*") {
             extractSegmentKeysFromGroupSegments(rule.segments).forEach((segmentKey) => {
               if (!segmentsUsedInFeatures[segmentKey]) {
@@ -135,9 +153,15 @@ export async function generateSiteSearchIndex(
             });
           }
         });
+      }
+    }
 
-        if (env.force) {
-          env.force.forEach((force) => {
+    // force
+    if (parsed.force) {
+      if (!Array.isArray(parsed.force)) {
+        // with environments
+        Object.keys(parsed.force).forEach((environmentKey) => {
+          parsed.force?.[environmentKey].forEach((force) => {
             if (force.segments && force.segments !== "*") {
               extractSegmentKeysFromGroupSegments(force.segments).forEach((segmentKey) => {
                 if (!segmentsUsedInFeatures[segmentKey]) {
@@ -158,47 +182,31 @@ export async function generateSiteSearchIndex(
               });
             }
           });
-        }
-      });
-    }
-
-    // no environments
-    if (parsed.rules) {
-      parsed.rules.forEach((rule) => {
-        if (rule.segments && rule.segments !== "*") {
-          extractSegmentKeysFromGroupSegments(rule.segments).forEach((segmentKey) => {
-            if (!segmentsUsedInFeatures[segmentKey]) {
-              segmentsUsedInFeatures[segmentKey] = new Set();
-            }
-
-            segmentsUsedInFeatures[segmentKey].add(entityName);
-          });
-        }
-      });
-    }
-
-    if (parsed.force) {
-      parsed.force.forEach((force) => {
-        if (force.segments && force.segments !== "*") {
-          extractSegmentKeysFromGroupSegments(force.segments).forEach((segmentKey) => {
-            if (!segmentsUsedInFeatures[segmentKey]) {
-              segmentsUsedInFeatures[segmentKey] = new Set();
-            }
+        });
+      } else {
+        // no environments
+        parsed.force.forEach((force) => {
+          if (force.segments && force.segments !== "*") {
+            extractSegmentKeysFromGroupSegments(force.segments).forEach((segmentKey) => {
+              if (!segmentsUsedInFeatures[segmentKey]) {
+                segmentsUsedInFeatures[segmentKey] = new Set();
+              }
 
-            segmentsUsedInFeatures[segmentKey].add(entityName);
-          });
-        }
+              segmentsUsedInFeatures[segmentKey].add(entityName);
+            });
+          }
 
-        if (force.conditions) {
-          extractAttributeKeysFromConditions(force.conditions).forEach((attributeKey) => {
-            if (!attributesUsedInFeatures[attributeKey]) {
-              attributesUsedInFeatures[attributeKey] = new Set();
-            }
+          if (force.conditions) {
+            extractAttributeKeysFromConditions(force.conditions).forEach((attributeKey) => {
+              if (!attributesUsedInFeatures[attributeKey]) {
+                attributesUsedInFeatures[attributeKey] = new Set();
+              }
 
-            attributesUsedInFeatures[attributeKey].add(entityName);
-          });
-        }
-      });
+              attributesUsedInFeatures[attributeKey].add(entityName);
+            });
+          }
+        });
+      }
     }
 
     // push

package/src/site/getLastModifiedFromHistory.ts

@@ -1,4 +1,4 @@
-import { HistoryEntry, LastModified } from "@featurevisor/types";
+import type { HistoryEntry, LastModified } from "@featurevisor/types";
 
 export function getLastModifiedFromHistory(
   fullHistory: HistoryEntry[],

package/src/tester/helpers.spec.ts

@@ -0,0 +1,149 @@
+import { checkIfObjectsAreEqual, checkIfArraysAreEqual } from "./helpers";
+
+describe("helpers", function () {
+  describe("checkIfObjectsAreEqual", function () {
+    it("should return true for two empty objects", () => {
+      expect(checkIfObjectsAreEqual({}, {})).toBe(true);
+    });
+
+    it("should return true for objects with same keys and values", () => {
+      expect(checkIfObjectsAreEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true);
+    });
+
+    it("should return false for objects with different keys", () => {
+      expect(checkIfObjectsAreEqual({ a: 1 }, { b: 1 })).toBe(false);
+    });
+
+    it("should return false for objects with same keys but different values", () => {
+      expect(checkIfObjectsAreEqual({ a: 1 }, { a: 2 })).toBe(false);
+    });
+
+    it("should return false if one object has extra keys", () => {
+      expect(checkIfObjectsAreEqual({ a: 1, b: 2 }, { a: 1 })).toBe(false);
+      expect(checkIfObjectsAreEqual({ a: 1 }, { a: 1, b: 2 })).toBe(false);
+    });
+
+    it("should return true for nested objects that are deeply equal", () => {
+      expect(checkIfObjectsAreEqual({ a: { b: 2 }, c: 3 }, { a: { b: 2 }, c: 3 })).toBe(true);
+    });
+
+    it("should return false for nested objects that are not deeply equal", () => {
+      expect(checkIfObjectsAreEqual({ a: { b: 2 }, c: 3 }, { a: { b: 3 }, c: 3 })).toBe(false);
+    });
+
+    // it("should return false if types differ", () => {
+    //   expect(checkIfObjectsAreEqual({ a: 1 }, null as any)).toBe(false);
+    //   expect(checkIfObjectsAreEqual(null as any, { a: 1 })).toBe(false);
+    //   expect(checkIfObjectsAreEqual([], {})).toBe(false);
+    // });
+
+    it("should return true for objects with array values that are equal", () => {
+      expect(checkIfObjectsAreEqual({ a: [1, 2, 3] }, { a: [1, 2, 3] })).toBe(true);
+    });
+
+    it("should return false for objects with array values that are not equal", () => {
+      expect(checkIfObjectsAreEqual({ a: [1, 2, 3] }, { a: [1, 2, 4] })).toBe(false);
+    });
+
+    it("should return true for objects with different key order", () => {
+      expect(checkIfObjectsAreEqual({ a: 1, b: 2 }, { b: 2, a: 1 })).toBe(true);
+    });
+
+    it("should return true for objects with undefined values if both have them", () => {
+      expect(checkIfObjectsAreEqual({ a: undefined }, { a: undefined })).toBe(true);
+    });
+
+    it("should return false for objects with one undefined and one missing key", () => {
+      expect(checkIfObjectsAreEqual({ a: undefined }, {})).toBe(false);
+    });
+  });
+
+  describe("checkIfArraysAreEqual", function () {
+    it("should return true for two empty arrays", () => {
+      expect(checkIfArraysAreEqual([], [])).toBe(true);
+    });
+
+    it("should return true for arrays with same elements in same order", () => {
+      expect(checkIfArraysAreEqual([1, 2, 3], [1, 2, 3])).toBe(true);
+    });
+
+    it("should return false for arrays with same elements in different order", () => {
+      expect(checkIfArraysAreEqual([1, 2, 3], [3, 2, 1])).toBe(false);
+    });
+
+    it("should return false for arrays of different lengths", () => {
+      expect(checkIfArraysAreEqual([1, 2], [1, 2, 3])).toBe(false);
+      expect(checkIfArraysAreEqual([1, 2, 3], [1, 2])).toBe(false);
+    });
+
+    it("should return false for arrays with different elements", () => {
+      expect(checkIfArraysAreEqual([1, 2, 3], [1, 2, 4])).toBe(false);
+    });
+
+    it("should return true for nested arrays that are deeply equal", () => {
+      expect(checkIfArraysAreEqual([[1, 2], [3]], [[1, 2], [3]])).toBe(true);
+    });
+
+    it("should return false for nested arrays that are not deeply equal", () => {
+      expect(checkIfArraysAreEqual([[1, 2], [3]], [[1, 2], [4]])).toBe(false);
+    });
+
+    it("should return true for arrays with objects that are deeply equal", () => {
+      expect(checkIfArraysAreEqual([{ a: 1 }, { b: 2 }], [{ a: 1 }, { b: 2 }])).toBe(true);
+    });
+
+    it("should return false for arrays with objects that are not deeply equal", () => {
+      expect(checkIfArraysAreEqual([{ a: 1 }, { b: 2 }], [{ a: 1 }, { b: 3 }])).toBe(false);
+    });
+
+    it("should return false if types differ", () => {
+      expect(checkIfArraysAreEqual([1, 2, 3], null as any)).toBe(false);
+      expect(checkIfArraysAreEqual(null as any, [1, 2, 3])).toBe(false);
+      expect(checkIfArraysAreEqual({} as any, [])).toBe(false);
+    });
+
+    it("should return true for arrays with undefined values if both have them in same positions", () => {
+      expect(checkIfArraysAreEqual([1, undefined, 3], [1, undefined, 3])).toBe(true);
+    });
+
+    it("should return false for arrays with undefined values in different positions", () => {
+      expect(checkIfArraysAreEqual([1, undefined, 3], [1, 3, undefined])).toBe(false);
+    });
+
+    it("should return true for arrays with different reference but same primitive values", () => {
+      expect(checkIfArraysAreEqual([1, 2, 3], [1, 2, 3])).toBe(true);
+    });
+
+    it("should return true for arrays with nested objects and arrays that are deeply equal", () => {
+      expect(
+        checkIfArraysAreEqual([{ a: [1, 2], b: { c: 3 } }], [{ a: [1, 2], b: { c: 3 } }]),
+      ).toBe(true);
+    });
+
+    it("should return false for arrays with nested objects and arrays that are not deeply equal", () => {
+      expect(
+        checkIfArraysAreEqual([{ a: [1, 2], b: { c: 3 } }], [{ a: [1, 2], b: { c: 4 } }]),
+      ).toBe(false);
+    });
+
+    it("should return false for arrays with extra undefined at the end", () => {
+      expect(checkIfArraysAreEqual([1, 2], [1, 2, undefined])).toBe(false);
+    });
+
+    // it("should return true for arrays with NaN values in same positions", () => {
+    //   expect(checkIfArraysAreEqual([NaN, 2], [NaN, 2])).toBe(true);
+    // });
+
+    // it("should return false for arrays with NaN values in different positions", () => {
+    //   expect(checkIfArraysAreEqual([2, NaN], [NaN, 2])).toBe(false);
+    // });
+
+    it("should return true for arrays with null values in same positions", () => {
+      expect(checkIfArraysAreEqual([null, 2], [null, 2])).toBe(true);
+    });
+
+    it("should return false for arrays with null values in different positions", () => {
+      expect(checkIfArraysAreEqual([2, null], [null, 2])).toBe(false);
+    });
+  });
+});

package/src/tester/helpers.ts

@@ -0,0 +1,76 @@
+export function checkIfObjectsAreEqual(obj1: any, obj2: any): boolean {
+  if (obj1 === obj2) {
+    return true;
+  }
+
+  if (typeof obj1 !== "object" || obj1 === null || typeof obj2 !== "object" || obj2 === null) {
+    return false;
+  }
+
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+
+  for (const key of keys1) {
+    if (!keys2.includes(key)) {
+      return false;
+    }
+
+    const val1 = obj1[key];
+    const val2 = obj2[key];
+
+    if (Array.isArray(val1) && Array.isArray(val2)) {
+      if (!checkIfArraysAreEqual(val1, val2)) {
+        return false;
+      }
+    } else if (typeof val1 === "object" && typeof val2 === "object") {
+      if (!checkIfObjectsAreEqual(val1, val2)) {
+        return false;
+      }
+    } else if (val1 !== val2) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export function checkIfArraysAreEqual(arr1: any[], arr2: any[]): boolean {
+  if (arr1 === arr2) {
+    return true;
+  }
+
+  if (!Array.isArray(arr1) || !Array.isArray(arr2)) {
+    return false;
+  }
+
+  if (arr1.length !== arr2.length) {
+    return false;
+  }
+
+  for (let i = 0; i < arr1.length; i++) {
+    const val1 = arr1[i];
+    const val2 = arr2[i];
+
+    if (Array.isArray(val1) && Array.isArray(val2)) {
+      if (!checkIfArraysAreEqual(val1, val2)) {
+        return false;
+      }
+    } else if (
+      typeof val1 === "object" &&
+      typeof val2 === "object" &&
+      val1 !== null &&
+      val2 !== null
+    ) {
+      if (!checkIfObjectsAreEqual(val1, val2)) {
+        return false;
+      }
+    } else if (val1 !== val2) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/tester/index.ts

@@ -1,3 +1,2 @@
 export * from "./testProject";
 export * from "./testFeature";
-export * from "./matrix";

package/src/tester/printTestResult.ts

@@ -1,4 +1,4 @@
-import { TestResult } from "@featurevisor/types";
+import type { TestResult } from "@featurevisor/types";
 
 import { CLI_FORMAT_BOLD, CLI_FORMAT_RED } from "./cliFormat";
 import { prettyDuration } from "./prettyDuration";
@@ -35,16 +35,38 @@ export function printTestResult(testResult: TestResult, relativeTestFilePath, ro
           return;
         }
 
+        let section: string = error.type;
+
+        if (error.type === "flag") {
+          section = "expectedToBeEnabled";
+        } else if (error.type === "variation") {
+          section = "expectedVariation";
+        } else if (error.type === "variable") {
+          section = "expectedVariables";
+        }
+
+        if (error.details && error.details.childIndex !== undefined) {
+          section = `children[${error.details.childIndex}].${section}`;
+        }
+
         if (error.type === "variable") {
           const variableKey = (error.details as any).variableKey;
 
-          console.log(CLI_FORMAT_RED, `    => variable key: ${variableKey}`);
+          console.log(CLI_FORMAT_RED, `    => ${section}.${variableKey}:`);
           console.log(CLI_FORMAT_RED, `       => expected: ${error.expected}`);
           console.log(CLI_FORMAT_RED, `       => received: ${error.actual}`);
         } else {
+          if (error.type === "evaluation") {
+            if (error.details && error.details.variableKey) {
+              section = `${section}.variables.${error.details.variableKey}.${error.details.evaluationKey}`;
+            } else if (error.details && error.details.evaluationType) {
+              section = `${section}.${error.details.evaluationType}.${error.details.evaluationKey}`;
+            }
+          }
+
           console.log(
             CLI_FORMAT_RED,
-            `    => ${error.type}: expected "${error.expected}", received "${error.actual}"`,
+            `    => ${section}: expected "${error.expected}", received "${error.actual}"`,
           );
         }
       });