@fncts/test 0.0.20 → 0.0.22

package/_src/api.ts

@@ -50,21 +50,25 @@ export function traverseResult<A>(value: A, assertResult: AssertResult<A>, asser
 }
 
 /**
- * @tsplus fluent global assert 1
+ * @tsplus pipeable global assert
  */
-export function assert_<A>(value: A, assertion: Assertion<A>): TestResult {
-  return traverseResult(value, assertion.run(value), assertion);
+export function assert<A>(assertion: Assertion<A>) {
+  return (value: A): TestResult => {
+    return traverseResult(value, assertion.run(value), assertion);
+  };
 }
 
 /**
- * @tsplus fluent global assert 0
+ * @tsplus pipeable fncts.io.IO assert
  */
-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 assertIO<A>(assertion: AssertionIO<A>) {
+  return <R, E>(io: IO<R, E, A>): IO<R, E, TestResult> => {
+    return Do((_) => {
+      const value        = _(io);
+      const assertResult = _(assertion.runIO(value));
+      return traverseResult(value, assertResult, assertion);
+    });
+  };
 }
 
 export function suite<Specs extends ReadonlyArray<Spec<any, any>>>(
@@ -83,44 +87,41 @@ export function test(label: string, assertion: Lazy<TestResult>): Spec<never, ne
 }
 
 /**
- * @tsplus fluent fncts.test.Gen check
+ * @tsplus pipeable fncts.test.Gen check
  */
-export function check<R, A>(rv: Gen<R, A>, test: (a: A) => TestResult): IO<R | TestConfig, never, TestResult> {
-  return TestConfig.samples.flatMap((n) =>
-    checkStream(rv.sample.forever.filterMap(identity).take(n), (a) => IO.succeed(test(a))),
-  );
+export function check<A>(test: (a: A) => TestResult) {
+  return <R>(rv: Gen<R, A>): IO<R | TestConfig, never, TestResult> => {
+    return TestConfig.samples.flatMap((n) =>
+      checkStream(rv.sample.forever.filterMap(identity).take(n), (a) => IO.succeed(test(a))),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.Gen check
+ * @tsplus pipeable fncts.test.Gen check
  */
-export function checkIO<R, A, R1, E>(
-  rv: Gen<R, A>,
-  test: (a: A) => IO<R1, E, TestResult>,
-): IO<R | R1 | TestConfig, E, TestResult> {
-  return TestConfig.samples.flatMap((n) => checkStream(rv.sample.forever.filterMap(identity).take(n), test));
+export function checkIO<A, R1, E>(test: (a: A) => IO<R1, E, TestResult>) {
+  return <R>(rv: Gen<R, A>): IO<R | R1 | TestConfig, E, TestResult> => {
+    return TestConfig.samples.flatMap((n) => checkStream(rv.sample.forever.filterMap(identity).take(n), test));
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.Gen checkAllC
+ * @tsplus pipeable fncts.test.Gen checkAllC
  */
-export function checkAllC<R, A>(
-  rv: Gen<R, A>,
-  concurrency: number,
-  test: (a: A) => TestResult,
-): IO<R | TestConfig, never, TestResult> {
-  return checkStreamC(rv.sample.forever.filterMap(identity), concurrency, (a) => IO.succeed(test(a)));
+export function checkAllC<A>(concurrency: number, test: (a: A) => TestResult) {
+  return <R>(rv: Gen<R, A>): IO<R | TestConfig, never, TestResult> => {
+    return checkStreamC(rv.sample.forever.filterMap(identity), concurrency, (a) => IO.succeed(test(a)));
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.Gen checkAllC
+ * @tsplus pipeable fncts.test.Gen checkAllC
  */
-export function checkAllIOC<R, A, R1, E>(
-  rv: Gen<R, A>,
-  concurrency: number,
-  test: (a: A) => IO<R1, E, TestResult>,
-): IO<R | R1 | TestConfig, E, TestResult> {
-  return checkStreamC(rv.sample.forever.filterMap(identity), concurrency, test);
+export function checkAllIOC<A, R1, E>(concurrency: number, test: (a: A) => IO<R1, E, TestResult>) {
+  return <R>(rv: Gen<R, A>): IO<R | R1 | TestConfig, E, TestResult> => {
+    return checkStreamC(rv.sample.forever.filterMap(identity), concurrency, test);
+  };
 }
 
 function checkStreamC<R, E, A, R1>(

package/_src/control/AbstractRunnableSpec.ts

@@ -8,16 +8,10 @@ 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<TestLogger, ExecutedSpec<E>> {
     return this.runSpec(this.spec);
   }
-
   runSpec(spec: Spec<R, E>): URIO<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/live.ts

@@ -6,15 +6,12 @@ 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(
@@ -23,19 +20,16 @@ export class LiveAnnotations extends Annotations {
       ),
     );
   }
-
-  supervisedFibers = IO.descriptorWith((descriptor) =>
+  supervisedFibers = IO.fiberId.flatMap((fiberId) =>
     this.fiberRef.get
       .map((m) => m.get(TestAnnotation.Fibers))
       .flatMap((r) =>
         r.match(
-          () => IO.succeed(HashSet.makeDefault<Fiber.Runtime<any, any>>()),
+          () => IO.succeed(HashSet.empty<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))),
+              .map((fibers) => fibers.foldLeft(HashSet.empty<Fiber.Runtime<any, any>>(), (s1, s2) => s1.union(s2)))
+              .map((s) => s.filter((f) => Equatable.strictEquals(f.id, fiberId))),
         ),
       ),
   );

package/_src/control/Assertion/api.ts

@@ -10,14 +10,16 @@ import { RenderParam } from "../../data/RenderParam.js";
 import { Assertion } from "./definition.js";
 
 /**
- * @tsplus fluent fncts.test.Assertion and
- * @tsplus operator fncts.test.Assertion &&
+ * @tsplus pipeable fncts.test.Assertion and
+ * @tsplus pipeable-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),
-  );
+export function and<A>(that: Assertion<A>) {
+  return (self: Assertion<A>): Assertion<A> => {
+    return new Assertion(
+      Render.infix(RenderParam(self), "&&", RenderParam(that)),
+      (actual) => self.run(actual) && that.run(actual),
+    );
+  };
 }
 
 /**
@@ -115,8 +117,8 @@ 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 some<A>(assertion: Assertion<A>): Assertion<Iterable<A>> {
+  return Assertion.rec("some", [RenderParam(assertion)], assertion, (ia) => ia.find((a) => assertion.test(a)));
 }
 
 export function fails<E>(assertion: Assertion<E>): Assertion<Exit<E, any>> {
@@ -128,9 +130,9 @@ export function fails<E>(assertion: Assertion<E>): Assertion<Exit<E, any>> {
   );
 }
 
-export function forall<A>(assertion: Assertion<A>): Assertion<Iterable<A>> {
+export function every<A>(assertion: Assertion<A>): Assertion<Iterable<A>> {
   return Assertion.rec(
-    "forall",
+    "every",
     [RenderParam(assertion)],
     assertion,
     (ia) => ia.find((a) => !assertion.test(a)),
@@ -156,7 +158,7 @@ export function deepEqualTo<A>(expected: A): Assertion<A> {
 }
 
 export function equals<A>(expected: A, E: Eq<A>): Assertion<A> {
-  return Assertion.make("equals", [RenderParam(expected)], (actual) => E.equals(actual, expected));
+  return Assertion.make("equals", [RenderParam(expected)], E.equals(expected));
 }
 
 export const isFalse: Assertion<boolean> = Assertion.make("isFale", [], (b) => !b);
@@ -210,10 +212,12 @@ export function isLessThanOrEqualTo(n: number): Assertion<number> {
 }
 
 /**
- * @tsplus fluent fncts.test.Assertion label
+ * @tsplus pipeable 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);
+export function label(label: string) {
+  return <A>(self: Assertion<A>): Assertion<A> => {
+    return new Assertion(Render.infix(RenderParam(self), ":", RenderParam(label)), self.run);
+  };
 }
 
 /**
@@ -224,16 +228,21 @@ export function not<A>(assertion: Assertion<A>): Assertion<A> {
 }
 
 /**
- * @tsplus fluent fncts.test.Assertion or
- * @tsplus operator fncts.test.Assertion ||
+ * @tsplus pipeable fncts.test.Assertion or
+ * @tsplus pipeable-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 or<A>(that: Assertion<A>) {
+  return (self: Assertion<A>): Assertion<A> => {
+    return new Assertion(
+      Render.infix(RenderParam(self), "||", RenderParam(that)),
+      (actual) => self.run(actual) || that.run(actual),
+    );
+  };
 }
 
+/**
+ * @tsplus getter fncts.test.Assertion succeeds
+ */
 export function succeeds<A>(assertion: Assertion<A>): Assertion<Exit<any, A>> {
   return Assertion.rec("succeeds", [RenderParam(assertion)], assertion, (exit) =>
     exit.match(
@@ -244,10 +253,12 @@ export function succeeds<A>(assertion: Assertion<A>): Assertion<Exit<any, A>> {
 }
 
 /**
- * @tsplus fluent fncts.test.Assertion test
+ * @tsplus pipeable fncts.test.Assertion test
  */
-export function test_<A>(self: Assertion<A>, actual: A): boolean {
-  return self.run(actual).isSuccess;
+export function test<A>(actual: A) {
+  return (self: Assertion<A>): boolean => {
+    return self.run(actual).isSuccess;
+  };
 }
 
 export const completes = Assertion.make("completes", [], () => true);

package/_src/control/AssertionIO/api.ts

@@ -3,30 +3,36 @@ import { RenderParam } from "../../data/RenderParam.js";
 import { AssertionIO } from "./definition.js";
 
 /**
- * @tsplus fluent fncts.test.AssertionIO and
- * @tsplus operator fncts.test.AssertionIO &&
+ * @tsplus pipeable fncts.test.AssertionIO and
+ * @tsplus pipeable-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),
-  );
+export function and<A>(that: AssertionIO<A>) {
+  return (self: 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 ||
+ * @tsplus pipeable fncts.test.AssertionIO or
+ * @tsplus pipeable-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),
-  );
+export function or<A>(that: AssertionIO<A>) {
+  return (self: 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
+ * @tsplus pipeable 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);
+export function label(label: string) {
+  return <A>(self: AssertionIO<A>): AssertionIO<A> => {
+    return new AssertionIO(Render.infix(RenderParam(self), ":", RenderParam(label)), self.runIO);
+  };
 }

package/_src/control/DefaultTestReporter/render.ts

@@ -51,15 +51,12 @@ export function renderStats<E>(duration: number, executedSpec: ExecutedSpec<E>)
         ],
     }),
   );
-
   const total = success + ignore + failure;
-
   const stats = detail(
     `Ran ${total} test${
       total === 1 ? "" : "s"
     } in ${duration}ms: ${success} succeeded, ${ignore} ignored, ${failure} failed`,
   );
-
   return rendered(Other, "", Passed, 0, List(stats.toLine));
 }
 
@@ -82,14 +79,13 @@ function renderLoop<E>(
     }
     case ExecutedSpecCaseTag.Multiple: {
       const specs       = executedSpec.caseValue.specs;
-      const hasFailures = executedSpec.exists((specCase) => {
+      const hasFailures = executedSpec.some((specCase) => {
         if (specCase._tag === ExecutedSpecCaseTag.Test) {
           return specCase.test.isLeft();
         } else {
           return false;
         }
       });
-
       const annotations = executedSpec.fold<E, TestAnnotationMap>(
         matchTag({
           Labeled: ({ spec }) => spec,
@@ -97,19 +93,15 @@ function renderLoop<E>(
           Test: ({ annotations }) => annotations,
         }),
       );
-
       const [status, renderedLabel] = specs.isEmpty
         ? [Ignored, Vector(renderSuiteIgnored(labels.reverse.join(" - "), depth))]
         : hasFailures
         ? [Failed, Vector(renderSuiteFailed(labels.reverse.join(" - "), depth))]
         : [Passed, Vector(renderSuiteSucceeded(labels.reverse.join(" - "), depth))];
-
       const allAnnotations = ancestors.prepend(annotations);
-
-      const rest = Vector.from(specs).flatMap((spec) =>
+      const rest           = Vector.from(specs).flatMap((spec) =>
         renderLoop(spec, depth + 1, ancestors.prepend(annotations), List.empty()),
       );
-
       return rest.prepend(
         rendered(
           Suite,
@@ -215,7 +207,6 @@ function renderGenFailureDetails(failureDetails: Maybe<GenFailureDetails>, offse
           `Test failed after ${details.iterations + 1} iteration${details.iterations > 0 ? "s" : ""} with input: `,
         ) + error(shrunken)
       ).withOffset(offset + 1);
-
       return initial === shrunken
         ? renderShrunken.toMessage
         : renderShrunken | (Fragment("Original input before shrinking was: ") + error(initial)).withOffset(offset + 1);
@@ -246,7 +237,6 @@ function renderValue<A>(av: AssertionValue<A>, offset: number) {
 
 function expressionRedundant(valueStr: string, expression: string) {
   const strip = (s: string) => s.replace('"', "").replace(" ", "").replace("\n", "").replace("\\n", "");
-
   return strip(valueStr) === strip(expression);
 }
 

package/_src/control/FreeBooleanAlgebraIO/api.ts

@@ -3,25 +3,23 @@ import type { FreeBooleanAlgebraIO } from "./definition.js";
 import { FreeBooleanAlgebra } from "../../data/FreeBooleanAlgebra.js";
 
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebraIO and
- * @tsplus operator fncts.test.FreeBooleanAlgebraIO &&
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebraIO and
+ * @tsplus pipeable-operator fncts.test.FreeBooleanAlgebraIO &&
  */
-export function and_<R, E, A extends A1, R1, E1, A1>(
-  self: FreeBooleanAlgebraIO<R, E, A>,
-  that: FreeBooleanAlgebraIO<R1, E1, A1>,
-): FreeBooleanAlgebraIO<R | R1, E | E1, A | A1> {
-  return self.zipWith(that, (a, b) => a && b);
+export function and<R1, E1, A1>(that: FreeBooleanAlgebraIO<R1, E1, A1>) {
+  return <R, E, A extends A1>(self: FreeBooleanAlgebraIO<R, E, A>): FreeBooleanAlgebraIO<R | R1, E | E1, A | A1> => {
+    return self.zipWith(that, (a, b) => a && b);
+  };
 }
 
 /**
- * @tsplus fluent fncts.test.FreeBooleanAlgebraIO or
- * @tsplus operator fncts.test.FreeBooleanAlgebraIO ||
+ * @tsplus pipeable fncts.test.FreeBooleanAlgebraIO or
+ * @tsplus pipeable-operator fncts.test.FreeBooleanAlgebraIO ||
  */
-export function or_<R, E, A extends A1, R1, E1, A1>(
-  self: FreeBooleanAlgebraIO<R, E, A>,
-  that: FreeBooleanAlgebraIO<R1, E1, A1>,
-): FreeBooleanAlgebraIO<R | R1, E | E1, A | A1> {
-  return self.zipWith(that, (a, b) => a || b);
+export function or<R1, E1, A1>(that: FreeBooleanAlgebraIO<R1, E1, A1>) {
+  return <R, E, A extends A1>(self: FreeBooleanAlgebraIO<R, E, A>): FreeBooleanAlgebraIO<R | R1, E | E1, A | A1> => {
+    return self.zipWith(that, (a, b) => a || b);
+  };
 }
 
 /**