@featurevisor/core 0.53.1 → 0.53.3

package/src/tester/testFeature.ts

@@ -10,25 +10,28 @@ import { SCHEMA_VERSION } from "../config";
 
 import { checkIfArraysAreEqual } from "./checkIfArraysAreEqual";
 import { checkIfObjectsAreEqual } from "./checkIfObjectsAreEqual";
+import { CLI_FORMAT_BOLD, CLI_FORMAT_RED } from "./cliFormat";
 
-export function testFeature(
+export async function testFeature(
   datasource: Datasource,
   projectConfig: ProjectConfig,
   test: TestFeature,
-): boolean {
+): Promise<boolean> {
   let hasError = false;
   const featureKey = test.feature;
 
-  console.log(`     => Feature "${featureKey}":`);
+  console.log(CLI_FORMAT_BOLD, `  Feature "${featureKey}":`);
 
-  test.assertions.forEach(function (assertion, aIndex) {
+  for (let aIndex = 0; aIndex < test.assertions.length; aIndex++) {
+    const assertion = test.assertions[aIndex];
     const description = assertion.description || `at ${assertion.at}%`;
 
-    console.log(`        => Assertion #${aIndex + 1}: (${assertion.environment}) ${description}`);
+    console.log(`  Assertion #${aIndex + 1}: (${assertion.environment}) ${description}`);
 
-    const featuresToInclude = Array.from(datasource.getRequiredFeaturesChain(test.feature));
+    const requiredChain = await datasource.getRequiredFeaturesChain(test.feature);
+    const featuresToInclude = Array.from(requiredChain);
 
-    const datafileContent = buildDatafile(
+    const datafileContent = await buildDatafile(
       projectConfig,
       datasource,
       {
@@ -60,7 +63,8 @@ export function testFeature(
         hasError = true;
 
         console.error(
-          `           isEnabled failed: expected "${assertion.expectedToBeEnabled}", got "${isEnabled}"`,
+          CLI_FORMAT_RED,
+          `    isEnabled failed: expected "${assertion.expectedToBeEnabled}", got "${isEnabled}"`,
         );
       }
     }
@@ -73,7 +77,8 @@ export function testFeature(
         hasError = true;
 
         console.error(
-          `           Variation failed: expected "${assertion.expectedVariation}", got "${variation}"`,
+          CLI_FORMAT_RED,
+          `    Variation failed: expected "${assertion.expectedVariation}", got "${variation}"`,
         );
       }
     }
@@ -99,14 +104,15 @@ export function testFeature(
           hasError = true;
 
           console.error(
-            `           Variable "${variableKey}" failed: expected ${JSON.stringify(
+            CLI_FORMAT_RED,
+            `    Variable "${variableKey}" failed: expected ${JSON.stringify(
               expectedValue,
             )}, got "${JSON.stringify(actualValue)}"`,
           );
         }
       });
     }
-  });
+  }
 
   return hasError;
 }

package/src/tester/testProject.ts

@@ -7,8 +7,12 @@ import { Datasource } from "../datasource";
 
 import { testSegment } from "./testSegment";
 import { testFeature } from "./testFeature";
+import { CLI_FORMAT_BOLD, CLI_FORMAT_GREEN, CLI_FORMAT_RED } from "./cliFormat";
 
-export function testProject(rootDirectoryPath: string, projectConfig: ProjectConfig): boolean {
+export async function testProject(
+  rootDirectoryPath: string,
+  projectConfig: ProjectConfig,
+): Promise<boolean> {
   let hasError = false;
   const datasource = new Datasource(projectConfig);
 
@@ -19,7 +23,7 @@ export function testProject(rootDirectoryPath: string, projectConfig: ProjectCon
     return hasError;
   }
 
-  const testFiles = datasource.listTests();
+  const testFiles = await datasource.listTests();
 
   if (testFiles.length === 0) {
     console.error(`No tests found in: ${projectConfig.testsDirectoryPath}`);
@@ -31,15 +35,16 @@ export function testProject(rootDirectoryPath: string, projectConfig: ProjectCon
   for (const testFile of testFiles) {
     const testFilePath = datasource.getEntityPath("test", testFile);
 
-    console.log(`  => Testing: ${testFilePath.replace(rootDirectoryPath, "")}`);
+    console.log("");
+    console.log(CLI_FORMAT_BOLD, `Testing: ${testFilePath.replace(rootDirectoryPath, "")}`);
 
-    const t = datasource.readTest(testFile);
+    const t = await datasource.readTest(testFile);
 
     if ((t as TestSegment).segment) {
       // segment testing
       const test = t as TestSegment;
 
-      const segmentHasError = testSegment(datasource, test);
+      const segmentHasError = await testSegment(datasource, test);
 
       if (segmentHasError) {
         hasError = true;
@@ -48,16 +53,24 @@ export function testProject(rootDirectoryPath: string, projectConfig: ProjectCon
       // feature testing
       const test = t as TestFeature;
 
-      const featureHasError = testFeature(datasource, projectConfig, test);
+      const featureHasError = await testFeature(datasource, projectConfig, test);
 
       if (featureHasError) {
         hasError = true;
       }
     } else {
-      console.error(`     => Invalid test: ${JSON.stringify(test)}`);
+      console.error(`  => Invalid test: ${JSON.stringify(test)}`);
       hasError = true;
     }
   }
 
+  console.log("");
+  if (hasError) {
+    console.log(CLI_FORMAT_RED, `Some tests failed`);
+  } else {
+    console.log(CLI_FORMAT_GREEN, `All tests passed`);
+  }
+  console.log("");
+
   return hasError;
 }

package/src/tester/testSegment.ts

@@ -3,29 +3,31 @@ import { allConditionsAreMatched } from "@featurevisor/sdk";
 
 import { Datasource } from "../datasource";
 
-export function testSegment(datasource: Datasource, test: TestSegment): boolean {
+import { CLI_FORMAT_BOLD, CLI_FORMAT_RED } from "./cliFormat";
+
+export async function testSegment(datasource: Datasource, test: TestSegment): Promise<boolean> {
   let hasError = false;
 
   const segmentKey = test.segment;
 
-  console.log(`     => Segment "${segmentKey}":`);
+  console.log(CLI_FORMAT_BOLD, `  Segment "${segmentKey}":`);
 
-  const segmentExists = datasource.entityExists("segment", segmentKey);
+  const segmentExists = await datasource.entityExists("segment", segmentKey);
 
   if (!segmentExists) {
-    console.error(`        => Segment does not exist: ${segmentKey}`);
+    console.error(CLI_FORMAT_RED, `  Segment does not exist: ${segmentKey}`);
     hasError = true;
 
     return hasError;
   }
 
-  const parsedSegment = datasource.readSegment(segmentKey);
+  const parsedSegment = await datasource.readSegment(segmentKey);
   const conditions = parsedSegment.conditions as Condition | Condition[];
 
   test.assertions.forEach(function (assertion, aIndex) {
     const description = assertion.description || `#${aIndex + 1}`;
 
-    console.log(`        => Assertion #${aIndex + 1}: ${description}`);
+    console.log(`  Assertion #${aIndex + 1}: ${description}`);
 
     const expected = assertion.expectedToMatch;
     const actual = allConditionsAreMatched(conditions, assertion.context);
@@ -33,7 +35,7 @@ export function testSegment(datasource: Datasource, test: TestSegment): boolean
     if (actual !== expected) {
       hasError = true;
 
-      console.error(`           Segment failed: expected "${expected}", got "${actual}"`);
+      console.error(CLI_FORMAT_RED, `    Segment failed: expected "${expected}", got "${actual}"`);
     }
   });