@fncts/test 0.0.1

package/_src/control/Gen/api/string.ts

@@ -0,0 +1,71 @@
+import type { Sized } from "../../Sized.js";
+import type { LengthConstraints } from "../constraints.js";
+
+import { Gen } from "../definition.js";
+import { alphaNumericChar, asciiChar, base64Char, char16, fullUnicodeChar, hexChar, unicodeChar } from "./char.js";
+
+/**
+ * @tsplus static fncts.test.GenOps asciiString
+ */
+export function asciiString<R>(constraints?: LengthConstraints): Gen<R & Has<Sized>, string> {
+  return asciiChar.string(constraints);
+}
+
+/**
+ * @tsplus static fncts.test.GenOps alphaNumericString
+ */
+export function alphaNumericString(constraints: LengthConstraints = {}): Gen<unknown & Has<Sized>, string> {
+  return alphaNumericChar.string(constraints);
+}
+
+/**
+ * @tsplus static fncts.test.GenOps base64String
+ */
+export function base64String(constraints: LengthConstraints = {}): Gen<unknown & Has<Sized>, string> {
+  return base64Char.string(constraints);
+}
+
+/**
+ * @tsplus static fncts.test.GenOps fullUnicodeString
+ */
+export function fullUnicodeString(constraints: LengthConstraints = {}): Gen<unknown & Has<Sized>, string> {
+  return fullUnicodeChar.string(constraints);
+}
+
+/**
+ * @tsplus static fncts.test.GenOps hexString
+ */
+export function hexString(constraints: LengthConstraints = {}): Gen<unknown & Has<Sized>, string> {
+  return hexChar.string(constraints);
+}
+
+/**
+ * @tsplus static fncts.test.GenOps string16
+ */
+export function string16(constraints: LengthConstraints = {}): Gen<unknown & Has<Sized>, string> {
+  return char16.string(constraints);
+}
+
+/**
+ * @tsplus fluent fncts.test.Gen string
+ */
+export function string<R>(char: Gen<R, string>, constraints: LengthConstraints = {}): Gen<R & Has<Sized>, string> {
+  const min = constraints.minLength || 0;
+  return constraints.maxLength
+    ? Gen.bounded(min, constraints.maxLength, (n) => char.stringN(n))
+    : Gen.small((n) => char.stringN(n), min);
+}
+
+/**
+ * @tsplus fluent fncts.test.Gen stringN
+ */
+export function stringN<R>(char: Gen<R, string>, n: number): Gen<R, string> {
+  return char.arrayN(n).map((arr) => arr.join(""));
+}
+
+/**
+ * @tsplus static fncts.test.GenOps unicodeString
+ */
+export function unicodeString(constraints: LengthConstraints = {}): Gen<unknown & Has<Sized>, string> {
+  return unicodeChar.string(constraints);
+}

package/_src/control/Gen/api/struct.ts

@@ -0,0 +1,21 @@
+import type { _A, _R } from "@fncts/base/types";
+
+import { Gen } from "../definition.js";
+
+export function struct<P extends Record<string, Gen<any, any>>>(
+  properties: P,
+): Gen<_R<P[keyof P]>, { readonly [K in keyof P]: _A<P[K]> }> {
+  const entries = Object.entries(properties);
+  return entries.foldLeft(Gen.constant({}) as Gen<any, any>, (b, [k, gen]) =>
+    b.zipWith(gen, (out, a) => ({ ...out, [k]: a })),
+  );
+}
+
+export function partial<P extends Record<string, Gen<any, any>>>(
+  properties: P,
+): Gen<unknown & _R<P[keyof P]>, Partial<{ readonly [K in keyof P]: _A<P[K]> }>> {
+  const entries = Object.entries(properties);
+  return entries.foldLeft(Gen.constant({}) as Gen<any, any>, (b, [k, gen]) =>
+    Gen.unwrap(Random.nextBoolean.ifIO(IO.succeed(b.zipWith(gen, (r, a) => ({ ...r, [k]: a }))), IO.succeed(b))),
+  );
+}

package/_src/control/Gen/api.ts

