@fncts/test 0.0.1

package/_src/api.ts

@@ -0,0 +1,76 @@
+import type { Assertion, AssertResult } from "./control/Assertion.js";
+import type { AssertionIO } from "./control/AssertionIO.js";
+import type { TestResult } from "./data/FailureDetails.js";
+import type { _E, _R } from "@fncts/base/types";
+
+import { Spec } from "./control/Spec.js";
+import { Test } from "./control/Test.js";
+import { FailureDetailsResult } from "./data/AssertionResult.js";
+import { AssertionValue } from "./data/AssertionValue.js";
+import { FailureDetails } from "./data/FailureDetails.js";
+import { FreeBooleanAlgebra } from "./data/FreeBooleanAlgebra.js";
+import { TestAnnotationMap } from "./data/TestAnnotationMap.js";
+
+function traverseResultLoop<A>(whole: AssertionValue<A>, failureDetails: FailureDetails): TestResult {
+  if (whole.isSameAssertionAs(failureDetails.assertion.head)) {
+    return FreeBooleanAlgebra.success(new FailureDetailsResult(failureDetails));
+  } else {
+    const fragment = whole.result;
+    const r0       = fragment.value;
+    const result   = r0.isSuccess ? r0 : r0.invert;
+    return result.flatMap((fragment) =>
+      traverseResultLoop(fragment, new FailureDetails(Cons(whole, failureDetails.assertion), failureDetails.gen)),
+    );
+  }
+}
+
+export function traverseResult<A>(value: A, assertResult: AssertResult<A>, assertion: AssertionIO<A>): TestResult {
+  return assertResult.flatMap((fragment) =>
+    traverseResultLoop(
+      fragment,
+      new FailureDetails(
+        Cons(
+          new AssertionValue(
+            LazyValue(() => assertion),
+            value,
+            LazyValue(() => assertResult),
+          ),
+        ),
+        Nothing(),
+      ),
+    ),
+  );
+}
+
+/**
+ * @tsplus fluent global assert 1
+ */
+export function assert_<A>(value: A, assertion: Assertion<A>): TestResult {
+  return traverseResult(value, assertion.run(value), assertion);
+}
+
+/**
+ * @tsplus fluent global assert 0
+ */
+export function assertIO_<R, E, A>(io: IO<R, E, A>, assertion: AssertionIO<A>): IO<R, E, TestResult> {
+  return IO.gen(function* (_) {
+    const value        = yield* _(io);
+    const assertResult = yield* _(assertion.runIO(value));
+    return traverseResult(value, assertResult, assertion);
+  });
+}
+
+export function suite<Specs extends ReadonlyArray<Spec<any, any>>>(
+  label: string,
+  ...specs: Specs
+): Spec<_R<Specs[number]>, _E<Specs[number]>> {
+  return Spec.multiple(Conc.from(specs)).labeled(label);
+}
+
+export function testIO<R, E>(label: string, assertion: Lazy<IO<R, E, TestResult>>): Spec<R, E> {
+  return Spec.test(Test.fromAssertion(assertion), TestAnnotationMap.empty).labeled(label);
+}
+
+export function test(label: string, assertion: Lazy<TestResult>): Spec<unknown, never> {
+  return testIO(label, IO.succeed(assertion));
+}

package/_src/control/AbstractRunnableSpec.ts

@@ -0,0 +1,23 @@
+import type { Spec } from "@fncts/test/control/Spec";
+import type { TestAspect } from "@fncts/test/control/TestAspect";
+import type { TestLogger } from "@fncts/test/control/TestLogger";
+import type { TestRunner } from "@fncts/test/control/TestRunner";
+import type { ExecutedSpec } from "@fncts/test/data/ExecutedSpec";
+
+export abstract class AbstractRunnableSpec<R, E> {
+  abstract aspects: ReadonlyArray<TestAspect<R, any>>;
+  abstract runner: TestRunner<R, E>;
+  abstract spec: Spec<R, E>;
+
+  get _run(): URIO<Has<TestLogger>, ExecutedSpec<E>> {
+    return this.runSpec(this.spec);
+  }
+
+  runSpec(spec: Spec<R, E>): URIO<Has<TestLogger>, ExecutedSpec<E>> {
+    return this.runner.run(this.aspects.foldLeft(spec, (b, a) => a(b)));
+  }
+
+  get platform() {
+    return this.runner.runtimeConfig;
+  }
+}

