@davidsouther/jiffies 2026.4.0 → 2026.24.0

package/src/scope/display/dom.ts

@@ -1,36 +0,0 @@
-import { isHTMLLogger, makeHTMLLogger } from "../../components/logger.ts";
-import type { DOMElement } from "../../dom/dom.ts";
-import { DEFAULT_LOGGER, LEVEL } from "../../log.ts";
-import { getTotalCases } from "../describe.ts";
-import { flattenResults } from "../execute.ts";
-import type { TestResult } from "../scope.ts";
-
-export function displayStatistics(
-  results: TestResult,
-  root: DOMElement = document.body as DOMElement,
-) {
-  const { executed, failed } = results;
-  const logger = (() => {
-    try {
-      return makeHTMLLogger(
-        `Executed ${executed} of ${getTotalCases()}; ${failed} failed.`,
-      );
-    } catch (_e) {
-      return DEFAULT_LOGGER;
-    }
-  })();
-
-  logger.level = LEVEL.DEBUG;
-
-  const flat = flattenResults(results);
-  for (const { test, stack } of flat) {
-    if (stack) {
-      logger.info(test);
-      logger.debug(`${stack}`);
-    }
-  }
-
-  if (isHTMLLogger(logger)) {
-    root.appendChild(logger.root);
-  }
-}

package/src/scope/display/junit.ts

@@ -1,64 +0,0 @@
-import { xml } from "../../dom/xml.ts";
-import { type FlatResult, flattenResults } from "../execute.ts";
-import type { TestResult } from "../scope.ts";
-
-const cases = (results: TestResult) =>
-  Object.entries(results).filter(
-    ([key]) => !["executed", "passed", "failed"].includes(key),
-  );
-
-export function asXML(results: TestResult) {
-  return `<?xml version="1.0" encoding="UTF-8" ?>${xml(
-    "testsuites",
-    { tests: results.executed, failures: results.failed },
-    cases(results).map(([title, children]) =>
-      testsuite(
-        title,
-        (children as TestResult).executed,
-        (children as TestResult).failed,
-        flattenResults(children as TestResult),
-      ),
-    ),
-  )}`;
-}
-
-function testsuite(
-  name: string,
-  tests: number,
-  failures: number,
-  cases: FlatResult[],
-) {
-  const id = name.replace("s+", "_");
-  return xml(
-    "testsuite",
-    { id, name, tests, failures },
-    cases.map(({ test, stack }) =>
-      testcase({ name: `${name} ${test}` }, stack ? [stack as string] : []),
-    ),
-  );
-}
-
-function testcase(
-  {
-    name,
-    id = name.replace(/\s+/g, "_"),
-    time = "0.00",
-  }: { name: string; id?: string; time?: string },
-  failures: string[],
-) {
-  return xml(
-    "testcase",
-    { id, name, time },
-    failures.map((stack) => failure({ text: stack })),
-  );
-}
-
-function failure({
-  text,
-  message = text.split("\n")[0],
-}: {
-  text: string;
-  message?: string;
-}) {
-  return xml("failure", { message }, [`<![CDATA[${text}]]>`]);
-}

package/src/scope/execute.ts

@@ -1,110 +0,0 @@
-import {
-  afterall,
-  aftereach,
-  beforeall,
-  beforeeach,
-  rootCases,
-} from "./describe.ts";
-import type {
-  TestFailed,
-  TestPassed,
-  TestResult,
-  TestSummary,
-} from "./scope.ts";
-
-export async function execute(cases = rootCases()): Promise<TestResult> {
-  const beforeallfn = cases[beforeall] ?? (() => {});
-  const beforeeachfn = cases[beforeeach] ?? (() => {});
-  const afterallfn = cases[afterall] ?? (() => {});
-  const aftereachfn = cases[aftereach] ?? (() => {});
-
-  const result: TestResult = { executed: 0, passed: 0, failed: 0, total: 0 };
-
-  try {
-    await beforeallfn();
-  } catch (e) {
-    result._beforeAll = { error: e };
-    return result;
-  }
-
-  for (const [title, block] of Object.entries(cases)) {
-    if (typeof title === "symbol") {
-      continue;
-    }
-    if (block instanceof Function) {
-      try {
-        result.executed += 1;
-        await beforeeachfn();
-        await block();
-        await aftereachfn();
-        result.passed += 1;
-        result[title] = { passed: true };
-      } catch (e) {
-        result.failed += 1;
-        result[title] = { error: /** @type Error */ e };
-      }
-    } else if (block) {
-      const run = await execute(block);
-      result.executed += run.executed;
-      result.passed += run.passed;
-      result.failed += run.failed;
-      result[title] = run;
-    }
-  }
-
-  try {
-    await afterallfn();
-  } catch (e) {
-    result._afterAll = { error: e };
-  }
-
-  return result;
-}
-
-export function getError({ error }: TestResult) {
-  if (typeof error === "string") {
-    return error;
-  }
-  if ((error as TestResult).message) {
-    return (error as TestResult).stack;
-  }
-  return "unknown error";
-}
-
-export interface FlatResult {
-  test: string;
-  stack?: string | number | TestResult | TestSummary;
-  stats: { executed: number; failed: number };
-}
-
-function makeResult(
-  test: string,
-  result: TestResult | TestSummary,
-): FlatResult[] {
-  if ((result as TestFailed).error)
-    return [
-      {
-        test,
-        stack: getError(result as TestResult),
-        stats: { executed: 1, failed: 1 },
-      },
-    ];
-  if ((result as TestPassed).passed === true) {
-    return [{ test, stats: { executed: 1, failed: 0 } }];
-  }
-  return flattenResults(result as TestResult, test);
-}
-
-export function flattenResults(results: TestResult, prefix = ""): FlatResult[] {
-  const arrow = prefix === "" ? "" : " -> ";
-  let errorList: FlatResult[] = [];
-  for (const [title, result] of Object.entries(results).filter(
-    ([key]) => !["executed", "passed", "failed"].includes(key),
-  )) {
-    const test = `${prefix}${arrow}${title}`;
-    if (typeof result === "number") continue;
-    const flatResult = makeResult(test, result);
-    errorList = errorList.concat(flatResult);
-  }
-  return errorList;
-}