@@ -0,0 +1,276 @@
+import type { NumberConstraints } from "./constraints.js";
+import type { _A, _R } from "@fncts/base/types.js";
+
+import { SortedMap } from "@fncts/base/collection/immutable/SortedMap";
+import { IllegalArgumentError, NoSuchElementError } from "@fncts/base/data/exceptions";
+import { tuple } from "@fncts/base/data/function";
+import { identity } from "@fncts/base/data/function";
+
+import { clamp } from "../../util/math.js";
+import { Sample } from "../Sample.js";
+import { Sized } from "../Sized.js";
+import { Gen } from "./definition.js";
+
+/**
+ * @tsplus static fncts.test.GenOps anyBigInt
+ */
+export const anyBigInt: Gen<unknown, bigint> = fromIOSample(
+  Random.nextBigIntBetween(BigInt(-1) << BigInt(255), (BigInt(1) << BigInt(255)) - BigInt(1)).map(
+    Sample.shrinkBigInt(BigInt(0)),
+  ),
+);
+
+/**
+ * @tsplus static fncts.test.GenOps anyDouble
+ */
+export const anyDouble: Gen<unknown, number> = Gen.fromIOSample(Random.nextDouble.map(Sample.shrinkFractional(0)));
+
+/**
+ * @tsplus static fncts.test.GenOps anyInt
+ */
+export const anyInt: Gen<unknown, number> = Gen.fromIOSample(Random.nextInt.map(Sample.shrinkIntegral(0)));
+
+/**
+ * @tsplus static fncts.test.GenOps bounded
+ */
+export function bounded<R, A>(min: number, max: number, f: (n: number) => Gen<R, A>): Gen<R, A> {
+  return Gen.int({ min, max }).flatMap(f);
+}
+
+/**
+ * @tsplus static fncts.test.GenOps constant
+ */
+export function constant<A>(a: A): Gen<unknown, A> {
+  return new Gen(Stream.succeedNow(Just(Sample.noShrink(a))));
+}
+
+/**
+ * @tsplus fluent fncts.test.Gen flatMap
+ */
+export function flatMap_<R, A, R1, B>(ma: Gen<R, A>, f: (a: A) => Gen<R1, B>): Gen<R & R1, B> {
+  return new Gen(
+    Sample.flatMapStream(ma.sample, (sample) => {
+      const values  = f(sample.value).sample;
+      const shrinks = new Gen(sample.shrink).flatMap((a) => f(a)).sample;
+      return values.map((maybeSample) => maybeSample.map((sample) => sample.flatMap((b) => new Sample(b, shrinks))));
+    }),
+  );
+}
+
+/**
+ * @tsplus static fncts.test.GenOps defer
+ */
+export function defer<R, A>(gen: Lazy<Gen<R, A>>): Gen<R, A> {
+  return Gen.fromIO(IO.succeed(gen)).flatten;
+}
+
+/**
+ * @tsplus static fncts.test.GenOps empty
+ */
+export const empty: Gen<unknown, never> = new Gen(Stream.empty);
+
+/**
+ * @tsplus fluent fncts.test.Gen filter
+ */
+export function filter_<R, A, B extends A>(fa: Gen<R, A>, p: Refinement<A, B>): Gen<R, B>;
+export function filter_<R, A>(fa: Gen<R, A>, p: Predicate<A>): Gen<R, A>;
+export function filter_<R, A>(fa: Gen<R, A>, p: Predicate<A>): Gen<R, A> {
+  return fa.flatMap((a) => (p(a) ? Gen.constant(a) : Gen.empty));
+}
+
+/**
+ * @tsplus fluent fncts.test.Gen filterNot
+ */
+export function filterNot_<R, A>(fa: Gen<R, A>, p: Predicate<A>): Gen<R, A> {
+  return fa.filter((a) => !p(a));
+}
+
+/**
+ * @tsplus getter fncts.test.Gen flatten
+ */
+export function flatten<R, R1, A>(mma: Gen<R, Gen<R1, A>>): Gen<R & R1, A> {
+  return mma.flatMap(identity);
+}
+
+/**
+ * @tsplus static fncts.test.GenOps fromIO
+ */
+export function fromIO<R, A>(effect: IO<R, never, A>): Gen<R, A> {
+  return Gen.fromIOSample(effect.map(Sample.noShrink));
+}
+
+/**
+ * @tsplus static fncts.test.GenOps fromIOSample
+ */
+export function fromIOSample<R, A>(effect: IO<R, never, Sample<R, A>>): Gen<R, A> {
+  return new Gen(Stream.fromIO(effect.map(Maybe.just)));
+}
+
+/**
+ * @tsplus static fncts.test.GenOps int
+ */
+export function int(constraints: NumberConstraints = {}): Gen<unknown, number> {
+  return Gen.fromIOSample(
+    IO.defer(() => {
+      const min = constraints.min ?? -0x80000000;
+      const max = constraints.max ?? 0x7fffffff;
+      if (min > max || min < Number.MIN_SAFE_INTEGER || max > Number.MAX_SAFE_INTEGER) {
+        return IO.haltNow(new IllegalArgumentError("invalid bounds", "Gen.int"));
+      } else {
+        return Random.nextIntBetween(min, max).map(Sample.shrinkIntegral(min));
+      }
+    }),
+  );
+}
+
+/**
+ * @tsplus fluent fncts.test.Gen map
+ */
+export function map_<R, A, B>(self: Gen<R, A>, f: (a: A) => B): Gen<R, B> {
+  return new Gen(self.sample.map((maybeSample) => maybeSample.map((sample) => sample.map(f))));
+}
+
+/**
+ * @tsplus fluent fncts.test.Gen mapIO
+ */
+export function mapIO_<R, A, R1, B>(self: Gen<R, A>, f: (a: A) => IO<R1, never, B>): Gen<R & R1, B> {
+  return new Gen(
+    self.sample.mapIO((maybeSample) =>
+      maybeSample.match(
+        () => IO.succeedNow(Nothing()),
+        (sample) => sample.foreach(f).map(Maybe.just),
+      ),
+    ),
+  );
+}
+
+/**
+ * @tsplus static fncts.test.GenOps exponential
+ */
+export const exponential: Gen<unknown, number> = Gen.uniform.map((n) => -Math.log(1 - n));
+
+/**
+ * @tsplus static fncts.test.GenOps size
+ */
+export const size: Gen<Has<Sized>, number> = Gen.fromIO(Sized.size);
+
+/**
+ * @tsplus static fncts.test.GenOps medium
+ */
+export function medium<R, A>(f: (n: number) => Gen<R, A>, min = 0): Gen<R & Has<Sized>, A> {
+  return Gen.size
+    .flatMap((max) => Gen.exponential.map((n) => clamp(Math.round((n * max) / 10.0), min, max)))
+    .reshrink(Sample.shrinkIntegral(min))
+    .flatMap(f);
+}
+
+/**
+ * @tsplus static fncts.test.GenOps memo
+ */
+export function memo<R, A>(builder: (maxDepth: number) => Gen<R, A>): (maxDepth?: number) => Gen<R, A> {
+  const previous: { [depth: number]: Gen<R, A> } = {};
+  let remainingDepth = 10;
+  return (maxDepth?: number): Gen<R, A> => {
+    const n = maxDepth !== undefined ? maxDepth : remainingDepth;
+    if (!Object.prototype.hasOwnProperty.call(previous, n)) {
+      const prev     = remainingDepth;
+      remainingDepth = n - 1;
+      previous[n]    = builder(n);
+      remainingDepth = prev;
+    }
+    return previous[n]!;
+  };
+}
+
+/**
+ * @tsplus static fncts.test.GenOps nat
+ */
+export function nat(max = 0x7fffffff): Gen<unknown, number> {
+  return Gen.int({ min: 0, max: clamp(max, 0, max) });
+}
+
+/**
+ * @tsplus static fncts.test.GenOps oneOf
+ */
+export function oneOf<A extends ReadonlyArray<Gen<any, any>>>(...gens: A): Gen<_R<A[number]>, _A<A[number]>> {
+  if (gens.isEmpty()) return Gen.empty;
+  else return Gen.int({ min: 0, max: gens.length - 1 }).flatMap((i) => gens[i]!);
+}
+
+/**
+ * @tsplus fluent fncts.test.Gen reshrink
+ */
+export function reshrink_<R, A, R1, B>(gen: Gen<R, A>, f: (a: A) => Sample<R1, B>): Gen<R & R1, B> {
+  return new Gen(
+    (gen.sample as Stream<R & R1, never, Maybe<Sample<R, A>>>).map((maybeSample) =>
+      maybeSample.map((sample) => f(sample.value)),
+    ),
+  );
+}
+
+/**
+ * @tsplus static fncts.test.GenOps sized
+ */
+export function sized<R, A>(f: (size: number) => Gen<R, A>): Gen<R & Has<Sized>, A> {
+  return Gen.size.flatMap(f);
+}
+
+/**
+ * @tsplus static fncts.test.GenOps small
+ */
+export function small<R, A>(f: (size: number) => Gen<R, A>, min = 0): Gen<R & Has<Sized>, A> {
+  return Gen.size
+    .flatMap((max) => Gen.exponential.map((n) => clamp(Math.round((n * max) / 25), min, max)))
+    .reshrink(Sample.shrinkIntegral(min))
+    .flatMap(f);
+}
+
+/**
+ * @tsplus static fncts.test.GenOps unfoldGen
+ */
+export function unfoldGen<S, R, A>(s: S, f: (s: S) => Gen<R, readonly [S, A]>): Gen<R & Has<Sized>, Conc<A>> {
+  return Gen.small((n) => Gen.unfoldGenN(n, s, f));
+}
+
+/**
+ * @tsplus static fncts.test.GenOps unfoldGenN
+ */
+export function unfoldGenN<S, R, A>(n: number, s: S, f: (s: S) => Gen<R, readonly [S, A]>): Gen<R, Conc<A>> {
+  if (n <= 0) return Gen.constant(Conc());
+  else return f(s).flatMap(([s, a]) => Gen.unfoldGenN(n - 1, s, f).map((as) => as.append(a)));
+}
+
+/**
+ * @tsplus static fncts.test.GenOps uniform
+ */
+export const uniform: Gen<unknown, number> = Gen.fromIOSample(Random.nextDouble.map(Sample.shrinkFractional(0.0)));
+
+/**
+ * @tsplus static fncts.test.GenOps unwrap
+ */
+export function unwrap<R, R1, A>(effect: URIO<R, Gen<R1, A>>): Gen<R & R1, A> {
+  return Gen.fromIO(effect).flatten;
+}
+
+/**
+ * @tsplus static fncts.test.GenOps weighted
+ */
+export function weighted<R, A>(...gens: ReadonlyArray<readonly [Gen<R, A>, number]>): Gen<R, A> {
+  const sum   = gens.map(([, weight]) => weight).foldLeft(0, (b, a) => b + a);
+  const [map] = gens.foldLeft(tuple(SortedMap.make<number, Gen<R, A>>(Number.Ord), 0), ([map, acc], [gen, d]) => {
+    if ((acc + d) / sum > acc / sum) return tuple(map.insert((acc + d) / sum, gen), acc + d);
+    else return tuple(map, acc);
+  });
+  return Gen.uniform.flatMap((n) =>
+    map.getGte(n).getOrElse(() => {
+      throw new NoSuchElementError("Gen.weighted");
+    }),
+  );
+}
+
+/**
+ * @tsplus fluent fncts.test.Gen zipWith
+ */
+export function zipWith_<R, A, R1, B, C>(self: Gen<R, A>, that: Gen<R1, B>, f: (a: A, b: B) => C): Gen<R & R1, C> {
+  return self.flatMap((a) => that.map((b) => f(a, b)));
+}

