@messagevisor/core 0.0.1 → 0.1.0

package/src/tester/matrix.ts

@@ -0,0 +1,106 @@
+import type {
+  LocaleAssertion,
+  Matrix,
+  MessageAssertion,
+  TargetAssertion,
+  SegmentAssertion,
+} from "@messagevisor/types";
+
+import { applyCombinationToValue, getMatrixCombinations } from "../matrix";
+
+interface MatrixEnabledAssertion {
+  matrix?: Matrix;
+  description?: string;
+}
+
+interface ExpandedAssertionMeta {
+  assertionIndex: number;
+  matrixIndex?: number;
+}
+
+export type ExpandedMessageAssertion = Omit<MessageAssertion, "matrix"> & ExpandedAssertionMeta;
+export type ExpandedSegmentAssertion = Omit<SegmentAssertion, "matrix"> & ExpandedAssertionMeta;
+export type ExpandedLocaleAssertion = Omit<LocaleAssertion, "matrix"> & ExpandedAssertionMeta;
+export type ExpandedTargetAssertion = Omit<TargetAssertion, "matrix"> & ExpandedAssertionMeta;
+
+function normalizeBooleanLike(value: unknown): unknown {
+  if (value === "true") {
+    return true;
+  }
+
+  if (value === "false") {
+    return false;
+  }
+
+  return value;
+}
+
+function expandAssertions<T extends MatrixEnabledAssertion>(
+  assertions: T[],
+  normalizer?: (assertion: any) => any,
+): Array<Omit<T, "matrix"> & ExpandedAssertionMeta> {
+  const expanded: Array<Omit<T, "matrix"> & ExpandedAssertionMeta> = [];
+
+  for (let assertionIndex = 0; assertionIndex < assertions.length; assertionIndex++) {
+    const rawAssertion = assertions[assertionIndex];
+    const { matrix, ...assertionWithoutMatrix } = rawAssertion;
+
+    if (!matrix) {
+      expanded.push({
+        ...(normalizer ? normalizer({ ...assertionWithoutMatrix }) : assertionWithoutMatrix),
+        assertionIndex,
+      } as Omit<T, "matrix"> & ExpandedAssertionMeta);
+      continue;
+    }
+
+    const combinations = getMatrixCombinations(matrix);
+
+    for (let matrixIndex = 0; matrixIndex < combinations.length; matrixIndex++) {
+      const expandedAssertion = applyCombinationToValue(
+        assertionWithoutMatrix,
+        combinations[matrixIndex],
+      ) as Omit<T, "matrix">;
+
+      expanded.push({
+        ...(normalizer ? normalizer(expandedAssertion) : expandedAssertion),
+        assertionIndex,
+        matrixIndex,
+      } as Omit<T, "matrix"> & ExpandedAssertionMeta);
+    }
+  }
+
+  return expanded;
+}
+
+export function expandMessageAssertions(
+  assertions: MessageAssertion[],
+): ExpandedMessageAssertion[] {
+  return expandAssertions(assertions, (assertion) => ({
+    ...assertion,
+    withFlags: assertion.withFlags
+      ? Object.fromEntries(
+          Object.entries(assertion.withFlags).map(([key, value]) => [
+            key,
+            normalizeBooleanLike(value),
+          ]),
+        )
+      : assertion.withFlags,
+  }));
+}
+
+export function expandSegmentAssertions(
+  assertions: SegmentAssertion[],
+): ExpandedSegmentAssertion[] {
+  return expandAssertions(assertions, (assertion) => ({
+    ...assertion,
+    expectedToMatch: normalizeBooleanLike(assertion.expectedToMatch),
+  }));
+}
+
+export function expandLocaleAssertions(assertions: LocaleAssertion[]): ExpandedLocaleAssertion[] {
+  return expandAssertions(assertions);
+}
+
+export function expandTargetAssertions(assertions: TargetAssertion[]): ExpandedTargetAssertion[] {
+  return expandAssertions(assertions);
+}

package/src/tester/prettyDuration.ts

@@ -0,0 +1,34 @@
+export function prettyDuration(diffInMs: number) {
+  let diff = Math.abs(diffInMs);
+
+  if (diff === 0) {
+    return "0ms";
+  }
+
+  const ms = diff % 1000;
+  diff = (diff - ms) / 1000;
+  const secs = diff % 60;
+  diff = (diff - secs) / 60;
+  const mins = diff % 60;
+  const hrs = (diff - mins) / 60;
+
+  let result = "";
+
+  if (hrs) {
+    result += ` ${hrs}h`;
+  }
+
+  if (mins) {
+    result += ` ${mins}m`;
+  }
+
+  if (secs) {
+    result += ` ${secs}s`;
+  }
+
+  if (ms) {
+    result += ` ${ms}ms`;
+  }
+
+  return result.trim();
+}

package/src/tester/printTestResult.ts

@@ -0,0 +1,40 @@
+import { CLI_FORMAT_BOLD, CLI_FORMAT_RED } from "./cliFormat";
+import { prettyDuration } from "./prettyDuration";
+import type { TestResult } from "./types";
+
+export function printTestResult(testResult: TestResult) {
+  console.log("");
+  console.log(`Testing: ${testResult.key} (${prettyDuration(testResult.duration)})`);
+
+  console.log(CLI_FORMAT_BOLD, `  ${testResult.type} "${testResult.subject}":`);
+
+  testResult.assertions.forEach((assertion) => {
+    if (assertion.passed) {
+      console.log(`  ✔ ${assertion.description} (${prettyDuration(assertion.duration)})`);
+      return;
+    }
+
+    console.log(
+      CLI_FORMAT_RED,
+      `  ✘ ${assertion.description} (${prettyDuration(assertion.duration)})`,
+    );
+    console.log(CLI_FORMAT_RED, `    ${testResult.filePath}`);
+
+    assertion.errors.forEach((error) => {
+      console.log(CLI_FORMAT_RED, `    => ${error.message}`);
+
+      if (typeof error.expected !== "undefined" || typeof error.actual !== "undefined") {
+        console.log(CLI_FORMAT_RED, `       expected: ${formatValue(error.expected)}`);
+        console.log(CLI_FORMAT_RED, `       received: ${formatValue(error.actual)}`);
+      }
+    });
+  });
+}
+
+function formatValue(value: unknown) {
+  if (typeof value === "string") {
+    return value;
+  }
+
+  return JSON.stringify(value);
+}

package/src/tester/types.ts

@@ -0,0 +1,32 @@
+export interface TestAssertionError {
+  message: string;
+  expected?: unknown;
+  actual?: unknown;
+}
+
+export interface TestResultAssertion {
+  description: string;
+  duration: number;
+  passed: boolean;
+  errors: TestAssertionError[];
+}
+
+export interface TestResult {
+  key: string;
+  filePath: string;
+  type: "message" | "segment" | "target" | "locale";
+  subject: string;
+  duration: number;
+  passed: boolean;
+  assertions: TestResultAssertion[];
+}
+
+export interface TestProjectOptions {
+  keyPattern?: string;
+  assertionPattern?: string;
+  verbose?: boolean;
+  showDatafile?: boolean;
+  onlyFailures?: boolean;
+  json?: boolean;
+  pretty?: boolean;
+}

package/tsconfig.cjs.json

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

package/tsconfig.typecheck.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.cjs.json",
+  "exclude": []
+}