@systemfsoftware/vitest 0.0.0 → 0.1.0

package/dist/utils.mjs

@@ -1,227 +0,0 @@
-
-import { assert } from "vitest";
-import { dual } from "effect/Function";
-import * as Equal from "effect/Equal";
-import * as Exit from "effect/Exit";
-import * as Option from "effect/Option";
-import * as Predicate from "effect/Predicate";
-import * as Result from "effect/Result";
-//#region src/utils.ts
-/**
-* Whether `actual` — possibly absent — contains `expected`.
-*/
-const includes = (actual, expected) => actual !== void 0 && actual.includes(expected);
-/**
-* `assertEquals`'s message when the caller gave none: the two values are deep-equal, so only the `Equal` trait
-* explains the failure.
-*/
-const equalMismatch = (message) => message ?? "Expected values to be Equal.equals";
-/**
-* `assertInstanceOf`'s message when the caller gave none: the value may be anything, so only the constructor
-* names the expectation.
-*/
-const instanceMismatch = (constructor, message) => message ?? `Expected value to be an instance of ${constructor.name}`;
-/**
-* Runs `thunk`, then applies `error`'s expectation to anything it threw: a validator inspects the value, an
-* `Error` must be deep-strict-equal to it, and no expectation accepts any throw.
-*/
-const applyThrown = (thunk, error) => {
-	try {
-		thunk();
-	} catch (e) {
-		Option.match(Option.fromNullishOr(error), {
-			onNone: () => void 0,
-			onSome: (expectation) => Predicate.isFunction(expectation) ? expectation(e) : deepStrictEqual(e, expectation)
-		});
-		return;
-	}
-	fail("Expected to throw an error");
-};
-/**
-* Whether a dual assertion call is the data-first one: a piped call names the expected value alone, and a
-* pair of values is the only other shape these helpers take.
-*
-* No overload of them carries a message, because a pipeable signature has to repeat its data-first twin
-* parameter for parameter (`effecttsgo/missing-pipeable-signature`). A pair of values therefore cannot be
-* mistaken for a value and a message, in the types or here, and the message a caller might have written is
-* refused rather than dropped.
-*/
-const byTwoValues = (args) => args.length >= 2;
-/**
-* Fails the current test with the provided error message.
-*
-* @since 4.0.0
-*/
-function fail(message) {
-	assert.fail(message);
-}
-/**
-* Asserts that `actual` is deeply strictly equal to `expected`.
-*
-* @since 4.0.0
-*/
-const deepStrictEqual = dual(byTwoValues, (actual, expected, message) => {
-	assert.deepStrictEqual(actual, expected, message);
-});
-/**
-* Asserts that `actual` is not deeply strictly equal to `expected`.
-*
-* Chai names the negation of its deep comparison `notDeepEqual`; there, `deepStrictEqual` and `deepEqual` are
-* one function.
-*
-* @since 4.0.0
-*/
-const notDeepStrictEqual = dual(byTwoValues, (actual, expected, message) => {
-	assert.notDeepEqual(actual, expected, message);
-});
-/**
-* Asserts that `actual` is strictly equal to `expected`.
-*
-* @since 4.0.0
-*/
-const strictEqual = dual(byTwoValues, (actual, expected, message) => {
-	assert.strictEqual(actual, expected, message);
-});
-/**
-* Asserts that `actual` is equal to `expected` using the `Equal.equals` trait.
-*
-* @since 4.0.0
-*/
-const assertEquals = dual(byTwoValues, (actual, expected, message) => {
-	if (Equal.equals(actual, expected)) return;
-	assert.deepStrictEqual(actual, expected, message);
-	fail(equalMismatch(message));
-});
-/**
-* Asserts that `thunk` does not throw an error.
-*
-* @since 4.0.0
-*/
-const doesNotThrow = dual((args) => args.length >= 2 || typeof args[0] === "function", (thunk, message) => {
-	assert.doesNotThrow(thunk, void 0, void 0, message);
-});
-/**
-* Asserts that `value` is an instance of `constructor`.
-*
-* @since 4.0.0
-*/
-const assertInstanceOf = dual((args) => args.length >= 2 && typeof args[1] !== "string", (value, ctor, message) => {
-	if (value instanceof ctor) return;
-	fail(instanceMismatch(ctor, message));
-});
-/**
-* Asserts that `self` is `true`.
-*
-* @since 4.0.0
-*/
-const assertTrue = dual((args) => args.length >= 2 || typeof args[0] === "boolean", (self, message) => {
-	assert.strictEqual(self, true, message);
-});
-/**
-* Asserts that `self` is `false`.
-*
-* @since 4.0.0
-*/
-const assertFalse = dual((args) => args.length >= 2 || typeof args[0] === "boolean", (self, message) => {
-	assert.strictEqual(self, false, message);
-});
-/**
-* Asserts that `actual` includes `expected`.
-*
-* @since 4.0.0
-*/
-const assertInclude = dual((args) => args.length >= 2, (actual, expected) => {
-	if (!includes(actual, expected)) fail(`Expected\n\n${actual}\n\nto include\n\n${expected}`);
-});
-/**
-* Asserts that `actual` matches `regExp`.
-*
-* @since 4.0.0
-*/
-const assertMatch = dual((args) => args.length >= 2, (actual, regExp) => {
-	if (!regExp.test(actual)) fail(`Expected\n\n${actual}\n\nto match\n\n${regExp}`);
-});
-/**
-* Asserts that `thunk` throws, optionally checking the thrown value against an expected `Error` or validation
-* function.
-*
-* @since 4.0.0
-*/
-const throws = dual((args) => args.length >= 2 || typeof args[0] === "function", (thunk, error) => {
-	applyThrown(thunk, error);
-});
-/**
-* Asserts that `thunk` throws or returns a rejected promise, optionally checking the failure value against an
-* expected `Error` or validation function.
-*
-* @since 4.0.0
-*/
-const throwsAsync = dual((args) => args.length >= 2 || typeof args[0] === "function", (thunk, error) => Promise.resolve().then(thunk).then(() => fail("Expected to throw an error"), (thrown) => applyThrown(() => {
-	throw thrown;
-}, error)));
-/**
-* Asserts that `option` is `None`.
-*
-* @since 4.0.0
-*/
-function assertNone(option) {
-	deepStrictEqual(option, Option.none());
-}
-/**
-* Asserts that `a` is not `undefined`.
-*
-* @since 4.0.0
-*/
-function assertDefined(a) {
-	if (a === void 0) fail("Expected value to be defined");
-}
-/**
-* Asserts that `a` is `undefined`.
-*
-* @since 4.0.0
-*/
-function assertUndefined(a) {
-	if (a !== void 0) fail("Expected value to be undefined");
-}
-/**
-* Asserts that `option` is `Some` and contains a value equal to `expected`.
-*
-* @since 4.0.0
-*/
-const assertSome = dual((args) => args.length >= 2, (option, expected) => {
-	deepStrictEqual(option, Option.some(expected));
-});
-/**
-* Asserts that `result` is `Success` and contains a value equal to `expected`.
-*
-* @since 4.0.0
-*/
-const assertSuccess = dual((args) => args.length >= 2, (result, expected) => {
-	deepStrictEqual(result, Result.succeed(expected));
-});
-/**
-* Asserts that `result` is `Failure` and contains an error equal to `expected`.
-*
-* @since 4.0.0
-*/
-const assertFailure = dual((args) => args.length >= 2, (result, expected) => {
-	deepStrictEqual(result, Result.fail(expected));
-});
-/**
-* Asserts that `exit` is a failure with a cause equal to `expected`.
-*
-* @since 4.0.0
-*/
-const assertExitFailure = dual((args) => args.length >= 2, (exit, expected) => {
-	deepStrictEqual(exit, Exit.failCause(expected));
-});
-/**
-* Asserts that `exit` is a success with a value equal to `expected`.
-*
-* @since 4.0.0
-*/
-const assertExitSuccess = dual((args) => args.length >= 2, (exit, expected) => {
-	deepStrictEqual(exit, Exit.succeed(expected));
-});
-//#endregion
-export { assertDefined, assertEquals, assertExitFailure, assertExitSuccess, assertFailure, assertFalse, assertInclude, assertInstanceOf, assertMatch, assertNone, assertSome, assertSuccess, assertTrue, assertUndefined, deepStrictEqual, doesNotThrow, fail, notDeepStrictEqual, strictEqual, throws, throwsAsync };