@featurevisor/core 1.2.1 → 1.2.2

package/src/tester/testProject.ts

@@ -6,6 +6,8 @@ import { testSegment } from "./testSegment";
 import { testFeature } from "./testFeature";
 import { CLI_FORMAT_BOLD, CLI_FORMAT_GREEN, CLI_FORMAT_RED } from "./cliFormat";
 import { Dependencies } from "../dependencies";
+import { prettyDuration } from "./prettyDuration";
+import { printTestResult } from "./printTestResult";
 
 export interface TestProjectOptions {
   keyPattern?: string;
@@ -38,11 +40,19 @@ export async function testProject(
     return hasError;
   }
 
+  const startTime = Date.now();
+
   const patterns = {
     keyPattern: options.keyPattern ? new RegExp(options.keyPattern) : undefined,
     assertionPattern: options.assertionPattern ? new RegExp(options.assertionPattern) : undefined,
   };
 
+  let passedTestsCount = 0;
+  let failedTestsCount = 0;
+
+  let passedAssertionsCount = 0;
+  let failedAssertionsCount = 0;
+
   for (const testFile of testFiles) {
     const testFilePath = datasource.getTestSpecName(testFile);
 
@@ -56,12 +66,19 @@ export async function testProject(
         continue;
       }
 
-      console.log(CLI_FORMAT_BOLD, `\nTesting: ${testFilePath.replace(rootDirectoryPath, "")}`);
+      const testResult = await testSegment(datasource, test, patterns);
+      printTestResult(testResult, testFilePath, rootDirectoryPath);
 
-      const segmentHasError = await testSegment(datasource, test, patterns);
-
-      if (segmentHasError) {
+      if (!testResult.passed) {
         hasError = true;
+        failedTestsCount++;
+
+        failedAssertionsCount += testResult.assertions.filter((a) => !a.passed).length;
+        passedAssertionsCount += testResult.assertions.length - failedAssertionsCount;
+      } else {
+        passedTestsCount++;
+
+        passedAssertionsCount += testResult.assertions.length;
       }
     } else if ((t as TestFeature).feature) {
       // feature testing
@@ -71,12 +88,19 @@ export async function testProject(
         continue;
       }
 
-      console.log(CLI_FORMAT_BOLD, `\nTesting: ${testFilePath.replace(rootDirectoryPath, "")}`);
+      const testResult = await testFeature(datasource, projectConfig, test, options, patterns);
+      printTestResult(testResult, testFilePath, rootDirectoryPath);
 
-      const featureHasError = await testFeature(datasource, projectConfig, test, options, patterns);
-
-      if (featureHasError) {
+      if (!testResult.passed) {
         hasError = true;
+        failedTestsCount++;
+
+        failedAssertionsCount += testResult.assertions.filter((a) => !a.passed).length;
+        passedAssertionsCount += testResult.assertions.length - failedAssertionsCount;
+      } else {
+        passedTestsCount++;
+
+        passedAssertionsCount += testResult.assertions.length;
       }
     } else {
       console.error(`  => Invalid test: ${JSON.stringify(test)}`);
@@ -84,13 +108,21 @@ export async function testProject(
     }
   }
 
-  console.log("");
+  const diffInMs = Date.now() - startTime;
+
+  console.log("\n---\n");
+
+  const testSpecsMessage = `Test specs: ${passedTestsCount} passed, ${failedTestsCount} failed`;
+  const testAssertionsMessage = `Assertions: ${passedAssertionsCount} passed, ${failedAssertionsCount} failed`;
   if (hasError) {
-    console.log(CLI_FORMAT_RED, `Some tests failed`);
+    console.log(CLI_FORMAT_RED, testSpecsMessage);
+    console.log(CLI_FORMAT_RED, testAssertionsMessage);
   } else {
-    console.log(CLI_FORMAT_GREEN, `All tests passed`);
+    console.log(CLI_FORMAT_GREEN, testSpecsMessage);
+    console.log(CLI_FORMAT_GREEN, testAssertionsMessage);
   }
-  console.log("");
+
+  console.log(CLI_FORMAT_BOLD, `Time:       ${prettyDuration(diffInMs)}`);
 
   return hasError;
 }

package/src/tester/testSegment.ts

@@ -1,29 +1,42 @@
-import { TestSegment, Condition } from "@featurevisor/types";
+import {
+  TestSegment,
+  Condition,
+  TestResult,
+  TestResultAssertion,
+  TestResultAssertionError,
+} from "@featurevisor/types";
 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,
   test: TestSegment,
   patterns,
-): Promise<boolean> {
-  let hasError = false;
-
+): Promise<TestResult> {
+  const testStartTime = Date.now();
   const segmentKey = test.segment;
 
-  console.log(CLI_FORMAT_BOLD, `  Segment "${segmentKey}":`);
+  const testResult: TestResult = {
+    type: "segment",
+    key: segmentKey,
+
+    // to be updated later
+    notFound: false,
+    duration: 0,
+    passed: true,
+    assertions: [],
+  };
 
   const segmentExists = await datasource.segmentExists(segmentKey);
 
   if (!segmentExists) {
-    console.error(CLI_FORMAT_RED, `  Segment does not exist: ${segmentKey}`);
-    hasError = true;
+    testResult.notFound = true;
+    testResult.passed = false;
 
-    return hasError;
+    return testResult;
   }
 
   const parsedSegment = await datasource.readSegment(segmentKey);
@@ -33,25 +46,40 @@ export async function testSegment(
     const assertions = getSegmentAssertionsFromMatrix(aIndex, assertion);
 
     assertions.forEach(function (assertion) {
+      const assertionStartTime = Date.now();
+      const testResultAssertion: TestResultAssertion = {
+        description: assertion.description as string,
+        duration: 0,
+        passed: true,
+        errors: [],
+      };
+
       if (patterns.assertionPattern && !patterns.assertionPattern.test(assertion.description)) {
         return;
       }
 
-      console.log(assertion.description);
-
       const expected = assertion.expectedToMatch;
       const actual = allConditionsAreMatched(conditions, assertion.context);
-
-      if (actual !== expected) {
-        hasError = true;
-
-        console.error(
-          CLI_FORMAT_RED,
-          `    Segment failed: expected "${expected}", got "${actual}"`,
-        );
+      const passed = actual === expected;
+
+      if (!passed) {
+        const testResultAssertionError: TestResultAssertionError = {
+          type: "segment",
+          expected,
+          actual,
+        };
+
+        (testResultAssertion.errors as TestResultAssertionError[]).push(testResultAssertionError);
+        testResult.passed = false;
+        testResultAssertion.passed = passed;
       }
+
+      testResult.assertions.push(testResultAssertion);
+      testResultAssertion.duration = Date.now() - assertionStartTime;
     });
   });
 
-  return hasError;
+  testResult.duration = Date.now() - testStartTime;
+
+  return testResult;
 }