@eventvisor/core 0.0.2

package/src/tester/executeTest.ts

@@ -0,0 +1,436 @@
+import type { DatafileContent, Test, Value } from "@eventvisor/types";
+
+import type { TestProjectOptions } from "./testProject";
+import type { Dependencies } from "../dependencies";
+import { createTestInstance } from "./createTestInstance";
+
+export interface TestAssertionResult {
+  passed: boolean;
+  description?: string;
+  errors?: string[];
+}
+
+export interface TestAssertionResult {
+  passed: boolean;
+  description?: string;
+  errors?: string[];
+}
+
+export interface TestResult {
+  passed: boolean;
+  assertions: TestAssertionResult[];
+}
+
+export interface ExecuteTestOptions {
+  deps: Dependencies;
+  datafileContent: DatafileContent;
+  test: Test;
+  cliOptions: TestProjectOptions;
+}
+
+export async function executeTest(options: ExecuteTestOptions) {
+  const { datafileContent, test, cliOptions } = options;
+
+  const testResult: TestResult = {
+    passed: true,
+    assertions: [],
+  };
+
+  let testPassed = true;
+
+  /**
+   * Attribute
+   */
+  if ("attribute" in test) {
+    // attribute test spec
+    const attributeName = test.attribute;
+    const assertions = test.assertions;
+
+    for (const assertion of assertions) {
+      // @TODO: apply matrix
+
+      if (
+        cliOptions.assertionPattern &&
+        !assertion.description?.includes(cliOptions.assertionPattern)
+      ) {
+        continue;
+      }
+
+      let assertionPassed = true;
+
+      const { e } = createTestInstance({
+        datafile: datafileContent,
+        cliOptions,
+        withLookups: assertion.withLookups,
+      });
+
+      if (assertion.setAttribute) {
+        await e.setAttributeAsync(attributeName, assertion.setAttribute);
+      }
+
+      const previouslySetAttribute = e.getAttributeValue(attributeName);
+      const isAttributeSet = e.isAttributeSet(attributeName);
+
+      const testAssertionResult: TestAssertionResult = {
+        passed: assertionPassed,
+        description: assertion.description,
+        errors: [],
+      };
+
+      // expectedToBeValid
+      if (typeof assertion.expectedToBeValid === "boolean") {
+        if (
+          (assertion.expectedToBeValid === true && !isAttributeSet) ||
+          (assertion.expectedToBeValid === false && isAttributeSet)
+        ) {
+          assertionPassed = false;
+          testAssertionResult.errors?.push(
+            `expectedToBeValid: expected ${assertion.expectedToBeValid}, received ${!assertion.expectedToBeValid}`,
+          );
+        }
+      }
+
+      // expectedToBeSet
+      if (typeof assertion.expectedToBeSet === "boolean") {
+        if (
+          (assertion.expectedToBeSet === true && !isAttributeSet) ||
+          (assertion.expectedToBeSet === false && isAttributeSet)
+        ) {
+          assertionPassed = false;
+          testAssertionResult.errors?.push(
+            `expectedToBeSet: expected ${assertion.expectedToBeSet}, received ${!assertion.expectedToBeSet}`,
+          );
+        }
+      }
+
+      if (assertion.expectedAttribute) {
+        if (!checkIfObjectsAreDeepEqual(previouslySetAttribute, assertion.expectedAttribute)) {
+          assertionPassed = false;
+          testAssertionResult.errors?.push(
+            `expectedAttribute: \n  expected: ${JSON.stringify(assertion.expectedAttribute)}\n  received: ${JSON.stringify(
+              previouslySetAttribute,
+            )}`,
+          );
+        }
+      }
+
+      testAssertionResult.passed = assertionPassed;
+
+      if (!assertionPassed) {
+        testPassed = false;
+      }
+
+      testResult.assertions.push(testAssertionResult);
+    }
+  }
+
+  /**
+   * Effect
+   */
+  if ("effect" in test) {
+    const effectName = test.effect;
+    const assertions = test.assertions;
+
+    for (const assertion of assertions) {
+      // @TODO: apply matrix
+
+      if (
+        cliOptions.assertionPattern &&
+        !assertion.description?.includes(cliOptions.assertionPattern)
+      ) {
+        continue;
+      }
+
+      let assertionPassed = true;
+
+      const { e, getCalledStepsBySingleEffect } = createTestInstance({
+        datafile: datafileContent,
+        cliOptions,
+        withLookups: assertion.withLookups,
+      });
+
+      await e.onReady();
+
+      if (assertion.actions) {
+        for (const action of assertion.actions) {
+          if (action.type === "track") {
+            await e.trackAsync(action.name, action.value);
+          } else if (action.type === "setAttribute") {
+            await e.setAttributeAsync(action.name, action.value);
+          }
+        }
+      }
+
+      const testAssertionResult: TestAssertionResult = {
+        passed: assertionPassed,
+        description: assertion.description,
+        errors: [],
+      };
+
+      // expectedState
+      if (assertion.expectedState) {
+        const latestState = e.getStateValue(effectName);
+
+        if (!checkIfObjectsAreDeepEqual(latestState, assertion.expectedState)) {
+          assertionPassed = false;
+          testAssertionResult.errors?.push(
+            `expectedState: \n  expected: ${JSON.stringify(assertion.expectedState)}\n  received: ${JSON.stringify(latestState)}`,
+          );
+        }
+      }
+
+      // expectedHandlersToBeCalled
+      if (assertion.expectedToBeCalled) {
+        const calledSteps = getCalledStepsBySingleEffect(effectName);
+
+        for (const expectedToBeCalled of assertion.expectedToBeCalled) {
+          const { handler, times } = expectedToBeCalled;
+
+          const calledStepsForHandler = calledSteps?.filter((step) => step.handler === handler);
+
+          if (times) {
+            if (calledStepsForHandler?.length !== times) {
+              assertionPassed = false;
+              testAssertionResult.errors?.push(
+                `expectedToBeCalled: expected handler "${handler}" to be called ${times} times, received ${calledStepsForHandler?.length} times`,
+              );
+            }
+          } else {
+            if (!calledStepsForHandler?.length || calledStepsForHandler.length === 0) {
+              assertionPassed = false;
+              testAssertionResult.errors?.push(
+                `expectedToBeCalled: expected handler "${handler}" to be called at least once`,
+              );
+            }
+          }
+        }
+      }
+
+      testAssertionResult.passed = assertionPassed;
+
+      if (!assertionPassed) {
+        testPassed = false;
+      }
+
+      testResult.assertions.push(testAssertionResult);
+    }
+  }
+
+  /**
+   * Event
+   */
+  if ("event" in test) {
+    const eventName = test.event;
+    const assertions = test.assertions;
+
+    for (const assertion of assertions) {
+      // @TODO: apply matrix
+
+      if (
+        cliOptions.assertionPattern &&
+        !assertion.description?.includes(cliOptions.assertionPattern)
+      ) {
+        continue;
+      }
+
+      let assertionPassed = true;
+
+      const { e } = createTestInstance({
+        datafile: datafileContent,
+        cliOptions,
+        withLookups: assertion.withLookups,
+      });
+
+      let trackedEvent: Value | null = null;
+
+      if (assertion.track) {
+        trackedEvent = await e.trackAsync(eventName, assertion.track);
+      }
+
+      if (assertion.actions) {
+        for (const action of assertion.actions) {
+          if (action.type === "track") {
+            await e.trackAsync(action.name, action.value);
+          } else if (action.type === "setAttribute") {
+            await e.setAttributeAsync(action.name, action.value);
+          }
+        }
+      }
+
+      const testAssertionResult: TestAssertionResult = {
+        passed: assertionPassed,
+        description: assertion.description,
+        errors: [],
+      };
+
+      // expectedToBeValid
+      if (typeof assertion.expectedToBeValid === "boolean") {
+        if (
+          (assertion.expectedToBeValid === true && !trackedEvent) ||
+          (assertion.expectedToBeValid === false && trackedEvent)
+        ) {
+          assertionPassed = false;
+          testAssertionResult.errors?.push(
+            `expectedToBeValid: expected ${assertion.expectedToBeValid}, received ${!assertion.expectedToBeValid}`,
+          );
+        }
+      }
+
+      // expectedToContinue
+      if (assertion.expectedToContinue) {
+        // @TODO: implement
+      }
+
+      // expectedEvent
+      if (assertion.expectedEvent) {
+        if (!checkIfObjectsAreDeepEqual(trackedEvent, assertion.expectedEvent)) {
+          assertionPassed = false;
+          testAssertionResult.errors?.push(
+            `expectedEvent: \n  expected: ${JSON.stringify(assertion.expectedEvent)}\n  received: ${JSON.stringify(trackedEvent)}`,
+          );
+        }
+      }
+
+      // expectedDestinations
+      if (assertion.expectedDestinations) {
+        // if (!assertion.expectedDestinations.includes(m.getDestinationName())) {
+        //   assertionPassed = false;
+        //   testAssertionResult.errors?.push(
+        //     `expectedDestinations: expected ${assertion.expectedDestinations.join(", ")}, received ${m.getDestinationName()}`,
+        //   );
+        // }
+      }
+
+      // expectedDestinationsByTag
+      if (assertion.expectedDestinationsByTag) {
+        // @TODO: implement
+      }
+
+      testAssertionResult.passed = assertionPassed;
+
+      if (!assertionPassed) {
+        testPassed = false;
+      }
+
+      testResult.assertions.push(testAssertionResult);
+    }
+  }
+
+  /**
+   * Destination
+   */
+  if ("destination" in test) {
+    const destinationName = test.destination;
+    const assertions = test.assertions;
+
+    for (const assertion of assertions) {
+      // @TODO: apply matrix
+
+      if (
+        cliOptions.assertionPattern &&
+        !assertion.description?.includes(cliOptions.assertionPattern)
+      ) {
+        continue;
+      }
+
+      let assertionPassed = true;
+
+      const { e, getBodiesBySingleDestination } = createTestInstance({
+        datafile: datafileContent,
+        cliOptions,
+        withLookups: assertion.withLookups,
+      });
+
+      if (assertion.actions) {
+        for (const action of assertion.actions) {
+          if (action.type === "track") {
+            await e.trackAsync(action.name, action.value);
+          } else if (action.type === "setAttribute") {
+            await e.setAttributeAsync(action.name, action.value);
+          }
+        }
+      }
+
+      const testAssertionResult: TestAssertionResult = {
+        passed: assertionPassed,
+        description: assertion.description,
+        errors: [],
+      };
+
+      // expectedToBeTransported
+      if (typeof assertion.expectedToBeTransported === "boolean") {
+        const bodies = getBodiesBySingleDestination(destinationName);
+
+        if (
+          (assertion.expectedToBeTransported === false && bodies && bodies.length > 0) ||
+          (assertion.expectedToBeTransported === true && (!bodies || bodies.length === 0))
+        ) {
+          assertionPassed = false;
+          testAssertionResult.errors?.push(
+            `expectedToBeTransported: expected ${assertion.expectedToBeTransported}, received ${!assertion.expectedToBeTransported}`,
+          );
+        }
+      }
+
+      // expectedBody
+      if (assertion.expectedBody) {
+        const bodies = getBodiesBySingleDestination(destinationName);
+        if (!checkIfObjectsAreDeepEqual(bodies && bodies[0], assertion.expectedBody)) {
+          assertionPassed = false;
+          testAssertionResult.errors?.push(
+            `expectedBody: \n  expected: ${JSON.stringify(assertion.expectedBody, null, 2)}\n  received: ${JSON.stringify(bodies && bodies[0], null, 2)}`,
+          );
+        }
+      }
+
+      // @TODO: expectedBodies
+
+      testAssertionResult.passed = assertionPassed;
+
+      if (!assertionPassed) {
+        testPassed = false;
+      }
+
+      testResult.assertions.push(testAssertionResult);
+    }
+  }
+
+  testResult.passed = testPassed;
+
+  return testResult;
+}
+
+function checkIfObjectsAreDeepEqual(a: any, b: any) {
+  // Handle null/undefined cases
+  if (a === null || b === null || a === undefined || b === undefined) {
+    return a === b;
+  }
+
+  // Handle primitive types
+  if (typeof a !== "object" || typeof b !== "object") {
+    return a === b;
+  }
+
+  // Handle arrays
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    return a.every((item, index) => checkIfObjectsAreDeepEqual(item, b[index]));
+  }
+
+  // Handle objects
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+
+  return aKeys.every((key) => {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) {
+      return false;
+    }
+    return checkIfObjectsAreDeepEqual(a[key], b[key]);
+  });
+}