package/src/scope/expect.ts

@@ -1,169 +0,0 @@
-import { assert } from "../assert.ts";
-import { display } from "../display.ts";
-import { equals } from "../equal.ts";
-
-export class Matcher<T> {
-  actual: T;
-  constructor(actual: T) {
-    this.actual = actual;
-  }
-
-  get not(): Matcher<T> {
-    return new NotMatcher(this.actual);
-  }
-
-  toBe(expected: T) {
-    assert(this.actual === expected, () => `${this.actual} !== ${expected}`);
-  }
-
-  toEqual(expected: T, partial = false) {
-    assert(
-      equals(this.actual, expected, partial),
-      () =>
-        `Objects are not equivalent: ${display(this.actual)}, ${display(
-          expected,
-        )}`,
-    );
-  }
-
-  toMatch(expected: RegExp | string) {
-    assert(
-      typeof this.actual === "string",
-      () => "Must have string for regexp match",
-    );
-    // @ts-expect-error
-    const actual: string = this.actual;
-    if (typeof expected === "string") {
-      assert(
-        actual.includes(expected),
-        () => `${actual} does not include ${expected}`,
-      );
-    } else {
-      assert(
-        expected.test(actual),
-        () => `${actual} does not match ${expected}`,
-      );
-    }
-  }
-
-  toMatchObject(expected: Partial<T>) {
-    for (const [k, v] of Object.entries(expected)) {
-      // @ts-expect-error
-      const actual: Partial<T> = this.actual[k];
-      assert(
-        equals(actual, v, true),
-        () =>
-          `Comparing ${k}, properties not equal: ${display(actual)}, ${display(
-            v,
-          )}`,
-      );
-    }
-  }
-
-  toBeNull() {
-    assert(
-      this.actual === null,
-      () => `Expected null, got ${JSON.stringify(this.actual)}`,
-    );
-  }
-
-  toThrow(message = "") {
-    let didThrow = false;
-
-    let result: unknown;
-    try {
-      // @ts-expect-error
-      result = this.actual();
-    } catch (e) {
-      assert(
-        ((e as { message?: string }).message ?? "").match(message) !== null,
-        () => `Expected thrown message to match ${message}, got ${e}`,
-      );
-      didThrow = true;
-    }
-
-    assert(didThrow, () => `Expected throw but got ${JSON.stringify(result)}`);
-  }
-}
-
-export class NotMatcher<T> {
-  actual: T;
-  constructor(actual: T) {
-    this.actual = actual;
-  }
-
-  get not(): Matcher<T> {
-    return new Matcher(this.actual);
-  }
-
-  toBe(expected: T) {
-    assert(this.actual !== expected, () => `${this.actual} === ${expected}`);
-  }
-
-  toEqual(expected: T) {
-    assert(
-      !equals(this.actual, expected),
-      () =>
-        `Objects are equivalent: ${JSON.stringify(
-          this.actual,
-        )}, ${JSON.stringify(expected)}`,
-    );
-  }
-
-  toMatch(expected: RegExp | string) {
-    assert(
-      typeof this.actual === "string",
-      () => "Must have string for regexp match",
-    );
-    // @ts-expect-error
-    const actual: string = this.actual;
-    if (typeof expected === "string") {
-      assert(
-        !actual.includes(expected),
-        () => `${actual} includes ${expected}`,
-      );
-    } else {
-      assert(!expected.test(actual), () => `${actual} matches ${expected}`);
-    }
-  }
-
-  toMatchObject(expected: Partial<T>) {
-    for (const [k, v] of Object.entries(expected)) {
-      // @ts-expect-error
-      const actual = this.actual[k];
-      assert(
-        !equals(actual, v),
-        () =>
-          `Comparing ${k}, properties equal: ${JSON.stringify(
-            actual,
-          )}, ${JSON.stringify(v)}`,
-      );
-    }
-  }
-
-  toBeNull() {
-    assert(this.actual !== null, () => "Expected not null");
-  }
-
-  toThrow(message = "") {
-    let didThrow = false;
-
-    let result: unknown;
-    try {
-      // @ts-expect-error
-      result = this.actual();
-    } catch (e) {
-      assert(
-        ((e as { message?: string }).message ?? "").match(message) !== null,
-        () => `Expected thrown message to match ${message}, got ${e}`,
-      );
-      didThrow = true;
-    }
-
-    assert(!didThrow, () => `Expected throw but got ${JSON.stringify(result)}`);
-  }
-}
-
-export function expect<T>(t: T): Matcher<T> {
-  return new Matcher(t);
-}