package/_src/control/Gen/constraints.ts

@@ -0,0 +1,38 @@
+import type { Gen } from "./definition.js";
+import type { Eq } from "@fncts/base/typeclass";
+
+export interface LengthConstraints {
+  minLength?: number;
+  maxLength?: number;
+}
+
+export interface EqConstraint<A> {
+  eq?: Eq<A>;
+}
+
+export interface DateConstraints {
+  min?: Date;
+  max?: Date;
+}
+
+export interface ObjectConstraints {
+  maxDepth?: number;
+  maxKeys?: number;
+  key?: Gen<any, string>;
+  values?: Gen<any, any>[];
+  withSet?: boolean;
+  withMap?: boolean;
+  withBigint?: boolean;
+  withDate?: boolean;
+  withTypedArray?: boolean;
+}
+
+export interface NumberConstraints {
+  min?: number;
+  max?: number;
+}
+
+export interface FloatConstraints {
+  noDefaultInfinity?: boolean;
+  noNaN?: boolean;
+}

package/_src/control/Gen/definition.ts

@@ -0,0 +1,9 @@
+import type { Sample } from "../Sample.js";
+
+/**
+ * @tsplus type fncts.test.Gen
+ * @tsplus companion fncts.test.GenOps
+ */
+export class Gen<R, A> {
+  constructor(readonly sample: Stream<R, never, Maybe<Sample<R, A>>>) {}
+}

