@fncts/test 0.0.1

package/_src/control/Spec/api.ts

@@ -0,0 +1,384 @@
+import type { Annotated } from "../Annotations.js";
+import type { SpecCase } from "./definition.js";
+import type { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+import type { Spreadable } from "@fncts/base/types.js";
+import type { TestArgs } from "@fncts/test/data/TestArgs.js";
+
+import { identity, tuple } from "@fncts/base/data/function";
+import { matchTag, matchTag_ } from "@fncts/base/util/pattern";
+import { TestSuccess } from "@fncts/test/data/TestSuccess";
+
+import { TestAnnotation } from "../../data/TestAnnotation.js";
+import { TestAnnotationMap } from "../../data/TestAnnotationMap.js";
+import { Annotations } from "../Annotations.js";
+import { Spec } from "./definition.js";
+import { ExecCase, LabeledCase, MultipleCase, PSpec, ScopedCase, TestCase } from "./definition.js";
+
+/**
+ * @tsplus getter fncts.test.PSpec annotated
+ */
+export function annotated<R, E, T>(spec: PSpec<R, E, T>): PSpec<R & Has<Annotations>, Annotated<E>, Annotated<T>> {
+  return spec.transform(
+    matchTag(
+      {
+        Scoped: ({ scoped }) => new ScopedCase(scoped.mapError((e) => tuple(e, TestAnnotationMap.empty))),
+        Test: ({ test, annotations }) => new TestCase(Annotations.withAnnotations(test), annotations),
+      },
+      identity,
+    ),
+  );
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec combine
+ */
+export function combine_<R, E, T, R1, E1, T1>(
+  self: PSpec<R, E, T>,
+  that: PSpec<R1, E1, T1>,
+): PSpec<R & R1, E | E1, T | T1> {
+  if (self.caseValue.isMultiple() && that.caseValue.isMultiple()) {
+    return MultipleCase(self.caseValue.specs.concat(that.caseValue.specs));
+  }
+  if (self.caseValue.isMultiple()) {
+    return MultipleCase(self.caseValue.specs.append(that));
+  }
+  if (that.caseValue.isMultiple()) {
+    return MultipleCase(that.caseValue.specs.prepend(self));
+  }
+  return MultipleCase(Conc<PSpec<R & R1, E | E1, T | T1>>(self, that));
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec contramapEnvironment
+ */
+export function contramapEnvironment_<R, E, T, R0>(
+  self: PSpec<R, E, T>,
+  f: (r0: Environment<R0>) => Environment<R>,
+): PSpec<R0, E, T> {
+  return self.transform(
+    matchTag(
+      {
+        Scoped: ({ scoped }) =>
+          new ScopedCase(
+            scoped.contramapEnvironment((r: Environment<R0 & Has<Scope>>) =>
+              Environment.empty.add(r.get(Scope.Tag), Scope.Tag).union(f(r)),
+            ),
+          ),
+        Test: ({ test, annotations }) => new TestCase(test.contramapEnvironment(f), annotations),
+      },
+      identity,
+    ),
+  );
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec countTests
+ */
+export function countTests_<R, E, T>(spec: PSpec<R, E, T>, f: (t: T) => boolean): IO<R & Has<Scope>, E, number> {
+  return spec.fold(
+    matchTag({
+      Exec: ({ spec }) => spec,
+      Labeled: ({ spec }) => spec,
+      Scoped: ({ scoped }) => scoped.flatten,
+      Multiple: ({ specs }) => IO.sequenceIterable(specs).map((specs) => specs.foldLeft(0, (b, a) => b + a)),
+      Test: ({ test }) => test.map((t) => (f(t) ? 1 : 0)),
+    }),
+  );
+}
+
+/**
+ * @tsplus static fncts.test.PSpecOps empty
+ */
+export const empty: PSpec<unknown, never, never> = multipleCase(Conc.empty());
+
+/**
+ * @tsplus static fncts.test.PSpecOps exec
+ * @tsplus static fncts.test.PSpec.ExecCaseOps __call
+ */
+export function exec<R, E, T>(spec: PSpec<R, E, T>, exec: ExecutionStrategy): PSpec<R, E, T> {
+  return new PSpec(new ExecCase(exec, spec));
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec execute
+ */
+export function execute<R, E, T>(
+  self: PSpec<R, E, T>,
+  defExec: ExecutionStrategy,
+): IO<R & Has<Scope>, never, PSpec<unknown, E, T>> {
+  return IO.environmentWithIO((r: Environment<R & Has<Scope>>) =>
+    self.provideEnvironment(r).foreachExec(IO.failCauseNow, IO.succeedNow, defExec),
+  );
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec filterAnnotations
+ */
+export function filterAnnotations_<R, E, T, V>(
+  spec: PSpec<R, E, T>,
+  key: TestAnnotation<V>,
+  f: (v: V) => boolean,
+): Maybe<PSpec<R, E, T>> {
+  return matchTag_(spec.caseValue, {
+    Exec: ({ spec, exec }) => spec.filterAnnotations(key, f).map((spec) => ExecCase(spec, exec)),
+    Labeled: ({ label, spec }) => spec.filterAnnotations(key, f).map((spec) => LabeledCase(spec, label)),
+    Scoped: ({ scoped }) =>
+      Just(ScopedCase(scoped.map((spec) => spec.filterAnnotations(key, f).getOrElse(Spec.empty)))),
+    Multiple: ({ specs }) => {
+      const filtered = specs.filterMap((spec) => spec.filterAnnotations(key, f));
+      return filtered.isEmpty ? Nothing() : Just(MultipleCase(filtered));
+    },
+    Test: ({ test, annotations }) => (f(annotations.get(key)) ? Just(TestCase(test, annotations)) : Nothing()),
+  });
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec filterLabels
+ */
+export function filterLabels_<R, E, T>(spec: PSpec<R, E, T>, f: (label: string) => boolean): Maybe<PSpec<R, E, T>> {
+  return matchTag_(spec.caseValue, {
+    Exec: ({ spec, exec }) => spec.filterLabels(f).map((spec) => ExecCase(spec, exec)),
+    Labeled: ({ label, spec }) =>
+      f(label) ? Just(LabeledCase(spec, label)) : spec.filterLabels(f).map((spec) => LabeledCase(spec, label)),
+    Scoped: ({ scoped }) => Just(ScopedCase(scoped.map((spec) => spec.filterLabels(f).getOrElse(Spec.empty)))),
+    Multiple: ({ specs }) => {
+      const filtered = specs.filterMap((spec) => spec.filterLabels(f));
+      return filtered.isEmpty ? Nothing() : Just(MultipleCase(filtered));
+    },
+    Test: () => Nothing(),
+  });
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec filterTags
+ */
+export function filterTags_<R, E, T>(spec: PSpec<R, E, T>, f: (tag: string) => boolean): Maybe<PSpec<R, E, T>> {
+  return spec.filterAnnotations(TestAnnotation.Tagged, (v) => v.exists(f));
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec filterByArgs
+ */
+export function filterByArgs<R, E>(spec: Spec<R, E>, args: TestArgs): Spec<R, E> {
+  return spec
+    .filterTags(args.tagSearchTerms.elem(String.Eq))
+    .flatMap((spec) =>
+      spec.filterLabels((label) => args.testSearchTerms.findIndex((term) => term.includes(label)) === -1),
+    )
+    .getOrElse(() => spec);
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec fold
+ */
+export function fold_<R, E, T, Z>(spec: PSpec<R, E, T>, f: (_: SpecCase<R, E, T, Z>) => Z): Z {
+  return matchTag_(spec.caseValue, {
+    Exec: ({ exec, spec }) => f(new ExecCase(exec, spec.fold(f))),
+    Labeled: ({ label, spec }) => f(new LabeledCase(label, spec.fold(f))),
+    Scoped: ({ scoped }) => f(new ScopedCase(scoped.map((spec) => spec.fold(f)))),
+    Multiple: ({ specs }) => f(new MultipleCase(specs.map((spec) => spec.fold(f)))),
+    Test: (t) => f(t),
+  });
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec foldScoped
+ */
+export function foldScoped_<R, E, T, R1, E1, Z>(
+  spec: PSpec<R, E, T>,
+  f: (_: SpecCase<R, E, T, Z>) => IO<R1 & Has<Scope>, E1, Z>,
+  defExec: ExecutionStrategy,
+): IO<R & R1 & Has<Scope>, E1, Z> {
+  return matchTag_(spec.caseValue, {
+    Exec: ({ exec, spec }) => spec.foldScoped(f, exec).flatMap((z) => f(new ExecCase(exec, z))),
+    Labeled: ({ label, spec }) => spec.foldScoped(f, defExec).flatMap((z) => f(new LabeledCase(label, z))),
+    Scoped: ({ scoped }) =>
+      scoped.matchCauseIO(
+        (cause) => f(new ScopedCase(IO.haltNow(cause))),
+        (spec) => spec.foldScoped(f, defExec).flatMap((z) => f(new ScopedCase(IO.succeedNow(z)))),
+      ),
+    Multiple: ({ specs }) =>
+      IO.foreachExec(specs, defExec, (spec) => spec.foldScoped(f, defExec).scoped).flatMap((zs) =>
+        f(new MultipleCase(zs)),
+      ),
+    Test: f,
+  });
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec foreachExec
+ */
+export function foreachExec_<R, E, T, R1, E1, A, R2, E2, B>(
+  spec: PSpec<R, E, T>,
+  failure: (c: Cause<E>) => IO<R1, E1, A>,
+  success: (t: T) => IO<R2, E2, B>,
+  defExec: ExecutionStrategy,
+): IO<R & R1 & R2 & Has<Scope>, never, PSpec<R & R1 & R2, E1 | E2, A | B>> {
+  return spec.foldScoped(
+    matchTag({
+      Exec: ({ exec, spec }) => IO.succeedNow(ExecCase(spec, exec)),
+      Labeled: ({ label, spec }) => IO.succeedNow(LabeledCase(spec, label)),
+      Scoped: ({ scoped }) =>
+        scoped.matchCause(
+          (cause) => TestCase(failure(cause), TestAnnotationMap.empty),
+          (t) => ScopedCase(IO.succeedNow(t)),
+        ),
+      Multiple: ({ specs }) => IO.succeedNow(MultipleCase(specs)),
+      Test: ({ test, annotations }) =>
+        test.matchCause(
+          (cause) => TestCase(failure(cause), annotations),
+          (t) => TestCase(success(t), annotations),
+        ),
+    }),
+    defExec,
+  );
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec labeled
+ * @tsplus static fncts.test.PSpecOps labeled
+ * @tsplus static fncts.test.PSpec.LabeledCaseOps __call
+ */
+export function labeledCase<R, E, T>(spec: PSpec<R, E, T>, label: string): PSpec<R, E, T> {
+  return new PSpec(new LabeledCase(label, spec));
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec scoped
+ * @tsplus static fncts.test.PSpecOps scoped
+ * @tsplus static fncts.test.PSpec.ScopedCaseOps __call
+ */
+export function scoped<R, E, T>(managed: IO<R & Has<Scope>, E, PSpec<R, E, T>>): PSpec<R, E, T> {
+  return new PSpec(new ScopedCase(managed));
+}
+
+/**
+ * @tsplus fluent fncts.test.SpecCase mapError
+ */
+export function mapError<R, E, T, E1>(self: PSpec<R, E, T>, f: (e: E) => E1): PSpec<R, E1, T> {
+  return self.transform(
+    matchTag(
+      {
+        Scoped: ({ scoped }) => new ScopedCase(scoped.mapError(f)),
+        Test: ({ test, annotations }) => new TestCase(test.mapError(f), annotations),
+      },
+      identity,
+    ),
+  );
+}
+
+/**
+ * @tsplus fluent fncts.test.SpecCase map
+ */
+export function mapSpecCase_<R, E, T, A, B>(fa: SpecCase<R, E, T, A>, f: (a: A) => B): SpecCase<R, E, T, B> {
+  return matchTag_(fa, {
+    Exec: ({ exec, spec }) => new ExecCase(exec, f(spec)),
+    Labeled: ({ label, spec }) => new LabeledCase(label, f(spec)),
+    Scoped: ({ scoped }) => new ScopedCase(scoped.map(f)),
+    Multiple: ({ specs }) => new MultipleCase(specs.map(f)),
+    Test: ({ test, annotations }) => new TestCase(test, annotations),
+  });
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec multiple
+ * @tsplus static fncts.test.PSpecOps multiple
+ * @tsplus static fncts.test.PSpec.MultipleCaseOps __call
+ */
+export function multipleCase<R, E, T>(specs: Conc<PSpec<R, E, T>>): PSpec<R, E, T> {
+  return new PSpec(new MultipleCase(specs));
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec provideEnvironment
+ */
+export function provideEnvironment_<R, E, T>(self: PSpec<R, E, T>, r: Environment<R>): PSpec<unknown, E, T> {
+  return self.contramapEnvironment(() => r);
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec provideLayer
+ */
+export function provideLayer_<RIn, E, ROut extends Spreadable, R, E1, T>(
+  self: PSpec<ROut, E1, T>,
+  layer: Layer<RIn, E, ROut>,
+): PSpec<RIn, E | E1, T> {
+  return self.transform(
+    matchTag(
+      {
+        Scoped: ({ scoped }) => new ScopedCase(scoped.provideLayer(Layer.environment<Has<Scope>>().and(layer))),
+        Test: ({ test, annotations }) => new TestCase(test.provideLayer(layer), annotations),
+      },
+      identity,
+    ),
+  );
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec test
+ * @tsplus static fncts.test.PSpecOps test
+ * @tsplus static fncts.test.PSpec.TestCaseOps __call
+ */
+export function testCase<R, E, T>(test: IO<R, E, T>, annotations: TestAnnotationMap): PSpec<R, E, T> {
+  return new PSpec(new TestCase(test, annotations));
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec transform
+ */
+export function transform_<R, E, T, R1, E1, T1>(
+  spec: PSpec<R, E, T>,
+  f: (_: SpecCase<R, E, T, PSpec<R1, E1, T1>>) => SpecCase<R1, E1, T1, PSpec<R1, E1, T1>>,
+): PSpec<R1, E1, T1> {
+  return matchTag_(spec.caseValue, {
+    Exec: ({ exec, spec }) => new PSpec(f(new ExecCase(exec, spec.transform(f)))),
+    Labeled: ({ label, spec }) => new PSpec(f(new LabeledCase(label, spec.transform(f)))),
+    Scoped: ({ scoped }) => new PSpec(f(new ScopedCase(scoped.map((spec) => spec.transform(f))))),
+    Multiple: ({ specs }) => new PSpec(f(new MultipleCase(specs.map((spec) => spec.transform(f))))),
+    Test: (t) => new PSpec(f(t)),
+  });
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec annotate
+ */
+export function annotate_<R, E, T, V>(self: PSpec<R, E, T>, key: TestAnnotation<V>, value: V): PSpec<R, E, T> {
+  return self.transform(
+    matchTag(
+      {
+        Test: ({ test, annotations }) => new TestCase(test, annotations.annotate(key, value)),
+      },
+      identity,
+    ),
+  );
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec whenIO
+ */
+export function whenIO_<R, E, R1, E1>(
+  self: PSpec<R, E, TestSuccess>,
+  b: IO<R1, E1, boolean>,
+): PSpec<R & R1 & Has<Annotations>, E | E1, TestSuccess> {
+  return matchTag_(self.caseValue, {
+    Exec: (c) => exec(c.spec.whenIO(b), c.exec),
+    Labeled: ({ label, spec }) => Spec.labeled(spec.whenIO(b), label),
+    Scoped: (c) => Spec.scoped(b.flatMap((b) => (b ? c.scoped : IO.succeedNow(Spec.empty)))),
+    Multiple: ({ specs }) => Spec.multiple(specs.map((_) => _.whenIO(b))),
+    Test: (c) =>
+      Spec.test(
+        b.flatMap((b) => IO.if(b, c.test, Annotations.annotate(TestAnnotation.Ignored, 1)).as(TestSuccess.Ignored)),
+        c.annotations,
+      ),
+  });
+}
+
+/**
+ * @tsplus fluent fncts.test.PSpec when
+ */
+export function when_<R, E>(
+  self: PSpec<R, E, TestSuccess>,
+  b: Lazy<boolean>,
+): PSpec<R & Has<Annotations>, E, TestSuccess> {
+  return self.whenIO(IO.succeed(b));
+}

package/_src/control/Spec/definition.ts

@@ -0,0 +1,103 @@
+import type { TestAnnotationMap } from "../../data/TestAnnotationMap.js";
+import type { TestFailure } from "../../data/TestFailure.js";
+import type { TestSuccess } from "../../data/TestSuccess.js";
+import type { _A, _E, _R } from "@fncts/base/types.js";
+
+/**
+ * @tsplus type fncts.test.PSpec
+ * @tsplus companion fncts.test.PSpecOps
+ */
+export class PSpec<R, E, T> {
+  readonly _R!: (_: R) => void;
+  readonly _E!: () => E;
+  readonly _A!: () => T;
+
+  constructor(readonly caseValue: SpecCase<R, E, T, PSpec<R, E, T>>) {}
+}
+
+/**
+ * @tsplus type fncts.test.PSpecOps
+ */
+export interface SpecOps {}
+
+export const Spec: SpecOps = {};
+
+/**
+ * @tsplus type fncts.test.PSpec
+ */
+export type Spec<R, E> = PSpec<R, TestFailure<E>, TestSuccess>;
+
+export const enum SpecCaseTag {
+  Exec = "Exec",
+  Labeled = "Labeled",
+  Scoped = "Scoped",
+  Multiple = "Multiple",
+  Test = "Test",
+}
+
+/**
+ * @tsplus companion fncts.test.PSpec.ExecCaseOps
+ */
+export class ExecCase<Spec> {
+  readonly _tag = SpecCaseTag.Exec;
+  constructor(readonly exec: ExecutionStrategy, readonly spec: Spec) {}
+}
+
+/**
+ * @tsplus companion fncts.test.PSpec.LabeledCaseOps
+ */
+export class LabeledCase<Spec> {
+  readonly _tag = SpecCaseTag.Labeled;
+  constructor(readonly label: string, readonly spec: Spec) {}
+}
+
+/**
+ * @tsplus companion fncts.test.PSpec.ScopedCaseOps
+ */
+export class ScopedCase<R, E, Spec> {
+  readonly _tag = SpecCaseTag.Scoped;
+  constructor(readonly scoped: IO<R & Has<Scope>, E, Spec>) {}
+}
+
+/**
+ * @tsplus companion fncts.test.PSpec.MultipleCaseOps
+ */
+export class MultipleCase<Spec> {
+  readonly _tag = SpecCaseTag.Multiple;
+  constructor(readonly specs: Conc<Spec>) {}
+}
+
+/**
+ * @tsplus companion fncts.test.PSpec.TestCaseOps
+ */
+export class TestCase<R, E, T> {
+  readonly _R!: (_: R) => void;
+  readonly _E!: () => E;
+  readonly _A!: () => T;
+  readonly _tag = SpecCaseTag.Test;
+  constructor(readonly test: IO<R, E, T>, readonly annotations: TestAnnotationMap) {}
+}
+
+/**
+ * @tsplus type fncts.test.SpecCase
+ */
+export type SpecCase<R, E, T, A> =
+  | ExecCase<A>
+  | LabeledCase<A>
+  | ScopedCase<R, E, A>
+  | MultipleCase<A>
+  | TestCase<R, E, T>;
+
+/**
+ * @tsplus fluent fncts.test.SpecCase isMultiple
+ */
+export function isMultiple<R, E, T, A>(self: SpecCase<R, E, T, A>): self is MultipleCase<A> {
+  return self._tag === SpecCaseTag.Multiple;
+}
+
+/**
+ * @tsplus unify fncts.test.PSpec
+ */
+export function unifyPSpec<X extends PSpec<any, any, any>>(_: X): PSpec<_R<X>, _E<X>, _A<X>> {
+  return _;
+}

package/_src/control/Spec.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./Spec/*.ts }
+export * from "./Spec/api.js";
+export * from "./Spec/definition.js";
+// codegen:end

package/_src/control/SummaryBuilder.ts

@@ -0,0 +1,68 @@
+import type { TestFailure } from "@fncts/test/data/TestFailure";
+import type { TestSuccess } from "@fncts/test/data/TestSuccess";
+
+import { matchTag } from "@fncts/base/util/pattern";
+import { render } from "@fncts/test/control/DefaultTestReporter/render";
+import { silent } from "@fncts/test/control/TestAnnotationRenderer";
+import { ConsoleRenderer } from "@fncts/test/control/TestRenderer/ConsoleRenderer";
+import { ExecutedSpec } from "@fncts/test/data/ExecutedSpec";
+import { Summary } from "@fncts/test/data/Summary";
+
+/**
+ * @tsplus type fncts.test.SummaryBuilder
+ */
+export interface SummaryBuilderOps {}
+
+export const SummaryBuilder: SummaryBuilderOps = {};
+
+/**
+ * @tsplus static fncts.test.SummaryBuilder buildSummary
+ */
+export function buildSummary<E>(executedSpec: ExecutedSpec<E>): Summary {
+  const success = countTestResults(executedSpec, (_) =>
+    _.match(
+      () => false,
+      (_) => _._tag === "Succeeded",
+    ),
+  );
+  const fail   = countTestResults(executedSpec, (_) => _.isLeft());
+  const ignore = countTestResults(executedSpec, (_) =>
+    _.match(
+      () => false,
+      (_) => _._tag === "Ignored",
+    ),
+  );
+  const failures = extractFailures(executedSpec);
+  const rendered = ConsoleRenderer.render(failures.flatMap(render), silent).join("\n");
+
+  return new Summary(success, fail, ignore, rendered);
+}
+
+function countTestResults<E>(
+  executedSpec: ExecutedSpec<E>,
+  predicate: (r: Either<TestFailure<E>, TestSuccess>) => boolean,
+): number {
+  return executedSpec.fold(
+    matchTag({
+      Labeled: ({ spec }) => spec,
+      Multiple: ({ specs }) => specs.foldLeft(0, (b, a) => b + a),
+      Test: ({ test }) => (predicate(test) ? 1 : 0),
+    }),
+  );
+}
+
+function extractFailures<E>(executedSpec: ExecutedSpec<E>): Vector<ExecutedSpec<E>> {
+  return executedSpec.fold(
+    matchTag({
+      Labeled: ({ label, spec }) => spec.map((spec) => ExecutedSpec.labeled(spec, label)),
+      Test: (c) => (c.test.isLeft() ? Vector.single(new ExecutedSpec(c)) : Vector.empty<ExecutedSpec<E>>()),
+      Multiple: ({ specs }) => {
+        const newSpecs = specs.flatMap(Conc.from);
+        if (newSpecs.isNonEmpty) {
+          return Vector.single(ExecutedSpec.multiple(newSpecs));
+        }
+        return Vector.empty<ExecutedSpec<E>>();
+      },
+    }),
+  );
+}

package/_src/control/Test.ts

@@ -0,0 +1,31 @@
+import type { TestResult } from "../data/FailureDetails.js";
+
+import { FreeBooleanAlgebra } from "../data/FreeBooleanAlgebra.js";
+import { TestFailure } from "../data/TestFailure.js";
+import { TestSuccess } from "../data/TestSuccess.js";
+
+/**
+ * @tsplus type fncts.control.IO
+ */
+export type Test<R, E> = IO<R, TestFailure<E>, TestSuccess>;
+
+/**
+ * @tsplus type fncts.test.TestOps
+ */
+export interface TestOps {}
+
+export const Test: TestOps = {};
+
+/**
+ * @tsplus static fncts.test.TestOps fromAssertion
+ */
+export function fromAssertion<R, E>(assertion: Lazy<IO<R, E, TestResult>>): Test<R, E> {
+  return IO.defer(assertion).matchCauseIO(
+    (cause) => IO.failNow(TestFailure.failCause(cause)),
+    (testResult) =>
+      testResult.failures.match(
+        () => IO.succeedNow(TestSuccess.Succeeded(FreeBooleanAlgebra.success(undefined))),
+        (failure) => IO.failNow(TestFailure.assertion(failure)),
+      ),
+  );
+}

package/_src/control/TestAnnotationRenderer/api.ts

@@ -0,0 +1,75 @@
+import type { TestAnnotationRenderer } from "./definition.js";
+
+import { TestAnnotation } from "../../data/TestAnnotation.js";
+import { LeafRenderer } from "./definition.js";
+import { CompositeRenderer, TestAnnotationRendererTag } from "./definition.js";
+
+/**
+ * @tsplus fluent fncts.test.TestAnnotationRenderer combine
+ * @tsplus operator fncts.test.TestAnnotationRenderer +
+ */
+export function combine_(self: TestAnnotationRenderer, that: TestAnnotationRenderer): TestAnnotationRenderer {
+  if (
+    self._tag === TestAnnotationRendererTag.CompositeRenderer &&
+    that._tag === TestAnnotationRendererTag.CompositeRenderer
+  ) {
+    return new CompositeRenderer(self.renderers.concat(that.renderers));
+  } else if (self._tag === TestAnnotationRendererTag.CompositeRenderer) {
+    return new CompositeRenderer(self.renderers.append(that));
+  } else if (that._tag === TestAnnotationRendererTag.CompositeRenderer) {
+    return new CompositeRenderer(that.renderers.prepend(self));
+  } else {
+    return new CompositeRenderer(Vector(self, that));
+  }
+}
+
+/**
+ * @tsplus static fncts.test.TestAnnotationRendererOps Ignored
+ */
+export const ignored: TestAnnotationRenderer = new LeafRenderer((f) =>
+  f(TestAnnotation.Ignored, (children) => children.head.flatMap((n) => (n === 0 ? Nothing() : Just(`ignored: ${n}`)))),
+);
+
+/**
+ * @tsplus static fncts.test.TestAnnotationRendererOps Repeated
+ */
+export const repeated: TestAnnotationRenderer = new LeafRenderer((f) =>
+  f(TestAnnotation.Repeated, (children) =>
+    children.head.flatMap((n) => (n === 0 ? Nothing() : Just(`repeated: ${n}`))),
+  ),
+);
+
+/**
+ * @tsplus static fncts.test.TestAnnotationRendererOps Retried
+ */
+export const retried: TestAnnotationRenderer = new LeafRenderer((f) =>
+  f(TestAnnotation.Repeated, (children) => children.head.flatMap((n) => (n === 0 ? Nothing() : Just(`retried: ${n}`)))),
+);
+
+/**
+ * @tsplus static fncts.test.TestAnnotationRendererOps Tagged
+ */
+export const tagged: TestAnnotationRenderer = new LeafRenderer((f) =>
+  f(TestAnnotation.Tagged, (children) =>
+    children.head.flatMap((child) =>
+      child.size === 0 ? Nothing() : Just(`tagged: ${child.map((s) => s.surround('"')).join(", ")}`),
+    ),
+  ),
+);
+
+/**
+ * @tsplus static fncts.test.TestAnnotationRendererOps Timed
+ */
+export const timed: TestAnnotationRenderer = new LeafRenderer((f) =>
+  f(TestAnnotation.Timing, (children) => children.head.flatMap((n) => (n === 0 ? Nothing() : Just(`${n}ms`)))),
+);
+
+/**
+ * @tsplus static fncts.test.TestAnnotationRendererOps Silent
+ */
+export const silent: TestAnnotationRenderer = new CompositeRenderer(Vector.empty());
+
+/**
+ * @tsplus static fncts.test.TestAnnotationRendererOps Default
+ */
+export const Default: TestAnnotationRenderer = new CompositeRenderer(Vector(ignored, repeated, retried, tagged, timed));