package/_src/control/Annotations/api.ts

@@ -0,0 +1,33 @@
+import type { TestAnnotation } from "../../data/TestAnnotation.js";
+import type { Annotated } from "./definition.js";
+
+import { Annotations } from "./definition.js";
+
+/**
+ * @tsplus static fncts.test.AnnotationsOps annotate
+ */
+export function annotate<V>(key: TestAnnotation<V>, value: V): URIO<Has<Annotations>, void> {
+  return IO.serviceWithIO((annotations) => annotations.annotate(key, value), Annotations.Tag);
+}
+
+/**
+ * @tsplus static fncts.test.AnnotationsOps get
+ */
+export function get<V>(key: TestAnnotation<V>): URIO<Has<Annotations>, V> {
+  return IO.serviceWithIO((annotations) => annotations.get(key), Annotations.Tag);
+}
+
+/**
+ * @tsplus static fncts.test.AnnotationsOps withAnnotations
+ */
+export function withAnnotation<R, E, A>(io: IO<R, E, A>): IO<R & Has<Annotations>, Annotated<E>, Annotated<A>> {
+  return IO.serviceWithIO((annotations) => annotations.withAnnotation(io), Annotations.Tag);
+}
+
+/**
+ * @tsplus static fncts.test.AnnotationsOps supervisedFibers
+ */
+export const supervisedFibers: URIO<Has<Annotations>, HashSet<Fiber.Runtime<any, any>>> = IO.serviceWithIO(
+  (annotations) => annotations.supervisedFibers,
+  Annotations.Tag,
+);

package/_src/control/Annotations/definition.ts

@@ -0,0 +1,20 @@
+import type { TestAnnotation } from "../../data/TestAnnotation.js";
+import type { TestAnnotationMap } from "../../data/TestAnnotationMap.js";
+
+export type Annotated<A> = readonly [A, TestAnnotationMap];
+
+/**
+ * @tsplus type fncts.test.Annotations
+ * @tsplus companion fncts.test.AnnotationsOps
+ */
+export abstract class Annotations {
+  abstract annotate<V>(key: TestAnnotation<V>, value: V): UIO<void>;
+  abstract get<V>(key: TestAnnotation<V>): UIO<V>;
+  abstract withAnnotation<R, E, A>(io: IO<R, E, A>): IO<R, Annotated<E>, Annotated<A>>;
+  abstract readonly supervisedFibers: UIO<HashSet<Fiber.Runtime<any, any>>>;
+}
+
+/**
+ * @tsplus static fncts.test.AnnotationsOps Tag
+ */
+export const AnnotationsTag = Tag<Annotations>();

package/_src/control/Annotations/live.ts