package/_src/control/Gen.ts

@@ -0,0 +1,15 @@
+// codegen:start { preset: barrel, include: ./Gen/*.ts }
+export * from "./Gen/api.js";
+export * from "./Gen/constraints.js";
+export * from "./Gen/definition.js";
+// codegen:end
+
+// codegen:start { preset: barrel, include: ./Gen/api/*.ts }
+export * from "./Gen/api/array.js";
+export * from "./Gen/api/char.js";
+export * from "./Gen/api/conc.js";
+export * from "./Gen/api/double.js";
+export * from "./Gen/api/float.js";
+export * from "./Gen/api/string.js";
+export * from "./Gen/api/struct.js";
+// codegen:end

package/_src/control/Live/definition.ts

@@ -0,0 +1,47 @@
+import type { Erase } from "@fncts/typelevel/Intersection";
+
+import { IOEnv } from "@fncts/io/IOEnv";
+
+/**
+ * @tsplus static fncts.test.LiveOps Tag
+ */
+export const LiveTag = Tag<Live>();
+
+/**
+ * @tsplus companion fncts.test.LiveOps
+ */
+export abstract class Live {
+  abstract provide<R, E, A>(io: IO<R, E, A>): IO<R, E, A>;
+
+  static Default: Layer<IOEnv, never, Has<Live>> = Layer.fromIO(
+    IO.environmentWith(
+      (env) =>
+        new (class extends Live {
+          provide<R, E, A>(io: IO<R, E, A>): IO<R, E, A> {
+            return IOEnv.services.locallyWith((_) => _.union(env))(io);
+          }
+        })(),
+    ),
+    LiveTag,
+  );
+
+  static Live<R extends Has<Live>, E, A>(io: IO<R, E, A>): IO<R & Has<Live>, E, A> {
+    return IO.serviceWithIO((live) => live.provide(io), LiveTag);
+  }
+}
+
+/**
+ * @tsplus static fncts.test.LiveOps withLive
+ */
+export function withLive_<R, E, A, E1, B>(
+  io: IO<R, E, A>,
+  f: (_: IO<unknown, E, A>) => IO<IOEnv, E1, B>,
+): IO<Erase<R, Has<Live>>, E | E1, B> {
+  // @ts-expect-error
+  return IO.environment<R & Has<Live>>().flatMap((r) => Live.Live(f(io.provideEnvironment(r))));
+}
+
+export function withLive<R extends Has<Live>, E, A>(io: IO<R, E, A>) {
+  return <E1, B>(f: (_: IO<R, E, A>) => IO<R, E1, B>): IO<R & Has<Live>, E1, B> =>
+    IOEnv.services.getWith((services) => Live.Live(f(IOEnv.services.locally(services)(io))));
+}