package/src/tester/index.ts

@@ -0,0 +1 @@
+export * from "./testProject";

package/src/tester/printTestResult.ts

@@ -0,0 +1,60 @@
+import * as path from "path";
+import chalk from "chalk";
+
+import { Test } from "@eventvisor/types";
+
+import { Dependencies } from "../dependencies";
+import { TestResult } from "./executeTest";
+
+function prefixLines(str: string, prefix: string) {
+  return str.replace(/^/gm, prefix);
+}
+
+export interface PrintTestResultOptions {
+  testName: string;
+  test: Test;
+  testResult: TestResult;
+  deps: Dependencies;
+}
+
+export function printTestResult(options: PrintTestResultOptions) {
+  const { testName, test, testResult, deps } = options;
+  const { projectConfig, rootDirectoryPath, datasource } = deps;
+
+  const relativeTestPath = path.relative(
+    rootDirectoryPath,
+    path.join(projectConfig.testsDirectoryPath, testName + "." + datasource.getExtension()),
+  );
+
+  console.log(`\n\n`);
+
+  if (testResult.passed) {
+    console.log(chalk.green(`Testing: ${relativeTestPath}`));
+  } else {
+    console.error(chalk.red(`Testing: ${relativeTestPath}`));
+  }
+
+  if ("attribute" in test) {
+    if (testResult.passed) {
+      console.log(chalk.green(`  Attribute "${chalk.green(test.attribute)}":`));
+    } else {
+      console.error(chalk.red(`  Attribute "${chalk.red(test.attribute)}":`));
+    }
+  }
+
+  if (testResult.assertions.length > 0) {
+    for (const assertion of testResult.assertions) {
+      if (assertion.passed) {
+        console.log(chalk.green(`  ✓ ${assertion.description}`));
+      } else {
+        console.error(chalk.red(`  ✗ ${assertion.description}`));
+      }
+
+      if (assertion.errors) {
+        for (const error of assertion.errors) {
+          console.error(chalk.red(prefixLines(error, "    ")));
+        }
+      }
+    }
+  }
+}