package/src/scope/fix.ts

@@ -1,30 +0,0 @@
-/**
- * Given a value with numbers, attempt to fix all numbers to 1 decimal point.
- */
-export function fix<T>(n: T): T {
-  if (typeof n === "number") {
-    return +n.toFixed(1) as T;
-  }
-  if (n !== Object(n)) {
-    // A primitive
-    return n;
-  }
-  if (Array.isArray(n)) {
-    return n.map(fix) as T;
-  }
-  // @ts-expect-error
-  return mapreduce<T>(fix, n as Record<string, T>);
-}
-
-function mapreduce<T, U>(
-  fn: (t: T) => U,
-  iter: Record<string, T>,
-): Record<string, U> {
-  return Object.entries(iter).reduce(
-    (acc, [k, v]) => {
-      acc[k] = fn(v);
-      return acc;
-    },
-    {} as Record<string, U>,
-  );
-}

package/src/scope/index.ts

@@ -1,11 +0,0 @@
-export {
-  afterAll,
-  afterEach,
-  beforeAll,
-  beforeEach,
-  cleanState,
-  describe,
-  it,
-} from "./describe.ts";
-export { expect } from "./expect.ts";
-export { fix } from "./fix.ts";

package/src/scope/scope.ts

@@ -1,21 +0,0 @@
-export interface TestCase {
-  [k: string]: CallableFunction | TestCase;
-  [k: symbol]: CallableFunction;
-}
-
-export interface TestResult {
-  executed: number;
-  passed: number;
-  failed: number;
-  [k: string]: TestResult | TestSummary | number;
-}
-
-export type TestSummary = TestFailed | TestPassed;
-
-export interface TestFailed {
-  error: unknown;
-}
-
-export interface TestPassed {
-  passed: true;
-}

package/src/scope/state.ts

@@ -1,13 +0,0 @@
-import type { Awaitable } from "../awaitable.ts";
-
-export function cleanState<State extends {}>(
-  init: () => Awaitable<State>,
-  runner: (action: () => Promise<void>) => void,
-): State {
-  const state = {};
-  runner(async () => {
-    const freshState = await init();
-    Object.assign(state, freshState);
-  });
-  return state as State;
-}

package/src/test.mjs

@@ -1,33 +0,0 @@
-#!/usr/bin/env node
-
-import { parse } from "./flags.ts";
-import { onConsole } from "./scope/display/console.ts";
-import { asXML } from "./scope/display/junit.ts";
-import { execute } from "./scope/execute.ts";
-
-async function main() {
-  await import("./test_all.ts");
-
-  (async () => {
-    const results = await execute();
-
-    const FLAGS = parse(process.argv);
-
-    switch (FLAGS.asString("mode", "console")) {
-      case "junit": {
-        const xml = asXML(results);
-        console.log(xml);
-        break;
-      }
-      default:
-        onConsole(results);
-        break;
-    }
-
-    if (results.failed > 0) {
-      process.exit(1);
-    }
-  })();
-}
-
-main();

package/src/test_all.ts

@@ -1,35 +0,0 @@
-// This file must be .js for imports to run. Unused imports in .ts files are
-// discarded during transpilation.
-import { describe, expect, it } from "./scope/index.ts";
-
-describe("Test executor", () => {
-  it("matches equality", () => {
-    expect(1).toBe(1);
-  });
-
-  it("fails on inequality", () => {
-    expect(() => expect(1).toBe(2)).toThrow();
-  });
-});
-
-import "./context.test.ts";
-import "./diff.test.ts";
-import "./equal.test.ts";
-import "./flags.test.ts";
-import "./fs.test.ts";
-import "./generator.test.ts";
-import "./lock.test.ts";
-import "./result.test.ts";
-import "./observable/observable.test.ts";
-
-if (
-  typeof process !== "undefined" &&
-  process.env.CI?.toLowerCase() !== "true"
-) {
-  (async () => {
-    const components = await import("./components/test.ts");
-    const dom = await import("./dom/test.ts");
-    await components.loadTests();
-    await dom.loadTests();
-  })();
-}