package/_src/control/Live.ts

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

package/_src/control/RunnableSpec.ts

@@ -0,0 +1,42 @@
+import type { Spec } from "@fncts/test/control/Spec";
+import type { TestArgs } from "@fncts/test/data/TestArgs";
+
+import { matchTag } from "@fncts/base/util/pattern";
+import { isObject } from "@fncts/base/util/predicates";
+import { AbstractRunnableSpec } from "@fncts/test/control/AbstractRunnableSpec";
+import { SummaryBuilder } from "@fncts/test/control/SummaryBuilder";
+import { TestLogger } from "@fncts/test/control/TestLogger";
+
+export abstract class RunnableSpec<R, E> extends AbstractRunnableSpec<R, E> {
+  readonly _tag = "RunnableSpec";
+  run(spec: Spec<R, E>): URIO<Has<TestLogger>, number> {
+    const self = this;
+    return IO.gen(function* (_) {
+      const results     = yield* _(self.runSpec(spec));
+      const hasFailures = results.exists(
+        matchTag(
+          {
+            Test: ({ test }) => test.isLeft(),
+          },
+          () => false,
+        ),
+      );
+      const summary = SummaryBuilder.buildSummary(results);
+      yield* _(TestLogger.logLine(summary.summary));
+      return hasFailures ? 1 : 0;
+    });
+  }
+
+  main(_args?: TestArgs): void {
+    // const filteredSpec = this.spec.filterByArgs(this.spec, args);
+    this.run(this.spec)
+      .provideLayer(this.runner.bootstrap)
+      .unsafeRunAsyncWith((exit) => {
+        console.log(exit);
+      });
+  }
+}
+
+export function isRunnableSpec(u: unknown): u is RunnableSpec<unknown, unknown> {
+  return isObject(u) && "_tag" in u && u["_tag"] === "RunnableSpec";
+}