@@ -0,0 +1,50 @@
+import { TestAnnotation } from "../../data/TestAnnotation.js";
+import { TestAnnotationMap } from "../../data/TestAnnotationMap.js";
+import { Annotations } from "./definition.js";
+
+export class LiveAnnotations extends Annotations {
+  constructor(private fiberRef: FiberRef<TestAnnotationMap>) {
+    super();
+  }
+
+  annotate<V>(key: TestAnnotation<V>, value: V): UIO<void> {
+    return this.fiberRef.update((map) => map.annotate(key, value));
+  }
+
+  get<V>(key: TestAnnotation<V>) {
+    return this.fiberRef.get.map((map) => map.get(key));
+  }
+
+  withAnnotation<R, E, A>(io: IO<R, E, A>) {
+    return this.fiberRef.locally(TestAnnotationMap.empty)(
+      io.matchIO(
+        (e) => this.fiberRef.get.map((m) => [e, m] as const).swap,
+        (a) => this.fiberRef.get.map((m) => [a, m] as const),
+      ),
+    );
+  }
+
+  supervisedFibers = IO.descriptorWith((descriptor) =>
+    this.fiberRef.get
+      .map((m) => m.get(TestAnnotation.Fibers))
+      .flatMap((r) =>
+        r.match(
+          () => IO.succeed(HashSet.makeDefault<Fiber.Runtime<any, any>>()),
+          (refs) =>
+            IO.foreach(refs, (ref) => ref.get)
+              .map((fibers) =>
+                fibers.foldLeft(HashSet.makeDefault<Fiber.Runtime<any, any>>(), (s1, s2) => s1.union(s2)),
+              )
+              .map((s) => s.filter((f) => Equatable.strictEquals(f.id, descriptor.id))),
+        ),
+      ),
+  );
+}
+
+/**
+ * @tsplus static fncts.test.AnnotationsOps Live
+ */
+export const live = Layer.scoped(
+  FiberRef.make(TestAnnotationMap.empty).map((fiberRef) => new LiveAnnotations(fiberRef)),
+  Annotations.Tag,
+);

package/_src/control/Annotations.ts

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

package/_src/control/Assertion/api.ts