package/src/tester/testProject.ts

@@ -0,0 +1,129 @@
+import chalk from "chalk";
+
+import { Dependencies } from "../dependencies";
+import { Plugin } from "../cli";
+import { buildDatafile } from "../builder";
+import { prettyDuration } from "../utils";
+import { printTestResult } from "./printTestResult";
+import { executeTest } from "./executeTest";
+
+export interface TestProjectOptions {
+  keyPattern?: string;
+  entityType?: string;
+  assertionPattern?: string;
+  onlyFailures?: boolean;
+  quiet?: boolean;
+  verbose?: boolean;
+}
+
+export async function testProject(
+  deps: Dependencies,
+  options: TestProjectOptions,
+): Promise<boolean> {
+  const beforeDatafileBuild = new Date();
+  console.log("Building datafile...");
+
+  const datafileContent = await buildDatafile(deps);
+  const afterDatafileBuild = new Date();
+  console.log(
+    `Datafile built in ${afterDatafileBuild.getTime() - beforeDatafileBuild.getTime()}ms`,
+  );
+
+  const tests = await deps.datasource.listTests();
+
+  const totals = {
+    specsPassed: 0,
+    specsFailed: 0,
+    assertionsPassed: 0,
+    assertionsFailed: 0,
+  };
+
+  let hasFailures = false;
+
+  const start = new Date();
+
+  for (const test of tests) {
+    // @TODO: use regex?
+    if (options.keyPattern && !test.includes(options.keyPattern)) {
+      continue;
+    }
+
+    const testContent = await deps.datasource.readTest(test);
+    const testResult = await executeTest({
+      deps,
+      datafileContent,
+      test: testContent,
+      cliOptions: options,
+    });
+
+    if (!testResult.passed) {
+      hasFailures = true;
+      totals.specsFailed++;
+    } else {
+      totals.specsPassed++;
+    }
+
+    for (const assertion of testResult.assertions) {
+      if (assertion.passed) {
+        totals.assertionsPassed++;
+      } else {
+        totals.assertionsFailed++;
+      }
+    }
+
+    if (typeof options.onlyFailures === "undefined" || !testResult.passed) {
+      // print
+      printTestResult({
+        testName: test,
+        test: testContent,
+        testResult,
+        deps,
+      });
+    }
+  }
+
+  console.log(`\n\n`);
+
+  if (hasFailures) {
+    console.log(
+      chalk.red(`Test specs: ${totals.specsPassed} passed, ${totals.specsFailed} failed`),
+    );
+    console.log(
+      chalk.red(`Assertions: ${totals.assertionsPassed} passed, ${totals.assertionsFailed} failed`),
+    );
+  } else {
+    console.log(
+      chalk.green(`Test specs: ${totals.specsPassed} passed, ${totals.specsFailed} failed`),
+    );
+    console.log(
+      chalk.green(
+        `Assertions: ${totals.assertionsPassed} passed, ${totals.assertionsFailed} failed`,
+      ),
+    );
+  }
+
+  const end = new Date();
+  console.log(`Time:       ${prettyDuration(end.getTime() - start.getTime())}`);
+
+  if (hasFailures) {
+    return false;
+  }
+
+  return true;
+}
+
+export const testPlugin: Plugin = {
+  command: "test",
+  handler: async function ({ rootDirectoryPath, projectConfig, datasource, parsed }) {
+    return testProject(
+      {
+        rootDirectoryPath,
+        projectConfig,
+        datasource,
+        options: parsed,
+      },
+      parsed as TestProjectOptions,
+    );
+  },
+  examples: [],
+};

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from "./prettyDuration";

package/src/utils/prettyDuration.ts

@@ -0,0 +1,27 @@
+export function prettyDuration(duration: number) {
+  if (duration < 1000) {
+    return `${Math.floor(duration)}ms`;
+  }
+
+  const hours = Math.floor(duration / (1000 * 60 * 60));
+  const minutes = Math.floor((duration % (1000 * 60 * 60)) / (1000 * 60));
+  const seconds = Math.floor((duration % (1000 * 60)) / 1000);
+  const milliseconds = Math.floor(duration % 1000);
+
+  let result = "";
+
+  if (hours > 0) {
+    result += `${hours}h`;
+  }
+  if (minutes > 0) {
+    result += `${minutes}m`;
+  }
+  if (seconds > 0) {
+    result += `${seconds}s`;
+  }
+  if (milliseconds > 0) {
+    result += `${milliseconds}ms`;
+  }
+
+  return result;
+}

package/tsconfig.cjs.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.cjs.json",
+  "compilerOptions": {
+    "target": "es2020",
+    "outDir": "./lib",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["./src/**/*.ts"]
+}