@@ -0,0 +1,236 @@
+import type { Eq } from "@fncts/base/typeclass";
+
+import { identity } from "@fncts/base/data/function";
+
+import { AssertionData } from "../../data/AssertionData.js";
+import { AssertionValue } from "../../data/AssertionValue.js";
+import { FreeBooleanAlgebra } from "../../data/FreeBooleanAlgebra.js";
+import { Render } from "../../data/Render.js";
+import { RenderParam } from "../../data/RenderParam.js";
+import { Assertion } from "./definition.js";
+
+/**
+ * @tsplus fluent fncts.test.Assertion and
+ * @tsplus operator fncts.test.Assertion &&
+ */
+export function and_<A>(self: Assertion<A>, that: Assertion<A>): Assertion<A> {
+  return new Assertion(
+    Render.infix(RenderParam(self), "&&", RenderParam(that)),
+    (actual) => self.run(actual) && that.run(actual),
+  );
+}
+
+/**
+ * @tsplus static fncts.test.AssertionOps anything
+ */
+export const anything: Assertion<any> = Assertion.make("anything", [], () => true);
+
+/**
+ * @tsplus static fncts.test.AssertionOps approximatelyEquals
+ */
+export function approximatelyEquals(reference: number, tolerance: number): Assertion<number> {
+  return Assertion.make("approximatelyEquals", [RenderParam(reference), RenderParam(tolerance)], (actual) => {
+    const max = reference + tolerance;
+    const min = reference - tolerance;
+    return actual >= min && actual <= max;
+  });
+}
+
+/**
+ * @tsplus static fncts.test.AssertionOps make
+ */
+export function assertion<A>(
+  name: string,
+  params: ReadonlyArray<RenderParam>,
+  run: (actual: A) => boolean,
+): Assertion<A> {
+  const assertion: LazyValue<Assertion<A>> = LazyValue(() => {
+    return Assertion.direct(name, params, (actual) => {
+      const result: LazyValue<FreeBooleanAlgebra<AssertionValue<A>>> = LazyValue(() => {
+        if (run(actual)) {
+          return FreeBooleanAlgebra.success(new AssertionValue(assertion, actual, result));
+        } else {
+          return FreeBooleanAlgebra.failure(new AssertionValue(assertion, actual, result));
+        }
+      });
+      return result.value;
+    });
+  });
+  return assertion.value;
+}
+
+/**
+ * @tsplus static fncts.test.AssertionOps direct
+ */
+export function assertionDirect<A>(
+  name: string,
+  params: ReadonlyArray<RenderParam>,
+  run: (actual: A) => FreeBooleanAlgebra<AssertionValue<A>>,
+): Assertion<A> {
+  return new Assertion(Render.fn(name, Conc.single(Conc.from(params))), run);
+}
+
+/**
+ * @tsplus static fncts.test.AssertionOps rec
+ */
+export function assertionRec<A, B>(
+  name: string,
+  params: ReadonlyArray<RenderParam>,
+  assertion: Assertion<B>,
+  get: (a: A) => Maybe<B>,
+  orElse: (data: AssertionData<A>) => FreeBooleanAlgebra<AssertionValue<A>> = (_) => _.asFailure,
+): Assertion<A> {
+  const resultAssertion: LazyValue<Assertion<A>> = LazyValue(() =>
+    Assertion.direct(name, params, (a) =>
+      get(a).match(
+        () => orElse(new AssertionData(a, resultAssertion.value)),
+        (b) => {
+          const innerResult = assertion.run(b);
+          const result: LazyValue<FreeBooleanAlgebra<AssertionValue<any>>> = LazyValue(() => {
+            if (innerResult.isSuccess) {
+              return FreeBooleanAlgebra.success(new AssertionValue(resultAssertion, a, result));
+            } else {
+              return FreeBooleanAlgebra.failure(new AssertionValue(LazyValue(assertion), b, LazyValue(innerResult)));
+            }
+          });
+          return result.value;
+        },
+      ),
+    ),
+  );
+  return resultAssertion.value;
+}
+
+export function contains<A>(element: A): Assertion<Iterable<A>> {
+  return Assertion.make("contains", [RenderParam(element)], (ia) =>
+    ia.find((a) => Equatable.deepEquals(a, element)).isJust(),
+  );
+}
+
+export function containsCause<E>(cause: Cause<E>): Assertion<Cause<E>> {
+  return Assertion.make("containsCause", [RenderParam(cause)], (c) => c.contains(cause));
+}
+
+export function containsString(element: string): Assertion<string> {
+  return Assertion.make("containsString", [RenderParam(element)], (str) => str.includes(element));
+}
+
+export function exists<A>(assertion: Assertion<A>): Assertion<Iterable<A>> {
+  return Assertion.rec("exists", [RenderParam(assertion)], assertion, (ia) => ia.find((a) => assertion.test(a)));
+}
+
+export function fails<E>(assertion: Assertion<E>): Assertion<Exit<E, any>> {
+  return Assertion.rec("fails", [RenderParam(assertion)], assertion, (exit) =>
+    exit.match(
+      (cause) => cause.failures.head,
+      () => Nothing(),
+    ),
+  );
+}
+
+export function forall<A>(assertion: Assertion<A>): Assertion<Iterable<A>> {
+  return Assertion.rec(
+    "forall",
+    [RenderParam(assertion)],
+    assertion,
+    (ia) => ia.find((a) => !assertion.test(a)),
+    (data) => data.asSuccess,
+  );
+}
+
+export function halts(assertion: Assertion<any>): Assertion<Exit<any, any>> {
+  return Assertion.rec("halts", [RenderParam(assertion)], assertion, (exit) =>
+    exit.match(
+      (c) => c.haltMaybe,
+      () => Nothing(),
+    ),
+  );
+}
+
+export function strictEqualTo<A>(expected: A): Assertion<A> {
+  return Assertion.make("strictEqualTo", [RenderParam(expected)], (actual) => Equatable.strictEquals(actual, expected));
+}
+
+export function deepEqualTo<A>(expected: A): Assertion<A> {
+  return Assertion.make("deepEqualTo", [RenderParam(expected)], (actual) => Equatable.deepEquals(actual, expected));
+}
+
+export function equals<A>(expected: A, E: Eq<A>): Assertion<A> {
+  return Assertion.make("equals", [RenderParam(expected)], (actual) => E.equals_(actual, expected));
+}
+
+export const isFalse: Assertion<boolean> = Assertion.make("isFale", [], (b) => !b);
+
+export const isInterrupted: Assertion<Exit<any, any>> = Assertion.make("isInterrupted", [], (exit) =>
+  exit.match(
+    (cause) => cause.interrupted,
+    () => false,
+  ),
+);
+
+export function isLeft<A>(assertion: Assertion<A>): Assertion<Either<A, any>> {
+  return Assertion.rec("isLeft", [RenderParam(assertion)], assertion, (actual) =>
+    actual.match(
+      (a) => Just(a),
+      () => Nothing(),
+    ),
+  );
+}
+
+export function isJust<A>(assertion: Assertion<A>): Assertion<Maybe<A>> {
+  return Assertion.rec("isJust", [RenderParam(assertion)], assertion, identity);
+}
+
+export const isNothing: Assertion<Maybe<any>> = Assertion.make("isNothing", [], (actual) => actual.isNothing());
+
+export function isRight<A>(assertion: Assertion<A>): Assertion<Either<any, A>> {
+  return Assertion.rec("isRight", [RenderParam(assertion)], assertion, (actual) =>
+    actual.match(
+      () => Nothing(),
+      (a) => Just(a),
+    ),
+  );
+}
+
+export const isTrue: Assertion<boolean> = Assertion.make("isTrue", [], identity);
+
+/**
+ * @tsplus fluent fncts.test.Assertion label
+ */
+export function label_<A>(self: Assertion<A>, label: string): Assertion<A> {
+  return new Assertion(Render.infix(RenderParam(self), ":", RenderParam(label)), self.run);
+}
+
+/**
+ * @tsplus getter fncts.test.Assertion invert
+ */
+export function not<A>(assertion: Assertion<A>): Assertion<A> {
+  return Assertion.direct("not", [RenderParam(assertion)], (actual) => assertion.run(actual).invert);
+}
+
+/**
+ * @tsplus fluent fncts.test.Assertion or
+ * @tsplus operator fncts.test.Assertion ||
+ */
+export function or_<A>(self: Assertion<A>, that: Assertion<A>): Assertion<A> {
+  return new Assertion(
+    Render.infix(RenderParam(self), "||", RenderParam(that)),
+    (actual) => self.run(actual) || that.run(actual),
+  );
+}
+
+export function succeeds<A>(assertion: Assertion<A>): Assertion<Exit<any, A>> {
+  return Assertion.rec("succeeds", [RenderParam(assertion)], assertion, (exit) =>
+    exit.match(
+      () => Nothing(),
+      (a) => Just(a),
+    ),
+  );
+}
+
+/**
+ * @tsplus fluent fncts.test.Assertion test
+ */
+export function test_<A>(self: Assertion<A>, actual: A): boolean {
+  return self.run(actual).isSuccess;
+}

package/_src/control/Assertion/definition.ts

@@ -0,0 +1,20 @@
+import type { AssertionValue } from "../../data/AssertionValue.js";
+import type { FreeBooleanAlgebra } from "../../data/FreeBooleanAlgebra.js";
+import type { Render } from "../../data/Render.js";
+
+import { AssertionIO } from "../AssertionIO.js";
+
+/**
+ * @tsplus type fncts.test.FreeBooleanAlgebra
+ */
+export type AssertResult<A> = FreeBooleanAlgebra<AssertionValue<A>>;
+
+/**
+ * @tsplus type fncts.test.Assertion
+ * @tsplus companion fncts.test.AssertionOps
+ */
+export class Assertion<A> extends AssertionIO<A> {
+  constructor(readonly render: Render, readonly run: (actual: A) => AssertResult<A>) {
+    super(render, (actual) => IO.succeedNow(run(actual)));
+  }
+}

package/_src/control/Assertion.ts

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

package/_src/control/AssertionIO/api.ts

@@ -0,0 +1,32 @@
+import { Render } from "../../data/Render.js";
+import { RenderParam } from "../../data/RenderParam.js";
+import { AssertionIO } from "./definition.js";
+
+/**
+ * @tsplus fluent fncts.test.AssertionIO and
+ * @tsplus operator fncts.test.AssertionIO &&
+ */
+export function and_<A>(self: AssertionIO<A>, that: AssertionIO<A>): AssertionIO<A> {
+  return new AssertionIO(
+    Render.infix(RenderParam(self), "&&", RenderParam(that)),
+    (actual) => self.runIO(actual) && that.runIO(actual),
+  );
+}
+
+/**
+ * @tsplus fluent fncts.test.AssertionIO or
+ * @tsplus operator fncts.test.AssertionIO ||
+ */
+export function or_<A>(self: AssertionIO<A>, that: AssertionIO<A>): AssertionIO<A> {
+  return new AssertionIO(
+    Render.infix(RenderParam(self), "||", RenderParam(that)),
+    (actual) => self.runIO(actual) || that.runIO(actual),
+  );
+}
+
+/**
+ * @tsplus fluent fncts.test.AssertionIO label
+ */
+export function label_<A>(self: AssertionIO<A>, label: string): AssertionIO<A> {
+  return new AssertionIO(Render.infix(RenderParam(self), ":", RenderParam(label)), self.runIO);
+}

package/_src/control/AssertionIO/definition.ts

@@ -0,0 +1,26 @@
+import type { AssertionValue } from "../../data/AssertionValue.js";
+import type { Render } from "../../data/Render.js";
+import type { FreeBooleanAlgebraIO } from "../FreeBooleanAlgebraIO.js";
+
+import { hasTypeId } from "@fncts/base/util/predicates";
+
+export type AssertResultIO<A> = FreeBooleanAlgebraIO<unknown, never, AssertionValue<A>>;
+
+export const AssertionIOTypeId = Symbol.for("fncts.test.AssertionIO");
+export type AssertionIOTypeId = typeof AssertionIOTypeId;
+
+/**
+ * @tsplus type fncts.test.AssertionIO
+ * @tsplus companion fncts.test.AssertionIOOps
+ */
+export class AssertionIO<A> {
+  readonly _typeId: AssertionIOTypeId = AssertionIOTypeId;
+  constructor(readonly render: Render, readonly runIO: (actual: A) => AssertResultIO<A>) {}
+  get rendered() {
+    return this.render.rendered;
+  }
+}
+
+export function isAssertionIO(u: unknown): u is AssertionIO<unknown> {
+  return hasTypeId(u, AssertionIOTypeId);
+}

package/_src/control/AssertionIO.ts

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

package/_src/control/DefaultRunnableSpec.ts

@@ -0,0 +1,12 @@
+import { RunnableSpec } from "@fncts/test/control/RunnableSpec";
+import { timeoutWarning } from "@fncts/test/control/TestAspect";
+import { TestEnvironment } from "@fncts/test/control/TestEnvironment";
+import { defaultTestExecutor } from "@fncts/test/control/TestExecutor";
+import { TestRunner } from "@fncts/test/control/TestRunner";
+
+const defaultTestRunner = new TestRunner(defaultTestExecutor(TestEnvironment));
+
+export abstract class DefaultRunnableSpec extends RunnableSpec<TestEnvironment, any> {
+  aspects = [timeoutWarning(60000)];
+  runner  = defaultTestRunner;
+}

package/_src/control/DefaultTestReporter/definition.ts

@@ -0,0 +1,6 @@
+/**
+ * @tsplus type fncts.test.DefaultTestReporter
+ */
+export interface DefaultTestReporter {}
+
+export const DefaultTestReporter: DefaultTestReporter = {};