diff --git a/packages/effect/src/Chunk.ts b/packages/effect/src/Chunk.ts
index 60ac5f071e5..500766e4a53 100644
--- a/packages/effect/src/Chunk.ts
+++ b/packages/effect/src/Chunk.ts
@@ -230,9 +230,8 @@ export const empty: () => Chunk = () => _empty
* @category constructors
* @since 2.0.0
*/
-export const make = ]>(
- ...as: As
-): NonEmptyChunk => as.length === 1 ? of(as[0]) : unsafeFromNonEmptyArray(as)
+export const make = ]>(...as: As): NonEmptyChunk =>
+ unsafeFromNonEmptyArray(as)
/**
* Builds a `NonEmptyChunk` from a single element.
@@ -249,7 +248,7 @@ export const of = (a: A): NonEmptyChunk => makeChunk({ _tag: "ISingleton",
* @since 2.0.0
*/
export const fromIterable = (self: Iterable): Chunk =>
- isChunk(self) ? self : makeChunk({ _tag: "IArray", array: RA.fromIterable(self) })
+ isChunk(self) ? self : unsafeFromArray(RA.fromIterable(self))
const copyToArray = (self: Chunk, array: Array, initial: number): void => {
switch (self.backing._tag) {
@@ -384,7 +383,8 @@ export const get: {
* @since 2.0.0
* @category unsafe
*/
-export const unsafeFromArray = (self: ReadonlyArray): Chunk => makeChunk({ _tag: "IArray", array: self })
+export const unsafeFromArray = (self: ReadonlyArray): Chunk =>
+ self.length === 0 ? empty() : self.length === 1 ? of(self[0]) : makeChunk({ _tag: "IArray", array: self })
/**
* Wraps an array into a chunk without copying, unsafe on mutable arrays
@@ -1216,8 +1216,7 @@ export const zip: {
)
/**
- * Delete the element at the specified index, creating a new `Chunk`,
- * or returning the input if the index is out of bounds.
+ * Delete the element at the specified index, creating a new `Chunk`.
*
* @since 2.0.0
*/
diff --git a/packages/effect/src/ConfigProvider.ts b/packages/effect/src/ConfigProvider.ts
index 001d6ac5708..a466c334412 100644
--- a/packages/effect/src/ConfigProvider.ts
+++ b/packages/effect/src/ConfigProvider.ts
@@ -195,6 +195,7 @@ export const fromFlat: (flat: ConfigProvider.Flat) => ConfigProvider = internal.
*/
export const fromJson: (json: unknown) => ConfigProvider = internal.fromJson
+// TODO: use `_` for nested configs instead of `.` in next major
/**
* Constructs a ConfigProvider using a map and the specified delimiter string,
* which determines how to split the keys in the map into path segments.
diff --git a/packages/effect/src/ParseResult.ts b/packages/effect/src/ParseResult.ts
index 01a1c491e78..40f55a6d3e9 100644
--- a/packages/effect/src/ParseResult.ts
+++ b/packages/effect/src/ParseResult.ts
@@ -3,7 +3,7 @@
*/
import * as array_ from "./Array.js"
-import type * as cause_ from "./Cause.js"
+import * as cause_ from "./Cause.js"
import { TaggedError } from "./Data.js"
import * as Effect from "./Effect.js"
import * as Either from "./Either.js"
@@ -14,6 +14,7 @@ import * as Inspectable from "./Inspectable.js"
import * as util_ from "./internal/schema/util.js"
import * as Option from "./Option.js"
import * as Predicate from "./Predicate.js"
+import * as Runtime from "./Runtime.js"
import type * as Schema from "./Schema.js"
import * as AST from "./SchemaAST.js"
import type { Concurrency } from "./Types.js"
@@ -1649,13 +1650,19 @@ const handleForbidden = (
try {
return Effect.runSync(Effect.either(effect as Effect.Effect))
} catch (e) {
- return Either.left(
- new Forbidden(
- ast,
- actual,
- "cannot be be resolved synchronously, this is caused by using runSync on an effect that performs async work"
- )
- )
+ if (Runtime.isFiberFailure(e)) {
+ const cause = e[Runtime.FiberFailureCauseId]
+ if (cause_.isDieType(cause) && Runtime.isAsyncFiberException(cause.defect)) {
+ return Either.left(
+ new Forbidden(
+ ast,
+ actual,
+ "cannot be be resolved synchronously, this is caused by using runSync on an effect that performs async work"
+ )
+ )
+ }
+ }
+ return Either.left(new Forbidden(ast, actual, String(e)))
}
}
diff --git a/packages/effect/src/internal/secret.ts b/packages/effect/src/internal/secret.ts
index 3ef59924ceb..2d12b35f6cf 100644
--- a/packages/effect/src/internal/secret.ts
+++ b/packages/effect/src/internal/secret.ts
@@ -23,15 +23,17 @@ export const SecretTypeId: Secret.SecretTypeId = Symbol.for(
*/
export const isSecret = (u: unknown): u is Secret.Secret => hasProperty(u, SecretTypeId)
+const SecretProto = {
+ ...redacted_.proto,
+ [SecretTypeId]: SecretTypeId
+}
+
/**
* @internal
* @deprecated
*/
export const make = (bytes: Array): Secret.Secret => {
- const secret = Object.create({
- ...redacted_.proto,
- [SecretTypeId]: SecretTypeId
- })
+ const secret = Object.create(SecretProto)
Object.defineProperty(secret, "toString", {
enumerable: false,
value() {
diff --git a/packages/effect/test/Array.test.ts b/packages/effect/test/Array.test.ts
index 22d83732f77..465a701c850 100644
--- a/packages/effect/test/Array.test.ts
+++ b/packages/effect/test/Array.test.ts
@@ -1,167 +1,166 @@
-import * as RA from "effect/Array"
-import * as E from "effect/Either"
-import * as fc from "effect/FastCheck"
-import { identity, pipe } from "effect/Function"
-import * as Number from "effect/Number"
-import * as O from "effect/Option"
-import * as Order from "effect/Order"
-import type { Predicate } from "effect/Predicate"
-import * as String from "effect/String"
-import { deepStrictEqual, double, strictEqual } from "effect/test/util"
-import * as Util from "effect/test/util"
-import { assert, describe, expect, it } from "vitest"
+import {
+ Array as Arr,
+ Either,
+ FastCheck as fc,
+ identity,
+ Number as Num,
+ Option,
+ Order,
+ pipe,
+ type Predicate,
+ String as Str
+} from "effect"
+import { assertNone, assertSome, deepStrictEqual, strictEqual, throws } from "effect/test/util"
+import { describe, it } from "vitest"
const symA = Symbol.for("a")
const symB = Symbol.for("b")
const symC = Symbol.for("c")
-describe("ReadonlyArray", () => {
- it("exports", () => {
- expect(RA.fromRecord).exist
- expect(RA.getEquivalence).exist
- })
+const double = (n: number) => n * 2
+describe("Array", () => {
it("of", () => {
- expect(RA.of(1)).toEqual([1])
+ deepStrictEqual(Arr.of(1), [1])
})
it("fromIterable/Array should return the same reference if the iterable is an Array", () => {
const i = [1, 2, 3]
- expect(RA.fromIterable(i) === i).toEqual(true)
+ strictEqual(Arr.fromIterable(i), i)
})
it("fromIterable/Iterable", () => {
- expect(RA.fromIterable(new Set([1, 2, 3]))).toEqual([1, 2, 3])
+ deepStrictEqual(Arr.fromIterable(new Set([1, 2, 3])), [1, 2, 3])
})
it("ensure", () => {
- expect(RA.ensure(1)).toEqual([1])
- expect(RA.ensure(null)).toEqual([null])
- expect(RA.ensure([1])).toEqual([1])
- expect(RA.ensure([1, 2])).toEqual([1, 2])
- expect(RA.ensure(new Set([1, 2]))).toEqual([new Set([1, 2])])
+ deepStrictEqual(Arr.ensure(1), [1])
+ deepStrictEqual(Arr.ensure(null), [null])
+ deepStrictEqual(Arr.ensure([1]), [1])
+ deepStrictEqual(Arr.ensure([1, 2]), [1, 2])
+ deepStrictEqual(Arr.ensure(new Set([1, 2])), [new Set([1, 2])])
})
describe("iterable inputs", () => {
it("prepend", () => {
- deepStrictEqual(pipe([1, 2, 3], RA.prepend(0)), [0, 1, 2, 3])
- deepStrictEqual(pipe([[2]], RA.prepend([1])), [[1], [2]])
+ deepStrictEqual(pipe([1, 2, 3], Arr.prepend(0)), [0, 1, 2, 3])
+ deepStrictEqual(pipe([[2]], Arr.prepend([1])), [[1], [2]])
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.prepend(0)), [0, 1, 2, 3])
- deepStrictEqual(pipe(new Set([[2]]), RA.prepend([1])), [[1], [2]])
+ deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.prepend(0)), [0, 1, 2, 3])
+ deepStrictEqual(pipe(new Set([[2]]), Arr.prepend([1])), [[1], [2]])
})
it("prependAll", () => {
- deepStrictEqual(pipe([3, 4], RA.prependAll([1, 2])), [1, 2, 3, 4])
+ deepStrictEqual(pipe([3, 4], Arr.prependAll([1, 2])), [1, 2, 3, 4])
- deepStrictEqual(pipe([3, 4], RA.prependAll(new Set([1, 2]))), [1, 2, 3, 4])
- deepStrictEqual(pipe(new Set([3, 4]), RA.prependAll([1, 2])), [1, 2, 3, 4])
+ deepStrictEqual(pipe([3, 4], Arr.prependAll(new Set([1, 2]))), [1, 2, 3, 4])
+ deepStrictEqual(pipe(new Set([3, 4]), Arr.prependAll([1, 2])), [1, 2, 3, 4])
})
it("append", () => {
- deepStrictEqual(pipe([1, 2, 3], RA.append(4)), [1, 2, 3, 4])
- deepStrictEqual(pipe([[1]], RA.append([2])), [[1], [2]])
+ deepStrictEqual(pipe([1, 2, 3], Arr.append(4)), [1, 2, 3, 4])
+ deepStrictEqual(pipe([[1]], Arr.append([2])), [[1], [2]])
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.append(4)), [1, 2, 3, 4])
- deepStrictEqual(pipe(new Set([[1]]), RA.append([2])), [[1], [2]])
+ deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.append(4)), [1, 2, 3, 4])
+ deepStrictEqual(pipe(new Set([[1]]), Arr.append([2])), [[1], [2]])
})
it("appendAll", () => {
- deepStrictEqual(pipe([1, 2], RA.appendAll([3, 4])), [1, 2, 3, 4])
+ deepStrictEqual(pipe([1, 2], Arr.appendAll([3, 4])), [1, 2, 3, 4])
- deepStrictEqual(pipe([1, 2], RA.appendAll(new Set([3, 4]))), [1, 2, 3, 4])
- deepStrictEqual(pipe(new Set([1, 2]), RA.appendAll([3, 4])), [1, 2, 3, 4])
+ deepStrictEqual(pipe([1, 2], Arr.appendAll(new Set([3, 4]))), [1, 2, 3, 4])
+ deepStrictEqual(pipe(new Set([1, 2]), Arr.appendAll([3, 4])), [1, 2, 3, 4])
})
it("scan", () => {
const f = (b: number, a: number) => b - a
- deepStrictEqual(pipe([1, 2, 3], RA.scan(10, f)), [10, 9, 7, 4])
- deepStrictEqual(pipe([0], RA.scan(10, f)), [10, 10])
- deepStrictEqual(pipe([], RA.scan(10, f)), [10])
+ deepStrictEqual(pipe([1, 2, 3], Arr.scan(10, f)), [10, 9, 7, 4])
+ deepStrictEqual(pipe([0], Arr.scan(10, f)), [10, 10])
+ deepStrictEqual(pipe([], Arr.scan(10, f)), [10])
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.scan(10, f)), [10, 9, 7, 4])
- deepStrictEqual(pipe(new Set([0]), RA.scan(10, f)), [10, 10])
- deepStrictEqual(pipe(new Set([]), RA.scan(10, f)), [10])
+ deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.scan(10, f)), [10, 9, 7, 4])
+ deepStrictEqual(pipe(new Set([0]), Arr.scan(10, f)), [10, 10])
+ deepStrictEqual(pipe(new Set([]), Arr.scan(10, f)), [10])
})
it("scanRight", () => {
const f = (b: number, a: number) => a - b
- deepStrictEqual(pipe([1, 2, 3], RA.scanRight(10, f)), [-8, 9, -7, 10])
- deepStrictEqual(pipe([0], RA.scanRight(10, f)), [-10, 10])
- deepStrictEqual(pipe([], RA.scanRight(10, f)), [10])
+ deepStrictEqual(pipe([1, 2, 3], Arr.scanRight(10, f)), [-8, 9, -7, 10])
+ deepStrictEqual(pipe([0], Arr.scanRight(10, f)), [-10, 10])
+ deepStrictEqual(pipe([], Arr.scanRight(10, f)), [10])
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.scanRight(10, f)), [-8, 9, -7, 10])
- deepStrictEqual(pipe(new Set([0]), RA.scanRight(10, f)), [-10, 10])
- deepStrictEqual(pipe(new Set([]), RA.scanRight(10, f)), [10])
+ deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.scanRight(10, f)), [-8, 9, -7, 10])
+ deepStrictEqual(pipe(new Set([0]), Arr.scanRight(10, f)), [-10, 10])
+ deepStrictEqual(pipe(new Set([]), Arr.scanRight(10, f)), [10])
})
it("tail", () => {
- deepStrictEqual(RA.tail([1, 2, 3]), O.some([2, 3]))
- deepStrictEqual(RA.tail([]), O.none())
+ assertSome(Arr.tail([1, 2, 3]), [2, 3])
+ assertNone(Arr.tail([]))
- deepStrictEqual(RA.tail(new Set([1, 2, 3])), O.some([2, 3]))
- deepStrictEqual(RA.tail(new Set([])), O.none())
+ assertSome(Arr.tail(new Set([1, 2, 3])), [2, 3])
+ assertNone(Arr.tail(new Set([])))
})
it("init", () => {
- deepStrictEqual(RA.init([1, 2, 3]), O.some([1, 2]))
- deepStrictEqual(RA.init([]), O.none())
+ assertSome(Arr.init([1, 2, 3]), [1, 2])
+ assertNone(Arr.init([]))
- deepStrictEqual(RA.init(new Set([1, 2, 3])), O.some([1, 2]))
- deepStrictEqual(RA.init(new Set([])), O.none())
+ assertSome(Arr.init(new Set([1, 2, 3])), [1, 2])
+ assertNone(Arr.init(new Set([])))
})
it("take", () => {
- expect(pipe([1, 2, 3, 4], RA.take(2))).toEqual([1, 2])
- expect(pipe([1, 2, 3, 4], RA.take(0))).toEqual([])
+ deepStrictEqual(pipe([1, 2, 3, 4], Arr.take(2)), [1, 2])
+ deepStrictEqual(pipe([1, 2, 3, 4], Arr.take(0)), [])
// out of bounds
- expect(pipe([1, 2, 3, 4], RA.take(-10))).toEqual([])
- expect(pipe([1, 2, 3, 4], RA.take(10))).toEqual([1, 2, 3, 4])
+ deepStrictEqual(pipe([1, 2, 3, 4], Arr.take(-10)), [])
+ deepStrictEqual(pipe([1, 2, 3, 4], Arr.take(10)), [1, 2, 3, 4])
- expect(pipe(new Set([1, 2, 3, 4]), RA.take(2))).toEqual([1, 2])
- expect(pipe(new Set([1, 2, 3, 4]), RA.take(0))).toEqual([])
+ deepStrictEqual(pipe(new Set([1, 2, 3, 4]), Arr.take(2)), [1, 2])
+ deepStrictEqual(pipe(new Set([1, 2, 3, 4]), Arr.take(0)), [])
// out of bounds
- expect(pipe(new Set([1, 2, 3, 4]), RA.take(-10))).toEqual([])
- expect(pipe(new Set([1, 2, 3, 4]), RA.take(10))).toEqual([1, 2, 3, 4])
+ deepStrictEqual(pipe(new Set([1, 2, 3, 4]), Arr.take(-10)), [])
+ deepStrictEqual(pipe(new Set([1, 2, 3, 4]), Arr.take(10)), [1, 2, 3, 4])
})
it("takeRight", () => {
- deepStrictEqual(pipe(RA.empty(), RA.takeRight(0)), [])
- deepStrictEqual(pipe([1, 2], RA.takeRight(0)), [])
- deepStrictEqual(pipe([1, 2], RA.takeRight(1)), [2])
- deepStrictEqual(pipe([1, 2], RA.takeRight(2)), [1, 2])
+ deepStrictEqual(pipe(Arr.empty(), Arr.takeRight(0)), [])
+ deepStrictEqual(pipe([1, 2], Arr.takeRight(0)), [])
+ deepStrictEqual(pipe([1, 2], Arr.takeRight(1)), [2])
+ deepStrictEqual(pipe([1, 2], Arr.takeRight(2)), [1, 2])
// out of bound
- deepStrictEqual(pipe(RA.empty(), RA.takeRight(1)), [])
- deepStrictEqual(pipe(RA.empty(), RA.takeRight(-1)), [])
- deepStrictEqual(pipe([1, 2], RA.takeRight(3)), [1, 2])
- deepStrictEqual(pipe([1, 2], RA.takeRight(-1)), [])
-
- deepStrictEqual(pipe(new Set(), RA.takeRight(0)), [])
- deepStrictEqual(pipe(new Set([1, 2]), RA.takeRight(0)), [])
- deepStrictEqual(pipe(new Set([1, 2]), RA.takeRight(1)), [2])
- deepStrictEqual(pipe(new Set([1, 2]), RA.takeRight(2)), [1, 2])
+ deepStrictEqual(pipe(Arr.empty(), Arr.takeRight(1)), [])
+ deepStrictEqual(pipe(Arr.empty(), Arr.takeRight(-1)), [])
+ deepStrictEqual(pipe([1, 2], Arr.takeRight(3)), [1, 2])
+ deepStrictEqual(pipe([1, 2], Arr.takeRight(-1)), [])
+
+ deepStrictEqual(pipe(new Set(), Arr.takeRight(0)), [])
+ deepStrictEqual(pipe(new Set([1, 2]), Arr.takeRight(0)), [])
+ deepStrictEqual(pipe(new Set([1, 2]), Arr.takeRight(1)), [2])
+ deepStrictEqual(pipe(new Set([1, 2]), Arr.takeRight(2)), [1, 2])
// out of bound
- deepStrictEqual(pipe(new Set(), RA.takeRight(1)), [])
- deepStrictEqual(pipe(new Set(), RA.takeRight(-1)), [])
- deepStrictEqual(pipe(new Set([1, 2]), RA.takeRight(3)), [1, 2])
- deepStrictEqual(pipe(new Set([1, 2]), RA.takeRight(-1)), [])
+ deepStrictEqual(pipe(new Set(), Arr.takeRight(1)), [])
+ deepStrictEqual(pipe(new Set(), Arr.takeRight(-1)), [])
+ deepStrictEqual(pipe(new Set([1, 2]), Arr.takeRight(3)), [1, 2])
+ deepStrictEqual(pipe(new Set([1, 2]), Arr.takeRight(-1)), [])
})
it("takeWhile", () => {
const f = (n: number) => n % 2 === 0
- deepStrictEqual(pipe([2, 4, 3, 6], RA.takeWhile(f)), [2, 4])
- deepStrictEqual(pipe(RA.empty(), RA.takeWhile(f)), [])
- deepStrictEqual(pipe([1, 2, 4], RA.takeWhile(f)), [])
- deepStrictEqual(pipe([2, 4], RA.takeWhile(f)), [2, 4])
-
- deepStrictEqual(pipe(new Set([2, 4, 3, 6]), RA.takeWhile(f)), [2, 4])
- deepStrictEqual(pipe(new Set(), RA.takeWhile(f)), [])
- deepStrictEqual(pipe(new Set([1, 2, 4]), RA.takeWhile(f)), [])
- deepStrictEqual(pipe(new Set([2, 4]), RA.takeWhile(f)), [2, 4])
+ deepStrictEqual(pipe([2, 4, 3, 6], Arr.takeWhile(f)), [2, 4])
+ deepStrictEqual(pipe(Arr.empty(), Arr.takeWhile(f)), [])
+ deepStrictEqual(pipe([1, 2, 4], Arr.takeWhile(f)), [])
+ deepStrictEqual(pipe([2, 4], Arr.takeWhile(f)), [2, 4])
+
+ deepStrictEqual(pipe(new Set([2, 4, 3, 6]), Arr.takeWhile(f)), [2, 4])
+ deepStrictEqual(pipe(new Set(), Arr.takeWhile(f)), [])
+ deepStrictEqual(pipe(new Set([1, 2, 4]), Arr.takeWhile(f)), [])
+ deepStrictEqual(pipe(new Set([2, 4]), Arr.takeWhile(f)), [2, 4])
})
it("span", () => {
- const f = RA.span((n) => n % 2 === 1)
+ const f = Arr.span((n) => n % 2 === 1)
const assertSpan = (
input: Iterable,
expectedInit: ReadonlyArray,
@@ -172,18 +171,18 @@ describe("ReadonlyArray", () => {
deepStrictEqual(rest, expectedRest)
}
assertSpan([1, 3, 2, 4, 5], [1, 3], [2, 4, 5])
- assertSpan(RA.empty(), RA.empty(), RA.empty())
- assertSpan([1, 3], [1, 3], RA.empty())
- assertSpan([2, 4], RA.empty(), [2, 4])
+ assertSpan(Arr.empty(), Arr.empty(), Arr.empty())
+ assertSpan([1, 3], [1, 3], Arr.empty())
+ assertSpan([2, 4], Arr.empty(), [2, 4])
assertSpan(new Set([1, 3, 2, 4, 5]), [1, 3], [2, 4, 5])
- assertSpan(new Set(), RA.empty(), RA.empty())
- assertSpan(new Set([1, 3]), [1, 3], RA.empty())
- assertSpan(new Set([2, 4]), RA.empty(), [2, 4])
+ assertSpan(new Set(), Arr.empty(), Arr.empty())
+ assertSpan(new Set([1, 3]), [1, 3], Arr.empty())
+ assertSpan(new Set([2, 4]), Arr.empty(), [2, 4])
})
it("splitWhere", () => {
- const f = RA.splitWhere((n) => n % 2 !== 1)
+ const f = Arr.splitWhere((n) => n % 2 !== 1)
const assertSplitWhere = (
input: Iterable,
expectedInit: ReadonlyArray,
@@ -194,295 +193,292 @@ describe("ReadonlyArray", () => {
deepStrictEqual(rest, expectedRest)
}
assertSplitWhere([1, 3, 2, 4, 5], [1, 3], [2, 4, 5])
- assertSplitWhere(RA.empty(), RA.empty(), RA.empty())
- assertSplitWhere([1, 3], [1, 3], RA.empty())
- assertSplitWhere([2, 4], RA.empty(), [2, 4])
+ assertSplitWhere(Arr.empty(), Arr.empty(), Arr.empty())
+ assertSplitWhere([1, 3], [1, 3], Arr.empty())
+ assertSplitWhere([2, 4], Arr.empty(), [2, 4])
assertSplitWhere(new Set([1, 3, 2, 4, 5]), [1, 3], [2, 4, 5])
- assertSplitWhere(new Set(), RA.empty(), RA.empty())
- assertSplitWhere(new Set([1, 3]), [1, 3], RA.empty())
- assertSplitWhere(new Set([2, 4]), RA.empty(), [2, 4])
+ assertSplitWhere(new Set(), Arr.empty(), Arr.empty())
+ assertSplitWhere(new Set([1, 3]), [1, 3], Arr.empty())
+ assertSplitWhere(new Set([2, 4]), Arr.empty(), [2, 4])
})
it("split", () => {
- expect(pipe(RA.empty(), RA.split(2))).toEqual(RA.empty())
- expect(pipe(RA.make(1), RA.split(2))).toEqual(
- RA.make(RA.make(1))
- )
- expect(pipe(RA.make(1, 2), RA.split(2))).toEqual(
- RA.make(RA.make(1), RA.make(2))
- )
- expect(pipe(RA.make(1, 2, 3, 4, 5), RA.split(2))).toEqual(
- RA.make(RA.make(1, 2, 3), RA.make(4, 5))
- )
- expect(pipe(RA.make(1, 2, 3, 4, 5), RA.split(3))).toEqual(
- RA.make(RA.make(1, 2), RA.make(3, 4), RA.make(5))
+ deepStrictEqual(pipe(Arr.empty(), Arr.split(2)), Arr.empty())
+ deepStrictEqual(pipe(Arr.make(1), Arr.split(2)), Arr.make(Arr.make(1)))
+ deepStrictEqual(pipe(Arr.make(1, 2), Arr.split(2)), Arr.make(Arr.make(1), Arr.make(2)))
+ deepStrictEqual(pipe(Arr.make(1, 2, 3, 4, 5), Arr.split(2)), Arr.make(Arr.make(1, 2, 3), Arr.make(4, 5)))
+ deepStrictEqual(
+ pipe(Arr.make(1, 2, 3, 4, 5), Arr.split(3)),
+ Arr.make(Arr.make(1, 2), Arr.make(3, 4), Arr.make(5))
)
})
it("drop", () => {
- deepStrictEqual(pipe(RA.empty(), RA.drop(0)), [])
- deepStrictEqual(pipe([1, 2], RA.drop(0)), [1, 2])
- deepStrictEqual(pipe([1, 2], RA.drop(1)), [2])
- deepStrictEqual(pipe([1, 2], RA.drop(2)), [])
+ deepStrictEqual(pipe(Arr.empty(), Arr.drop(0)), [])
+ deepStrictEqual(pipe([1, 2], Arr.drop(0)), [1, 2])
+ deepStrictEqual(pipe([1, 2], Arr.drop(1)), [2])
+ deepStrictEqual(pipe([1, 2], Arr.drop(2)), [])
// out of bound
- deepStrictEqual(pipe(RA.empty(), RA.drop(1)), [])
- deepStrictEqual(pipe(RA.empty(), RA.drop(-1)), [])
- deepStrictEqual(pipe([1, 2], RA.drop(3)), [])
- deepStrictEqual(pipe([1, 2], RA.drop(-1)), [1, 2])
-
- deepStrictEqual(pipe(new Set(), RA.drop(0)), [])
- deepStrictEqual(pipe(new Set([1, 2]), RA.drop(0)), [1, 2])
- deepStrictEqual(pipe(new Set([1, 2]), RA.drop(1)), [2])
- deepStrictEqual(pipe(new Set([1, 2]), RA.drop(2)), [])
+ deepStrictEqual(pipe(Arr.empty(), Arr.drop(1)), [])
+ deepStrictEqual(pipe(Arr.empty(), Arr.drop(-1)), [])
+ deepStrictEqual(pipe([1, 2], Arr.drop(3)), [])
+ deepStrictEqual(pipe([1, 2], Arr.drop(-1)), [1, 2])
+
+ deepStrictEqual(pipe(new Set(), Arr.drop(0)), [])
+ deepStrictEqual(pipe(new Set([1, 2]), Arr.drop(0)), [1, 2])
+ deepStrictEqual(pipe(new Set([1, 2]), Arr.drop(1)), [2])
+ deepStrictEqual(pipe(new Set([1, 2]), Arr.drop(2)), [])
// out of bound
- deepStrictEqual(pipe(new Set(), RA.drop(1)), [])
- deepStrictEqual(pipe(new Set(), RA.drop(-1)), [])
- deepStrictEqual(pipe(new Set([1, 2]), RA.drop(3)), [])
- deepStrictEqual(pipe(new Set([1, 2]), RA.drop(-1)), [1, 2])
+ deepStrictEqual(pipe(new Set(), Arr.drop(1)), [])
+ deepStrictEqual(pipe(new Set(), Arr.drop(-1)), [])
+ deepStrictEqual(pipe(new Set([1, 2]), Arr.drop(3)), [])
+ deepStrictEqual(pipe(new Set([1, 2]), Arr.drop(-1)), [1, 2])
})
it("dropRight", () => {
- deepStrictEqual(pipe([], RA.dropRight(0)), [])
- deepStrictEqual(pipe([1, 2], RA.dropRight(0)), [1, 2])
- deepStrictEqual(pipe([1, 2], RA.dropRight(1)), [1])
- deepStrictEqual(pipe([1, 2], RA.dropRight(2)), [])
+ deepStrictEqual(pipe([], Arr.dropRight(0)), [])
+ deepStrictEqual(pipe([1, 2], Arr.dropRight(0)), [1, 2])
+ deepStrictEqual(pipe([1, 2], Arr.dropRight(1)), [1])
+ deepStrictEqual(pipe([1, 2], Arr.dropRight(2)), [])
// out of bound
- deepStrictEqual(pipe([], RA.dropRight(1)), [])
- deepStrictEqual(pipe([1, 2], RA.dropRight(3)), [])
- deepStrictEqual(pipe([], RA.dropRight(-1)), [])
- deepStrictEqual(pipe([1, 2], RA.dropRight(-1)), [1, 2])
-
- deepStrictEqual(pipe(new Set(), RA.dropRight(0)), [])
- deepStrictEqual(pipe(new Set([1, 2]), RA.dropRight(0)), [1, 2])
- deepStrictEqual(pipe(new Set([1, 2]), RA.dropRight(1)), [1])
- deepStrictEqual(pipe(new Set([1, 2]), RA.dropRight(2)), [])
+ deepStrictEqual(pipe([], Arr.dropRight(1)), [])
+ deepStrictEqual(pipe([1, 2], Arr.dropRight(3)), [])
+ deepStrictEqual(pipe([], Arr.dropRight(-1)), [])
+ deepStrictEqual(pipe([1, 2], Arr.dropRight(-1)), [1, 2])
+
+ deepStrictEqual(pipe(new Set(), Arr.dropRight(0)), [])
+ deepStrictEqual(pipe(new Set([1, 2]), Arr.dropRight(0)), [1, 2])
+ deepStrictEqual(pipe(new Set([1, 2]), Arr.dropRight(1)), [1])
+ deepStrictEqual(pipe(new Set([1, 2]), Arr.dropRight(2)), [])
// out of bound
- deepStrictEqual(pipe(new Set(), RA.dropRight(1)), [])
- deepStrictEqual(pipe(new Set([1, 2]), RA.dropRight(3)), [])
- deepStrictEqual(pipe(new Set(), RA.dropRight(-1)), [])
- deepStrictEqual(pipe(new Set([1, 2]), RA.dropRight(-1)), [1, 2])
+ deepStrictEqual(pipe(new Set(), Arr.dropRight(1)), [])
+ deepStrictEqual(pipe(new Set([1, 2]), Arr.dropRight(3)), [])
+ deepStrictEqual(pipe(new Set(), Arr.dropRight(-1)), [])
+ deepStrictEqual(pipe(new Set([1, 2]), Arr.dropRight(-1)), [1, 2])
})
it("dropWhile", () => {
- const f = RA.dropWhile((n) => n > 0)
+ const f = Arr.dropWhile((n) => n > 0)
deepStrictEqual(f([]), [])
- deepStrictEqual(f([1, 2]), RA.empty())
+ deepStrictEqual(f([1, 2]), Arr.empty())
deepStrictEqual(f([-1, -2]), [-1, -2])
deepStrictEqual(f([-1, 2]), [-1, 2])
deepStrictEqual(f([1, -2, 3]), [-2, 3])
deepStrictEqual(f(new Set()), [])
- deepStrictEqual(f(new Set([1, 2])), RA.empty())
+ deepStrictEqual(f(new Set([1, 2])), Arr.empty())
deepStrictEqual(f(new Set([-1, -2])), [-1, -2])
deepStrictEqual(f(new Set([-1, 2])), [-1, 2])
deepStrictEqual(f(new Set([1, -2, 3])), [-2, 3])
})
it("findFirstIndex", () => {
- deepStrictEqual(pipe([], RA.findFirstIndex((n) => n % 2 === 0)), O.none())
- deepStrictEqual(pipe([1, 2, 3], RA.findFirstIndex((n) => n % 2 === 0)), O.some(1))
- deepStrictEqual(pipe([1, 2, 3, 1], RA.findFirstIndex((n) => n % 2 === 0)), O.some(1))
+ assertNone(pipe([], Arr.findFirstIndex((n) => n % 2 === 0)))
+ assertSome(pipe([1, 2, 3], Arr.findFirstIndex((n) => n % 2 === 0)), 1)
+ assertSome(pipe([1, 2, 3, 1], Arr.findFirstIndex((n) => n % 2 === 0)), 1)
- deepStrictEqual(pipe(new Set(), RA.findFirstIndex((n) => n % 2 === 0)), O.none())
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.findFirstIndex((n) => n % 2 === 0)), O.some(1))
- deepStrictEqual(pipe(new Set([1, 2, 3, 4]), RA.findFirstIndex((n) => n % 2 === 0)), O.some(1))
+ assertNone(pipe(new Set(), Arr.findFirstIndex((n) => n % 2 === 0)))
+ assertSome(pipe(new Set([1, 2, 3]), Arr.findFirstIndex((n) => n % 2 === 0)), 1)
+ assertSome(pipe(new Set([1, 2, 3, 4]), Arr.findFirstIndex((n) => n % 2 === 0)), 1)
})
it("findLastIndex", () => {
- deepStrictEqual(pipe([], RA.findLastIndex((n) => n % 2 === 0)), O.none())
- deepStrictEqual(pipe([1, 2, 3], RA.findLastIndex((n) => n % 2 === 0)), O.some(1))
- deepStrictEqual(pipe([1, 2, 3, 4], RA.findLastIndex((n) => n % 2 === 0)), O.some(3))
+ assertNone(pipe([], Arr.findLastIndex((n) => n % 2 === 0)))
+ assertSome(pipe([1, 2, 3], Arr.findLastIndex((n) => n % 2 === 0)), 1)
+ assertSome(pipe([1, 2, 3, 4], Arr.findLastIndex((n) => n % 2 === 0)), 3)
- deepStrictEqual(pipe(new Set(), RA.findLastIndex((n) => n % 2 === 0)), O.none())
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.findLastIndex((n) => n % 2 === 0)), O.some(1))
- deepStrictEqual(pipe(new Set([1, 2, 3, 4]), RA.findLastIndex((n) => n % 2 === 0)), O.some(3))
+ assertNone(pipe(new Set(), Arr.findLastIndex((n) => n % 2 === 0)))
+ assertSome(pipe(new Set([1, 2, 3]), Arr.findLastIndex((n) => n % 2 === 0)), 1)
+ assertSome(pipe(new Set([1, 2, 3, 4]), Arr.findLastIndex((n) => n % 2 === 0)), 3)
})
describe("findFirst", () => {
it("boolean-returning overloads", () => {
- deepStrictEqual(pipe([], RA.findFirst((n) => n % 2 === 0)), O.none())
- deepStrictEqual(pipe([1, 2, 3], RA.findFirst((n) => n % 2 === 0)), O.some(2))
- deepStrictEqual(pipe([1, 2, 3, 4], RA.findFirst((n) => n % 2 === 0)), O.some(2))
+ assertNone(pipe([], Arr.findFirst((n) => n % 2 === 0)))
+ assertSome(pipe([1, 2, 3], Arr.findFirst((n) => n % 2 === 0)), 2)
+ assertSome(pipe([1, 2, 3, 4], Arr.findFirst((n) => n % 2 === 0)), 2)
- deepStrictEqual(pipe(new Set(), RA.findFirst((n) => n % 2 === 0)), O.none())
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.findFirst((n) => n % 2 === 0)), O.some(2))
- deepStrictEqual(pipe(new Set([1, 2, 3, 4]), RA.findFirst((n) => n % 2 === 0)), O.some(2))
+ assertNone(pipe(new Set(), Arr.findFirst((n) => n % 2 === 0)))
+ assertSome(pipe(new Set([1, 2, 3]), Arr.findFirst((n) => n % 2 === 0)), 2)
+ assertSome(pipe(new Set([1, 2, 3, 4]), Arr.findFirst((n) => n % 2 === 0)), 2)
})
it("Option-returning overloads", () => {
- deepStrictEqual(pipe([], RA.findFirst((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())), O.none())
- deepStrictEqual(
- pipe([1, 2, 3], RA.findFirst((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
- O.some([2, 1])
+ assertNone(
+ pipe([], Arr.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none()))
)
- deepStrictEqual(
- pipe([1, 2, 3, 4], RA.findFirst((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
- O.some([2, 1])
+ assertSome(
+ pipe([1, 2, 3], Arr.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
+ [2, 1]
+ )
+ assertSome(
+ pipe([1, 2, 3, 4], Arr.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
+ [2, 1]
)
- deepStrictEqual(
- pipe(new Set(), RA.findFirst((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
- O.none()
+ assertNone(
+ pipe(new Set(), Arr.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none()))
)
- deepStrictEqual(
- pipe(new Set([1, 2, 3]), RA.findFirst((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
- O.some([2, 1])
+ assertSome(
+ pipe(new Set([1, 2, 3]), Arr.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
+ [2, 1]
)
- deepStrictEqual(
- pipe(new Set([1, 2, 3, 4]), RA.findFirst((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
- O.some([2, 1])
+ assertSome(
+ pipe(new Set([1, 2, 3, 4]), Arr.findFirst((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
+ [2, 1]
)
})
})
describe("findLast", () => {
it("boolean-returning overloads", () => {
- deepStrictEqual(pipe([], RA.findLast((n) => n % 2 === 0)), O.none())
- deepStrictEqual(pipe([1, 2, 3], RA.findLast((n) => n % 2 === 0)), O.some(2))
- deepStrictEqual(pipe([1, 2, 3, 4], RA.findLast((n) => n % 2 === 0)), O.some(4))
+ assertNone(pipe([], Arr.findLast((n) => n % 2 === 0)))
+ assertSome(pipe([1, 2, 3], Arr.findLast((n) => n % 2 === 0)), 2)
+ assertSome(pipe([1, 2, 3, 4], Arr.findLast((n) => n % 2 === 0)), 4)
- deepStrictEqual(pipe(new Set(), RA.findLast((n) => n % 2 === 0)), O.none())
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.findLast((n) => n % 2 === 0)), O.some(2))
- deepStrictEqual(pipe(new Set([1, 2, 3, 4]), RA.findLast((n) => n % 2 === 0)), O.some(4))
+ assertNone(pipe(new Set(), Arr.findLast((n) => n % 2 === 0)))
+ assertSome(pipe(new Set([1, 2, 3]), Arr.findLast((n) => n % 2 === 0)), 2)
+ assertSome(pipe(new Set([1, 2, 3, 4]), Arr.findLast((n) => n % 2 === 0)), 4)
})
it("Option-returning overloads", () => {
- deepStrictEqual(pipe([], RA.findLast((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())), O.none())
- deepStrictEqual(
- pipe([1, 2, 3], RA.findLast((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
- O.some([2, 1])
+ assertNone(
+ pipe([], Arr.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none()))
+ )
+ assertSome(
+ pipe([1, 2, 3], Arr.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
+ [2, 1]
)
- deepStrictEqual(
- pipe([1, 2, 3, 4], RA.findLast((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
- O.some([4, 3])
+ assertSome(
+ pipe([1, 2, 3, 4], Arr.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
+ [4, 3]
)
- deepStrictEqual(
- pipe(new Set(), RA.findLast((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
- O.none()
+ assertNone(
+ pipe(new Set(), Arr.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none()))
)
- deepStrictEqual(
- pipe(new Set([1, 2, 3]), RA.findLast((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
- O.some([2, 1])
+ assertSome(
+ pipe(new Set([1, 2, 3]), Arr.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
+ [2, 1]
)
- deepStrictEqual(
- pipe(new Set([1, 2, 3, 4]), RA.findLast((n, i) => n % 2 === 0 ? O.some([n, i]) : O.none())),
- O.some([4, 3])
+ assertSome(
+ pipe(new Set([1, 2, 3, 4]), Arr.findLast((n, i) => n % 2 === 0 ? Option.some([n, i]) : Option.none())),
+ [4, 3]
)
})
})
it("insertAt", () => {
- deepStrictEqual(RA.insertAt(1, 1)([]), O.none())
- deepStrictEqual(RA.insertAt(0, 1)([]), O.some([1]))
- deepStrictEqual(RA.insertAt(2, 5)([1, 2, 3, 4]), O.some([1, 2, 5, 3, 4]))
+ assertNone(Arr.insertAt(1, 1)([]))
+ assertSome(Arr.insertAt(0, 1)([]), [1])
+ assertSome(Arr.insertAt(2, 5)([1, 2, 3, 4]), [1, 2, 5, 3, 4])
// out of bound
- deepStrictEqual(RA.insertAt(-1, 5)([1, 2, 3, 4]), O.none())
- deepStrictEqual(RA.insertAt(10, 5)([1, 2, 3, 4]), O.none())
+ assertNone(Arr.insertAt(-1, 5)([1, 2, 3, 4]))
+ assertNone(Arr.insertAt(10, 5)([1, 2, 3, 4]))
- deepStrictEqual(RA.insertAt(1, 1)(new Set([])), O.none())
- deepStrictEqual(RA.insertAt(0, 1)(new Set([])), O.some([1]))
- deepStrictEqual(RA.insertAt(2, 5)(new Set([1, 2, 3, 4])), O.some([1, 2, 5, 3, 4]))
+ assertNone(Arr.insertAt(1, 1)(new Set([])))
+ assertSome(Arr.insertAt(0, 1)(new Set([])), [1])
+ assertSome(Arr.insertAt(2, 5)(new Set([1, 2, 3, 4])), [1, 2, 5, 3, 4])
// out of bound
- deepStrictEqual(RA.insertAt(-1, 5)(new Set([1, 2, 3, 4])), O.none())
- deepStrictEqual(RA.insertAt(10, 5)(new Set([1, 2, 3, 4])), O.none())
+ assertNone(Arr.insertAt(-1, 5)(new Set([1, 2, 3, 4])))
+ assertNone(Arr.insertAt(10, 5)(new Set([1, 2, 3, 4])))
})
it("replace", () => {
- deepStrictEqual(pipe([1, 2, 3], RA.replace(1, "a")), [1, "a", 3])
+ deepStrictEqual(pipe([1, 2, 3], Arr.replace(1, "a")), [1, "a", 3])
// out of bound
- deepStrictEqual(pipe([], RA.replace(1, "a")), [])
- deepStrictEqual(pipe([1, 2, 3], RA.replace(-1, "a")), [1, 2, 3])
- deepStrictEqual(pipe([1, 2, 3], RA.replace(10, "a")), [1, 2, 3])
+ deepStrictEqual(pipe([], Arr.replace(1, "a")), [])
+ deepStrictEqual(pipe([1, 2, 3], Arr.replace(-1, "a")), [1, 2, 3])
+ deepStrictEqual(pipe([1, 2, 3], Arr.replace(10, "a")), [1, 2, 3])
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.replace(1, "a")), [1, "a", 3])
+ deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.replace(1, "a")), [1, "a", 3])
// out of bound
- deepStrictEqual(pipe(new Set([]), RA.replace(1, "a")), [])
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.replace(-1, "a")), [1, 2, 3])
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.replace(10, "a")), [1, 2, 3])
+ deepStrictEqual(pipe(new Set([]), Arr.replace(1, "a")), [])
+ deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.replace(-1, "a")), [1, 2, 3])
+ deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.replace(10, "a")), [1, 2, 3])
})
it("replaceOption", () => {
- deepStrictEqual(pipe([1, 2, 3], RA.replaceOption(1, "a")), O.some([1, "a", 3]))
+ assertSome(pipe([1, 2, 3], Arr.replaceOption(1, "a")), [1, "a", 3])
// out of bound
- deepStrictEqual(pipe([], RA.replaceOption(1, "a")), O.none())
- deepStrictEqual(pipe([1, 2, 3], RA.replaceOption(-1, "a")), O.none())
- deepStrictEqual(pipe([1, 2, 3], RA.replaceOption(10, "a")), O.none())
+ assertNone(pipe([], Arr.replaceOption(1, "a")))
+ assertNone(pipe([1, 2, 3], Arr.replaceOption(-1, "a")))
+ assertNone(pipe([1, 2, 3], Arr.replaceOption(10, "a")))
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.replaceOption(1, "a")), O.some([1, "a", 3]))
+ assertSome(pipe(new Set([1, 2, 3]), Arr.replaceOption(1, "a")), [1, "a", 3])
// out of bound
- deepStrictEqual(pipe(new Set([]), RA.replaceOption(1, "a")), O.none())
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.replaceOption(-1, "a")), O.none())
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.replaceOption(10, "a")), O.none())
+ assertNone(pipe(new Set([]), Arr.replaceOption(1, "a")))
+ assertNone(pipe(new Set([1, 2, 3]), Arr.replaceOption(-1, "a")))
+ assertNone(pipe(new Set([1, 2, 3]), Arr.replaceOption(10, "a")))
})
it("modify", () => {
- deepStrictEqual(pipe([1, 2, 3], RA.modify(1, double)), [1, 4, 3])
+ deepStrictEqual(pipe([1, 2, 3], Arr.modify(1, double)), [1, 4, 3])
// out of bound
- deepStrictEqual(pipe([], RA.modify(1, double)), [])
- deepStrictEqual(pipe([1, 2, 3], RA.modify(10, double)), [1, 2, 3])
+ deepStrictEqual(pipe([], Arr.modify(1, double)), [])
+ deepStrictEqual(pipe([1, 2, 3], Arr.modify(10, double)), [1, 2, 3])
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.modify(1, double)), [1, 4, 3])
+ deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.modify(1, double)), [1, 4, 3])
// out of bound
- deepStrictEqual(pipe(new Set([]), RA.modify(1, double)), [])
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.modify(10, double)), [1, 2, 3])
+ deepStrictEqual(pipe(new Set([]), Arr.modify(1, double)), [])
+ deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.modify(10, double)), [1, 2, 3])
})
it("modifyOption", () => {
- deepStrictEqual(pipe([1, 2, 3], RA.modifyOption(1, double)), O.some([1, 4, 3]))
+ assertSome(pipe([1, 2, 3], Arr.modifyOption(1, double)), [1, 4, 3])
// out of bound
- deepStrictEqual(pipe([], RA.modifyOption(1, double)), O.none())
- deepStrictEqual(pipe([1, 2, 3], RA.modifyOption(10, double)), O.none())
+ assertNone(pipe([], Arr.modifyOption(1, double)))
+ assertNone(pipe([1, 2, 3], Arr.modifyOption(10, double)))
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.modifyOption(1, double)), O.some([1, 4, 3]))
+ assertSome(pipe(new Set([1, 2, 3]), Arr.modifyOption(1, double)), [1, 4, 3])
// out of bound
- deepStrictEqual(pipe(new Set([]), RA.modifyOption(1, double)), O.none())
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.modifyOption(10, double)), O.none())
+ assertNone(pipe(new Set([]), Arr.modifyOption(1, double)))
+ assertNone(pipe(new Set([1, 2, 3]), Arr.modifyOption(10, double)))
})
it("remove", () => {
- deepStrictEqual(pipe([1, 2, 3], RA.remove(0)), [2, 3])
+ deepStrictEqual(pipe([1, 2, 3], Arr.remove(0)), [2, 3])
// out of bound
- deepStrictEqual(pipe([], RA.remove(0)), [])
- deepStrictEqual(pipe([1, 2, 3], RA.remove(-1)), [1, 2, 3])
- deepStrictEqual(pipe([1, 2, 3], RA.remove(10)), [1, 2, 3])
+ deepStrictEqual(pipe([], Arr.remove(0)), [])
+ deepStrictEqual(pipe([1, 2, 3], Arr.remove(-1)), [1, 2, 3])
+ deepStrictEqual(pipe([1, 2, 3], Arr.remove(10)), [1, 2, 3])
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.remove(0)), [2, 3])
+ deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.remove(0)), [2, 3])
// out of bound
- deepStrictEqual(pipe(new Set([]), RA.remove(0)), [])
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.remove(-1)), [1, 2, 3])
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.remove(10)), [1, 2, 3])
+ deepStrictEqual(pipe(new Set([]), Arr.remove(0)), [])
+ deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.remove(-1)), [1, 2, 3])
+ deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.remove(10)), [1, 2, 3])
})
it("reverse", () => {
- deepStrictEqual(RA.reverse([]), [])
- deepStrictEqual(RA.reverse([1]), [1])
- deepStrictEqual(RA.reverse([1, 2, 3]), [3, 2, 1])
+ deepStrictEqual(Arr.reverse([]), [])
+ deepStrictEqual(Arr.reverse([1]), [1])
+ deepStrictEqual(Arr.reverse([1, 2, 3]), [3, 2, 1])
- deepStrictEqual(RA.reverse(new Set([])), [])
- deepStrictEqual(RA.reverse(new Set([1])), [1])
- deepStrictEqual(RA.reverse(new Set([1, 2, 3])), [3, 2, 1])
+ deepStrictEqual(Arr.reverse(new Set([])), [])
+ deepStrictEqual(Arr.reverse(new Set([1])), [1])
+ deepStrictEqual(Arr.reverse(new Set([1, 2, 3])), [3, 2, 1])
})
it("sort", () => {
- deepStrictEqual(RA.sort(Number.Order)([]), [])
- deepStrictEqual(RA.sort(Number.Order)([1, 3, 2]), [1, 2, 3])
+ deepStrictEqual(Arr.sort(Num.Order)([]), [])
+ deepStrictEqual(Arr.sort(Num.Order)([1, 3, 2]), [1, 2, 3])
- deepStrictEqual(RA.sort(Number.Order)(new Set()), [])
- deepStrictEqual(RA.sort(Number.Order)(new Set([1, 3, 2])), [1, 2, 3])
+ deepStrictEqual(Arr.sort(Num.Order)(new Set()), [])
+ deepStrictEqual(Arr.sort(Num.Order)(new Set([1, 3, 2])), [1, 2, 3])
})
it("zip", () => {
- deepStrictEqual(pipe(new Set([]), RA.zip(new Set(["a", "b", "c", "d"]))), [])
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.zip(new Set([]))), [])
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.zip(new Set(["a", "b", "c", "d"]))), [
+ deepStrictEqual(pipe(new Set([]), Arr.zip(new Set(["a", "b", "c", "d"]))), [])
+ deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.zip(new Set([]))), [])
+ deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.zip(new Set(["a", "b", "c", "d"]))), [
[1, "a"],
[2, "b"],
[3, "c"]
])
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.zip(new Set(["a", "b", "c", "d"]))), [
+ deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.zip(new Set(["a", "b", "c", "d"]))), [
[1, "a"],
[2, "b"],
[3, "c"]
@@ -491,27 +487,27 @@ describe("ReadonlyArray", () => {
it("zipWith", () => {
deepStrictEqual(
- pipe(new Set([1, 2, 3]), RA.zipWith(new Set([]), (n, s) => s + n)),
+ pipe(new Set([1, 2, 3]), Arr.zipWith(new Set([]), (n, s) => s + n)),
[]
)
deepStrictEqual(
- pipe(new Set([]), RA.zipWith(new Set(["a", "b", "c", "d"]), (n, s) => s + n)),
+ pipe(new Set([]), Arr.zipWith(new Set(["a", "b", "c", "d"]), (n, s) => s + n)),
[]
)
deepStrictEqual(
- pipe(new Set([]), RA.zipWith(new Set([]), (n, s) => s + n)),
+ pipe(new Set([]), Arr.zipWith(new Set([]), (n, s) => s + n)),
[]
)
deepStrictEqual(
- pipe(new Set([1, 2, 3]), RA.zipWith(new Set(["a", "b", "c", "d"]), (n, s) => s + n)),
+ pipe(new Set([1, 2, 3]), Arr.zipWith(new Set(["a", "b", "c", "d"]), (n, s) => s + n)),
["a1", "b2", "c3"]
)
})
it("unzip", () => {
- deepStrictEqual(RA.unzip(new Set([])), [[], []])
+ deepStrictEqual(Arr.unzip(new Set([])), [[], []])
deepStrictEqual(
- RA.unzip(
+ Arr.unzip(
new Set(
[
[1, "a"],
@@ -528,43 +524,43 @@ describe("ReadonlyArray", () => {
})
it("intersperse", () => {
- deepStrictEqual(pipe([], RA.intersperse(0)), [])
- deepStrictEqual(pipe([1], RA.intersperse(0)), [1])
- deepStrictEqual(pipe([1, 2, 3], RA.intersperse(0)), [1, 0, 2, 0, 3])
- deepStrictEqual(pipe([1, 2], RA.intersperse(0)), [1, 0, 2])
- deepStrictEqual(pipe([1, 2, 3, 4], RA.intersperse(0)), [1, 0, 2, 0, 3, 0, 4])
-
- deepStrictEqual(pipe(new Set([]), RA.intersperse(0)), [])
- deepStrictEqual(pipe(new Set([1]), RA.intersperse(0)), [1])
- deepStrictEqual(pipe(new Set([1, 2, 3]), RA.intersperse(0)), [1, 0, 2, 0, 3])
- deepStrictEqual(pipe(new Set([1, 2]), RA.intersperse(0)), [1, 0, 2])
- deepStrictEqual(pipe(new Set([1, 2, 3, 4]), RA.intersperse(0)), [1, 0, 2, 0, 3, 0, 4])
+ deepStrictEqual(pipe([], Arr.intersperse(0)), [])
+ deepStrictEqual(pipe([1], Arr.intersperse(0)), [1])
+ deepStrictEqual(pipe([1, 2, 3], Arr.intersperse(0)), [1, 0, 2, 0, 3])
+ deepStrictEqual(pipe([1, 2], Arr.intersperse(0)), [1, 0, 2])
+ deepStrictEqual(pipe([1, 2, 3, 4], Arr.intersperse(0)), [1, 0, 2, 0, 3, 0, 4])
+
+ deepStrictEqual(pipe(new Set([]), Arr.intersperse(0)), [])
+ deepStrictEqual(pipe(new Set([1]), Arr.intersperse(0)), [1])
+ deepStrictEqual(pipe(new Set([1, 2, 3]), Arr.intersperse(0)), [1, 0, 2, 0, 3])
+ deepStrictEqual(pipe(new Set([1, 2]), Arr.intersperse(0)), [1, 0, 2])
+ deepStrictEqual(pipe(new Set([1, 2, 3, 4]), Arr.intersperse(0)), [1, 0, 2, 0, 3, 0, 4])
})
it("rotate", () => {
- deepStrictEqual(RA.rotate(0)(RA.empty()), RA.empty())
- deepStrictEqual(RA.rotate(1)(RA.empty()), RA.empty())
- deepStrictEqual(RA.rotate(1)([1]), [1])
- deepStrictEqual(RA.rotate(2)([1]), [1])
- deepStrictEqual(RA.rotate(-1)([1]), [1])
- deepStrictEqual(RA.rotate(-2)([1]), [1])
- deepStrictEqual(RA.rotate(2)([1, 2]), [1, 2])
- deepStrictEqual(RA.rotate(0)([1, 2]), [1, 2])
- deepStrictEqual(RA.rotate(-2)([1, 2]), [1, 2])
- deepStrictEqual(RA.rotate(1)([1, 2]), [2, 1])
- deepStrictEqual(RA.rotate(1)(new Set([1, 2, 3, 4, 5])), [5, 1, 2, 3, 4])
- deepStrictEqual(RA.rotate(2)(new Set([1, 2, 3, 4, 5])), [4, 5, 1, 2, 3])
- deepStrictEqual(RA.rotate(-1)(new Set([1, 2, 3, 4, 5])), [2, 3, 4, 5, 1])
- deepStrictEqual(RA.rotate(-2)(new Set([1, 2, 3, 4, 5])), [3, 4, 5, 1, 2])
+ deepStrictEqual(Arr.rotate(0)(Arr.empty()), Arr.empty())
+ deepStrictEqual(Arr.rotate(1)(Arr.empty()), Arr.empty())
+ deepStrictEqual(Arr.rotate(1)([1]), [1])
+ deepStrictEqual(Arr.rotate(2)([1]), [1])
+ deepStrictEqual(Arr.rotate(-1)([1]), [1])
+ deepStrictEqual(Arr.rotate(-2)([1]), [1])
+ deepStrictEqual(Arr.rotate(2)([1, 2]), [1, 2])
+ deepStrictEqual(Arr.rotate(0)([1, 2]), [1, 2])
+ deepStrictEqual(Arr.rotate(-2)([1, 2]), [1, 2])
+ deepStrictEqual(Arr.rotate(1)([1, 2]), [2, 1])
+ deepStrictEqual(Arr.rotate(1)(new Set([1, 2, 3, 4, 5])), [5, 1, 2, 3, 4])
+ deepStrictEqual(Arr.rotate(2)(new Set([1, 2, 3, 4, 5])), [4, 5, 1, 2, 3])
+ deepStrictEqual(Arr.rotate(-1)(new Set([1, 2, 3, 4, 5])), [2, 3, 4, 5, 1])
+ deepStrictEqual(Arr.rotate(-2)(new Set([1, 2, 3, 4, 5])), [3, 4, 5, 1, 2])
// out of bounds
- deepStrictEqual(RA.rotate(7)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])
- deepStrictEqual(RA.rotate(-7)([1, 2, 3, 4, 5]), [3, 4, 5, 1, 2])
- deepStrictEqual(RA.rotate(2.2)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])
- deepStrictEqual(RA.rotate(-2.2)([1, 2, 3, 4, 5]), [3, 4, 5, 1, 2])
+ deepStrictEqual(Arr.rotate(7)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])
+ deepStrictEqual(Arr.rotate(-7)([1, 2, 3, 4, 5]), [3, 4, 5, 1, 2])
+ deepStrictEqual(Arr.rotate(2.2)([1, 2, 3, 4, 5]), [4, 5, 1, 2, 3])
+ deepStrictEqual(Arr.rotate(-2.2)([1, 2, 3, 4, 5]), [3, 4, 5, 1, 2])
})
it("containsWith", () => {
- const contains = RA.containsWith(Number.Equivalence)
+ const contains = Arr.containsWith(Num.Equivalence)
deepStrictEqual(pipe([1, 2, 3], contains(2)), true)
deepStrictEqual(pipe([1, 2, 3], contains(0)), false)
@@ -573,7 +569,7 @@ describe("ReadonlyArray", () => {
})
it("contains", () => {
- const contains = RA.contains
+ const contains = Arr.contains
deepStrictEqual(pipe([1, 2, 3], contains(2)), true)
deepStrictEqual(pipe([1, 2, 3], contains(0)), false)
@@ -582,7 +578,7 @@ describe("ReadonlyArray", () => {
})
it("dedupeWith", () => {
- const dedupe = RA.dedupeWith(Number.Equivalence)
+ const dedupe = Arr.dedupeWith(Num.Equivalence)
deepStrictEqual(dedupe([]), [])
deepStrictEqual(dedupe([-0, -0]), [-0])
deepStrictEqual(dedupe([0, -0]), [0])
@@ -595,10 +591,10 @@ describe("ReadonlyArray", () => {
})
it("dedupeAdjacentWith", () => {
- const dedupeAdjacent = RA.dedupeAdjacentWith(Number.Equivalence)
- expect(dedupeAdjacent([])).toEqual([])
- expect(dedupeAdjacent([1, 2, 3])).toEqual([1, 2, 3])
- expect(dedupeAdjacent([1, 2, 2, 3, 3])).toEqual([1, 2, 3])
+ const dedupeAdjacent = Arr.dedupeAdjacentWith(Num.Equivalence)
+ deepStrictEqual(dedupeAdjacent([]), [])
+ deepStrictEqual(dedupeAdjacent([1, 2, 3]), [1, 2, 3])
+ deepStrictEqual(dedupeAdjacent([1, 2, 2, 3, 3]), [1, 2, 3])
})
it("splitAt", () => {
@@ -608,17 +604,17 @@ describe("ReadonlyArray", () => {
expectedInit: ReadonlyArray,
expectedRest: ReadonlyArray
) => {
- const [init, rest] = RA.splitAt(index)(input)
+ const [init, rest] = Arr.splitAt(index)(input)
deepStrictEqual(init, expectedInit)
deepStrictEqual(rest, expectedRest)
}
- deepStrictEqual(RA.splitAt(1)([1, 2]), [[1], [2]])
+ deepStrictEqual(Arr.splitAt(1)([1, 2]), [[1], [2]])
assertSplitAt([1, 2], 2, [1, 2], [])
- deepStrictEqual(RA.splitAt(2)([1, 2, 3, 4, 5]), [
+ deepStrictEqual(Arr.splitAt(2)([1, 2, 3, 4, 5]), [
[1, 2],
[3, 4, 5]
])
- deepStrictEqual(RA.splitAt(2)(new Set([1, 2, 3, 4, 5])), [
+ deepStrictEqual(Arr.splitAt(2)(new Set([1, 2, 3, 4, 5])), [
[1, 2],
[3, 4, 5]
])
@@ -634,30 +630,30 @@ describe("ReadonlyArray", () => {
})
it("splitNonEmptyAt", () => {
- deepStrictEqual(pipe(RA.make(1, 2, 3, 4), RA.splitNonEmptyAt(2)), [[1, 2], [3, 4]])
- deepStrictEqual(pipe(RA.make(1, 2, 3, 4), RA.splitNonEmptyAt(10)), [[1, 2, 3, 4], []])
+ deepStrictEqual(pipe(Arr.make(1, 2, 3, 4), Arr.splitNonEmptyAt(2)), [[1, 2], [3, 4]])
+ deepStrictEqual(pipe(Arr.make(1, 2, 3, 4), Arr.splitNonEmptyAt(10)), [[1, 2, 3, 4], []])
})
describe("unsafeGet", () => {
it("should throw on index out of bound", () => {
- expect(() => pipe([], RA.unsafeGet(100))).toThrowError(new Error("Index 100 out of bounds"))
+ throws(() => pipe([], Arr.unsafeGet(100)), new Error("Index 100 out of bounds"))
})
})
it("fromNullable", () => {
- deepStrictEqual(RA.fromNullable(undefined), [])
- deepStrictEqual(RA.fromNullable(null), [])
- deepStrictEqual(RA.fromNullable(1), [1])
+ deepStrictEqual(Arr.fromNullable(undefined), [])
+ deepStrictEqual(Arr.fromNullable(null), [])
+ deepStrictEqual(Arr.fromNullable(1), [1])
})
it("liftNullable", () => {
- const f = RA.liftNullable((n: number) => (n > 0 ? n : null))
+ const f = Arr.liftNullable((n: number) => (n > 0 ? n : null))
deepStrictEqual(f(1), [1])
deepStrictEqual(f(-1), [])
})
it("flatMapNullable", () => {
- const f = RA.flatMapNullable((n: number) => (n > 0 ? n : null))
+ const f = Arr.flatMapNullable((n: number) => (n > 0 ? n : null))
deepStrictEqual(pipe([], f), [])
deepStrictEqual(pipe([1], f), [1])
deepStrictEqual(pipe([1, 2], f), [1, 2])
@@ -667,122 +663,122 @@ describe("ReadonlyArray", () => {
it("liftPredicate", () => {
const p = (n: number): boolean => n > 2
- const f = RA.liftPredicate(p)
+ const f = Arr.liftPredicate(p)
deepStrictEqual(f(1), [])
deepStrictEqual(f(3), [3])
})
it("liftOption", () => {
- const f = RA.liftOption((n: number) => (n > 0 ? O.some(n) : O.none()))
+ const f = Arr.liftOption((n: number) => (n > 0 ? Option.some(n) : Option.none()))
deepStrictEqual(f(1), [1])
deepStrictEqual(f(-1), [])
})
it("unprepend", () => {
- deepStrictEqual(RA.unprepend([0]), [0, []])
- deepStrictEqual(RA.unprepend([1, 2, 3, 4]), [1, [2, 3, 4]])
+ deepStrictEqual(Arr.unprepend([0]), [0, []])
+ deepStrictEqual(Arr.unprepend([1, 2, 3, 4]), [1, [2, 3, 4]])
})
it("unappend", () => {
- deepStrictEqual(RA.unappend([0]), [[], 0])
- deepStrictEqual(RA.unappend([1, 2, 3, 4]), [
- RA.make(1, 2, 3),
+ deepStrictEqual(Arr.unappend([0]), [[], 0])
+ deepStrictEqual(Arr.unappend([1, 2, 3, 4]), [
+ Arr.make(1, 2, 3),
4
])
- deepStrictEqual(RA.unappend([0]), [[], 0])
- deepStrictEqual(RA.unappend([1, 2, 3, 4]), [
- RA.make(1, 2, 3),
+ deepStrictEqual(Arr.unappend([0]), [[], 0])
+ deepStrictEqual(Arr.unappend([1, 2, 3, 4]), [
+ Arr.make(1, 2, 3),
4
])
})
it("modifyNonEmptyHead", () => {
const f = (s: string) => s + "!"
- deepStrictEqual(pipe(["a"], RA.modifyNonEmptyHead(f)), ["a!"])
- deepStrictEqual(pipe(["a", "b"], RA.modifyNonEmptyHead(f)), ["a!", "b"])
- deepStrictEqual(pipe(["a", "b", "c"], RA.modifyNonEmptyHead(f)), ["a!", "b", "c"])
+ deepStrictEqual(pipe(["a"], Arr.modifyNonEmptyHead(f)), ["a!"])
+ deepStrictEqual(pipe(["a", "b"], Arr.modifyNonEmptyHead(f)), ["a!", "b"])
+ deepStrictEqual(pipe(["a", "b", "c"], Arr.modifyNonEmptyHead(f)), ["a!", "b", "c"])
})
it("modifyNonEmptyLast", () => {
const f = (s: string) => s + "!"
- deepStrictEqual(pipe(["a"], RA.modifyNonEmptyLast(f)), ["a!"])
- deepStrictEqual(pipe(["a", "b"], RA.modifyNonEmptyLast(f)), ["a", "b!"])
- deepStrictEqual(pipe(["a", "b", "c"], RA.modifyNonEmptyLast(f)), ["a", "b", "c!"])
+ deepStrictEqual(pipe(["a"], Arr.modifyNonEmptyLast(f)), ["a!"])
+ deepStrictEqual(pipe(["a", "b"], Arr.modifyNonEmptyLast(f)), ["a", "b!"])
+ deepStrictEqual(pipe(["a", "b", "c"], Arr.modifyNonEmptyLast(f)), ["a", "b", "c!"])
})
it("setNonEmptyHead", () => {
- deepStrictEqual(pipe(RA.make("a"), RA.setNonEmptyHead("d")), ["d"])
- deepStrictEqual(pipe(RA.make("a", "b"), RA.setNonEmptyHead("d")), ["d", "b"])
- deepStrictEqual(pipe(RA.make("a", "b", "c"), RA.setNonEmptyHead("d")), ["d", "b", "c"])
+ deepStrictEqual(pipe(Arr.make("a"), Arr.setNonEmptyHead("d")), ["d"])
+ deepStrictEqual(pipe(Arr.make("a", "b"), Arr.setNonEmptyHead("d")), ["d", "b"])
+ deepStrictEqual(pipe(Arr.make("a", "b", "c"), Arr.setNonEmptyHead("d")), ["d", "b", "c"])
})
it("setNonEmptyLast", () => {
- deepStrictEqual(pipe(RA.make("a"), RA.setNonEmptyLast("d")), ["d"])
- deepStrictEqual(pipe(RA.make("a", "b"), RA.setNonEmptyLast("d")), ["a", "d"])
- deepStrictEqual(pipe(RA.make("a", "b", "c"), RA.setNonEmptyLast("d")), ["a", "b", "d"])
+ deepStrictEqual(pipe(Arr.make("a"), Arr.setNonEmptyLast("d")), ["d"])
+ deepStrictEqual(pipe(Arr.make("a", "b"), Arr.setNonEmptyLast("d")), ["a", "d"])
+ deepStrictEqual(pipe(Arr.make("a", "b", "c"), Arr.setNonEmptyLast("d")), ["a", "b", "d"])
})
it("liftEither", () => {
- const f = RA.liftEither((s: string) => s.length > 2 ? E.right(s.length) : E.left("e"))
+ const f = Arr.liftEither((s: string) => s.length > 2 ? Either.right(s.length) : Either.left("e"))
deepStrictEqual(f("a"), [])
deepStrictEqual(f("aaa"), [3])
})
it("headNonEmpty", () => {
- deepStrictEqual(RA.headNonEmpty(RA.make(1, 2)), 1)
+ deepStrictEqual(Arr.headNonEmpty(Arr.make(1, 2)), 1)
})
it("tailNonEmpty", () => {
- deepStrictEqual(RA.tailNonEmpty(RA.make(1, 2)), [2])
+ deepStrictEqual(Arr.tailNonEmpty(Arr.make(1, 2)), [2])
})
it("lastNonEmpty", () => {
- deepStrictEqual(RA.lastNonEmpty(RA.make(1, 2, 3)), 3)
- deepStrictEqual(RA.lastNonEmpty([1]), 1)
+ deepStrictEqual(Arr.lastNonEmpty(Arr.make(1, 2, 3)), 3)
+ deepStrictEqual(Arr.lastNonEmpty([1]), 1)
})
it("initNonEmpty", () => {
deepStrictEqual(
- RA.initNonEmpty(RA.make(1, 2, 3)),
- RA.make(1, 2)
+ Arr.initNonEmpty(Arr.make(1, 2, 3)),
+ Arr.make(1, 2)
)
- deepStrictEqual(RA.initNonEmpty([1]), [])
+ deepStrictEqual(Arr.initNonEmpty([1]), [])
})
it("get", () => {
- deepStrictEqual(pipe([1, 2, 3], RA.get(0)), O.some(1))
- deepStrictEqual(pipe([1, 2, 3], RA.get(3)), O.none())
+ assertSome(pipe([1, 2, 3], Arr.get(0)), 1)
+ assertNone(pipe([1, 2, 3], Arr.get(3)))
})
it("unfold", () => {
- const as = RA.unfold(5, (n) => (n > 0 ? O.some([n, n - 1]) : O.none()))
+ const as = Arr.unfold(5, (n) => (n > 0 ? Option.some([n, n - 1]) : Option.none()))
deepStrictEqual(as, [5, 4, 3, 2, 1])
})
it("map", () => {
deepStrictEqual(
- pipe([1, 2, 3], RA.map((n) => n * 2)),
+ pipe([1, 2, 3], Arr.map((n) => n * 2)),
[2, 4, 6]
)
deepStrictEqual(
- pipe(["a", "b"], RA.map((s, i) => s + i)),
+ pipe(["a", "b"], Arr.map((s, i) => s + i)),
["a0", "b1"]
)
})
it("flatMap", () => {
deepStrictEqual(
- pipe([1, 2, 3], RA.flatMap((n) => [n, n + 1])),
+ pipe([1, 2, 3], Arr.flatMap((n) => [n, n + 1])),
[1, 2, 2, 3, 3, 4]
)
- const f = RA.flatMap((n: number, i) => [n + i])
+ const f = Arr.flatMap((n: number, i) => [n + i])
deepStrictEqual(pipe([], f), [])
deepStrictEqual(pipe([1, 2, 3], f), [1, 3, 5])
})
it("extend", () => {
- deepStrictEqual(pipe([1, 2, 3, 4], RA.extend(Number.sumAll)), [10, 9, 7, 4])
- deepStrictEqual(pipe([1, 2, 3, 4], RA.extend(identity)), [
+ deepStrictEqual(pipe([1, 2, 3, 4], Arr.extend(Num.sumAll)), [10, 9, 7, 4])
+ deepStrictEqual(pipe([1, 2, 3, 4], Arr.extend(identity)), [
[1, 2, 3, 4],
[2, 3, 4],
[3, 4],
@@ -791,61 +787,68 @@ describe("ReadonlyArray", () => {
})
it("compact", () => {
- assert.deepStrictEqual(RA.getSomes([]), [])
- assert.deepStrictEqual(RA.getSomes([O.some(1), O.some(2), O.some(3)]), [
+ deepStrictEqual(Arr.getSomes([]), [])
+ deepStrictEqual(Arr.getSomes([Option.some(1), Option.some(2), Option.some(3)]), [
1,
2,
3
])
- assert.deepStrictEqual(RA.getSomes([O.some(1), O.none(), O.some(3)]), [
+ deepStrictEqual(Arr.getSomes([Option.some(1), Option.none(), Option.some(3)]), [
1,
3
])
})
it("separate", () => {
- expect(RA.separate([])).toEqual([[], []])
- expect(RA.separate([E.right(1), E.left("e"), E.left(2), E.right(2)])).toEqual([
+ deepStrictEqual(Arr.separate([]), [[], []])
+ deepStrictEqual(Arr.separate([Either.right(1), Either.left("e"), Either.left(2), Either.right(2)]), [
["e", 2],
[1, 2]
])
})
it("filter", () => {
- deepStrictEqual(RA.filter([1, 2, 3], (n) => n % 2 === 1), [1, 3])
- deepStrictEqual(RA.filter([O.some(3), O.some(2), O.some(1)], O.isSome), [O.some(3), O.some(2), O.some(1)])
- deepStrictEqual(RA.filter([O.some(3), O.none(), O.some(1)], O.isSome), [O.some(3), O.some(1)])
- deepStrictEqual(RA.filter(["a", "b", "c"], (_, i) => i % 2 === 0), ["a", "c"])
+ deepStrictEqual(Arr.filter([1, 2, 3], (n) => n % 2 === 1), [1, 3])
+ deepStrictEqual(Arr.filter([Option.some(3), Option.some(2), Option.some(1)], Option.isSome), [
+ Option.some(3),
+ Option.some(2),
+ Option.some(1)
+ ])
+ deepStrictEqual(Arr.filter([Option.some(3), Option.none(), Option.some(1)], Option.isSome), [
+ Option.some(3),
+ Option.some(1)
+ ])
+ deepStrictEqual(Arr.filter(["a", "b", "c"], (_, i) => i % 2 === 0), ["a", "c"])
})
it("filterMap", () => {
- const f = (n: number) => (n % 2 === 0 ? O.none() : O.some(n))
- deepStrictEqual(pipe([1, 2, 3], RA.filterMap(f)), [1, 3])
- deepStrictEqual(pipe([], RA.filterMap(f)), [])
- const g = (n: number, i: number) => ((i + n) % 2 === 0 ? O.none() : O.some(n))
- deepStrictEqual(pipe([1, 2, 4], RA.filterMap(g)), [1, 2])
- deepStrictEqual(pipe([], RA.filterMap(g)), [])
+ const f = (n: number) => (n % 2 === 0 ? Option.none() : Option.some(n))
+ deepStrictEqual(pipe([1, 2, 3], Arr.filterMap(f)), [1, 3])
+ deepStrictEqual(pipe([], Arr.filterMap(f)), [])
+ const g = (n: number, i: number) => ((i + n) % 2 === 0 ? Option.none() : Option.some(n))
+ deepStrictEqual(pipe([1, 2, 4], Arr.filterMap(g)), [1, 2])
+ deepStrictEqual(pipe([], Arr.filterMap(g)), [])
})
it("partitionMap", () => {
- expect(RA.partitionMap([], identity)).toEqual([[], []])
- expect(RA.partitionMap([E.right(1), E.left("a"), E.right(2)], identity)).toEqual([["a"], [1, 2]])
+ deepStrictEqual(Arr.partitionMap([], identity), [[], []])
+ deepStrictEqual(Arr.partitionMap([Either.right(1), Either.left("a"), Either.right(2)], identity), [["a"], [1, 2]])
})
it("partition", () => {
- expect(RA.partition([], (n) => n > 2)).toEqual([[], []])
- expect(RA.partition([1, 3], (n) => n > 2)).toEqual([[1], [3]])
+ deepStrictEqual(Arr.partition([], (n) => n > 2), [[], []])
+ deepStrictEqual(Arr.partition([1, 3], (n) => n > 2), [[1], [3]])
- expect(RA.partition([], (n, i) => n + i > 2)).toEqual([[], []])
- expect(RA.partition([1, 2], (n, i) => n + i > 2)).toEqual([[1], [2]])
+ deepStrictEqual(Arr.partition([], (n, i) => n + i > 2), [[], []])
+ deepStrictEqual(Arr.partition([1, 2], (n, i) => n + i > 2), [[1], [2]])
})
it("reduce", () => {
- deepStrictEqual(pipe(["a", "b", "c"], RA.reduce("", (b, a) => b + a)), "abc")
+ deepStrictEqual(pipe(["a", "b", "c"], Arr.reduce("", (b, a) => b + a)), "abc")
deepStrictEqual(
pipe(
["a", "b"],
- RA.reduce("", (b, a, i) => b + i + a)
+ Arr.reduce("", (b, a, i) => b + i + a)
),
"0a1b"
)
@@ -853,19 +856,19 @@ describe("ReadonlyArray", () => {
it("reduceRight", () => {
const f = (b: string, a: string) => b + a
- deepStrictEqual(pipe(["a", "b", "c"], RA.reduceRight("", f)), "cba")
- deepStrictEqual(pipe([], RA.reduceRight("", f)), "")
+ deepStrictEqual(pipe(["a", "b", "c"], Arr.reduceRight("", f)), "cba")
+ deepStrictEqual(pipe([], Arr.reduceRight("", f)), "")
deepStrictEqual(
pipe(
["a", "b"],
- RA.reduceRight("", (b, a, i) => b + i + a)
+ Arr.reduceRight("", (b, a, i) => b + i + a)
),
"1b0a"
)
})
it("getOrder", () => {
- const O = RA.getOrder(String.Order)
+ const O = Arr.getOrder(Str.Order)
deepStrictEqual(O([], []), 0)
deepStrictEqual(O(["a"], ["a"]), 0)
@@ -891,106 +894,106 @@ describe("ReadonlyArray", () => {
})
it("isEmptyReadonlyArray", () => {
- deepStrictEqual(RA.isEmptyReadonlyArray([1, 2, 3]), false)
- deepStrictEqual(RA.isEmptyReadonlyArray([]), true)
+ deepStrictEqual(Arr.isEmptyReadonlyArray([1, 2, 3]), false)
+ deepStrictEqual(Arr.isEmptyReadonlyArray([]), true)
})
it("isEmptyArray", () => {
- deepStrictEqual(RA.isEmptyArray([1, 2, 3]), false)
- deepStrictEqual(RA.isEmptyArray([]), true)
+ deepStrictEqual(Arr.isEmptyArray([1, 2, 3]), false)
+ deepStrictEqual(Arr.isEmptyArray([]), true)
})
it("isNonEmptyReadonlyArray", () => {
- deepStrictEqual(RA.isNonEmptyReadonlyArray([1, 2, 3]), true)
- deepStrictEqual(RA.isNonEmptyReadonlyArray([]), false)
+ deepStrictEqual(Arr.isNonEmptyReadonlyArray([1, 2, 3]), true)
+ deepStrictEqual(Arr.isNonEmptyReadonlyArray([]), false)
})
it("isNonEmptyArray", () => {
- deepStrictEqual(RA.isNonEmptyArray([1, 2, 3]), true)
- deepStrictEqual(RA.isNonEmptyArray([]), false)
+ deepStrictEqual(Arr.isNonEmptyArray([1, 2, 3]), true)
+ deepStrictEqual(Arr.isNonEmptyArray([]), false)
})
it("head", () => {
const as: ReadonlyArray = [1, 2, 3]
- deepStrictEqual(RA.head(as), O.some(1))
- deepStrictEqual(RA.head([]), O.none())
+ assertSome(Arr.head(as), 1)
+ assertNone(Arr.head([]))
})
it("last", () => {
const as: ReadonlyArray = [1, 2, 3]
- deepStrictEqual(RA.last(as), O.some(3))
- deepStrictEqual(RA.last([]), O.none())
+ assertSome(Arr.last(as), 3)
+ assertNone(Arr.last([]))
})
it("chunksOf", () => {
- deepStrictEqual(RA.chunksOf(2)([1, 2, 3, 4, 5]), [
- RA.make(1, 2),
+ deepStrictEqual(Arr.chunksOf(2)([1, 2, 3, 4, 5]), [
+ Arr.make(1, 2),
[3, 4],
[5]
])
- deepStrictEqual(RA.chunksOf(2)([1, 2, 3, 4, 5, 6]), [
- RA.make(1, 2),
+ deepStrictEqual(Arr.chunksOf(2)([1, 2, 3, 4, 5, 6]), [
+ Arr.make(1, 2),
[3, 4],
[5, 6]
])
- deepStrictEqual(RA.chunksOf(1)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
- deepStrictEqual(RA.chunksOf(5)([1, 2, 3, 4, 5]), [[1, 2, 3, 4, 5]])
+ deepStrictEqual(Arr.chunksOf(1)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
+ deepStrictEqual(Arr.chunksOf(5)([1, 2, 3, 4, 5]), [[1, 2, 3, 4, 5]])
// out of bounds
- deepStrictEqual(RA.chunksOf(0)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
- deepStrictEqual(RA.chunksOf(-1)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
+ deepStrictEqual(Arr.chunksOf(0)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
+ deepStrictEqual(Arr.chunksOf(-1)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
const assertSingleChunk = (
- input: RA.NonEmptyReadonlyArray,
+ input: Arr.NonEmptyReadonlyArray,
n: number
) => {
- const chunks = RA.chunksOf(n)(input)
+ const chunks = Arr.chunksOf(n)(input)
strictEqual(chunks.length, 1)
- deepStrictEqual(RA.headNonEmpty(chunks), input)
+ deepStrictEqual(Arr.headNonEmpty(chunks), input)
}
// n = length
- assertSingleChunk(RA.make(1, 2), 2)
+ assertSingleChunk(Arr.make(1, 2), 2)
// n out of bounds
- assertSingleChunk(RA.make(1, 2), 3)
+ assertSingleChunk(Arr.make(1, 2), 3)
})
it("min", () => {
- deepStrictEqual(RA.min(Number.Order)([2, 1, 3]), 1)
- deepStrictEqual(RA.min(Number.Order)([3]), 3)
+ deepStrictEqual(Arr.min(Num.Order)([2, 1, 3]), 1)
+ deepStrictEqual(Arr.min(Num.Order)([3]), 3)
})
it("max", () => {
deepStrictEqual(
- RA.max(Number.Order)(RA.make(1, 2, 3)),
+ Arr.max(Num.Order)(Arr.make(1, 2, 3)),
3
)
- deepStrictEqual(RA.max(Number.Order)([1]), 1)
+ deepStrictEqual(Arr.max(Num.Order)([1]), 1)
})
it("flatten", () => {
- expect(RA.flatten([[1], [2], [3]])).toEqual([1, 2, 3])
+ deepStrictEqual(Arr.flatten([[1], [2], [3]]), [1, 2, 3])
})
it("groupWith", () => {
- const groupWith = RA.groupWith(Number.Equivalence)
+ const groupWith = Arr.groupWith(Num.Equivalence)
deepStrictEqual(groupWith([1, 2, 1, 1]), [[1], [2], [1, 1]])
deepStrictEqual(groupWith([1, 2, 1, 1, 3]), [[1], [2], [1, 1], [3]])
})
it("groupBy", () => {
- deepStrictEqual(RA.groupBy((_) => "")([]), {})
- deepStrictEqual(RA.groupBy((a) => `${a}`)([1]), { "1": [1] })
+ deepStrictEqual(Arr.groupBy((_) => "")([]), {})
+ deepStrictEqual(Arr.groupBy((a) => `${a}`)([1]), { "1": [1] })
deepStrictEqual(
- RA.groupBy((s: string) => `${s.length}`)(["foo", "bar", "foobar"]),
+ Arr.groupBy((s: string) => `${s.length}`)(["foo", "bar", "foobar"]),
{
"3": ["foo", "bar"],
"6": ["foobar"]
}
)
- expect(RA.groupBy(["a", "b"], (s) => s === "a" ? symA : s === "b" ? symB : symC)).toStrictEqual({
+ deepStrictEqual(Arr.groupBy(["a", "b"], (s) => s === "a" ? symA : s === "b" ? symB : symC), {
[symA]: ["a"],
[symB]: ["b"]
})
- expect(RA.groupBy(["a", "b", "c", "d"], (s) => s === "a" ? symA : s === "b" ? symB : symC)).toStrictEqual({
+ deepStrictEqual(Arr.groupBy(["a", "b", "c", "d"], (s) => s === "a" ? symA : s === "b" ? symB : symC), {
[symA]: ["a"],
[symB]: ["b"],
[symC]: ["c", "d"]
@@ -998,7 +1001,7 @@ describe("ReadonlyArray", () => {
})
it("match", () => {
- const len: (as: ReadonlyArray) => number = RA.match({
+ const len: (as: ReadonlyArray) => number = Arr.match({
onEmpty: () => 0,
onNonEmpty: (as) => 1 + len(as.slice(1))
})
@@ -1006,7 +1009,7 @@ describe("ReadonlyArray", () => {
})
it("matchLeft", () => {
- const len: (as: ReadonlyArray) => number = RA.matchLeft({
+ const len: (as: ReadonlyArray) => number = Arr.matchLeft({
onEmpty: () => 0,
onNonEmpty: (_, tail) => 1 + len(tail)
})
@@ -1014,7 +1017,7 @@ describe("ReadonlyArray", () => {
})
it("matchRight", () => {
- const len: (as: ReadonlyArray) => number = RA.matchRight({
+ const len: (as: ReadonlyArray) => number = Arr.matchRight({
onEmpty: () => 0,
onNonEmpty: (init, _) => 1 + len(init)
})
@@ -1029,25 +1032,25 @@ describe("ReadonlyArray", () => {
}
const byName = pipe(
- String.Order,
+ Str.Order,
Order.mapInput((p: { readonly a: string; readonly b: number }) => p.a)
)
const byAge = pipe(
- Number.Order,
+ Num.Order,
Order.mapInput((p: { readonly a: string; readonly b: number }) => p.b)
)
- const sortByNameByAge = RA.sortBy(byName, byAge)
+ const sortByNameByAge = Arr.sortBy(byName, byAge)
- const xs: RA.NonEmptyArray = [
+ const xs: Arr.NonEmptyArray = [
{ a: "a", b: 1, c: true },
{ a: "b", b: 3, c: true },
{ a: "c", b: 2, c: true },
{ a: "b", b: 2, c: true }
]
- deepStrictEqual(RA.sortBy()(xs), xs)
+ deepStrictEqual(Arr.sortBy()(xs), xs)
deepStrictEqual(sortByNameByAge([]), [])
deepStrictEqual(sortByNameByAge(xs), [
{ a: "a", b: 1, c: true },
@@ -1056,7 +1059,7 @@ describe("ReadonlyArray", () => {
{ a: "c", b: 2, c: true }
])
- deepStrictEqual(RA.sortBy()(new Set(xs)), xs)
+ deepStrictEqual(Arr.sortBy()(new Set(xs)), xs)
deepStrictEqual(sortByNameByAge(new Set([])), [])
deepStrictEqual(sortByNameByAge(new Set(xs)), [
{ a: "a", b: 1, c: true },
@@ -1065,7 +1068,7 @@ describe("ReadonlyArray", () => {
{ a: "c", b: 2, c: true }
])
- const sortByAgeByName = RA.sortBy(byAge, byName)
+ const sortByAgeByName = Arr.sortBy(byAge, byName)
deepStrictEqual(sortByAgeByName(xs), [
{ a: "a", b: 1, c: true },
{ a: "b", b: 2, c: true },
@@ -1075,39 +1078,39 @@ describe("ReadonlyArray", () => {
})
it("copy", () => {
- expect(pipe([], RA.copy)).toEqual([])
- expect(pipe([1, 2, 3], RA.copy)).toEqual([1, 2, 3])
+ deepStrictEqual(pipe([], Arr.copy), [])
+ deepStrictEqual(pipe([1, 2, 3], Arr.copy), [1, 2, 3])
})
it("chop", () => {
- deepStrictEqual(pipe([], RA.chop((as) => [as[0] * 2, as.slice(1)])), [])
- deepStrictEqual(pipe([1, 2, 3], RA.chop((as) => [as[0] * 2, as.slice(1)])), [2, 4, 6])
+ deepStrictEqual(pipe([], Arr.chop((as) => [as[0] * 2, as.slice(1)])), [])
+ deepStrictEqual(pipe([1, 2, 3], Arr.chop((as) => [as[0] * 2, as.slice(1)])), [2, 4, 6])
})
it("pad", () => {
- deepStrictEqual(pipe([], RA.pad(0, 0)), [])
- deepStrictEqual(pipe([1, 2, 3], RA.pad(0, 0)), [])
- deepStrictEqual(pipe([1, 2, 3], RA.pad(2, 0)), [1, 2])
- deepStrictEqual(pipe([1, 2, 3], RA.pad(6, 0)), [1, 2, 3, 0, 0, 0])
- deepStrictEqual(pipe([1, 2, 3], RA.pad(-2, 0)), [])
+ deepStrictEqual(pipe([], Arr.pad(0, 0)), [])
+ deepStrictEqual(pipe([1, 2, 3], Arr.pad(0, 0)), [])
+ deepStrictEqual(pipe([1, 2, 3], Arr.pad(2, 0)), [1, 2])
+ deepStrictEqual(pipe([1, 2, 3], Arr.pad(6, 0)), [1, 2, 3, 0, 0, 0])
+ deepStrictEqual(pipe([1, 2, 3], Arr.pad(-2, 0)), [])
})
describe("chunksOf", () => {
it("should split a `ReadonlyArray` into length-n pieces", () => {
- deepStrictEqual(RA.chunksOf(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4], [5]])
- deepStrictEqual(RA.chunksOf(2)([1, 2, 3, 4, 5, 6]), [
+ deepStrictEqual(Arr.chunksOf(2)([1, 2, 3, 4, 5]), [[1, 2], [3, 4], [5]])
+ deepStrictEqual(Arr.chunksOf(2)([1, 2, 3, 4, 5, 6]), [
[1, 2],
[3, 4],
[5, 6]
])
- deepStrictEqual(RA.chunksOf(1)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
- deepStrictEqual(RA.chunksOf(5)([1, 2, 3, 4, 5]), [[1, 2, 3, 4, 5]])
+ deepStrictEqual(Arr.chunksOf(1)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
+ deepStrictEqual(Arr.chunksOf(5)([1, 2, 3, 4, 5]), [[1, 2, 3, 4, 5]])
// out of bounds
- deepStrictEqual(RA.chunksOf(0)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
- deepStrictEqual(RA.chunksOf(-1)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
+ deepStrictEqual(Arr.chunksOf(0)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
+ deepStrictEqual(Arr.chunksOf(-1)([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]])
const assertSingleChunk = (input: ReadonlyArray, n: number) => {
- const chunks = RA.chunksOf(n)(input)
+ const chunks = Arr.chunksOf(n)(input)
deepStrictEqual(chunks.length, 1)
deepStrictEqual(chunks[0], input)
}
@@ -1119,20 +1122,20 @@ describe("ReadonlyArray", () => {
it("returns an empty array if provided an empty array", () => {
const empty: ReadonlyArray = []
- deepStrictEqual(RA.chunksOf(0)(empty), RA.empty())
- deepStrictEqual(RA.chunksOf(0)(RA.empty()), RA.empty())
- deepStrictEqual(RA.chunksOf(1)(empty), RA.empty())
- deepStrictEqual(RA.chunksOf(1)(RA.empty()), RA.empty())
- deepStrictEqual(RA.chunksOf(2)(empty), RA.empty())
- deepStrictEqual(RA.chunksOf(2)(RA.empty()), RA.empty())
+ deepStrictEqual(Arr.chunksOf(0)(empty), Arr.empty())
+ deepStrictEqual(Arr.chunksOf(0)(Arr.empty()), Arr.empty())
+ deepStrictEqual(Arr.chunksOf(1)(empty), Arr.empty())
+ deepStrictEqual(Arr.chunksOf(1)(Arr.empty()), Arr.empty())
+ deepStrictEqual(Arr.chunksOf(2)(empty), Arr.empty())
+ deepStrictEqual(Arr.chunksOf(2)(Arr.empty()), Arr.empty())
})
it("should respect the law: chunksOf(n)(xs).concat(chunksOf(n)(ys)) == chunksOf(n)(xs.concat(ys)))", () => {
const xs: ReadonlyArray = []
const ys: ReadonlyArray = [1, 2]
deepStrictEqual(
- RA.chunksOf(2)(xs).concat(RA.chunksOf(2)(ys)),
- RA.chunksOf(2)(xs.concat(ys))
+ Arr.chunksOf(2)(xs).concat(Arr.chunksOf(2)(ys)),
+ Arr.chunksOf(2)(xs.concat(ys))
)
fc.assert(
fc.property(
@@ -1140,8 +1143,8 @@ describe("ReadonlyArray", () => {
fc.array(fc.integer()),
fc.integer({ min: 1, max: 1 }).map((x) => x * 2), // Generates `n` to be even so that it evenly divides `xs`
(xs, ys, n) => {
- const as = RA.chunksOf(n)(xs).concat(RA.chunksOf(n)(ys))
- const bs = RA.chunksOf(n)(xs.concat(ys))
+ const as = Arr.chunksOf(n)(xs).concat(Arr.chunksOf(n)(ys))
+ const bs = Arr.chunksOf(n)(xs.concat(ys))
deepStrictEqual(as, bs)
}
)
@@ -1150,87 +1153,87 @@ describe("ReadonlyArray", () => {
})
it("makeBy", () => {
- deepStrictEqual(RA.makeBy(5, (n) => n * 2), [0, 2, 4, 6, 8])
- deepStrictEqual(RA.makeBy(2.2, (n) => n * 2), [0, 2])
+ deepStrictEqual(Arr.makeBy(5, (n) => n * 2), [0, 2, 4, 6, 8])
+ deepStrictEqual(Arr.makeBy(2.2, (n) => n * 2), [0, 2])
})
it("replicate", () => {
- deepStrictEqual(RA.replicate("a", 0), ["a"])
- deepStrictEqual(RA.replicate("a", -1), ["a"])
- deepStrictEqual(RA.replicate("a", 3), ["a", "a", "a"])
- deepStrictEqual(RA.replicate("a", 2.2), ["a", "a"])
+ deepStrictEqual(Arr.replicate("a", 0), ["a"])
+ deepStrictEqual(Arr.replicate("a", -1), ["a"])
+ deepStrictEqual(Arr.replicate("a", 3), ["a", "a", "a"])
+ deepStrictEqual(Arr.replicate("a", 2.2), ["a", "a"])
})
it("range", () => {
- expect(RA.range(0, 0)).toEqual([0])
- expect(RA.range(0, 1)).toEqual([0, 1])
- expect(RA.range(1, 5)).toEqual([1, 2, 3, 4, 5])
- expect(RA.range(10, 15)).toEqual([10, 11, 12, 13, 14, 15])
- expect(RA.range(-1, 0)).toEqual([-1, 0])
- expect(RA.range(-5, -1)).toEqual([-5, -4, -3, -2, -1])
+ deepStrictEqual(Arr.range(0, 0), [0])
+ deepStrictEqual(Arr.range(0, 1), [0, 1])
+ deepStrictEqual(Arr.range(1, 5), [1, 2, 3, 4, 5])
+ deepStrictEqual(Arr.range(10, 15), [10, 11, 12, 13, 14, 15])
+ deepStrictEqual(Arr.range(-1, 0), [-1, 0])
+ deepStrictEqual(Arr.range(-5, -1), [-5, -4, -3, -2, -1])
// out of bound
- expect(RA.range(2, 1)).toEqual([2])
- expect(RA.range(-1, -2)).toEqual([-1])
+ deepStrictEqual(Arr.range(2, 1), [2])
+ deepStrictEqual(Arr.range(-1, -2), [-1])
})
it("unionWith", () => {
const two: ReadonlyArray = [1, 2]
- deepStrictEqual(pipe(two, RA.unionWith([3, 4], Number.Equivalence)), [1, 2, 3, 4])
- deepStrictEqual(pipe(two, RA.unionWith([2, 3], Number.Equivalence)), [1, 2, 3])
- deepStrictEqual(pipe(two, RA.unionWith([1, 2], Number.Equivalence)), [1, 2])
- deepStrictEqual(pipe(two, RA.unionWith(RA.empty(), Number.Equivalence)), two)
- deepStrictEqual(pipe(RA.empty(), RA.unionWith(two, Number.Equivalence)), two)
+ deepStrictEqual(pipe(two, Arr.unionWith([3, 4], Num.Equivalence)), [1, 2, 3, 4])
+ deepStrictEqual(pipe(two, Arr.unionWith([2, 3], Num.Equivalence)), [1, 2, 3])
+ deepStrictEqual(pipe(two, Arr.unionWith([1, 2], Num.Equivalence)), [1, 2])
+ deepStrictEqual(pipe(two, Arr.unionWith(Arr.empty(), Num.Equivalence)), two)
+ deepStrictEqual(pipe(Arr.empty(), Arr.unionWith(two, Num.Equivalence)), two)
deepStrictEqual(
- pipe(RA.empty(), RA.unionWith(RA.empty(), Number.Equivalence)),
- RA.empty()
+ pipe(Arr.empty(), Arr.unionWith(Arr.empty(), Num.Equivalence)),
+ Arr.empty()
)
})
it("intersectionWith", () => {
- const intersectionWith = RA.intersectionWith(Number.Equivalence)
+ const intersectionWith = Arr.intersectionWith(Num.Equivalence)
deepStrictEqual(pipe([1, 2], intersectionWith([3, 4])), [])
deepStrictEqual(pipe([1, 2], intersectionWith([2, 3])), [2])
deepStrictEqual(pipe([1, 2], intersectionWith([1, 2])), [1, 2])
})
it("differenceWith", () => {
- const differenceWith = RA.differenceWith(Number.Equivalence)
+ const differenceWith = Arr.differenceWith(Num.Equivalence)
deepStrictEqual(pipe([1, 2], differenceWith([3, 4])), [1, 2])
deepStrictEqual(pipe([1, 2], differenceWith([2, 3])), [1])
deepStrictEqual(pipe([1, 2], differenceWith([1, 2])), [])
})
it("empty", () => {
- deepStrictEqual(RA.empty.length, 0)
+ deepStrictEqual(Arr.empty.length, 0)
})
it("every", () => {
- const isPositive: Predicate = (n) => n > 0
- expect(RA.every([1, 2, 3], isPositive)).toEqual(true)
- expect(RA.every([1, 2, -3], isPositive)).toEqual(false)
+ const isPositive: Predicate.Predicate = (n) => n > 0
+ deepStrictEqual(Arr.every([1, 2, 3], isPositive), true)
+ deepStrictEqual(Arr.every([1, 2, -3], isPositive), false)
})
it("some", () => {
- const isPositive: Predicate = (n) => n > 0
- expect(RA.some([-1, -2, 3], isPositive)).toEqual(true)
- expect(RA.some([-1, -2, -3], isPositive)).toEqual(false)
+ const isPositive: Predicate.Predicate = (n) => n > 0
+ deepStrictEqual(Arr.some([-1, -2, 3], isPositive), true)
+ deepStrictEqual(Arr.some([-1, -2, -3], isPositive), false)
})
it("length", () => {
- deepStrictEqual(RA.length(RA.empty()), 0)
- deepStrictEqual(RA.length([]), 0)
- deepStrictEqual(RA.length(["a"]), 1)
+ deepStrictEqual(Arr.length(Arr.empty()), 0)
+ deepStrictEqual(Arr.length([]), 0)
+ deepStrictEqual(Arr.length(["a"]), 1)
})
it("fromOption", () => {
- deepStrictEqual(RA.fromOption(O.some("hello")), ["hello"])
- deepStrictEqual(RA.fromOption(O.none()), [])
+ deepStrictEqual(Arr.fromOption(Option.some("hello")), ["hello"])
+ deepStrictEqual(Arr.fromOption(Option.none()), [])
})
it("forEach", () => {
const log: Array = []
- RA.forEach(["a", "b", "c"], (a, i) => log.push(`${a}-${i}`))
- expect(log).toEqual(["a-0", "b-1", "c-2"])
+ Arr.forEach(["a", "b", "c"], (a, i) => log.push(`${a}-${i}`))
+ deepStrictEqual(log, ["a-0", "b-1", "c-2"])
})
it("sortWith", () => {
@@ -1239,28 +1242,28 @@ describe("ReadonlyArray", () => {
b: number
}
const arr: ReadonlyArray = [{ a: "a", b: 2 }, { a: "b", b: 1 }]
- expect(RA.sortWith(arr, (x) => x.b, Order.number)).toEqual([{ a: "b", b: 1 }, { a: "a", b: 2 }])
+ deepStrictEqual(Arr.sortWith(arr, (x) => x.b, Order.number), [{ a: "b", b: 1 }, { a: "a", b: 2 }])
})
it("Do notation", () => {
- const _do = RA.Do
- Util.deepStrictEqual(_do, RA.of({}))
+ const _do = Arr.Do
+ deepStrictEqual(_do, Arr.of({}))
- const doA = RA.bind(_do, "a", () => ["a"])
- Util.deepStrictEqual(doA, RA.of({ a: "a" }))
+ const doA = Arr.bind(_do, "a", () => ["a"])
+ deepStrictEqual(doA, Arr.of({ a: "a" }))
- const doAB = RA.bind(doA, "b", (x) => ["b", x.a + "b"])
- Util.deepStrictEqual(doAB, [
+ const doAB = Arr.bind(doA, "b", (x) => ["b", x.a + "b"])
+ deepStrictEqual(doAB, [
{ a: "a", b: "b" },
{ a: "a", b: "ab" }
])
- const doABC = RA.let(doAB, "c", (x) => [x.a, x.b, x.a + x.b])
- Util.deepStrictEqual(doABC, [
+ const doABC = Arr.let(doAB, "c", (x) => [x.a, x.b, x.a + x.b])
+ deepStrictEqual(doABC, [
{ a: "a", b: "b", c: ["a", "b", "ab"] },
{ a: "a", b: "ab", c: ["a", "ab", "aab"] }
])
- const doABCD = RA.bind(doABC, "d", () => RA.empty())
- Util.deepStrictEqual(doABCD, [])
+ const doABCD = Arr.bind(doABC, "d", () => Arr.empty())
+ deepStrictEqual(doABCD, [])
})
})
diff --git a/packages/effect/test/BigDecimal.test.ts b/packages/effect/test/BigDecimal.test.ts
index 191d048b7b3..41469cdefd9 100644
--- a/packages/effect/test/BigDecimal.test.ts
+++ b/packages/effect/test/BigDecimal.test.ts
@@ -1,83 +1,89 @@
-import * as BigDecimal from "effect/BigDecimal"
-import * as Equal from "effect/Equal"
-import * as fc from "effect/FastCheck"
-import * as Option from "effect/Option"
-import { assert, describe, expect, it } from "vitest"
-
-const _ = BigDecimal.unsafeFromString
-const assertEquals = (a: BigDecimal.BigDecimal, b: BigDecimal.BigDecimal) => assert.isTrue(BigDecimal.equals(a, b))
+import { BigDecimal, Equal, FastCheck as fc, Option } from "effect"
+import {
+ assertFalse,
+ assertNone,
+ assertSome,
+ assertTrue,
+ deepStrictEqual,
+ equals,
+ strictEqual,
+ throws
+} from "effect/test/util"
+import { describe, it } from "vitest"
+
+const $ = BigDecimal.unsafeFromString
describe("BigDecimal", () => {
it("isBigDecimal", () => {
- assert.isTrue(BigDecimal.isBigDecimal(_("0")))
- assert.isTrue(BigDecimal.isBigDecimal(_("987")))
- assert.isTrue(BigDecimal.isBigDecimal(_("123.0")))
- assert.isTrue(BigDecimal.isBigDecimal(_("0.123")))
- assert.isTrue(BigDecimal.isBigDecimal(_("123.456")))
- assert.isFalse(BigDecimal.isBigDecimal("1"))
- assert.isFalse(BigDecimal.isBigDecimal(true))
+ assertTrue(BigDecimal.isBigDecimal($("0")))
+ assertTrue(BigDecimal.isBigDecimal($("987")))
+ assertTrue(BigDecimal.isBigDecimal($("123.0")))
+ assertTrue(BigDecimal.isBigDecimal($("0.123")))
+ assertTrue(BigDecimal.isBigDecimal($("123.456")))
+ assertFalse(BigDecimal.isBigDecimal("1"))
+ assertFalse(BigDecimal.isBigDecimal(true))
})
it("sign", () => {
- assert.deepStrictEqual(BigDecimal.sign(_("-5")), -1)
- assert.deepStrictEqual(BigDecimal.sign(_("0")), 0)
- assert.deepStrictEqual(BigDecimal.sign(_("5")), 1)
- assert.deepStrictEqual(BigDecimal.sign(_("-123.456")), -1)
- assert.deepStrictEqual(BigDecimal.sign(_("456.789")), 1)
+ deepStrictEqual(BigDecimal.sign($("-5")), -1)
+ deepStrictEqual(BigDecimal.sign($("0")), 0)
+ deepStrictEqual(BigDecimal.sign($("5")), 1)
+ deepStrictEqual(BigDecimal.sign($("-123.456")), -1)
+ deepStrictEqual(BigDecimal.sign($("456.789")), 1)
})
it("equals", () => {
- assert.isTrue(BigDecimal.equals(_("1"), _("1")))
- assert.isTrue(BigDecimal.equals(_("0.00012300"), _("0.000123")))
- assert.isTrue(BigDecimal.equals(_("5"), _("5.0")))
- assert.isTrue(BigDecimal.equals(_("123.0000"), _("123.00")))
- assert.isFalse(BigDecimal.equals(_("1"), _("2")))
- assert.isFalse(BigDecimal.equals(_("1"), _("1.1")))
- assert.isFalse(BigDecimal.equals(_("1"), _("0.1")))
+ assertTrue(BigDecimal.equals($("1"), $("1")))
+ assertTrue(BigDecimal.equals($("0.00012300"), $("0.000123")))
+ assertTrue(BigDecimal.equals($("5"), $("5.0")))
+ assertTrue(BigDecimal.equals($("123.0000"), $("123.00")))
+ assertFalse(BigDecimal.equals($("1"), $("2")))
+ assertFalse(BigDecimal.equals($("1"), $("1.1")))
+ assertFalse(BigDecimal.equals($("1"), $("0.1")))
})
it("sum", () => {
- assertEquals(BigDecimal.sum(_("2"), _("0")), _("2"))
- assertEquals(BigDecimal.sum(_("0"), _("2")), _("2"))
- assertEquals(BigDecimal.sum(_("0"), _("0")), _("0"))
- assertEquals(BigDecimal.sum(_("2"), _("1")), _("3"))
- assertEquals(BigDecimal.sum(_("3.00000"), _("50")), _("53"))
- assertEquals(BigDecimal.sum(_("1.23"), _("0.0045678")), _("1.2345678"))
- assertEquals(BigDecimal.sum(_("123.456"), _("-123.456")), _("0"))
+ equals(BigDecimal.sum($("2"), $("0")), $("2"))
+ equals(BigDecimal.sum($("0"), $("2")), $("2"))
+ equals(BigDecimal.sum($("0"), $("0")), $("0"))
+ equals(BigDecimal.sum($("2"), $("1")), $("3"))
+ equals(BigDecimal.sum($("3.00000"), $("50")), $("53"))
+ equals(BigDecimal.sum($("1.23"), $("0.0045678")), $("1.2345678"))
+ equals(BigDecimal.sum($("123.456"), $("-123.456")), $("0"))
})
it("multiply", () => {
- assertEquals(BigDecimal.multiply(_("3"), _("2")), _("6"))
- assertEquals(BigDecimal.multiply(_("3"), _("0")), _("0"))
- assertEquals(BigDecimal.multiply(_("3"), _("-1")), _("-3"))
- assertEquals(BigDecimal.multiply(_("3"), _("0.5")), _("1.5"))
- assertEquals(BigDecimal.multiply(_("3"), _("-2.5")), _("-7.5"))
+ equals(BigDecimal.multiply($("3"), $("2")), $("6"))
+ equals(BigDecimal.multiply($("3"), $("0")), $("0"))
+ equals(BigDecimal.multiply($("3"), $("-1")), $("-3"))
+ equals(BigDecimal.multiply($("3"), $("0.5")), $("1.5"))
+ equals(BigDecimal.multiply($("3"), $("-2.5")), $("-7.5"))
})
it("subtract", () => {
- assertEquals(BigDecimal.subtract(_("0"), _("1")), _("-1"))
- assertEquals(BigDecimal.subtract(_("2.1"), _("1")), _("1.1"))
- assertEquals(BigDecimal.subtract(_("3"), _("1")), _("2"))
- assertEquals(BigDecimal.subtract(_("3"), _("0")), _("3"))
- assertEquals(BigDecimal.subtract(_("3"), _("-1")), _("4"))
- assertEquals(BigDecimal.subtract(_("3"), _("0.5")), _("2.5"))
- assertEquals(BigDecimal.subtract(_("3"), _("-2.5")), _("5.5"))
+ equals(BigDecimal.subtract($("0"), $("1")), $("-1"))
+ equals(BigDecimal.subtract($("2.1"), $("1")), $("1.1"))
+ equals(BigDecimal.subtract($("3"), $("1")), $("2"))
+ equals(BigDecimal.subtract($("3"), $("0")), $("3"))
+ equals(BigDecimal.subtract($("3"), $("-1")), $("4"))
+ equals(BigDecimal.subtract($("3"), $("0.5")), $("2.5"))
+ equals(BigDecimal.subtract($("3"), $("-2.5")), $("5.5"))
})
it("roundTerminal", () => {
- expect(BigDecimal.roundTerminal(0n)).toStrictEqual(0n)
- expect(BigDecimal.roundTerminal(4n)).toStrictEqual(0n)
- expect(BigDecimal.roundTerminal(5n)).toStrictEqual(1n)
- expect(BigDecimal.roundTerminal(9n)).toStrictEqual(1n)
- expect(BigDecimal.roundTerminal(49n)).toStrictEqual(0n)
- expect(BigDecimal.roundTerminal(59n)).toStrictEqual(1n)
- expect(BigDecimal.roundTerminal(99n)).toStrictEqual(1n)
- expect(BigDecimal.roundTerminal(-4n)).toStrictEqual(0n)
- expect(BigDecimal.roundTerminal(-5n)).toStrictEqual(1n)
- expect(BigDecimal.roundTerminal(-9n)).toStrictEqual(1n)
- expect(BigDecimal.roundTerminal(-49n)).toStrictEqual(0n)
- expect(BigDecimal.roundTerminal(-59n)).toStrictEqual(1n)
- expect(BigDecimal.roundTerminal(-99n)).toStrictEqual(1n)
+ strictEqual(BigDecimal.roundTerminal(0n), 0n)
+ strictEqual(BigDecimal.roundTerminal(4n), 0n)
+ strictEqual(BigDecimal.roundTerminal(5n), 1n)
+ strictEqual(BigDecimal.roundTerminal(9n), 1n)
+ strictEqual(BigDecimal.roundTerminal(49n), 0n)
+ strictEqual(BigDecimal.roundTerminal(59n), 1n)
+ strictEqual(BigDecimal.roundTerminal(99n), 1n)
+ strictEqual(BigDecimal.roundTerminal(-4n), 0n)
+ strictEqual(BigDecimal.roundTerminal(-5n), 1n)
+ strictEqual(BigDecimal.roundTerminal(-9n), 1n)
+ strictEqual(BigDecimal.roundTerminal(-49n), 0n)
+ strictEqual(BigDecimal.roundTerminal(-59n), 1n)
+ strictEqual(BigDecimal.roundTerminal(-99n), 1n)
})
it("divide", () => {
@@ -126,234 +132,234 @@ describe("BigDecimal", () => {
]
for (const [x, y, z] of cases) {
- assertEquals(BigDecimal.divide(_(x), _(y)).pipe(Option.getOrThrow), _(z))
- assertEquals(BigDecimal.unsafeDivide(_(x), _(y)), _(z))
+ equals(BigDecimal.divide($(x), $(y)).pipe(Option.getOrThrow), $(z))
+ equals(BigDecimal.unsafeDivide($(x), $(y)), $(z))
}
- assert.isTrue(Option.isNone(BigDecimal.divide(_("5"), _("0"))))
- assert.throws(() => BigDecimal.unsafeDivide(_("5"), _("0")), "Division by zero")
+ assertTrue(Option.isNone(BigDecimal.divide($("5"), $("0"))))
+ throws(() => BigDecimal.unsafeDivide($("5"), $("0")), new RangeError("Division by zero"))
})
it("Equivalence", () => {
- assert.isTrue(BigDecimal.Equivalence(_("1"), _("1")))
- assert.isTrue(BigDecimal.Equivalence(_("0.00012300"), _("0.000123")))
- assert.isTrue(BigDecimal.Equivalence(_("5"), _("5.00")))
- assert.isFalse(BigDecimal.Equivalence(_("1"), _("2")))
- assert.isFalse(BigDecimal.Equivalence(_("1"), _("1.1")))
+ assertTrue(BigDecimal.Equivalence($("1"), $("1")))
+ assertTrue(BigDecimal.Equivalence($("0.00012300"), $("0.000123")))
+ assertTrue(BigDecimal.Equivalence($("5"), $("5.00")))
+ assertFalse(BigDecimal.Equivalence($("1"), $("2")))
+ assertFalse(BigDecimal.Equivalence($("1"), $("1.1")))
})
it("Order", () => {
- assert.deepStrictEqual(BigDecimal.Order(_("1"), _("2")), -1)
- assert.deepStrictEqual(BigDecimal.Order(_("2"), _("1")), 1)
- assert.deepStrictEqual(BigDecimal.Order(_("2"), _("2")), 0)
- assert.deepStrictEqual(BigDecimal.Order(_("1"), _("1.1")), -1)
- assert.deepStrictEqual(BigDecimal.Order(_("1.1"), _("1")), 1)
- assert.deepStrictEqual(BigDecimal.Order(_("0.00012300"), _("0.000123")), 0)
- assert.deepStrictEqual(BigDecimal.Order(_("5"), _("5.000")), 0)
- assert.deepStrictEqual(BigDecimal.Order(_("5"), _("0.500")), 1)
- assert.deepStrictEqual(BigDecimal.Order(_("5"), _("50.00")), -1)
+ deepStrictEqual(BigDecimal.Order($("1"), $("2")), -1)
+ deepStrictEqual(BigDecimal.Order($("2"), $("1")), 1)
+ deepStrictEqual(BigDecimal.Order($("2"), $("2")), 0)
+ deepStrictEqual(BigDecimal.Order($("1"), $("1.1")), -1)
+ deepStrictEqual(BigDecimal.Order($("1.1"), $("1")), 1)
+ deepStrictEqual(BigDecimal.Order($("0.00012300"), $("0.000123")), 0)
+ deepStrictEqual(BigDecimal.Order($("5"), $("5.000")), 0)
+ deepStrictEqual(BigDecimal.Order($("5"), $("0.500")), 1)
+ deepStrictEqual(BigDecimal.Order($("5"), $("50.00")), -1)
})
it("lessThan", () => {
- assert.isTrue(BigDecimal.lessThan(_("2"), _("3")))
- assert.isFalse(BigDecimal.lessThan(_("3"), _("3")))
- assert.isFalse(BigDecimal.lessThan(_("4"), _("3")))
+ assertTrue(BigDecimal.lessThan($("2"), $("3")))
+ assertFalse(BigDecimal.lessThan($("3"), $("3")))
+ assertFalse(BigDecimal.lessThan($("4"), $("3")))
})
it("lessThanOrEqualTo", () => {
- assert.isTrue(BigDecimal.lessThanOrEqualTo(_("2"), _("3")))
- assert.isTrue(BigDecimal.lessThanOrEqualTo(_("3"), _("3")))
- assert.isFalse(BigDecimal.lessThanOrEqualTo(_("4"), _("3")))
+ assertTrue(BigDecimal.lessThanOrEqualTo($("2"), $("3")))
+ assertTrue(BigDecimal.lessThanOrEqualTo($("3"), $("3")))
+ assertFalse(BigDecimal.lessThanOrEqualTo($("4"), $("3")))
})
it("greaterThan", () => {
- assert.isFalse(BigDecimal.greaterThan(_("2"), _("3")))
- assert.isFalse(BigDecimal.greaterThan(_("3"), _("3")))
- assert.isTrue(BigDecimal.greaterThan(_("4"), _("3")))
+ assertFalse(BigDecimal.greaterThan($("2"), $("3")))
+ assertFalse(BigDecimal.greaterThan($("3"), $("3")))
+ assertTrue(BigDecimal.greaterThan($("4"), $("3")))
})
it("greaterThanOrEqualTo", () => {
- assert.deepStrictEqual(BigDecimal.greaterThanOrEqualTo(_("2"), _("3")), false)
- assert.deepStrictEqual(BigDecimal.greaterThanOrEqualTo(_("3"), _("3")), true)
- assert.deepStrictEqual(BigDecimal.greaterThanOrEqualTo(_("4"), _("3")), true)
+ deepStrictEqual(BigDecimal.greaterThanOrEqualTo($("2"), $("3")), false)
+ deepStrictEqual(BigDecimal.greaterThanOrEqualTo($("3"), $("3")), true)
+ deepStrictEqual(BigDecimal.greaterThanOrEqualTo($("4"), $("3")), true)
})
it("between", () => {
- assert.deepStrictEqual(BigDecimal.between({ minimum: _("0"), maximum: _("5") })(_("3")), true)
- assert.deepStrictEqual(BigDecimal.between({ minimum: _("0"), maximum: _("5") })(_("-1")), false)
- assert.deepStrictEqual(BigDecimal.between({ minimum: _("0"), maximum: _("5") })(_("6")), false)
- assert.deepStrictEqual(BigDecimal.between({ minimum: _("0.02"), maximum: _("5") })(_("0.0123")), false)
- assert.deepStrictEqual(BigDecimal.between({ minimum: _("0.02"), maximum: _("5") })(_("0.05")), true)
+ deepStrictEqual(BigDecimal.between({ minimum: $("0"), maximum: $("5") })($("3")), true)
+ deepStrictEqual(BigDecimal.between({ minimum: $("0"), maximum: $("5") })($("-1")), false)
+ deepStrictEqual(BigDecimal.between({ minimum: $("0"), maximum: $("5") })($("6")), false)
+ deepStrictEqual(BigDecimal.between({ minimum: $("0.02"), maximum: $("5") })($("0.0123")), false)
+ deepStrictEqual(BigDecimal.between({ minimum: $("0.02"), maximum: $("5") })($("0.05")), true)
- assert.deepStrictEqual(BigDecimal.between(_("3"), { minimum: _("0"), maximum: _("5") }), true)
+ deepStrictEqual(BigDecimal.between($("3"), { minimum: $("0"), maximum: $("5") }), true)
})
it("clamp", () => {
- assertEquals(BigDecimal.clamp({ minimum: _("0"), maximum: _("5") })(_("3")), _("3"))
- assertEquals(BigDecimal.clamp({ minimum: _("0"), maximum: _("5") })(_("-1")), _("0"))
- assertEquals(BigDecimal.clamp({ minimum: _("0"), maximum: _("5") })(_("6")), _("5"))
- assertEquals(BigDecimal.clamp({ minimum: _("0.02"), maximum: _("5") })(_("0.0123")), _("0.02"))
+ equals(BigDecimal.clamp({ minimum: $("0"), maximum: $("5") })($("3")), $("3"))
+ equals(BigDecimal.clamp({ minimum: $("0"), maximum: $("5") })($("-1")), $("0"))
+ equals(BigDecimal.clamp({ minimum: $("0"), maximum: $("5") })($("6")), $("5"))
+ equals(BigDecimal.clamp({ minimum: $("0.02"), maximum: $("5") })($("0.0123")), $("0.02"))
- assertEquals(BigDecimal.clamp(_("3"), { minimum: _("0"), maximum: _("5") }), _("3"))
+ equals(BigDecimal.clamp($("3"), { minimum: $("0"), maximum: $("5") }), $("3"))
})
it("min", () => {
- assertEquals(BigDecimal.min(_("2"), _("3")), _("2"))
- assertEquals(BigDecimal.min(_("5"), _("0.1")), _("0.1"))
- assertEquals(BigDecimal.min(_("0.005"), _("3")), _("0.005"))
- assertEquals(BigDecimal.min(_("123.456"), _("1.2")), _("1.2"))
+ equals(BigDecimal.min($("2"), $("3")), $("2"))
+ equals(BigDecimal.min($("5"), $("0.1")), $("0.1"))
+ equals(BigDecimal.min($("0.005"), $("3")), $("0.005"))
+ equals(BigDecimal.min($("123.456"), $("1.2")), $("1.2"))
})
it("max", () => {
- assertEquals(BigDecimal.max(_("2"), _("3")), _("3"))
- assertEquals(BigDecimal.max(_("5"), _("0.1")), _("5"))
- assertEquals(BigDecimal.max(_("0.005"), _("3")), _("3"))
- assertEquals(BigDecimal.max(_("123.456"), _("1.2")), _("123.456"))
+ equals(BigDecimal.max($("2"), $("3")), $("3"))
+ equals(BigDecimal.max($("5"), $("0.1")), $("5"))
+ equals(BigDecimal.max($("0.005"), $("3")), $("3"))
+ equals(BigDecimal.max($("123.456"), $("1.2")), $("123.456"))
})
it("abs", () => {
- assertEquals(BigDecimal.abs(_("2")), _("2"))
- assertEquals(BigDecimal.abs(_("-3")), _("3"))
- assertEquals(BigDecimal.abs(_("0.000456")), _("0.000456"))
- assertEquals(BigDecimal.abs(_("-0.123")), _("0.123"))
+ equals(BigDecimal.abs($("2")), $("2"))
+ equals(BigDecimal.abs($("-3")), $("3"))
+ equals(BigDecimal.abs($("0.000456")), $("0.000456"))
+ equals(BigDecimal.abs($("-0.123")), $("0.123"))
})
it("negate", () => {
- assertEquals(BigDecimal.negate(_("2")), _("-2"))
- assertEquals(BigDecimal.negate(_("-3")), _("3"))
- assertEquals(BigDecimal.negate(_("0.000456")), _("-0.000456"))
- assertEquals(BigDecimal.negate(_("-0.123")), _("0.123"))
+ equals(BigDecimal.negate($("2")), $("-2"))
+ equals(BigDecimal.negate($("-3")), $("3"))
+ equals(BigDecimal.negate($("0.000456")), $("-0.000456"))
+ equals(BigDecimal.negate($("-0.123")), $("0.123"))
})
it("remainder", () => {
- assertEquals(BigDecimal.remainder(_("5"), _("2")).pipe(Option.getOrThrow), _("1"))
- assertEquals(BigDecimal.remainder(_("4"), _("2")).pipe(Option.getOrThrow), _("0"))
- assertEquals(BigDecimal.remainder(_("123.456"), _("0.2")).pipe(Option.getOrThrow), _("0.056"))
- assert.isTrue(Option.isNone(BigDecimal.remainder(_("5"), _("0"))))
+ equals(BigDecimal.remainder($("5"), $("2")).pipe(Option.getOrThrow), $("1"))
+ equals(BigDecimal.remainder($("4"), $("2")).pipe(Option.getOrThrow), $("0"))
+ equals(BigDecimal.remainder($("123.456"), $("0.2")).pipe(Option.getOrThrow), $("0.056"))
+ assertTrue(Option.isNone(BigDecimal.remainder($("5"), $("0"))))
})
it("unsafeRemainder", () => {
- assertEquals(BigDecimal.unsafeRemainder(_("5"), _("2")), _("1"))
- assertEquals(BigDecimal.unsafeRemainder(_("4"), _("2")), _("0"))
- assertEquals(BigDecimal.unsafeRemainder(_("123.456"), _("0.2")), _("0.056"))
- assert.throws(() => BigDecimal.unsafeRemainder(_("5"), _("0")), "Division by zero")
+ equals(BigDecimal.unsafeRemainder($("5"), $("2")), $("1"))
+ equals(BigDecimal.unsafeRemainder($("4"), $("2")), $("0"))
+ equals(BigDecimal.unsafeRemainder($("123.456"), $("0.2")), $("0.056"))
+ throws(() => BigDecimal.unsafeRemainder($("5"), $("0")), new RangeError("Division by zero"))
})
it("normalize", () => {
- assert.deepStrictEqual(BigDecimal.normalize(_("0")), BigDecimal.unsafeMakeNormalized(0n, 0))
- assert.deepStrictEqual(BigDecimal.normalize(_("0.123000")), BigDecimal.unsafeMakeNormalized(123n, 3))
- assert.deepStrictEqual(BigDecimal.normalize(_("123.000")), BigDecimal.unsafeMakeNormalized(123n, 0))
- assert.deepStrictEqual(BigDecimal.normalize(_("-0.000123000")), BigDecimal.unsafeMakeNormalized(-123n, 6))
- assert.deepStrictEqual(BigDecimal.normalize(_("-123.000")), BigDecimal.unsafeMakeNormalized(-123n, 0))
- assert.deepStrictEqual(BigDecimal.normalize(_("12300000")), BigDecimal.unsafeMakeNormalized(123n, -5))
+ deepStrictEqual(BigDecimal.normalize($("0")), BigDecimal.unsafeMakeNormalized(0n, 0))
+ deepStrictEqual(BigDecimal.normalize($("0.123000")), BigDecimal.unsafeMakeNormalized(123n, 3))
+ deepStrictEqual(BigDecimal.normalize($("123.000")), BigDecimal.unsafeMakeNormalized(123n, 0))
+ deepStrictEqual(BigDecimal.normalize($("-0.000123000")), BigDecimal.unsafeMakeNormalized(-123n, 6))
+ deepStrictEqual(BigDecimal.normalize($("-123.000")), BigDecimal.unsafeMakeNormalized(-123n, 0))
+ deepStrictEqual(BigDecimal.normalize($("12300000")), BigDecimal.unsafeMakeNormalized(123n, -5))
})
it("fromString", () => {
- assert.deepStrictEqual(BigDecimal.fromString("2"), Option.some(BigDecimal.make(2n, 0)))
- assert.deepStrictEqual(BigDecimal.fromString("-2"), Option.some(BigDecimal.make(-2n, 0)))
- assert.deepStrictEqual(BigDecimal.fromString("0.123"), Option.some(BigDecimal.make(123n, 3)))
- assert.deepStrictEqual(BigDecimal.fromString("200"), Option.some(BigDecimal.make(200n, 0)))
- assert.deepStrictEqual(BigDecimal.fromString("20000000"), Option.some(BigDecimal.make(20000000n, 0)))
- assert.deepStrictEqual(BigDecimal.fromString("-20000000"), Option.some(BigDecimal.make(-20000000n, 0)))
- assert.deepStrictEqual(BigDecimal.fromString("2.00"), Option.some(BigDecimal.make(200n, 2)))
- assert.deepStrictEqual(BigDecimal.fromString("0.0000200"), Option.some(BigDecimal.make(200n, 7)))
- assert.deepStrictEqual(BigDecimal.fromString(""), Option.some(BigDecimal.normalize(BigDecimal.make(0n, 0))))
- assert.deepStrictEqual(BigDecimal.fromString("1e5"), Option.some(BigDecimal.make(1n, -5)))
- assert.deepStrictEqual(BigDecimal.fromString("1E15"), Option.some(BigDecimal.make(1n, -15)))
- assert.deepStrictEqual(BigDecimal.fromString("1e+5"), Option.some(BigDecimal.make(1n, -5)))
- assert.deepStrictEqual(BigDecimal.fromString("1E+15"), Option.some(BigDecimal.make(1n, -15)))
- assert.deepStrictEqual(BigDecimal.fromString("-1.5E3"), Option.some(BigDecimal.make(-15n, -2)))
- assert.deepStrictEqual(BigDecimal.fromString("-1.5e3"), Option.some(BigDecimal.make(-15n, -2)))
- assert.deepStrictEqual(BigDecimal.fromString("-.5e3"), Option.some(BigDecimal.make(-5n, -2)))
- assert.deepStrictEqual(BigDecimal.fromString("-5e3"), Option.some(BigDecimal.make(-5n, -3)))
- assert.deepStrictEqual(BigDecimal.fromString("-5e-3"), Option.some(BigDecimal.make(-5n, 3)))
- assert.deepStrictEqual(BigDecimal.fromString("15e-3"), Option.some(BigDecimal.make(15n, 3)))
- assert.deepStrictEqual(BigDecimal.fromString("0.00002e5"), Option.some(BigDecimal.make(2n, 0)))
- assert.deepStrictEqual(BigDecimal.fromString("0.00002e-5"), Option.some(BigDecimal.make(2n, 10)))
- assert.isTrue(Option.isNone(BigDecimal.fromString("0.0000e2e1")))
- assert.isTrue(Option.isNone(BigDecimal.fromString("0.1.2")))
+ assertSome(BigDecimal.fromString("2"), BigDecimal.make(2n, 0))
+ assertSome(BigDecimal.fromString("-2"), BigDecimal.make(-2n, 0))
+ assertSome(BigDecimal.fromString("0.123"), BigDecimal.make(123n, 3))
+ assertSome(BigDecimal.fromString("200"), BigDecimal.make(200n, 0))
+ assertSome(BigDecimal.fromString("20000000"), BigDecimal.make(20000000n, 0))
+ assertSome(BigDecimal.fromString("-20000000"), BigDecimal.make(-20000000n, 0))
+ assertSome(BigDecimal.fromString("2.00"), BigDecimal.make(200n, 2))
+ assertSome(BigDecimal.fromString("0.0000200"), BigDecimal.make(200n, 7))
+ assertSome(BigDecimal.fromString(""), BigDecimal.normalize(BigDecimal.make(0n, 0)))
+ assertSome(BigDecimal.fromString("1e5"), BigDecimal.make(1n, -5))
+ assertSome(BigDecimal.fromString("1E15"), BigDecimal.make(1n, -15))
+ assertSome(BigDecimal.fromString("1e+5"), BigDecimal.make(1n, -5))
+ assertSome(BigDecimal.fromString("1E+15"), BigDecimal.make(1n, -15))
+ assertSome(BigDecimal.fromString("-1.5E3"), BigDecimal.make(-15n, -2))
+ assertSome(BigDecimal.fromString("-1.5e3"), BigDecimal.make(-15n, -2))
+ assertSome(BigDecimal.fromString("-.5e3"), BigDecimal.make(-5n, -2))
+ assertSome(BigDecimal.fromString("-5e3"), BigDecimal.make(-5n, -3))
+ assertSome(BigDecimal.fromString("-5e-3"), BigDecimal.make(-5n, 3))
+ assertSome(BigDecimal.fromString("15e-3"), BigDecimal.make(15n, 3))
+ assertSome(BigDecimal.fromString("0.00002e5"), BigDecimal.make(2n, 0))
+ assertSome(BigDecimal.fromString("0.00002e-5"), BigDecimal.make(2n, 10))
+ assertNone(BigDecimal.fromString("0.0000e2e1"))
+ assertNone(BigDecimal.fromString("0.1.2"))
})
it("format", () => {
- assert.strictEqual(BigDecimal.format(_("2")), "2")
- assert.strictEqual(BigDecimal.format(_("-2")), "-2")
- assert.strictEqual(BigDecimal.format(_("0.123")), "0.123")
- assert.strictEqual(BigDecimal.format(_("200")), "200")
- assert.strictEqual(BigDecimal.format(_("20000000")), "20000000")
- assert.strictEqual(BigDecimal.format(_("-20000000")), "-20000000")
- assert.strictEqual(BigDecimal.format(_("2.00")), "2")
- assert.strictEqual(BigDecimal.format(_("0.200")), "0.2")
- assert.strictEqual(BigDecimal.format(_("0.123000")), "0.123")
- assert.strictEqual(BigDecimal.format(_("-456.123")), "-456.123")
- assert.strictEqual(BigDecimal.format(BigDecimal.make(10n, -1)), "100")
- assert.strictEqual(BigDecimal.format(BigDecimal.make(1n, -25)), "1e+25")
- assert.strictEqual(BigDecimal.format(BigDecimal.make(12345n, -25)), "1.2345e+29")
- assert.strictEqual(BigDecimal.format(BigDecimal.make(12345n, 25)), "1.2345e-21")
- assert.strictEqual(BigDecimal.format(BigDecimal.make(-12345n, 20)), "-1.2345e-16")
+ strictEqual(BigDecimal.format($("2")), "2")
+ strictEqual(BigDecimal.format($("-2")), "-2")
+ strictEqual(BigDecimal.format($("0.123")), "0.123")
+ strictEqual(BigDecimal.format($("200")), "200")
+ strictEqual(BigDecimal.format($("20000000")), "20000000")
+ strictEqual(BigDecimal.format($("-20000000")), "-20000000")
+ strictEqual(BigDecimal.format($("2.00")), "2")
+ strictEqual(BigDecimal.format($("0.200")), "0.2")
+ strictEqual(BigDecimal.format($("0.123000")), "0.123")
+ strictEqual(BigDecimal.format($("-456.123")), "-456.123")
+ strictEqual(BigDecimal.format(BigDecimal.make(10n, -1)), "100")
+ strictEqual(BigDecimal.format(BigDecimal.make(1n, -25)), "1e+25")
+ strictEqual(BigDecimal.format(BigDecimal.make(12345n, -25)), "1.2345e+29")
+ strictEqual(BigDecimal.format(BigDecimal.make(12345n, 25)), "1.2345e-21")
+ strictEqual(BigDecimal.format(BigDecimal.make(-12345n, 20)), "-1.2345e-16")
})
it("toJSON()", () => {
- assert.deepStrictEqual(JSON.stringify(_("2")), JSON.stringify({ _id: "BigDecimal", value: "2", scale: 0 }))
+ deepStrictEqual(JSON.stringify($("2")), JSON.stringify({ _id: "BigDecimal", value: "2", scale: 0 }))
})
it("inspect", () => {
if (typeof window === "undefined") {
// eslint-disable-next-line @typescript-eslint/no-var-requires
const { inspect } = require("node:util")
- expect(inspect(_("2"))).toEqual(inspect({ _id: "BigDecimal", value: "2", scale: 0 }))
+ deepStrictEqual(inspect($("2")), inspect({ _id: "BigDecimal", value: "2", scale: 0 }))
}
})
it("toString()", () => {
- assert.strictEqual(String(_("2")), "BigDecimal(2)")
+ strictEqual(String($("2")), "BigDecimal(2)")
})
it("Equal.symbol", () => {
- expect(Equal.equals(_("2"), _("2"))).toBe(true)
+ assertTrue(Equal.equals($("2"), $("2")))
})
it("pipe()", () => {
- expect(_("2").pipe(BigDecimal.multiply(_("3")))).toEqual(_("6"))
+ deepStrictEqual($("2").pipe(BigDecimal.multiply($("3"))), $("6"))
})
it("scale", () => {
- expect(BigDecimal.scale(_("3.0005"), 3)).toStrictEqual(_("3.000"))
+ deepStrictEqual(BigDecimal.scale($("3.0005"), 3), $("3.000"))
})
it("fromBigInt", () => {
- expect(BigDecimal.fromBigInt(1n)).toStrictEqual(BigDecimal.make(1n, 0))
+ deepStrictEqual(BigDecimal.fromBigInt(1n), BigDecimal.make(1n, 0))
})
it("fromNumber", () => {
- expect(BigDecimal.fromNumber(123)).toStrictEqual(BigDecimal.make(123n, 0))
- expect(BigDecimal.fromNumber(123.456)).toStrictEqual(BigDecimal.make(123456n, 3))
+ deepStrictEqual(BigDecimal.fromNumber(123), BigDecimal.make(123n, 0))
+ deepStrictEqual(BigDecimal.fromNumber(123.456), BigDecimal.make(123456n, 3))
})
it("unsafeToNumber", () => {
- assert.strictEqual(BigDecimal.unsafeToNumber(_("123.456")), 123.456)
+ strictEqual(BigDecimal.unsafeToNumber($("123.456")), 123.456)
})
it("isInteger", () => {
- assert.isTrue(BigDecimal.isInteger(_("0")))
- assert.isTrue(BigDecimal.isInteger(_("1")))
- assert.isFalse(BigDecimal.isInteger(_("1.1")))
+ assertTrue(BigDecimal.isInteger($("0")))
+ assertTrue(BigDecimal.isInteger($("1")))
+ assertFalse(BigDecimal.isInteger($("1.1")))
})
it("isZero", () => {
- assert.isTrue(BigDecimal.isZero(_("0")))
- assert.isFalse(BigDecimal.isZero(_("1")))
+ assertTrue(BigDecimal.isZero($("0")))
+ assertFalse(BigDecimal.isZero($("1")))
})
it("isNegative", () => {
- assert.isTrue(BigDecimal.isNegative(_("-1")))
- assert.isFalse(BigDecimal.isNegative(_("0")))
- assert.isFalse(BigDecimal.isNegative(_("1")))
+ assertTrue(BigDecimal.isNegative($("-1")))
+ assertFalse(BigDecimal.isNegative($("0")))
+ assertFalse(BigDecimal.isNegative($("1")))
})
it("isPositive", () => {
- assert.isFalse(BigDecimal.isPositive(_("-1")))
- assert.isFalse(BigDecimal.isPositive(_("0")))
- assert.isTrue(BigDecimal.isPositive(_("1")))
+ assertFalse(BigDecimal.isPositive($("-1")))
+ assertFalse(BigDecimal.isPositive($("0")))
+ assertTrue(BigDecimal.isPositive($("1")))
})
})
diff --git a/packages/effect/test/BigInt.test.ts b/packages/effect/test/BigInt.test.ts
index 7b40e37d2b5..0eee411d1a9 100644
--- a/packages/effect/test/BigInt.test.ts
+++ b/packages/effect/test/BigInt.test.ts
@@ -1,21 +1,19 @@
-import * as BigInt_ from "effect/BigInt"
-import { pipe } from "effect/Function"
-import * as Option from "effect/Option"
-import { deepStrictEqual } from "effect/test/util"
-import { assert, describe, expect, it } from "vitest"
+import { BigInt as BigInt_, pipe } from "effect"
+import { assertFalse, assertNone, assertSome, assertTrue, deepStrictEqual, strictEqual, throws } from "effect/test/util"
+import { describe, it } from "vitest"
describe("BigInt", () => {
it("sign", () => {
- assert.deepStrictEqual(BigInt_.sign(-5n), -1)
- assert.deepStrictEqual(BigInt_.sign(0n), 0)
- assert.deepStrictEqual(BigInt_.sign(5n), 1)
+ strictEqual(BigInt_.sign(-5n), -1)
+ strictEqual(BigInt_.sign(0n), 0)
+ strictEqual(BigInt_.sign(5n), 1)
})
it("isBigInt", () => {
- expect(BigInt_.isBigInt(1n)).toEqual(true)
- expect(BigInt_.isBigInt(1)).toEqual(false)
- expect(BigInt_.isBigInt("a")).toEqual(false)
- expect(BigInt_.isBigInt(true)).toEqual(false)
+ assertTrue(BigInt_.isBigInt(1n))
+ assertFalse(BigInt_.isBigInt(1))
+ assertFalse(BigInt_.isBigInt("a"))
+ assertFalse(BigInt_.isBigInt(true))
})
it("sum", () => {
@@ -31,8 +29,8 @@ describe("BigInt", () => {
})
it("divide", () => {
- deepStrictEqual(pipe(6n, BigInt_.divide(2n)), Option.some(3n))
- deepStrictEqual(pipe(6n, BigInt_.divide(0n)), Option.none())
+ assertSome(pipe(6n, BigInt_.divide(2n)), 3n)
+ assertNone(pipe(6n, BigInt_.divide(0n)))
})
it("unsafeDivide", () => {
@@ -48,8 +46,8 @@ describe("BigInt", () => {
})
it("Equivalence", () => {
- expect(BigInt_.Equivalence(1n, 1n)).toBe(true)
- expect(BigInt_.Equivalence(1n, 2n)).toBe(false)
+ assertTrue(BigInt_.Equivalence(1n, 1n))
+ assertFalse(BigInt_.Equivalence(1n, 2n))
})
it("Order", () => {
@@ -59,126 +57,126 @@ describe("BigInt", () => {
})
it("lessThan", () => {
- assert.deepStrictEqual(BigInt_.lessThan(2n, 3n), true)
- assert.deepStrictEqual(BigInt_.lessThan(3n, 3n), false)
- assert.deepStrictEqual(BigInt_.lessThan(4n, 3n), false)
+ deepStrictEqual(BigInt_.lessThan(2n, 3n), true)
+ deepStrictEqual(BigInt_.lessThan(3n, 3n), false)
+ deepStrictEqual(BigInt_.lessThan(4n, 3n), false)
})
it("lessThanOrEqualTo", () => {
- assert.deepStrictEqual(BigInt_.lessThanOrEqualTo(2n, 3n), true)
- assert.deepStrictEqual(BigInt_.lessThanOrEqualTo(3n, 3n), true)
- assert.deepStrictEqual(BigInt_.lessThanOrEqualTo(4n, 3n), false)
+ deepStrictEqual(BigInt_.lessThanOrEqualTo(2n, 3n), true)
+ deepStrictEqual(BigInt_.lessThanOrEqualTo(3n, 3n), true)
+ deepStrictEqual(BigInt_.lessThanOrEqualTo(4n, 3n), false)
})
it("greaterThan", () => {
- assert.deepStrictEqual(BigInt_.greaterThan(2n, 3n), false)
- assert.deepStrictEqual(BigInt_.greaterThan(3n, 3n), false)
- assert.deepStrictEqual(BigInt_.greaterThan(4n, 3n), true)
+ deepStrictEqual(BigInt_.greaterThan(2n, 3n), false)
+ deepStrictEqual(BigInt_.greaterThan(3n, 3n), false)
+ deepStrictEqual(BigInt_.greaterThan(4n, 3n), true)
})
it("greaterThanOrEqualTo", () => {
- assert.deepStrictEqual(BigInt_.greaterThanOrEqualTo(2n, 3n), false)
- assert.deepStrictEqual(BigInt_.greaterThanOrEqualTo(3n, 3n), true)
- assert.deepStrictEqual(BigInt_.greaterThanOrEqualTo(4n, 3n), true)
+ deepStrictEqual(BigInt_.greaterThanOrEqualTo(2n, 3n), false)
+ deepStrictEqual(BigInt_.greaterThanOrEqualTo(3n, 3n), true)
+ deepStrictEqual(BigInt_.greaterThanOrEqualTo(4n, 3n), true)
})
it("between", () => {
- assert.deepStrictEqual(BigInt_.between({ minimum: 0n, maximum: 5n })(3n), true)
- assert.deepStrictEqual(BigInt_.between({ minimum: 0n, maximum: 5n })(-1n), false)
- assert.deepStrictEqual(BigInt_.between({ minimum: 0n, maximum: 5n })(6n), false)
+ deepStrictEqual(BigInt_.between({ minimum: 0n, maximum: 5n })(3n), true)
+ deepStrictEqual(BigInt_.between({ minimum: 0n, maximum: 5n })(-1n), false)
+ deepStrictEqual(BigInt_.between({ minimum: 0n, maximum: 5n })(6n), false)
- assert.deepStrictEqual(BigInt_.between(3n, { minimum: 0n, maximum: 5n }), true)
+ deepStrictEqual(BigInt_.between(3n, { minimum: 0n, maximum: 5n }), true)
})
it("clamp", () => {
- assert.deepStrictEqual(BigInt_.clamp({ minimum: 0n, maximum: 5n })(3n), 3n)
- assert.deepStrictEqual(BigInt_.clamp({ minimum: 0n, maximum: 5n })(-1n), 0n)
- assert.deepStrictEqual(BigInt_.clamp({ minimum: 0n, maximum: 5n })(6n), 5n)
+ deepStrictEqual(BigInt_.clamp({ minimum: 0n, maximum: 5n })(3n), 3n)
+ deepStrictEqual(BigInt_.clamp({ minimum: 0n, maximum: 5n })(-1n), 0n)
+ deepStrictEqual(BigInt_.clamp({ minimum: 0n, maximum: 5n })(6n), 5n)
- assert.deepStrictEqual(BigInt_.clamp(3n, { minimum: 0n, maximum: 5n }), 3n)
+ deepStrictEqual(BigInt_.clamp(3n, { minimum: 0n, maximum: 5n }), 3n)
})
it("min", () => {
- assert.deepStrictEqual(BigInt_.min(2n, 3n), 2n)
+ deepStrictEqual(BigInt_.min(2n, 3n), 2n)
})
it("max", () => {
- assert.deepStrictEqual(BigInt_.max(2n, 3n), 3n)
+ deepStrictEqual(BigInt_.max(2n, 3n), 3n)
})
it("sumAll", () => {
- assert.deepStrictEqual(BigInt_.sumAll([2n, 3n, 4n]), 9n)
+ deepStrictEqual(BigInt_.sumAll([2n, 3n, 4n]), 9n)
})
it("multiplyAll", () => {
- assert.deepStrictEqual(BigInt_.multiplyAll([2n, 0n, 4n]), 0n)
- assert.deepStrictEqual(BigInt_.multiplyAll([2n, 3n, 4n]), 24n)
+ deepStrictEqual(BigInt_.multiplyAll([2n, 0n, 4n]), 0n)
+ deepStrictEqual(BigInt_.multiplyAll([2n, 3n, 4n]), 24n)
})
it("abs", () => {
- assert.deepStrictEqual(BigInt_.abs(2n), 2n)
- assert.deepStrictEqual(BigInt_.abs(-3n), 3n)
+ deepStrictEqual(BigInt_.abs(2n), 2n)
+ deepStrictEqual(BigInt_.abs(-3n), 3n)
})
it("gcd", () => {
- assert.deepStrictEqual(BigInt_.gcd(2n, 4n), 2n)
- assert.deepStrictEqual(BigInt_.gcd(3n, 4n), 1n)
+ deepStrictEqual(BigInt_.gcd(2n, 4n), 2n)
+ deepStrictEqual(BigInt_.gcd(3n, 4n), 1n)
})
it("lcm", () => {
- assert.deepStrictEqual(BigInt_.lcm(2n, 4n), 4n)
- assert.deepStrictEqual(BigInt_.lcm(3n, 4n), 12n)
+ deepStrictEqual(BigInt_.lcm(2n, 4n), 4n)
+ deepStrictEqual(BigInt_.lcm(3n, 4n), 12n)
})
it("sqrt", () => {
- assert.deepStrictEqual(BigInt_.sqrt(1n), Option.some(1n))
- assert.deepStrictEqual(BigInt_.sqrt(16n), Option.some(4n))
- assert.deepStrictEqual(BigInt_.sqrt(81n), Option.some(9n))
- assert.deepStrictEqual(BigInt_.sqrt(-123n), Option.none())
+ assertSome(BigInt_.sqrt(1n), 1n)
+ assertSome(BigInt_.sqrt(16n), 4n)
+ assertSome(BigInt_.sqrt(81n), 9n)
+ assertNone(BigInt_.sqrt(-123n))
})
it("sqrt", () => {
- expect(() => BigInt_.unsafeSqrt(-1n)).toThrow(new Error("Cannot take the square root of a negative number"))
+ throws(() => BigInt_.unsafeSqrt(-1n), new RangeError("Cannot take the square root of a negative number"))
})
it("toNumber", () => {
- assert.deepStrictEqual(BigInt_.toNumber(BigInt(Number.MAX_SAFE_INTEGER)), Option.some(Number.MAX_SAFE_INTEGER))
- assert.deepStrictEqual(BigInt_.toNumber(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)), Option.none())
- assert.deepStrictEqual(BigInt_.toNumber(BigInt(Number.MIN_SAFE_INTEGER)), Option.some(Number.MIN_SAFE_INTEGER))
- assert.deepStrictEqual(BigInt_.toNumber(BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)), Option.none())
- assert.deepStrictEqual(BigInt_.toNumber(BigInt(0)), Option.some(0))
- assert.deepStrictEqual(BigInt_.toNumber(BigInt(42)), Option.some(42))
- assert.deepStrictEqual(BigInt_.toNumber(BigInt(-42)), Option.some(-42))
+ assertSome(BigInt_.toNumber(BigInt(Number.MAX_SAFE_INTEGER)), Number.MAX_SAFE_INTEGER)
+ assertNone(BigInt_.toNumber(BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1)))
+ assertSome(BigInt_.toNumber(BigInt(Number.MIN_SAFE_INTEGER)), Number.MIN_SAFE_INTEGER)
+ assertNone(BigInt_.toNumber(BigInt(Number.MIN_SAFE_INTEGER) - BigInt(1)))
+ assertSome(BigInt_.toNumber(BigInt(0)), 0)
+ assertSome(BigInt_.toNumber(BigInt(42)), 42)
+ assertSome(BigInt_.toNumber(BigInt(-42)), -42)
})
it("fromString", () => {
- assert.deepStrictEqual(BigInt_.fromString("NaN"), Option.none())
- assert.deepStrictEqual(BigInt_.fromString("Infinity"), Option.none())
- assert.deepStrictEqual(BigInt_.fromString("-Infinity"), Option.none())
- assert.deepStrictEqual(BigInt_.fromString("3.14"), Option.none())
- assert.deepStrictEqual(BigInt_.fromString("-3.14"), Option.none())
- assert.deepStrictEqual(BigInt_.fromString("1e3"), Option.none())
- assert.deepStrictEqual(BigInt_.fromString("1e-3"), Option.none())
- assert.deepStrictEqual(BigInt_.fromString(""), Option.none())
- assert.deepStrictEqual(BigInt_.fromString("a"), Option.none())
- assert.deepStrictEqual(BigInt_.fromString("42"), Option.some(BigInt(42)))
- assert.deepStrictEqual(BigInt_.fromString("\n\r\t 42 \n\r\t"), Option.some(BigInt(42)))
+ assertNone(BigInt_.fromString("NaN"))
+ assertNone(BigInt_.fromString("Infinity"))
+ assertNone(BigInt_.fromString("-Infinity"))
+ assertNone(BigInt_.fromString("3.14"))
+ assertNone(BigInt_.fromString("-3.14"))
+ assertNone(BigInt_.fromString("1e3"))
+ assertNone(BigInt_.fromString("1e-3"))
+ assertNone(BigInt_.fromString(""))
+ assertNone(BigInt_.fromString("a"))
+ assertSome(BigInt_.fromString("42"), BigInt(42))
+ assertSome(BigInt_.fromString("\n\r\t 42 \n\r\t"), BigInt(42))
})
it("fromNumber", () => {
- assert.deepStrictEqual(BigInt_.fromNumber(Number.MAX_SAFE_INTEGER), Option.some(BigInt(Number.MAX_SAFE_INTEGER)))
- assert.deepStrictEqual(BigInt_.fromNumber(Number.MAX_SAFE_INTEGER + 1), Option.none())
- assert.deepStrictEqual(BigInt_.fromNumber(Number.MIN_SAFE_INTEGER), Option.some(BigInt(Number.MIN_SAFE_INTEGER)))
- assert.deepStrictEqual(BigInt_.fromNumber(Number.MIN_SAFE_INTEGER - 1), Option.none())
- assert.deepStrictEqual(BigInt_.fromNumber(Infinity), Option.none())
- assert.deepStrictEqual(BigInt_.fromNumber(-Infinity), Option.none())
- assert.deepStrictEqual(BigInt_.fromNumber(NaN), Option.none())
- assert.deepStrictEqual(BigInt_.fromNumber(1e100), Option.none())
- assert.deepStrictEqual(BigInt_.fromNumber(-1e100), Option.none())
- assert.deepStrictEqual(BigInt_.fromNumber(3.14), Option.none())
- assert.deepStrictEqual(BigInt_.fromNumber(-3.14), Option.none())
- assert.deepStrictEqual(BigInt_.fromNumber(0), Option.some(BigInt(0)))
- assert.deepStrictEqual(BigInt_.fromNumber(42), Option.some(BigInt(42)))
- assert.deepStrictEqual(BigInt_.fromNumber(-42), Option.some(BigInt(-42)))
+ assertSome(BigInt_.fromNumber(Number.MAX_SAFE_INTEGER), BigInt(Number.MAX_SAFE_INTEGER))
+ assertNone(BigInt_.fromNumber(Number.MAX_SAFE_INTEGER + 1))
+ assertSome(BigInt_.fromNumber(Number.MIN_SAFE_INTEGER), BigInt(Number.MIN_SAFE_INTEGER))
+ assertNone(BigInt_.fromNumber(Number.MIN_SAFE_INTEGER - 1))
+ assertNone(BigInt_.fromNumber(Infinity))
+ assertNone(BigInt_.fromNumber(-Infinity))
+ assertNone(BigInt_.fromNumber(NaN))
+ assertNone(BigInt_.fromNumber(1e100))
+ assertNone(BigInt_.fromNumber(-1e100))
+ assertNone(BigInt_.fromNumber(3.14))
+ assertNone(BigInt_.fromNumber(-3.14))
+ assertSome(BigInt_.fromNumber(0), BigInt(0))
+ assertSome(BigInt_.fromNumber(42), BigInt(42))
+ assertSome(BigInt_.fromNumber(-42), BigInt(-42))
})
})
diff --git a/packages/effect/test/Boolean.test.ts b/packages/effect/test/Boolean.test.ts
index 36cbe2860bf..933b3e40b4e 100644
--- a/packages/effect/test/Boolean.test.ts
+++ b/packages/effect/test/Boolean.test.ts
@@ -1,68 +1,67 @@
-import * as Boolean from "effect/Boolean"
-import { pipe } from "effect/Function"
-import { deepStrictEqual } from "effect/test/util"
-import { assert, describe, expect, it } from "vitest"
+import { Boolean, pipe } from "effect"
+import { assertFalse, assertTrue, deepStrictEqual } from "effect/test/util"
+import { describe, it } from "vitest"
describe("Boolean", () => {
it("isBoolean", () => {
- expect(Boolean.isBoolean(true)).toEqual(true)
- expect(Boolean.isBoolean(false)).toEqual(true)
- expect(Boolean.isBoolean("a")).toEqual(false)
- expect(Boolean.isBoolean(1)).toEqual(false)
+ assertTrue(Boolean.isBoolean(true))
+ assertTrue(Boolean.isBoolean(false))
+ assertFalse(Boolean.isBoolean("a"))
+ assertFalse(Boolean.isBoolean(1))
})
it("and", () => {
- deepStrictEqual(pipe(true, Boolean.and(true)), true)
- deepStrictEqual(pipe(true, Boolean.and(false)), false)
- deepStrictEqual(pipe(false, Boolean.and(true)), false)
- deepStrictEqual(pipe(false, Boolean.and(false)), false)
+ assertTrue(pipe(true, Boolean.and(true)))
+ assertFalse(pipe(true, Boolean.and(false)))
+ assertFalse(pipe(false, Boolean.and(true)))
+ assertFalse(pipe(false, Boolean.and(false)))
})
it("nand", () => {
- deepStrictEqual(pipe(true, Boolean.nand(true)), false)
- deepStrictEqual(pipe(true, Boolean.nand(false)), true)
- deepStrictEqual(pipe(false, Boolean.nand(true)), true)
- deepStrictEqual(pipe(false, Boolean.nand(false)), true)
+ assertFalse(pipe(true, Boolean.nand(true)))
+ assertTrue(pipe(true, Boolean.nand(false)))
+ assertTrue(pipe(false, Boolean.nand(true)))
+ assertTrue(pipe(false, Boolean.nand(false)))
})
it("or", () => {
- deepStrictEqual(pipe(true, Boolean.or(true)), true)
- deepStrictEqual(pipe(true, Boolean.or(false)), true)
- deepStrictEqual(pipe(false, Boolean.or(true)), true)
- deepStrictEqual(pipe(false, Boolean.or(false)), false)
+ assertTrue(pipe(true, Boolean.or(true)))
+ assertTrue(pipe(true, Boolean.or(false)))
+ assertTrue(pipe(false, Boolean.or(true)))
+ assertFalse(pipe(false, Boolean.or(false)))
})
it("nor", () => {
- deepStrictEqual(pipe(true, Boolean.nor(true)), false)
- deepStrictEqual(pipe(true, Boolean.nor(false)), false)
- deepStrictEqual(pipe(false, Boolean.nor(true)), false)
- deepStrictEqual(pipe(false, Boolean.nor(false)), true)
+ assertFalse(pipe(true, Boolean.nor(true)))
+ assertFalse(pipe(true, Boolean.nor(false)))
+ assertFalse(pipe(false, Boolean.nor(true)))
+ assertTrue(pipe(false, Boolean.nor(false)))
})
it("xor", () => {
- deepStrictEqual(pipe(true, Boolean.xor(true)), false)
- deepStrictEqual(pipe(true, Boolean.xor(false)), true)
- deepStrictEqual(pipe(false, Boolean.xor(true)), true)
- deepStrictEqual(pipe(false, Boolean.xor(false)), false)
+ assertFalse(pipe(true, Boolean.xor(true)))
+ assertTrue(pipe(true, Boolean.xor(false)))
+ assertTrue(pipe(false, Boolean.xor(true)))
+ assertFalse(pipe(false, Boolean.xor(false)))
})
it("eqv", () => {
- deepStrictEqual(pipe(true, Boolean.eqv(true)), true)
- deepStrictEqual(pipe(true, Boolean.eqv(false)), false)
- deepStrictEqual(pipe(false, Boolean.eqv(true)), false)
- deepStrictEqual(pipe(false, Boolean.eqv(false)), true)
+ assertTrue(pipe(true, Boolean.eqv(true)))
+ assertFalse(pipe(true, Boolean.eqv(false)))
+ assertFalse(pipe(false, Boolean.eqv(true)))
+ assertTrue(pipe(false, Boolean.eqv(false)))
})
it("implies", () => {
- deepStrictEqual(pipe(true, Boolean.implies(true)), true)
- deepStrictEqual(pipe(true, Boolean.implies(false)), false)
- deepStrictEqual(pipe(false, Boolean.implies(true)), true)
- deepStrictEqual(pipe(false, Boolean.implies(false)), true)
+ assertTrue(pipe(true, Boolean.implies(true)))
+ assertFalse(pipe(true, Boolean.implies(false)))
+ assertTrue(pipe(false, Boolean.implies(true)))
+ assertTrue(pipe(false, Boolean.implies(false)))
})
it("not", () => {
- deepStrictEqual(pipe(true, Boolean.not), false)
- deepStrictEqual(pipe(false, Boolean.not), true)
+ assertFalse(pipe(true, Boolean.not))
+ assertTrue(pipe(false, Boolean.not))
})
it("match", () => {
@@ -75,10 +74,10 @@ describe("Boolean", () => {
})
it("Equivalence", () => {
- expect(Boolean.Equivalence(true, true)).toBe(true)
- expect(Boolean.Equivalence(false, false)).toBe(true)
- expect(Boolean.Equivalence(true, false)).toBe(false)
- expect(Boolean.Equivalence(false, true)).toBe(false)
+ assertTrue(Boolean.Equivalence(true, true))
+ assertTrue(Boolean.Equivalence(false, false))
+ assertFalse(Boolean.Equivalence(true, false))
+ assertFalse(Boolean.Equivalence(false, true))
})
it("Order", () => {
@@ -88,12 +87,12 @@ describe("Boolean", () => {
})
it("every", () => {
- assert.deepStrictEqual(Boolean.every([true, true, true]), true)
- assert.deepStrictEqual(Boolean.every([true, false, true]), false)
+ assertTrue(Boolean.every([true, true, true]))
+ assertFalse(Boolean.every([true, false, true]))
})
it("some", () => {
- assert.deepStrictEqual(Boolean.some([true, false, true]), true)
- assert.deepStrictEqual(Boolean.some([false, false, false]), false)
+ assertTrue(Boolean.some([true, false, true]))
+ assertFalse(Boolean.some([false, false, false]))
})
})
diff --git a/packages/effect/test/Brand.test.ts b/packages/effect/test/Brand.test.ts
index b9f03a08236..0568e82f6de 100644
--- a/packages/effect/test/Brand.test.ts
+++ b/packages/effect/test/Brand.test.ts
@@ -1,7 +1,15 @@
-import * as Brand from "effect/Brand"
-import * as Either from "effect/Either"
-import * as Option from "effect/Option"
-import { assert, describe, expect, it } from "vitest"
+import { Brand, Option } from "effect"
+import {
+ assertFalse,
+ assertLeft,
+ assertNone,
+ assertRight,
+ assertSome,
+ assertTrue,
+ strictEqual,
+ throws
+} from "effect/test/util"
+import { describe, it } from "vitest"
declare const IntTypeId: unique symbol
type Int = number & Brand.Brand
@@ -23,62 +31,52 @@ describe("Brand", () => {
it("nominal", () => {
type MyNumber = number & Brand.Brand<"MyNumber">
const MyNumber = Brand.nominal()
- assert.strictEqual(MyNumber(1), 1)
- assert.strictEqual(MyNumber(1.1), 1.1)
- assert.isTrue(MyNumber.is(1))
- assert.isTrue(MyNumber.is(1.1))
+ strictEqual(MyNumber(1), 1)
+ strictEqual(MyNumber(1.1), 1.1)
+ assertTrue(MyNumber.is(1))
+ assertTrue(MyNumber.is(1.1))
})
it("refined (predicate overload)", () => {
- assert.strictEqual(Int(1), 1)
- assert.throws(() => Int(1.1))
- assert.deepStrictEqual(Int.option(1), Option.some(1))
- assert.deepStrictEqual(Int.option(1.1), Option.none())
- assert.deepStrictEqual(Int.either(1), Either.right(1 as Int))
- assert.deepStrictEqual(
+ strictEqual(Int(1), 1)
+ throws(() => Int(1.1))
+ assertSome(Int.option(1), 1 as Int)
+ assertNone(Int.option(1.1))
+ assertRight(Int.either(1), 1 as Int)
+ assertLeft(
Int.either(1.1),
- Either.left(Brand.error("Expected 1.1 to be an integer"))
+ Brand.error("Expected 1.1 to be an integer")
)
- assert.isTrue(Int.is(1))
- assert.isFalse(Int.is(1.1))
- try {
- Int(1.1)
- assert.fail("expected `Int(1.1)` to throw an error")
- } catch (e) {
- expect(e).toStrictEqual(Brand.error("Expected 1.1 to be an integer"))
- }
+ assertTrue(Int.is(1))
+ assertFalse(Int.is(1.1))
+ throws(() => Int(1.1), Brand.error("Expected 1.1 to be an integer"))
})
it("refined (Option overload)", () => {
const Int = Brand.refined(
(n) => Number.isInteger(n) ? Option.none() : Option.some(Brand.error(`Expected ${n} to be an integer`))
)
- try {
- Int(1.1)
- assert.fail("expected `Int(1.1)` to throw an error")
- } catch (e) {
- expect(e).toStrictEqual(Brand.error("Expected 1.1 to be an integer"))
- }
+ throws(() => Int(1.1), Brand.error("Expected 1.1 to be an integer"))
})
it("composition", () => {
- assert.strictEqual(PositiveInt(1), 1)
- assert.throws(() => PositiveInt(1.1))
- assert.deepStrictEqual(PositiveInt.option(1), Option.some(1))
- assert.deepStrictEqual(PositiveInt.option(1.1), Option.none())
- assert.deepStrictEqual(PositiveInt.either(1), Either.right(1 as PositiveInt))
- assert.deepStrictEqual(
+ strictEqual(PositiveInt(1), 1)
+ throws(() => PositiveInt(1.1))
+ assertSome(PositiveInt.option(1), 1 as PositiveInt)
+ assertNone(PositiveInt.option(1.1))
+ assertRight(PositiveInt.either(1), 1 as PositiveInt)
+ assertLeft(
PositiveInt.either(1.1),
- Either.left(Brand.error("Expected 1.1 to be an integer"))
+ Brand.error("Expected 1.1 to be an integer")
)
- assert.deepStrictEqual(
+ assertLeft(
PositiveInt.either(-1.1),
- Either.left(Brand.errors(
+ Brand.errors(
Brand.error("Expected -1.1 to be an integer"),
Brand.error("Expected -1.1 to be positive")
- ))
+ )
)
- assert.isTrue(PositiveInt.is(1))
- assert.isFalse(PositiveInt.is(1.1))
+ assertTrue(PositiveInt.is(1))
+ assertFalse(PositiveInt.is(1.1))
})
})
diff --git a/packages/effect/test/Cache.test.ts b/packages/effect/test/Cache.test.ts
index e859ac74560..45b4781e74a 100644
--- a/packages/effect/test/Cache.test.ts
+++ b/packages/effect/test/Cache.test.ts
@@ -1,22 +1,22 @@
-import * as Cache from "effect/Cache"
-import * as Effect from "effect/Effect"
+import { Cache, Effect } from "effect"
+import { strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
import * as TestClock from "effect/TestClock"
-import { describe, expect } from "vitest"
+import { describe } from "vitest"
describe("Cache", () => {
it.effect("should not increment cache hits on expired entries", () =>
- Effect.gen(function*(_) {
- const cache = yield* _(Cache.make({
+ Effect.gen(function*() {
+ const cache = yield* Cache.make({
capacity: 100,
timeToLive: "1 seconds",
lookup: (n: number): Effect.Effect => Effect.succeed(n)
- }))
- yield* _(cache.get(42))
- yield* _(TestClock.adjust("2 seconds"))
- yield* _(cache.get(42))
- const { hits, misses } = yield* _(cache.cacheStats)
- expect(hits).toBe(0)
- expect(misses).toBe(2)
+ })
+ yield* cache.get(42)
+ yield* TestClock.adjust("2 seconds")
+ yield* cache.get(42)
+ const { hits, misses } = yield* cache.cacheStats
+ strictEqual(hits, 0)
+ strictEqual(misses, 2)
}))
})
diff --git a/packages/effect/test/Cause.test.ts b/packages/effect/test/Cause.test.ts
index b0aa26eca70..a5d66fbcff9 100644
--- a/packages/effect/test/Cause.test.ts
+++ b/packages/effect/test/Cause.test.ts
@@ -1,10 +1,18 @@
-import * as assert from "assert"
-import { Array as Arr, Cause, Effect, Either, Equal, FiberId, Hash, Option, Predicate } from "effect"
-import * as fc from "effect/FastCheck"
+import { Array as Arr, Cause, Effect, Equal, FastCheck as fc, FiberId, Hash, Option, Predicate } from "effect"
import { NodeInspectSymbol } from "effect/Inspectable"
import * as internal from "effect/internal/cause"
+import {
+ assertFalse,
+ assertLeft,
+ assertNone,
+ assertRight,
+ assertSome,
+ assertTrue,
+ deepStrictEqual,
+ strictEqual
+} from "effect/test/util"
import { causes, equalCauses, errorCauseFunctions, errors } from "effect/test/utils/cause"
-import { describe, expect, it } from "vitest"
+import { describe, it } from "vitest"
describe("Cause", () => {
const empty = Cause.empty
@@ -18,42 +26,38 @@ describe("Cause", () => {
it("correctly implements toString() and the NodeInspectSymbol", () => {
// Referenced line to be included in the string output
const ex = new Cause.InterruptedException("my message")
- expect(ex.toString()).include("InterruptedException: my message")
+ assertTrue(ex.toString().includes("InterruptedException: my message"))
// In Node.js environments, ensure the 'inspect' method includes line information
if (typeof window === "undefined") {
// eslint-disable-next-line @typescript-eslint/no-var-requires
const { inspect } = require("node:util")
- expect(inspect(ex)).include("Cause.test.ts:20") // <= reference to the line above
+ assertTrue(inspect(ex).includes("Cause.test.ts:28")) // <= reference to the line above
}
})
})
describe("UnknownException", () => {
it("exposes its `error` property", () => {
- const err1 = new Cause.UnknownException("my message")
- expect(err1.error).toBe("my message")
- const err2 = new Cause.UnknownException(new Error("my error"))
- expect(err2.error).toBeInstanceOf(Error)
- expect((err2.error as Error).message).toBe("my error")
+ strictEqual(new Cause.UnknownException("my message").error, "my message")
+ const { error } = new Cause.UnknownException(new Error("my error"))
+ assertTrue(Predicate.isError(error))
+ strictEqual(error.message, "my error")
})
it("exposes its `cause` property", () => {
- const err1 = new Cause.UnknownException("my message")
- expect(err1.cause).toBe("my message")
+ strictEqual(new Cause.UnknownException("my message").cause, "my message")
const err2 = new Cause.UnknownException(new Error("my error"))
- expect(err2.cause).toBeInstanceOf(Error)
- expect((err2.cause as Error).message).toBe("my error")
+ assertTrue(Predicate.isError(err2.cause))
+ strictEqual(err2.cause.message, "my error")
})
it("uses a default message when none is provided", () => {
- const err1 = new Cause.UnknownException("my message")
- expect(err1.message).toBe("An unknown error occurred")
+ strictEqual(new Cause.UnknownException("my message").message, "An unknown error occurred")
})
it("accepts a custom override message", () => {
- const err1 = new Cause.UnknownException(new Error("my error"), "my message")
- expect(err1.message).toBe("my message")
+ strictEqual(new Cause.UnknownException(new Error("my error"), "my message").message, "my message")
})
})
@@ -61,25 +65,24 @@ describe("Cause", () => {
class Error1 {
readonly _tag = "WithTag"
}
- expect(internal.prettyErrorMessage(new Error1())).toBe(`{"_tag":"WithTag"}`)
+ strictEqual(internal.prettyErrorMessage(new Error1()), `{"_tag":"WithTag"}`)
class Error2 {
readonly _tag = "WithMessage"
readonly message = "my message"
}
- expect(internal.prettyErrorMessage(new Error2())).toBe(`{"_tag":"WithMessage","message":"my message"}`)
+ strictEqual(internal.prettyErrorMessage(new Error2()), `{"_tag":"WithMessage","message":"my message"}`)
class Error3 {
readonly _tag = "WithName"
readonly name = "my name"
}
- expect(internal.prettyErrorMessage(new Error3())).toBe(
- `{"_tag":"WithName","name":"my name"}`
- )
+ strictEqual(internal.prettyErrorMessage(new Error3()), `{"_tag":"WithName","name":"my name"}`)
class Error4 {
readonly _tag = "WithName"
readonly name = "my name"
readonly message = "my message"
}
- expect(internal.prettyErrorMessage(new Error4())).toBe(
+ strictEqual(
+ internal.prettyErrorMessage(new Error4()),
`{"_tag":"WithName","name":"my name","message":"my message"}`
)
class Error5 {
@@ -88,16 +91,14 @@ describe("Cause", () => {
return "Error: my string"
}
}
- expect(internal.prettyErrorMessage(new Error5())).toBe(
- `Error: my string`
- )
+ strictEqual(internal.prettyErrorMessage(new Error5()), `Error: my string`)
})
describe("Cause prototype", () => {
describe("toJSON / [NodeInspectSymbol]", () => {
const expectJSON = (cause: Cause.Cause, expected: unknown) => {
- assert.deepStrictEqual(cause.toJSON(), expected)
- assert.deepStrictEqual(cause[NodeInspectSymbol](), expected)
+ deepStrictEqual(cause.toJSON(), expected)
+ deepStrictEqual(cause[NodeInspectSymbol](), expected)
}
it("Empty", () => {
@@ -207,59 +208,62 @@ describe("Cause", () => {
describe("toString", () => {
it("Empty", () => {
- expect(String(Cause.empty)).toBe(`All fibers interrupted without errors.`)
+ strictEqual(String(Cause.empty), `All fibers interrupted without errors.`)
})
it("Fail", () => {
- expect(String(Cause.fail("my failure"))).toBe(`Error: my failure`)
- expect(String(Cause.fail(new Error("my failure")))).includes(`Error: my failure`)
+ strictEqual(String(Cause.fail("my failure")), `Error: my failure`)
+ assertTrue(String(Cause.fail(new Error("my failure"))).includes(`Error: my failure`))
})
it("Die", () => {
- expect(String(Cause.die("die message"))).toBe(`Error: die message`)
- expect(String(Cause.die(new Error("die message")))).includes(`Error: die message`)
+ strictEqual(String(Cause.die("die message")), `Error: die message`)
+ assertTrue(String(Cause.die(new Error("die message"))).includes(`Error: die message`))
})
it("Interrupt", () => {
- expect(String(Cause.interrupt(FiberId.none))).toBe(`All fibers interrupted without errors.`)
- expect(String(Cause.interrupt(FiberId.runtime(1, 0)))).toBe(`All fibers interrupted without errors.`)
- expect(String(Cause.interrupt(FiberId.composite(FiberId.none, FiberId.runtime(1, 0))))).toBe(
+ strictEqual(String(Cause.interrupt(FiberId.none)), `All fibers interrupted without errors.`)
+ strictEqual(String(Cause.interrupt(FiberId.runtime(1, 0))), `All fibers interrupted without errors.`)
+ strictEqual(
+ String(Cause.interrupt(FiberId.composite(FiberId.none, FiberId.runtime(1, 0)))),
`All fibers interrupted without errors.`
)
})
it("Sequential", () => {
- expect(String(Cause.sequential(Cause.fail("failure 1"), Cause.fail("failure 2")))).toBe(
+ strictEqual(
+ String(Cause.sequential(Cause.fail("failure 1"), Cause.fail("failure 2"))),
`Error: failure 1\nError: failure 2`
)
const actual = String(Cause.sequential(Cause.fail(new Error("failure 1")), Cause.fail(new Error("failure 2"))))
- expect(actual).includes("Error: failure 1")
- expect(actual).includes("Error: failure 2")
+ assertTrue(actual.includes("Error: failure 1"))
+ assertTrue(actual.includes("Error: failure 2"))
})
it("Parallel", () => {
- expect(String(Cause.parallel(Cause.fail("failure 1"), Cause.fail("failure 2")))).toBe(
+ strictEqual(
+ String(Cause.parallel(Cause.fail("failure 1"), Cause.fail("failure 2"))),
`Error: failure 1\nError: failure 2`
)
const actual = String(
String(Cause.parallel(Cause.fail(new Error("failure 1")), Cause.fail(new Error("failure 2"))))
)
- expect(actual).includes("Error: failure 1")
- expect(actual).includes("Error: failure 2")
+ assertTrue(actual.includes("Error: failure 1"))
+ assertTrue(actual.includes("Error: failure 2"))
})
})
describe("Equal.symbol implementation", () => {
it("compares causes by value", () => {
- assert.ok(Equal.equals(Cause.fail(0), Cause.fail(0)))
- assert.ok(Equal.equals(Cause.die(0), Cause.die(0)))
- assert.ok(!Equal.equals(Cause.fail(0), Cause.fail(1)))
- assert.ok(!Equal.equals(Cause.die(0), Cause.die(1)))
+ assertTrue(Equal.equals(Cause.fail(0), Cause.fail(0)))
+ assertTrue(Equal.equals(Cause.die(0), Cause.die(0)))
+ assertFalse(Equal.equals(Cause.fail(0), Cause.fail(1)))
+ assertFalse(Equal.equals(Cause.die(0), Cause.die(1)))
})
it("is symmetric", () => {
fc.assert(fc.property(causes, causes, (causeA, causeB) => {
- assert.strictEqual(
+ strictEqual(
Equal.equals(causeA, causeB),
Equal.equals(causeB, causeA)
)
@@ -268,164 +272,164 @@ describe("Cause", () => {
it("generates identical hashes for equal causes", () => {
fc.assert(fc.property(equalCauses, ([causeA, causeB]) => {
- assert.strictEqual(Hash.hash(causeA), Hash.hash(causeB))
+ strictEqual(Hash.hash(causeA), Hash.hash(causeB))
}))
})
it("distinguishes different failure types", () => {
- expect(Equal.equals(Cause.die(0), Cause.fail(0))).toBe(false)
- expect(
+ assertFalse(Equal.equals(Cause.die(0), Cause.fail(0)))
+ assertFalse(
Equal.equals(
Cause.parallel(Cause.fail("fail1"), Cause.die("fail2")),
Cause.parallel(Cause.fail("fail2"), Cause.die("fail1"))
)
- ).toBe(false)
- expect(
+ )
+ assertFalse(
Equal.equals(
Cause.sequential(Cause.fail("fail1"), Cause.die("fail2")),
Cause.parallel(Cause.fail("fail1"), Cause.die("fail2"))
)
- ).toBe(false)
+ )
})
})
})
describe("Guards", () => {
it("isCause", () => {
- expect(Cause.isCause(empty)).toBe(true)
- expect(Cause.isCause(failure)).toBe(true)
- expect(Cause.isCause(defect)).toBe(true)
- expect(Cause.isCause(interruption)).toBe(true)
- expect(Cause.isCause(sequential)).toBe(true)
- expect(Cause.isCause(parallel)).toBe(true)
-
- expect(Cause.isCause({})).toBe(false)
+ assertTrue(Cause.isCause(empty))
+ assertTrue(Cause.isCause(failure))
+ assertTrue(Cause.isCause(defect))
+ assertTrue(Cause.isCause(interruption))
+ assertTrue(Cause.isCause(sequential))
+ assertTrue(Cause.isCause(parallel))
+
+ assertFalse(Cause.isCause({}))
})
it("isEmptyType", () => {
- expect(Cause.isEmptyType(empty)).toBe(true)
- expect(Cause.isEmptyType(failure)).toBe(false)
- expect(Cause.isEmptyType(defect)).toBe(false)
- expect(Cause.isEmptyType(interruption)).toBe(false)
- expect(Cause.isEmptyType(sequential)).toBe(false)
- expect(Cause.isEmptyType(parallel)).toBe(false)
+ assertTrue(Cause.isEmptyType(empty))
+ assertFalse(Cause.isEmptyType(failure))
+ assertFalse(Cause.isEmptyType(defect))
+ assertFalse(Cause.isEmptyType(interruption))
+ assertFalse(Cause.isEmptyType(sequential))
+ assertFalse(Cause.isEmptyType(parallel))
})
it("isFailType", () => {
- expect(Cause.isFailType(empty)).toBe(false)
- expect(Cause.isFailType(failure)).toBe(true)
- expect(Cause.isFailType(defect)).toBe(false)
- expect(Cause.isFailType(interruption)).toBe(false)
- expect(Cause.isFailType(sequential)).toBe(false)
- expect(Cause.isFailType(parallel)).toBe(false)
+ assertFalse(Cause.isFailType(empty))
+ assertTrue(Cause.isFailType(failure))
+ assertFalse(Cause.isFailType(defect))
+ assertFalse(Cause.isFailType(interruption))
+ assertFalse(Cause.isFailType(sequential))
+ assertFalse(Cause.isFailType(parallel))
})
it("isDieType", () => {
- expect(Cause.isDieType(empty)).toBe(false)
- expect(Cause.isDieType(failure)).toBe(false)
- expect(Cause.isDieType(defect)).toBe(true)
- expect(Cause.isDieType(interruption)).toBe(false)
- expect(Cause.isDieType(sequential)).toBe(false)
- expect(Cause.isDieType(parallel)).toBe(false)
+ assertFalse(Cause.isDieType(empty))
+ assertFalse(Cause.isDieType(failure))
+ assertTrue(Cause.isDieType(defect))
+ assertFalse(Cause.isDieType(interruption))
+ assertFalse(Cause.isDieType(sequential))
+ assertFalse(Cause.isDieType(parallel))
})
it("isInterruptType", () => {
- expect(Cause.isInterruptType(empty)).toBe(false)
- expect(Cause.isInterruptType(failure)).toBe(false)
- expect(Cause.isInterruptType(defect)).toBe(false)
- expect(Cause.isInterruptType(interruption)).toBe(true)
- expect(Cause.isInterruptType(sequential)).toBe(false)
- expect(Cause.isInterruptType(parallel)).toBe(false)
+ assertFalse(Cause.isInterruptType(empty))
+ assertFalse(Cause.isInterruptType(failure))
+ assertFalse(Cause.isInterruptType(defect))
+ assertTrue(Cause.isInterruptType(interruption))
+ assertFalse(Cause.isInterruptType(sequential))
+ assertFalse(Cause.isInterruptType(parallel))
})
it("isSequentialType", () => {
- expect(Cause.isSequentialType(empty)).toBe(false)
- expect(Cause.isSequentialType(failure)).toBe(false)
- expect(Cause.isSequentialType(defect)).toBe(false)
- expect(Cause.isSequentialType(interruption)).toBe(false)
- expect(Cause.isSequentialType(sequential)).toBe(true)
- expect(Cause.isSequentialType(parallel)).toBe(false)
+ assertFalse(Cause.isSequentialType(empty))
+ assertFalse(Cause.isSequentialType(failure))
+ assertFalse(Cause.isSequentialType(defect))
+ assertFalse(Cause.isSequentialType(interruption))
+ assertTrue(Cause.isSequentialType(sequential))
+ assertFalse(Cause.isSequentialType(parallel))
})
it("isParallelType", () => {
- expect(Cause.isParallelType(empty)).toBe(false)
- expect(Cause.isParallelType(failure)).toBe(false)
- expect(Cause.isParallelType(defect)).toBe(false)
- expect(Cause.isParallelType(interruption)).toBe(false)
- expect(Cause.isParallelType(sequential)).toBe(false)
- expect(Cause.isParallelType(parallel)).toBe(true)
+ assertFalse(Cause.isParallelType(empty))
+ assertFalse(Cause.isParallelType(failure))
+ assertFalse(Cause.isParallelType(defect))
+ assertFalse(Cause.isParallelType(interruption))
+ assertFalse(Cause.isParallelType(sequential))
+ assertTrue(Cause.isParallelType(parallel))
})
})
describe("Getters", () => {
it("isEmpty", () => {
- expect(Cause.isEmpty(empty)).toBe(true)
- expect(Cause.isEmpty(Cause.sequential(empty, empty))).toBe(true)
- expect(Cause.isEmpty(Cause.parallel(empty, empty))).toBe(true)
- expect(Cause.isEmpty(Cause.parallel(empty, Cause.sequential(empty, empty)))).toBe(true)
- expect(Cause.isEmpty(Cause.sequential(empty, Cause.parallel(empty, empty)))).toBe(true)
-
- expect(Cause.isEmpty(defect)).toBe(false)
- expect(Cause.isEmpty(Cause.sequential(empty, failure))).toBe(false)
- expect(Cause.isEmpty(Cause.parallel(empty, failure))).toBe(false)
- expect(Cause.isEmpty(Cause.parallel(empty, Cause.sequential(empty, failure)))).toBe(false)
- expect(Cause.isEmpty(Cause.sequential(empty, Cause.parallel(empty, failure)))).toBe(false)
+ assertTrue(Cause.isEmpty(empty))
+ assertTrue(Cause.isEmpty(Cause.sequential(empty, empty)))
+ assertTrue(Cause.isEmpty(Cause.parallel(empty, empty)))
+ assertTrue(Cause.isEmpty(Cause.parallel(empty, Cause.sequential(empty, empty))))
+ assertTrue(Cause.isEmpty(Cause.sequential(empty, Cause.parallel(empty, empty))))
+
+ assertFalse(Cause.isEmpty(defect))
+ assertFalse(Cause.isEmpty(Cause.sequential(empty, failure)))
+ assertFalse(Cause.isEmpty(Cause.parallel(empty, failure)))
+ assertFalse(Cause.isEmpty(Cause.parallel(empty, Cause.sequential(empty, failure))))
+ assertFalse(Cause.isEmpty(Cause.sequential(empty, Cause.parallel(empty, failure))))
})
it("isFailure", () => {
- expect(Cause.isFailure(failure)).toBe(true)
- expect(Cause.isFailure(Cause.sequential(empty, failure))).toBe(true)
- expect(Cause.isFailure(Cause.parallel(empty, failure))).toBe(true)
- expect(Cause.isFailure(Cause.parallel(empty, Cause.sequential(empty, failure)))).toBe(true)
- expect(Cause.isFailure(Cause.sequential(empty, Cause.parallel(empty, failure)))).toBe(true)
+ assertTrue(Cause.isFailure(failure))
+ assertTrue(Cause.isFailure(Cause.sequential(empty, failure)))
+ assertTrue(Cause.isFailure(Cause.parallel(empty, failure)))
+ assertTrue(Cause.isFailure(Cause.parallel(empty, Cause.sequential(empty, failure))))
+ assertTrue(Cause.isFailure(Cause.sequential(empty, Cause.parallel(empty, failure))))
- expect(Cause.isFailure(Cause.sequential(empty, Cause.parallel(empty, empty)))).toBe(false)
+ assertFalse(Cause.isFailure(Cause.sequential(empty, Cause.parallel(empty, empty))))
})
it("isDie", () => {
- expect(Cause.isDie(defect)).toBe(true)
- expect(Cause.isDie(Cause.sequential(empty, defect))).toBe(true)
- expect(Cause.isDie(Cause.parallel(empty, defect))).toBe(true)
- expect(Cause.isDie(Cause.parallel(empty, Cause.sequential(empty, defect)))).toBe(true)
- expect(Cause.isDie(Cause.sequential(empty, Cause.parallel(empty, defect)))).toBe(true)
+ assertTrue(Cause.isDie(defect))
+ assertTrue(Cause.isDie(Cause.sequential(empty, defect)))
+ assertTrue(Cause.isDie(Cause.parallel(empty, defect)))
+ assertTrue(Cause.isDie(Cause.parallel(empty, Cause.sequential(empty, defect))))
+ assertTrue(Cause.isDie(Cause.sequential(empty, Cause.parallel(empty, defect))))
- expect(Cause.isDie(Cause.sequential(empty, Cause.parallel(empty, empty)))).toBe(false)
+ assertFalse(Cause.isDie(Cause.sequential(empty, Cause.parallel(empty, empty))))
})
it("isInterrupted", () => {
- expect(Cause.isInterrupted(interruption)).toBe(true)
- expect(Cause.isInterrupted(Cause.sequential(empty, interruption))).toBe(true)
- expect(Cause.isInterrupted(Cause.parallel(empty, interruption))).toBe(true)
- expect(Cause.isInterrupted(Cause.parallel(empty, Cause.sequential(empty, interruption)))).toBe(true)
- expect(Cause.isInterrupted(Cause.sequential(empty, Cause.parallel(empty, interruption)))).toBe(true)
-
- expect(Cause.isInterrupted(Cause.sequential(failure, interruption))).toBe(true)
- expect(Cause.isInterrupted(Cause.parallel(failure, interruption))).toBe(true)
- expect(Cause.isInterrupted(Cause.parallel(failure, Cause.sequential(empty, interruption)))).toBe(true)
- expect(Cause.isInterrupted(Cause.sequential(failure, Cause.parallel(empty, interruption)))).toBe(true)
-
- expect(Cause.isInterrupted(Cause.sequential(empty, Cause.parallel(empty, empty)))).toBe(false)
+ assertTrue(Cause.isInterrupted(interruption))
+ assertTrue(Cause.isInterrupted(Cause.sequential(empty, interruption)))
+ assertTrue(Cause.isInterrupted(Cause.parallel(empty, interruption)))
+ assertTrue(Cause.isInterrupted(Cause.parallel(empty, Cause.sequential(empty, interruption))))
+ assertTrue(Cause.isInterrupted(Cause.sequential(empty, Cause.parallel(empty, interruption))))
+
+ assertTrue(Cause.isInterrupted(Cause.sequential(failure, interruption)))
+ assertTrue(Cause.isInterrupted(Cause.parallel(failure, interruption)))
+ assertTrue(Cause.isInterrupted(Cause.parallel(failure, Cause.sequential(empty, interruption))))
+ assertTrue(Cause.isInterrupted(Cause.sequential(failure, Cause.parallel(empty, interruption))))
+
+ assertFalse(Cause.isInterrupted(Cause.sequential(empty, Cause.parallel(empty, empty))))
})
it("isInterruptedOnly", () => {
- expect(Cause.isInterruptedOnly(interruption)).toBe(true)
- expect(Cause.isInterruptedOnly(Cause.sequential(empty, interruption))).toBe(true)
- expect(Cause.isInterruptedOnly(Cause.parallel(empty, interruption))).toBe(true)
- expect(Cause.isInterruptedOnly(Cause.parallel(empty, Cause.sequential(empty, interruption)))).toBe(true)
- expect(Cause.isInterruptedOnly(Cause.sequential(empty, Cause.parallel(empty, interruption)))).toBe(true)
+ assertTrue(Cause.isInterruptedOnly(interruption))
+ assertTrue(Cause.isInterruptedOnly(Cause.sequential(empty, interruption)))
+ assertTrue(Cause.isInterruptedOnly(Cause.parallel(empty, interruption)))
+ assertTrue(Cause.isInterruptedOnly(Cause.parallel(empty, Cause.sequential(empty, interruption))))
+ assertTrue(Cause.isInterruptedOnly(Cause.sequential(empty, Cause.parallel(empty, interruption))))
// Cause.empty is considered a valid candidate
- expect(Cause.isInterruptedOnly(Cause.sequential(empty, Cause.parallel(empty, empty)))).toBe(true)
+ assertTrue(Cause.isInterruptedOnly(Cause.sequential(empty, Cause.parallel(empty, empty))))
- expect(Cause.isInterruptedOnly(Cause.sequential(failure, interruption))).toBe(false)
- expect(Cause.isInterruptedOnly(Cause.parallel(failure, interruption))).toBe(false)
- expect(Cause.isInterruptedOnly(Cause.parallel(failure, Cause.sequential(empty, interruption)))).toBe(false)
- expect(Cause.isInterruptedOnly(Cause.sequential(failure, Cause.parallel(empty, interruption)))).toBe(false)
+ assertFalse(Cause.isInterruptedOnly(Cause.sequential(failure, interruption)))
+ assertFalse(Cause.isInterruptedOnly(Cause.parallel(failure, interruption)))
+ assertFalse(Cause.isInterruptedOnly(Cause.parallel(failure, Cause.sequential(empty, interruption))))
+ assertFalse(Cause.isInterruptedOnly(Cause.sequential(failure, Cause.parallel(empty, interruption))))
})
describe("failures", () => {
it("should return a Chunk of all recoverable errors", () => {
const expectFailures = (cause: Cause.Cause, expected: Array) => {
- assert.deepStrictEqual([...Cause.failures(cause)], expected)
+ deepStrictEqual([...Cause.failures(cause)], expected)
}
expectFailures(empty, [])
expectFailures(failure, ["error"])
@@ -440,13 +444,13 @@ describe("Cause", () => {
const n = 10_000
const cause = Array.from({ length: n - 1 }, () => Cause.fail("fail")).reduce(Cause.parallel, Cause.fail("fail"))
const result = Cause.failures(cause)
- assert.strictEqual(Array.from(result).length, n)
+ strictEqual(Array.from(result).length, n)
})
})
it("defects", () => {
const expectDefects = (cause: Cause.Cause, expected: Array) => {
- assert.deepStrictEqual([...Cause.defects(cause)], expected)
+ deepStrictEqual([...Cause.defects(cause)], expected)
}
expectDefects(empty, [])
expectDefects(defect, ["defect"])
@@ -459,7 +463,7 @@ describe("Cause", () => {
it("interruptors", () => {
const expectInterruptors = (cause: Cause.Cause, expected: Array) => {
- assert.deepStrictEqual([...Cause.interruptors(cause)], expected)
+ deepStrictEqual([...Cause.interruptors(cause)], expected)
}
expectInterruptors(empty, [])
expectInterruptors(interruption, [FiberId.runtime(1, 0)])
@@ -473,20 +477,20 @@ describe("Cause", () => {
})
it("size", () => {
- expect(Cause.size(empty)).toBe(0)
- expect(Cause.size(failure)).toBe(1)
- expect(Cause.size(defect)).toBe(1)
- expect(Cause.size(Cause.parallel(Cause.fail("error1"), Cause.fail("error2")))).toBe(2)
- expect(Cause.size(Cause.sequential(Cause.fail("error1"), Cause.fail("error2")))).toBe(2)
- expect(Cause.size(Cause.parallel(failure, defect))).toBe(2)
- expect(Cause.size(Cause.sequential(failure, defect))).toBe(2)
- expect(Cause.size(Cause.sequential(interruption, Cause.parallel(empty, failure)))).toBe(2)
- expect(Cause.size(Cause.sequential(interruption, Cause.parallel(defect, failure)))).toBe(3)
+ strictEqual(Cause.size(empty), 0)
+ strictEqual(Cause.size(failure), 1)
+ strictEqual(Cause.size(defect), 1)
+ strictEqual(Cause.size(Cause.parallel(Cause.fail("error1"), Cause.fail("error2"))), 2)
+ strictEqual(Cause.size(Cause.sequential(Cause.fail("error1"), Cause.fail("error2"))), 2)
+ strictEqual(Cause.size(Cause.parallel(failure, defect)), 2)
+ strictEqual(Cause.size(Cause.sequential(failure, defect)), 2)
+ strictEqual(Cause.size(Cause.sequential(interruption, Cause.parallel(empty, failure))), 2)
+ strictEqual(Cause.size(Cause.sequential(interruption, Cause.parallel(defect, failure))), 3)
})
it("failureOption", () => {
const expectFailureOption = (cause: Cause.Cause, expected: Option.Option) => {
- assert.deepStrictEqual(Cause.failureOption(cause), expected)
+ deepStrictEqual(Cause.failureOption(cause), expected)
}
expectFailureOption(empty, Option.none())
expectFailureOption(failure, Option.some("error"))
@@ -499,10 +503,10 @@ describe("Cause", () => {
it("failureOrCause", () => {
const expectLeft = (cause: Cause.Cause, expected: E) => {
- assert.deepStrictEqual(Cause.failureOrCause(cause), Either.left(expected))
+ assertLeft(Cause.failureOrCause(cause), expected)
}
const expectRight = (cause: Cause.Cause) => {
- assert.deepStrictEqual(Cause.failureOrCause(cause), Either.right(cause))
+ assertRight(Cause.failureOrCause(cause), cause)
}
expectLeft(failure, "error")
@@ -517,50 +521,48 @@ describe("Cause", () => {
})
it("flipCauseOption", () => {
- assert.deepStrictEqual(Cause.flipCauseOption(empty), Option.some(empty))
- assert.deepStrictEqual(Cause.flipCauseOption(defect), Option.some(defect))
- assert.deepStrictEqual(Cause.flipCauseOption(interruption), Option.some(interruption))
- assert.deepStrictEqual(Cause.flipCauseOption(Cause.fail(Option.none())), Option.none())
- assert.deepStrictEqual(Cause.flipCauseOption(Cause.fail(Option.some("error"))), Option.some(Cause.fail("error")))
+ assertSome(Cause.flipCauseOption(empty), empty)
+ assertSome(Cause.flipCauseOption(defect), defect)
+ assertSome(Cause.flipCauseOption(interruption), interruption)
+ assertNone(Cause.flipCauseOption(Cause.fail(Option.none())))
+ assertSome(Cause.flipCauseOption(Cause.fail(Option.some("error"))), Cause.fail("error"))
// sequential
- assert.deepStrictEqual(
+ assertSome(
Cause.flipCauseOption(Cause.sequential(Cause.fail(Option.some("error1")), Cause.fail(Option.some("error2")))),
- Option.some(Cause.sequential(Cause.fail("error1"), Cause.fail("error2")))
+ Cause.sequential(Cause.fail("error1"), Cause.fail("error2"))
)
- assert.deepStrictEqual(
+ assertSome(
Cause.flipCauseOption(Cause.sequential(Cause.fail(Option.some("error1")), Cause.fail(Option.none()))),
- Option.some(Cause.fail("error1"))
+ Cause.fail("error1")
)
- assert.deepStrictEqual(
+ assertSome(
Cause.flipCauseOption(Cause.sequential(Cause.fail(Option.none()), Cause.fail(Option.some("error2")))),
- Option.some(Cause.fail("error2"))
+ Cause.fail("error2")
)
- assert.deepStrictEqual(
- Cause.flipCauseOption(Cause.sequential(Cause.fail(Option.none()), Cause.fail(Option.none()))),
- Option.none()
+ assertNone(
+ Cause.flipCauseOption(Cause.sequential(Cause.fail(Option.none()), Cause.fail(Option.none())))
)
// parallel
- assert.deepStrictEqual(
+ assertSome(
Cause.flipCauseOption(Cause.parallel(Cause.fail(Option.some("error1")), Cause.fail(Option.some("error2")))),
- Option.some(Cause.parallel(Cause.fail("error1"), Cause.fail("error2")))
+ Cause.parallel(Cause.fail("error1"), Cause.fail("error2"))
)
- assert.deepStrictEqual(
+ assertSome(
Cause.flipCauseOption(Cause.parallel(Cause.fail(Option.some("error1")), Cause.fail(Option.none()))),
- Option.some(Cause.fail("error1"))
+ Cause.fail("error1")
)
- assert.deepStrictEqual(
+ assertSome(
Cause.flipCauseOption(Cause.parallel(Cause.fail(Option.none()), Cause.fail(Option.some("error2")))),
- Option.some(Cause.fail("error2"))
+ Cause.fail("error2")
)
- assert.deepStrictEqual(
- Cause.flipCauseOption(Cause.parallel(Cause.fail(Option.none()), Cause.fail(Option.none()))),
- Option.none()
+ assertNone(
+ Cause.flipCauseOption(Cause.parallel(Cause.fail(Option.none()), Cause.fail(Option.none())))
)
})
it("dieOption", () => {
const expectDieOption = (cause: Cause.Cause, expected: Option.Option) => {
- assert.deepStrictEqual(Cause.dieOption(cause), expected)
+ deepStrictEqual(Cause.dieOption(cause), expected)
}
expectDieOption(empty, Option.none())
expectDieOption(defect, Option.some("defect"))
@@ -573,7 +575,7 @@ describe("Cause", () => {
it("interruptOption", () => {
const expectInterruptOption = (cause: Cause.Cause, expected: Option.Option) => {
- assert.deepStrictEqual(Cause.interruptOption(cause), expected)
+ deepStrictEqual(Cause.interruptOption(cause), expected)
}
expectInterruptOption(empty, Option.none())
expectInterruptOption(interruption, Option.some(FiberId.runtime(1, 0)))
@@ -587,32 +589,32 @@ describe("Cause", () => {
})
it("keepDefects", () => {
- assert.deepStrictEqual(Cause.keepDefects(empty), Option.none())
- assert.deepStrictEqual(Cause.keepDefects(failure), Option.none())
- assert.deepStrictEqual(Cause.keepDefects(defect), Option.some(defect))
- assert.deepStrictEqual(
+ assertNone(Cause.keepDefects(empty))
+ assertNone(Cause.keepDefects(failure))
+ assertSome(Cause.keepDefects(defect), defect)
+ assertSome(
Cause.keepDefects(Cause.sequential(Cause.die("defect1"), Cause.die("defect2"))),
- Option.some(Cause.sequential(Cause.die("defect1"), Cause.die("defect2")))
+ Cause.sequential(Cause.die("defect1"), Cause.die("defect2"))
)
- assert.deepStrictEqual(Cause.keepDefects(Cause.sequential(empty, empty)), Option.none())
- assert.deepStrictEqual(Cause.keepDefects(Cause.sequential(defect, failure)), Option.some(defect))
- assert.deepStrictEqual(Cause.keepDefects(Cause.parallel(empty, empty)), Option.none())
- assert.deepStrictEqual(Cause.keepDefects(Cause.parallel(defect, failure)), Option.some(defect))
- assert.deepStrictEqual(
+ assertNone(Cause.keepDefects(Cause.sequential(empty, empty)))
+ assertSome(Cause.keepDefects(Cause.sequential(defect, failure)), defect)
+ assertNone(Cause.keepDefects(Cause.parallel(empty, empty)))
+ assertSome(Cause.keepDefects(Cause.parallel(defect, failure)), defect)
+ assertSome(
Cause.keepDefects(Cause.parallel(Cause.die("defect1"), Cause.die("defect2"))),
- Option.some(Cause.parallel(Cause.die("defect1"), Cause.die("defect2")))
+ Cause.parallel(Cause.die("defect1"), Cause.die("defect2"))
)
- assert.deepStrictEqual(
+ assertSome(
Cause.keepDefects(
Cause.sequential(failure, Cause.parallel(Cause.die("defect1"), Cause.die("defect2")))
),
- Option.some(Cause.parallel(Cause.die("defect1"), Cause.die("defect2")))
+ Cause.parallel(Cause.die("defect1"), Cause.die("defect2"))
)
- assert.deepStrictEqual(
+ assertSome(
Cause.keepDefects(
Cause.sequential(Cause.die("defect1"), Cause.parallel(failure, Cause.die("defect2")))
),
- Option.some(Cause.sequential(Cause.die("defect1"), Cause.die("defect2")))
+ Cause.sequential(Cause.die("defect1"), Cause.die("defect2"))
)
})
@@ -630,7 +632,7 @@ describe("Cause", () => {
// TODO: what's the point of this API?
it("linearize", () => {
const expectLinearize = (cause: Cause.Cause, expected: Array>) => {
- assert.deepStrictEqual([...Cause.linearize(cause)], expected)
+ deepStrictEqual([...Cause.linearize(cause)], expected)
}
expectLinearize(empty, [])
expectLinearize(failure, [failure])
@@ -672,7 +674,7 @@ describe("Cause", () => {
it("stripFailures", () => {
const expectStripFailures = (cause: Cause.Cause, expected: Cause.Cause) => {
- assert.deepStrictEqual(Cause.stripFailures(cause), expected)
+ deepStrictEqual(Cause.stripFailures(cause), expected)
}
expectStripFailures(empty, empty)
expectStripFailures(failure, empty)
@@ -697,31 +699,31 @@ describe("Cause", () => {
? Option.some(defect) :
Option.none()
)
- assert.deepStrictEqual(stripNumberFormatException(empty), Option.some(empty))
- assert.deepStrictEqual(stripNumberFormatException(failure), Option.some(failure))
- assert.deepStrictEqual(stripNumberFormatException(interruption), Option.some(interruption))
- assert.deepStrictEqual(stripNumberFormatException(cause1), Option.none())
- assert.deepStrictEqual(stripNumberFormatException(Cause.sequential(cause1, cause1)), Option.none())
- assert.deepStrictEqual(stripNumberFormatException(Cause.sequential(cause1, cause2)), Option.some(cause2))
- assert.deepStrictEqual(stripNumberFormatException(Cause.sequential(cause2, cause1)), Option.some(cause2))
- assert.deepStrictEqual(
+ assertSome(stripNumberFormatException(empty), empty)
+ assertSome(stripNumberFormatException(failure), failure)
+ assertSome(stripNumberFormatException(interruption), interruption)
+ assertNone(stripNumberFormatException(cause1))
+ assertNone(stripNumberFormatException(Cause.sequential(cause1, cause1)))
+ assertSome(stripNumberFormatException(Cause.sequential(cause1, cause2)), cause2)
+ assertSome(stripNumberFormatException(Cause.sequential(cause2, cause1)), cause2)
+ assertSome(
stripNumberFormatException(Cause.sequential(cause2, cause2)),
- Option.some(Cause.sequential(cause2, cause2))
+ Cause.sequential(cause2, cause2)
)
- assert.deepStrictEqual(stripNumberFormatException(Cause.parallel(cause1, cause1)), Option.none())
- assert.deepStrictEqual(stripNumberFormatException(Cause.parallel(cause1, cause2)), Option.some(cause2))
- assert.deepStrictEqual(stripNumberFormatException(Cause.parallel(cause2, cause1)), Option.some(cause2))
- assert.deepStrictEqual(
+ assertNone(stripNumberFormatException(Cause.parallel(cause1, cause1)))
+ assertSome(stripNumberFormatException(Cause.parallel(cause1, cause2)), cause2)
+ assertSome(stripNumberFormatException(Cause.parallel(cause2, cause1)), cause2)
+ assertSome(
stripNumberFormatException(Cause.parallel(cause2, cause2)),
- Option.some(Cause.parallel(cause2, cause2))
+ Cause.parallel(cause2, cause2)
)
})
})
describe("Mapping", () => {
it("as", () => {
- const expectAs = (cause: Cause.Cause, expected: Cause.Cause) => {
- assert.deepStrictEqual(Cause.as(cause, 2), expected)
+ const expectAs = (cause: Cause.Cause, expected: Cause.Cause) => {
+ deepStrictEqual(Cause.as(cause, 2), expected)
}
expectAs(empty, empty)
expectAs(failure, Cause.fail(2))
@@ -732,8 +734,8 @@ describe("Cause", () => {
})
it("map", () => {
- const expectMap = (cause: Cause.Cause, expected: Cause.Cause) => {
- assert.deepStrictEqual(Cause.map(cause, () => 2), expected)
+ const expectMap = (cause: Cause.Cause, expected: Cause.Cause) => {
+ deepStrictEqual(Cause.map(cause, () => 2), expected)
}
expectMap(empty, empty)
expectMap(failure, Cause.fail(2))
@@ -750,7 +752,7 @@ describe("Cause", () => {
fc.assert(fc.property(causes, (cause) => {
const left = cause.pipe(Cause.flatMap(Cause.fail))
const right = cause
- assert.ok(Equal.equals(left, right))
+ assertTrue(Equal.equals(left, right))
}))
})
@@ -758,7 +760,7 @@ describe("Cause", () => {
fc.assert(fc.property(errors, errorCauseFunctions, (error, f) => {
const left = Cause.fail(error).pipe(Cause.flatMap(f))
const right = f(error)
- assert.ok(Equal.equals(left, right))
+ assertTrue(Equal.equals(left, right))
}))
})
@@ -766,7 +768,7 @@ describe("Cause", () => {
fc.assert(fc.property(causes, errorCauseFunctions, errorCauseFunctions, (cause, f, g) => {
const left = cause.pipe(Cause.flatMap(f), Cause.flatMap(g))
const right = cause.pipe(Cause.flatMap((error) => f(error).pipe(Cause.flatMap(g))))
- assert.ok(Equal.equals(left, right))
+ assertTrue(Equal.equals(left, right))
}))
})
})
@@ -774,15 +776,15 @@ describe("Cause", () => {
it("andThen returns the second cause if the first one is failing", () => {
const err1 = Cause.fail("err1")
const err2 = Cause.fail("err2")
- assert.deepStrictEqual(err1.pipe(Cause.andThen(() => err2)), err2)
- assert.deepStrictEqual(err1.pipe(Cause.andThen(err2)), err2)
- assert.deepStrictEqual(Cause.andThen(err1, () => err2), err2)
- assert.deepStrictEqual(Cause.andThen(err1, err2), err2)
+ deepStrictEqual(err1.pipe(Cause.andThen(() => err2)), err2)
+ deepStrictEqual(err1.pipe(Cause.andThen(err2)), err2)
+ deepStrictEqual(Cause.andThen(err1, () => err2), err2)
+ deepStrictEqual(Cause.andThen(err1, err2), err2)
})
it("flatten", () => {
const expectFlatten = (cause: Cause.Cause>, expected: Cause.Cause) => {
- assert.deepStrictEqual(Cause.flatten(cause), expected)
+ deepStrictEqual(Cause.flatten(cause), expected)
}
expectFlatten(Cause.fail(empty), empty)
expectFlatten(Cause.fail(failure), failure)
@@ -796,7 +798,7 @@ describe("Cause", () => {
describe("Elements", () => {
it("contains", () => {
const expectContains = (cause: Cause.Cause, expected: Cause.Cause) => {
- assert.ok(Cause.contains(cause, expected))
+ assertTrue(Cause.contains(cause, expected))
}
expectContains(empty, empty)
@@ -813,7 +815,7 @@ describe("Cause", () => {
it("find", () => {
const expectFind = (cause: Cause.Cause, expected: Option.Option) => {
- assert.deepStrictEqual(
+ deepStrictEqual(
Cause.find(
cause,
(cause) =>
@@ -835,7 +837,7 @@ describe("Cause", () => {
describe("Destructors", () => {
it("squash", () => {
const expectSquash = (cause: Cause.Cause, expected: unknown) => {
- assert.deepStrictEqual(Cause.squash(cause), expected)
+ deepStrictEqual(Cause.squash(cause), expected)
}
expectSquash(empty, new Cause.InterruptedException("Interrupted by fibers: "))
@@ -855,7 +857,7 @@ describe("Cause", () => {
describe("Filtering", () => {
it("filter", () => {
const expectFilter = (cause: Cause.Cause, expected: Cause.Cause) => {
- assert.deepStrictEqual(
+ deepStrictEqual(
Cause.filter(
cause,
(cause) => Cause.isFailType(cause) && Predicate.isString(cause.error) && cause.error === "error"
@@ -882,7 +884,7 @@ describe("Cause", () => {
describe("Matching", () => {
it("match", () => {
const expectMatch = (cause: Cause.Cause, expected: string) => {
- assert.strictEqual(
+ strictEqual(
Cause.match(cause, {
onEmpty: "Empty",
onFail: () => "Fail",
@@ -913,15 +915,15 @@ describe("Cause", () => {
describe("Formatting", () => {
it("prettyErrors", () => {
- assert.deepStrictEqual(Cause.prettyErrors(empty), [])
- assert.deepStrictEqual(Cause.prettyErrors(failure), [new internal.PrettyError("error")])
- assert.deepStrictEqual(Cause.prettyErrors(defect), [new internal.PrettyError("defect")])
- assert.deepStrictEqual(Cause.prettyErrors(interruption), [])
- assert.deepStrictEqual(Cause.prettyErrors(sequential), [
+ deepStrictEqual(Cause.prettyErrors(empty), [])
+ deepStrictEqual(Cause.prettyErrors(failure), [new internal.PrettyError("error")])
+ deepStrictEqual(Cause.prettyErrors(defect), [new internal.PrettyError("defect")])
+ deepStrictEqual(Cause.prettyErrors(interruption), [])
+ deepStrictEqual(Cause.prettyErrors(sequential), [
new internal.PrettyError("error"),
new internal.PrettyError("defect")
])
- assert.deepStrictEqual(Cause.prettyErrors(parallel), [
+ deepStrictEqual(Cause.prettyErrors(parallel), [
new internal.PrettyError("error"),
new internal.PrettyError("defect")
])
@@ -946,8 +948,8 @@ describe("Cause", () => {
describe("renderErrorCause: false", () => {
const expectPretty = (cause: Cause.Cause, expected: string | undefined) => {
- assert.deepStrictEqual(Cause.pretty(cause), expected)
- assert.deepStrictEqual(Cause.pretty(cause, { renderErrorCause: false }), expected)
+ deepStrictEqual(Cause.pretty(cause), expected)
+ deepStrictEqual(Cause.pretty(cause, { renderErrorCause: false }), expected)
}
it("handles array-based errors without throwing", () => {
@@ -992,11 +994,10 @@ describe("Cause", () => {
})
it("Interrupt", () => {
- expect(Cause.pretty(Cause.interrupt(FiberId.none))).toBe("All fibers interrupted without errors.")
- expect(Cause.pretty(Cause.interrupt(FiberId.runtime(1, 0)))).toBe(
- "All fibers interrupted without errors."
- )
- expect(Cause.pretty(Cause.interrupt(FiberId.composite(FiberId.none, FiberId.runtime(1, 0))))).toBe(
+ strictEqual(Cause.pretty(Cause.interrupt(FiberId.none)), "All fibers interrupted without errors.")
+ strictEqual(Cause.pretty(Cause.interrupt(FiberId.runtime(1, 0))), "All fibers interrupted without errors.")
+ strictEqual(
+ Cause.pretty(Cause.interrupt(FiberId.composite(FiberId.none, FiberId.runtime(1, 0)))),
"All fibers interrupted without errors."
)
})
@@ -1010,7 +1011,7 @@ describe("Cause", () => {
)
const cause = exit.cause
const pretty = Cause.pretty(cause)
- assert.deepStrictEqual(simplifyStackTrace(pretty), [`Error: my message`, "at [myspan]"])
+ deepStrictEqual(simplifyStackTrace(pretty), [`Error: my message`, "at [myspan]"])
})
})
})
@@ -1019,21 +1020,21 @@ describe("Cause", () => {
describe("Fail", () => {
it("no cause", () => {
const pretty = Cause.pretty(Cause.fail(new Error("my message")), { renderErrorCause: true })
- assert.deepStrictEqual(simplifyStackTrace(pretty), ["Error: my message"])
+ deepStrictEqual(simplifyStackTrace(pretty), ["Error: my message"])
})
it("string cause", () => {
const pretty = Cause.pretty(Cause.fail(new Error("my message", { cause: "my cause" })), {
renderErrorCause: true
})
- assert.deepStrictEqual(simplifyStackTrace(pretty), ["Error: my message", "[cause]: Error: my cause"])
+ deepStrictEqual(simplifyStackTrace(pretty), ["Error: my message", "[cause]: Error: my cause"])
})
it("error cause", () => {
const pretty = Cause.pretty(Cause.fail(new Error("my message", { cause: new Error("my cause") })), {
renderErrorCause: true
})
- assert.deepStrictEqual(simplifyStackTrace(pretty), ["Error: my message", "[cause]: Error: my cause"])
+ deepStrictEqual(simplifyStackTrace(pretty), ["Error: my message", "[cause]: Error: my cause"])
})
it("error cause with nested cause", () => {
@@ -1043,7 +1044,7 @@ describe("Cause", () => {
renderErrorCause: true
}
)
- assert.deepStrictEqual(simplifyStackTrace(pretty), [
+ deepStrictEqual(simplifyStackTrace(pretty), [
"Error: my message",
"[cause]: Error: my cause",
"[cause]: Error: nested cause"
@@ -1060,7 +1061,7 @@ describe("Cause", () => {
)
const cause = exit.cause
const pretty = Cause.pretty(cause, { renderErrorCause: true })
- assert.deepStrictEqual(simplifyStackTrace(pretty), [
+ deepStrictEqual(simplifyStackTrace(pretty), [
`Error: my message`,
"at [myspan]",
"[cause]: Error: my cause"
diff --git a/packages/effect/test/Channel/constructors.test.ts b/packages/effect/test/Channel/constructors.test.ts
index e2b00774dea..bfddeb20536 100644
--- a/packages/effect/test/Channel/constructors.test.ts
+++ b/packages/effect/test/Channel/constructors.test.ts
@@ -2,20 +2,21 @@ import * as Channel from "effect/Channel"
import * as Chunk from "effect/Chunk"
import * as Effect from "effect/Effect"
import * as Exit from "effect/Exit"
+import { assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Channel", () => {
it.effect("succeed", () =>
Effect.gen(function*($) {
const [chunk, value] = yield* $(Channel.runCollect(Channel.succeed(1)))
- assert.isTrue(Chunk.isEmpty(chunk))
- assert.strictEqual(value, 1)
+ assertTrue(Chunk.isEmpty(chunk))
+ strictEqual(value, 1)
}))
it.effect("fail", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.exit(Channel.runCollect(Channel.fail("uh oh"))))
- assert.deepStrictEqual(result, Exit.fail("uh oh"))
+ deepStrictEqual(result, Exit.fail("uh oh"))
}))
})
diff --git a/packages/effect/test/Channel/environment.test.ts b/packages/effect/test/Channel/environment.test.ts
index e3de0fda2e7..0fb34136ddb 100644
--- a/packages/effect/test/Channel/environment.test.ts
+++ b/packages/effect/test/Channel/environment.test.ts
@@ -4,8 +4,9 @@ import * as Effect from "effect/Effect"
import * as Equal from "effect/Equal"
import { pipe } from "effect/Function"
import * as Hash from "effect/Hash"
+import { deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
const NumberServiceSymbolKey = "effect/test/NumberService"
@@ -49,7 +50,7 @@ describe("Channel", () => {
Channel.provideService(NumberService, new NumberServiceImpl(100)),
Channel.run
)
- assert.deepStrictEqual(result, new NumberServiceImpl(100))
+ deepStrictEqual(result, new NumberServiceImpl(100))
}))
it.effect("provide -> zip -> provide", () =>
@@ -65,7 +66,7 @@ describe("Channel", () => {
),
Channel.run
)
- assert.deepStrictEqual(result, [new NumberServiceImpl(100), new NumberServiceImpl(200)])
+ deepStrictEqual(result, [new NumberServiceImpl(100), new NumberServiceImpl(200)])
}))
it.effect("concatMap(provide).provide", () =>
@@ -85,8 +86,8 @@ describe("Channel", () => {
Channel.provideService(NumberService, new NumberServiceImpl(100)),
Channel.runCollect
)
- assert.deepStrictEqual(Array.from(chunk), [[new NumberServiceImpl(100), new NumberServiceImpl(200)] as const])
- assert.isUndefined(value)
+ deepStrictEqual(Array.from(chunk), [[new NumberServiceImpl(100), new NumberServiceImpl(200)] as const])
+ strictEqual(value, undefined)
}))
it.effect("provide is modular", () =>
@@ -105,8 +106,8 @@ describe("Channel", () => {
Channel.runDrain,
Effect.provideService(NumberService, new NumberServiceImpl(4))
)
- assert.deepStrictEqual(result1, new NumberServiceImpl(4))
- assert.deepStrictEqual(result2, new NumberServiceImpl(2))
- assert.deepStrictEqual(result3, new NumberServiceImpl(4))
+ deepStrictEqual(result1, new NumberServiceImpl(4))
+ deepStrictEqual(result2, new NumberServiceImpl(2))
+ deepStrictEqual(result3, new NumberServiceImpl(4))
}))
})
diff --git a/packages/effect/test/Channel/error-handling.test.ts b/packages/effect/test/Channel/error-handling.test.ts
index c2cea2fb1b7..5457ed3d414 100644
--- a/packages/effect/test/Channel/error-handling.test.ts
+++ b/packages/effect/test/Channel/error-handling.test.ts
@@ -4,8 +4,9 @@ import * as Effect from "effect/Effect"
import * as Exit from "effect/Exit"
import { pipe } from "effect/Function"
import * as Ref from "effect/Ref"
+import { assertTrue, deepStrictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Channel", () => {
it.effect("catchAll - structure confusion", () =>
@@ -21,7 +22,7 @@ describe("Channel", () => {
Channel.concatMap(() => Channel.fail("error2"))
)
const result = yield* $(Effect.exit(Channel.runCollect(channel)))
- assert.deepStrictEqual(result, Exit.fail("error2"))
+ deepStrictEqual(result, Exit.fail("error2"))
}))
it.effect("error cause is propagated on channel interruption", () =>
@@ -43,13 +44,13 @@ describe("Channel", () => {
)
yield* $(Deferred.await(finished)) // Note: interruption in race is now done in the background
const result = yield* $(Ref.get(ref))
- assert.isTrue(Exit.isInterrupted(result))
+ assertTrue(Exit.isInterrupted(result))
}))
it.effect("scoped failures", () =>
Effect.gen(function*($) {
const channel = Channel.scoped(Effect.fail("error"))
const result = yield* $(Channel.runCollect(channel), Effect.exit)
- assert.deepStrictEqual(result, Exit.fail("error"))
+ deepStrictEqual(result, Exit.fail("error"))
}))
})
diff --git a/packages/effect/test/Channel/finalization.test.ts b/packages/effect/test/Channel/finalization.test.ts
index 4f3fc0da9a0..355e32eff87 100644
--- a/packages/effect/test/Channel/finalization.test.ts
+++ b/packages/effect/test/Channel/finalization.test.ts
@@ -3,8 +3,9 @@ import * as Effect from "effect/Effect"
import * as Exit from "effect/Exit"
import { pipe } from "effect/Function"
import * as Ref from "effect/Ref"
+import { assertTrue, deepStrictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
interface First {
readonly _tag: "First"
@@ -37,7 +38,7 @@ describe("Channel", () => {
)
)
const result = yield* $(Channel.runDrain(channel), Effect.zipRight(Ref.get(ref)))
- assert.deepStrictEqual(result, [
+ deepStrictEqual(result, [
"Acquire1",
"Release11",
"Release12",
@@ -70,13 +71,13 @@ describe("Channel", () => {
Effect.scoped,
Effect.zip(Ref.get(ref))
)
- assert.deepStrictEqual(eventsInScope, [
+ deepStrictEqual(eventsInScope, [
"Acquire1",
"Release11",
"Release12",
"Acquire2"
])
- assert.deepStrictEqual(eventsOutsideScope, [
+ deepStrictEqual(eventsOutsideScope, [
"Acquire1",
"Release11",
"Release12",
@@ -112,7 +113,7 @@ describe("Channel", () => {
Channel.runCollect(channel),
Effect.zip(Ref.get(ref))
)
- assert.deepStrictEqual(events, [
+ deepStrictEqual(events, [
"Second write",
"First write",
"Second write",
@@ -123,7 +124,7 @@ describe("Channel", () => {
"First concatMap",
"Second concatMap"
])
- assert.deepStrictEqual(Array.from(elements), [
+ deepStrictEqual(Array.from(elements), [
Second(First(1)),
Second(First(2)),
Second(First(3))
@@ -146,7 +147,7 @@ describe("Channel", () => {
)
yield* $(Channel.runDrain(channel))
const result = yield* $(Ref.get(ref))
- assert.deepStrictEqual(Array.from(result), [
+ deepStrictEqual(Array.from(result), [
"pulled 1",
"close 1",
"pulled 2",
@@ -163,6 +164,6 @@ describe("Channel", () => {
Channel.runDrain,
Effect.exit
)
- assert.isTrue(Exit.isFailure(result))
+ assertTrue(Exit.isFailure(result))
}))
})
diff --git a/packages/effect/test/Channel/foreign.test.ts b/packages/effect/test/Channel/foreign.test.ts
index 6f85e385b30..fc153aa6726 100644
--- a/packages/effect/test/Channel/foreign.test.ts
+++ b/packages/effect/test/Channel/foreign.test.ts
@@ -5,16 +5,17 @@ import * as Either from "effect/Either"
import * as Exit from "effect/Exit"
import * as Option from "effect/Option"
import * as Random from "effect/Random"
+import { strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
import { unify } from "effect/Unify"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Channel.Foreign", () => {
it.effect("Tag", () =>
Effect.gen(function*($) {
const tag = Context.GenericTag("number")
const result = yield* $(tag, Channel.run, Effect.provideService(tag, 10))
- assert.deepEqual(result, 10)
+ strictEqual(result, 10)
}))
it.effect("Unify", () =>
@@ -23,9 +24,9 @@ describe("Channel.Foreign", () => {
const unifiedExit = unify((yield* $(Random.nextInt)) > 1 ? Exit.succeed(0) : Exit.fail(1))
const unifiedEither = unify((yield* $(Random.nextInt)) > 1 ? Either.right(0) : Either.left(1))
const unifiedOption = unify((yield* $(Random.nextInt)) > 1 ? Option.some(0) : Option.none())
- assert.deepEqual(yield* $(Channel.run(unifiedEffect)), 0)
- assert.deepEqual(yield* $(Channel.run(unifiedExit)), 0)
- assert.deepEqual(yield* $(Channel.run(unifiedEither)), 0)
- assert.deepEqual(yield* $(Channel.run(unifiedOption)), 0)
+ strictEqual(yield* $(Channel.run(unifiedEffect)), 0)
+ strictEqual(yield* $(Channel.run(unifiedExit)), 0)
+ strictEqual(yield* $(Channel.run(unifiedEither)), 0)
+ strictEqual(yield* $(Channel.run(unifiedOption)), 0)
}))
})
diff --git a/packages/effect/test/Channel/interruption.test.ts b/packages/effect/test/Channel/interruption.test.ts
index 78057fc2021..de46217ff9d 100644
--- a/packages/effect/test/Channel/interruption.test.ts
+++ b/packages/effect/test/Channel/interruption.test.ts
@@ -1,12 +1,12 @@
import * as Channel from "effect/Channel"
import * as Deferred from "effect/Deferred"
import * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
import * as Fiber from "effect/Fiber"
import { pipe } from "effect/Function"
import * as Ref from "effect/Ref"
+import { assertLeft, assertTrue, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Channel", () => {
it.effect("interruptWhen - interrupts the current element", () =>
@@ -29,7 +29,7 @@ describe("Channel", () => {
)
yield* $(Fiber.await(fiber))
const result = yield* $(Ref.get(interrupted))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("interruptWhen - propagates errors", () =>
@@ -41,7 +41,7 @@ describe("Channel", () => {
)
yield* $(Deferred.fail(deferred, "fail"))
const result = yield* $(Effect.either(Channel.runDrain(channel)))
- assert.deepStrictEqual(result, Either.left("fail"))
+ assertLeft(result, "fail")
}))
it.effect("interruptWhenDeferred - interrupts the current element", () =>
@@ -64,7 +64,7 @@ describe("Channel", () => {
)
yield* $(Fiber.await(fiber))
const result = yield* $(Ref.get(interrupted))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("interruptWhenDeferred - propagates errors", () =>
@@ -76,12 +76,12 @@ describe("Channel", () => {
)
yield* $(Deferred.fail(deferred, "fail"))
const result = yield* $(Effect.either(Channel.runDrain(channel)))
- assert.deepStrictEqual(result, Either.left("fail"))
+ assertLeft(result, "fail")
}))
it.effect("runScoped - in uninterruptible region", () =>
Effect.gen(function*(_) {
const result = yield* _(Effect.uninterruptible(Channel.run(Channel.void)))
- assert.isUndefined(result)
+ strictEqual(result, undefined)
}))
})
diff --git a/packages/effect/test/Channel/mapping.test.ts b/packages/effect/test/Channel/mapping.test.ts
index c6b55877221..d6c971ff288 100644
--- a/packages/effect/test/Channel/mapping.test.ts
+++ b/packages/effect/test/Channel/mapping.test.ts
@@ -7,10 +7,11 @@ import * as Exit from "effect/Exit"
import { constVoid, pipe } from "effect/Function"
import * as Option from "effect/Option"
import * as Ref from "effect/Ref"
+import { assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
import * as UpstreamPullRequest from "effect/UpstreamPullRequest"
import * as UpstreamPullStrategy from "effect/UpstreamPullStrategy"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
interface First {
readonly _tag: "First"
@@ -34,8 +35,8 @@ describe("Channel", () => {
Channel.map((n) => n + 1),
Channel.runCollect
)
- assert.isTrue(Chunk.isEmpty(chunk))
- assert.strictEqual(value, 2)
+ assertTrue(Chunk.isEmpty(chunk))
+ strictEqual(value, 2)
}))
it.effect("mapError - structure confusion", () =>
@@ -46,7 +47,7 @@ describe("Channel", () => {
Channel.runCollect,
Effect.exit
)
- assert.deepStrictEqual(result, Exit.fail(1))
+ deepStrictEqual(result, Exit.fail(1))
}))
it.effect("mapOut - simple", () =>
@@ -56,8 +57,8 @@ describe("Channel", () => {
Channel.mapOut((n) => n + 1),
Channel.runCollect
)
- assert.deepStrictEqual(Chunk.toReadonlyArray(chunk), [2, 3, 4])
- assert.isUndefined(value)
+ deepStrictEqual(Chunk.toReadonlyArray(chunk), [2, 3, 4])
+ strictEqual(value, undefined)
}))
it.effect("mapOut - mixed with flatMap", () =>
@@ -68,8 +69,8 @@ describe("Channel", () => {
Channel.flatMap(() => Channel.write("x")),
Channel.runCollect
)
- assert.deepStrictEqual(Chunk.toReadonlyArray(chunk), ["1", "x"])
- assert.isUndefined(value)
+ deepStrictEqual(Chunk.toReadonlyArray(chunk), ["1", "x"])
+ strictEqual(value, undefined)
}))
it.effect("concatMap - plain", () =>
@@ -79,7 +80,7 @@ describe("Channel", () => {
Channel.concatMap((i) => Channel.writeAll(i, i)),
Channel.runCollect
)
- assert.deepStrictEqual(Chunk.toReadonlyArray(result), [1, 1, 2, 2, 3, 3])
+ deepStrictEqual(Chunk.toReadonlyArray(result), [1, 1, 2, 2, 3, 3])
}))
it.effect("concatMap - complex", () =>
@@ -92,7 +93,7 @@ describe("Channel", () => {
Channel.mapOut(Second),
Channel.runCollect
)
- assert.deepStrictEqual(Chunk.toReadonlyArray(result), [
+ deepStrictEqual(Chunk.toReadonlyArray(result), [
Second(First(1)),
Second(First(1)),
Second(First(1)),
@@ -120,7 +121,7 @@ describe("Channel", () => {
Channel.pipeTo(readers),
Channel.runCollect
)
- assert.deepStrictEqual(Chunk.toReadonlyArray(result), [1, 2, 3, 4])
+ deepStrictEqual(Chunk.toReadonlyArray(result), [1, 2, 3, 4])
}))
it.effect("concatMap - downstream failure", () =>
@@ -131,7 +132,7 @@ describe("Channel", () => {
Channel.runCollect,
Effect.exit
)
- assert.deepStrictEqual(result, Exit.fail("error"))
+ deepStrictEqual(result, Exit.fail("error"))
}))
it.effect("concatMap - upstream acquireReleaseOut + downstream failure", () =>
@@ -145,8 +146,8 @@ describe("Channel", () => {
Effect.exit
)
const [exit, events] = yield* $(effect, Effect.zip(Ref.get(ref)))
- assert.deepStrictEqual(exit, Exit.fail("error"))
- assert.deepStrictEqual(events, ["Acquired", "Released"])
+ deepStrictEqual(exit, Exit.fail("error"))
+ deepStrictEqual(events, ["Acquired", "Released"])
}))
it.effect("concatMap - multiple concatMaps with failure in first", () =>
@@ -158,7 +159,7 @@ describe("Channel", () => {
Channel.runCollect,
Effect.exit
)
- assert.deepStrictEqual(result, Exit.fail("error"))
+ deepStrictEqual(result, Exit.fail("error"))
}))
it.effect("concatMap - with failure then flatMap", () =>
@@ -170,7 +171,7 @@ describe("Channel", () => {
Channel.runCollect,
Effect.exit
)
- assert.deepStrictEqual(result, Exit.fail("error"))
+ deepStrictEqual(result, Exit.fail("error"))
}))
it.effect("concatMap - multiple concatMaps with failure in first and catchAll in second", () =>
@@ -182,7 +183,7 @@ describe("Channel", () => {
Channel.runCollect,
Effect.exit
)
- assert.deepStrictEqual(result, Exit.fail("error2"))
+ deepStrictEqual(result, Exit.fail("error2"))
}))
it.effect("concatMap - done value combination", () =>
@@ -197,9 +198,9 @@ describe("Channel", () => {
),
Channel.runCollect
)
- assert.deepStrictEqual(Chunk.toReadonlyArray(chunk), [1, 2, 3])
- assert.deepStrictEqual(array1, ["Inner-1", "Inner-2", "Inner-3"])
- assert.deepStrictEqual(array2, ["Outer-0"])
+ deepStrictEqual(Chunk.toReadonlyArray(chunk), [1, 2, 3])
+ deepStrictEqual(array1, ["Inner-1", "Inner-2", "Inner-3"])
+ deepStrictEqual(array2, ["Outer-0"])
}))
it.effect("concatMap - custom 1", () =>
@@ -231,7 +232,7 @@ describe("Channel", () => {
Channel.runCollect,
Effect.map(([chunk]) => pipe(Chunk.toReadonlyArray(chunk), Array.getSomes))
)
- assert.deepStrictEqual(result, [
+ deepStrictEqual(result, [
[1, 1] as const,
[2, 1] as const,
[3, 1] as const,
@@ -277,7 +278,7 @@ describe("Channel", () => {
Channel.runCollect,
Effect.map(([chunk]) => pipe(Chunk.toReadonlyArray(chunk), Array.getSomes))
)
- assert.deepStrictEqual(result, [
+ deepStrictEqual(result, [
[1, 1] as const,
[2, 1] as const,
[1, 2] as const,
diff --git a/packages/effect/test/Channel/merging.test.ts b/packages/effect/test/Channel/merging.test.ts
index da17dbf6122..de75937e2aa 100644
--- a/packages/effect/test/Channel/merging.test.ts
+++ b/packages/effect/test/Channel/merging.test.ts
@@ -6,8 +6,9 @@ import * as Exit from "effect/Exit"
import { constTrue, pipe } from "effect/Function"
import * as MergeDecision from "effect/MergeDecision"
import * as Ref from "effect/Ref"
+import { deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Channel", () => {
it.effect("mergeWith - simple merge", () =>
@@ -22,8 +23,8 @@ describe("Channel", () => {
}),
Channel.runCollect
)
- assert.deepStrictEqual(Array.from(chunk), [1, 2, 3, 4, 5, 6])
- assert.isUndefined(value)
+ deepStrictEqual(Array.from(chunk), [1, 2, 3, 4, 5, 6])
+ strictEqual(value, undefined)
}))
it.effect("mergeWith - merge with different types", () =>
@@ -68,8 +69,8 @@ describe("Channel", () => {
}),
Channel.runCollect
)
- assert.deepStrictEqual(Array.from(chunk), [1, 2])
- assert.deepStrictEqual(value, ["whatever", true])
+ deepStrictEqual(Array.from(chunk), [1, 2])
+ deepStrictEqual(value, ["whatever", true])
}))
it.effect("mergeWith - handles polymorphic failures", () =>
@@ -112,7 +113,7 @@ describe("Channel", () => {
Channel.runDrain,
Effect.exit
)
- assert.deepStrictEqual(result, Exit.fail<[string, boolean]>(["boom", true]))
+ deepStrictEqual(result, Exit.fail<[string, boolean]>(["boom", true]))
}))
it.effect("mergeWith - interrupts losing side", () =>
@@ -143,6 +144,6 @@ describe("Channel", () => {
))
})
const result = yield* $(Effect.exit(Channel.runDrain(merged)))
- assert.deepStrictEqual(result, Exit.succeed(void 0))
+ deepStrictEqual(result, Exit.succeed(void 0))
}))
})
diff --git a/packages/effect/test/Channel/reading.test.ts b/packages/effect/test/Channel/reading.test.ts
index 30cd414bc63..a30a752da36 100644
--- a/packages/effect/test/Channel/reading.test.ts
+++ b/packages/effect/test/Channel/reading.test.ts
@@ -10,8 +10,9 @@ import * as MergeDecision from "effect/MergeDecision"
import * as Option from "effect/Option"
import * as Random from "effect/Random"
import * as Ref from "effect/Ref"
+import { deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
export const mapper = (
f: (a: A) => B
@@ -91,13 +92,13 @@ describe("Channel", () => {
)
const result = yield* $(Channel.runCollect(channel))
const [chunk, value] = result
- assert.deepStrictEqual(Chunk.toReadonlyArray(chunk), [
+ deepStrictEqual(Chunk.toReadonlyArray(chunk), [
new Whatever(1),
new Whatever(2),
new Whatever(3),
new Whatever(4)
])
- assert.isUndefined(value)
+ strictEqual(value, undefined)
}))
it.effect("read pipelining", () =>
@@ -131,8 +132,8 @@ describe("Channel", () => {
Channel.pipeTo(innerChannel)
)
const [chunk, list] = yield* $(Channel.runCollect(channel))
- assert.deepStrictEqual(Chunk.toReadonlyArray(chunk), [1, 1, 2, 2])
- assert.deepStrictEqual(list, [1, 1, 2, 2])
+ deepStrictEqual(Chunk.toReadonlyArray(chunk), [1, 1, 2, 2])
+ deepStrictEqual(list, [1, 1, 2, 2])
}))
it.effect("read pipelining 2", () =>
@@ -178,7 +179,7 @@ describe("Channel", () => {
)
)
const result = yield* $(Channel.run(channel), Effect.zipRight(Ref.get(ref)))
- assert.deepStrictEqual(result, [3, 7])
+ deepStrictEqual(result, [3, 7])
}))
it.effect("reading with resources", () =>
@@ -215,7 +216,7 @@ describe("Channel", () => {
)
const channel = pipe(left, Channel.pipeTo(right))
const result = yield* $(Channel.runDrain(channel), Effect.zipRight(Ref.get(ref)))
- assert.deepStrictEqual(result, [
+ deepStrictEqual(result, [
"Acquire outer",
"Acquire 1",
"Read 1",
@@ -259,8 +260,8 @@ describe("Channel", () => {
})
)
- assert.strictEqual(HashSet.size(missing), 0)
- assert.strictEqual(HashSet.size(surplus), 0)
+ strictEqual(HashSet.size(missing), 0)
+ strictEqual(HashSet.size(surplus), 0)
}))
it.effect("nested concurrent reads", () =>
@@ -297,7 +298,7 @@ describe("Channel", () => {
return [missing, surplus] as const
})
)
- assert.strictEqual(HashSet.size(missing), 0)
- assert.strictEqual(HashSet.size(surplus), 0)
+ strictEqual(HashSet.size(missing), 0)
+ strictEqual(HashSet.size(surplus), 0)
}))
})
diff --git a/packages/effect/test/Channel/scoping.test.ts b/packages/effect/test/Channel/scoping.test.ts
index 74b7ac35632..87accb70e9a 100644
--- a/packages/effect/test/Channel/scoping.test.ts
+++ b/packages/effect/test/Channel/scoping.test.ts
@@ -2,13 +2,13 @@ import * as Cause from "effect/Cause"
import * as Channel from "effect/Channel"
import * as Deferred from "effect/Deferred"
import * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
import * as Fiber from "effect/Fiber"
import * as FiberId from "effect/FiberId"
import { pipe } from "effect/Function"
import * as Ref from "effect/Ref"
+import { assertLeft, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Channel", () => {
it.it("acquireUseReleaseOut - acquire is executed uninterruptibly", async () => {
@@ -29,7 +29,7 @@ describe("Channel", () => {
})
const result = await Effect.runPromise(program)
await Effect.runPromise(Deferred.succeed(latch, void 0))
- assert.strictEqual(result, 0)
+ strictEqual(result, 0)
}, 35_000)
it.it("scoped closes the scope", async () => {
@@ -50,7 +50,7 @@ describe("Channel", () => {
})
const result = await Effect.runPromise(program)
await Effect.runPromise(Deferred.succeed(latch, void 0))
- assert.strictEqual(result, 0)
+ strictEqual(result, 0)
}, 35_000)
it.effect("finalizer failure is propagated", () =>
@@ -64,6 +64,6 @@ describe("Channel", () => {
Effect.either
)
- assert.deepEqual(exit, Either.left(Cause.die("ok")))
+ assertLeft(exit, Cause.die("ok"))
}))
})
diff --git a/packages/effect/test/Channel/sequencing.test.ts b/packages/effect/test/Channel/sequencing.test.ts
index e171a9deac3..efa4747a7b8 100644
--- a/packages/effect/test/Channel/sequencing.test.ts
+++ b/packages/effect/test/Channel/sequencing.test.ts
@@ -3,8 +3,9 @@ import * as Chunk from "effect/Chunk"
import * as Effect from "effect/Effect"
import * as Exit from "effect/Exit"
import { pipe } from "effect/Function"
+import { assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Channel", () => {
it.effect("flatMap - simple", () =>
@@ -24,8 +25,8 @@ describe("Channel", () => {
)
)
const [chunk, value] = yield* $(Channel.runCollect(channel))
- assert.isTrue(Chunk.isEmpty(chunk))
- assert.strictEqual(value, 6)
+ assertTrue(Chunk.isEmpty(chunk))
+ strictEqual(value, 6)
}))
it.effect("flatMap - structure confusion", () =>
@@ -36,6 +37,6 @@ describe("Channel", () => {
Channel.zipRight(Channel.fail("hello"))
)
const result = yield* $(Effect.exit(Channel.runDrain(channel)))
- assert.deepStrictEqual(result, Exit.fail("hello"))
+ deepStrictEqual(result, Exit.fail("hello"))
}))
})
diff --git a/packages/effect/test/Channel/stack-safety.test.ts b/packages/effect/test/Channel/stack-safety.test.ts
index 754f845d525..4acae6a573f 100644
--- a/packages/effect/test/Channel/stack-safety.test.ts
+++ b/packages/effect/test/Channel/stack-safety.test.ts
@@ -2,8 +2,9 @@ import * as Channel from "effect/Channel"
import * as Chunk from "effect/Chunk"
import * as Effect from "effect/Effect"
import { pipe } from "effect/Function"
+import { deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Channel", () => {
it.effect("mapOut is stack safe", () =>
@@ -21,8 +22,8 @@ describe("Channel", () => {
Chunk.range(1, N),
Chunk.reduce(1, (x, y) => x + y)
)
- assert.strictEqual(Chunk.unsafeHead(chunk), expected)
- assert.isUndefined(value)
+ strictEqual(Chunk.unsafeHead(chunk), expected)
+ strictEqual(value, undefined)
}), 20_000)
it.effect("concatMap is stack safe", () =>
@@ -41,8 +42,8 @@ describe("Channel", () => {
),
Channel.runCollect
)
- assert.strictEqual(Chunk.unsafeHead(chunk), N)
- assert.isUndefined(value)
+ strictEqual(Chunk.unsafeHead(chunk), N)
+ strictEqual(value, undefined)
}), 20_000)
it.effect("flatMap is stack safe", () =>
@@ -56,7 +57,7 @@ describe("Channel", () => {
),
Channel.runCollect
)
- assert.deepStrictEqual(Array.from(chunk), Array.from(Chunk.range(0, N)))
- assert.isUndefined(value)
+ deepStrictEqual(Array.from(chunk), Array.from(Chunk.range(0, N)))
+ strictEqual(value, undefined)
}), 20_000)
})
diff --git a/packages/effect/test/Chunk.test.ts b/packages/effect/test/Chunk.test.ts
index cf6225942e4..eba37fa0929 100644
--- a/packages/effect/test/Chunk.test.ts
+++ b/packages/effect/test/Chunk.test.ts
@@ -1,45 +1,62 @@
-import * as RA from "effect/Array"
-import * as Chunk from "effect/Chunk"
-import * as Duration from "effect/Duration"
-import * as E from "effect/Either"
-import * as Equal from "effect/Equal"
-import { identity, pipe } from "effect/Function"
-import * as N from "effect/Number"
-import * as Option from "effect/Option"
-import * as Order from "effect/Order"
-import type { Predicate } from "effect/Predicate"
-import * as Util from "effect/test/util"
-import * as fc from "fast-check"
-import { assert, describe, expect, it } from "vitest"
+import {
+ Array as RA,
+ Chunk,
+ Either,
+ Equal,
+ FastCheck as fc,
+ identity,
+ Number as N,
+ Option,
+ Order,
+ pipe,
+ type Predicate
+} from "effect"
+import {
+ assertFalse,
+ assertNone,
+ assertSome,
+ assertTrue,
+ deepStrictEqual,
+ doesNotThrow,
+ equals,
+ strictEqual,
+ throws
+} from "effect/test/util"
+import { describe, it } from "vitest"
+
+const assertTuple = (
+ actual: [Chunk.Chunk, Chunk.Chunk],
+ expected: [Chunk.Chunk, Chunk.Chunk]
+) => {
+ equals(actual[0], expected[0])
+ equals(actual[1], expected[1])
+}
describe("Chunk", () => {
- it("exports", () => {
- expect(Chunk.unsafeFromNonEmptyArray).exist
- expect(Chunk.contains).exist
- expect(Chunk.containsWith).exist
- expect(Chunk.difference).exist
- expect(Chunk.differenceWith).exist
- expect(Chunk.findFirst).exist
- expect(Chunk.findFirstIndex).exist
- expect(Chunk.findLast).exist
- expect(Chunk.findLastIndex).exist
- expect(Chunk.every).exist
- expect(Chunk.join).exist
- expect(Chunk.reduce).exist
- expect(Chunk.reduceRight).exist
- expect(Chunk.some).exist
+ it("Equal.equals", () => {
+ assertTrue(Equal.equals(Chunk.make(0), Chunk.make(0)))
+ assertTrue(Equal.equals(Chunk.make(1, 2, 3), Chunk.make(1, 2, 3)))
+ assertFalse(Equal.equals(Chunk.make(1, 2, 3), Chunk.make(1, 2)))
+ assertFalse(Equal.equals(Chunk.make(1, 2), Chunk.make(1, 2, 3)))
+ assertFalse(Equal.equals(Chunk.make(1, 2, 3), Chunk.make(1, "a", 3)))
+ assertFalse(Equal.equals(Chunk.make(0), [0]))
})
it("toString", () => {
- expect(String(Chunk.make(0, 1, 2))).toEqual(`{
+ strictEqual(
+ String(Chunk.make(0, 1, 2)),
+ `{
"_id": "Chunk",
"values": [
0,
1,
2
]
-}`)
- expect(String(Chunk.make(Chunk.make(1, 2, 3)))).toEqual(`{
+}`
+ )
+ strictEqual(
+ String(Chunk.make(Chunk.make(1, 2, 3))),
+ `{
"_id": "Chunk",
"values": [
{
@@ -51,96 +68,92 @@ describe("Chunk", () => {
]
}
]
-}`)
- })
-
- it("toJSON", () => {
- expect(Chunk.make(0, 1, 2).toJSON()).toEqual(
- { _id: "Chunk", values: [0, 1, 2] }
- )
- expect(Chunk.make(Chunk.make(1, 2, 3)).toJSON()).toEqual(
- { _id: "Chunk", values: [{ _id: "Chunk", values: [1, 2, 3] }] }
+}`
)
})
- it("equals", () => {
- expect(Equal.equals(Chunk.make(0), Chunk.make(0))).toBe(true)
- expect(Equal.equals(Chunk.make(1, 2, 3), Chunk.make(1, 2, 3))).toBe(true)
- expect(Equal.equals(Chunk.make(0), Duration.millis(1))).toBe(false)
+ it("toJSON", () => {
+ deepStrictEqual(Chunk.make(0, 1, 2).toJSON(), { _id: "Chunk", values: [0, 1, 2] })
+ deepStrictEqual(Chunk.make(Chunk.make(1, 2, 3)).toJSON(), {
+ _id: "Chunk",
+ values: [{ _id: "Chunk", values: [1, 2, 3] }]
+ })
})
it("inspect", () => {
if (typeof window === "undefined") {
// eslint-disable-next-line @typescript-eslint/no-var-requires
const { inspect } = require("node:util")
- expect(inspect(Chunk.make(0, 1, 2))).toEqual(inspect({ _id: "Chunk", values: [0, 1, 2] }))
+ equals(inspect(Chunk.make(0, 1, 2)), inspect({ _id: "Chunk", values: [0, 1, 2] }))
}
})
it("modifyOption", () => {
- expect(pipe(Chunk.empty(), Chunk.modifyOption(0, (n: number) => n * 2))).toEqual(Option.none())
- expect(pipe(Chunk.make(1, 2, 3), Chunk.modifyOption(0, (n: number) => n * 2))).toEqual(
- Option.some(Chunk.make(2, 2, 3))
+ assertNone(pipe(Chunk.empty(), Chunk.modifyOption(0, (n: number) => n * 2)))
+ assertSome(
+ pipe(Chunk.make(1, 2, 3), Chunk.modifyOption(0, (n: number) => n * 2)),
+ Chunk.make(2, 2, 3)
)
})
it("modify", () => {
- expect(pipe(Chunk.empty(), Chunk.modify(0, (n: number) => n * 2))).toEqual(Chunk.empty())
- expect(pipe(Chunk.make(1, 2, 3), Chunk.modify(0, (n: number) => n * 2))).toEqual(Chunk.make(2, 2, 3))
+ equals(pipe(Chunk.empty(), Chunk.modify(0, (n: number) => n * 2)), Chunk.empty())
+ equals(pipe(Chunk.make(1, 2, 3), Chunk.modify(0, (n: number) => n * 2)), Chunk.make(2, 2, 3))
})
it("replaceOption", () => {
- expect(pipe(Chunk.empty(), Chunk.replaceOption(0, 2))).toEqual(Option.none())
- expect(pipe(Chunk.make(1, 2, 3), Chunk.replaceOption(0, 2))).toEqual(Option.some(Chunk.make(2, 2, 3)))
+ assertNone(pipe(Chunk.empty(), Chunk.replaceOption(0, 2)))
+ assertSome(pipe(Chunk.make(1, 2, 3), Chunk.replaceOption(0, 2)), Chunk.make(2, 2, 3))
})
it("replace", () => {
- expect(pipe(Chunk.empty(), Chunk.replace(0, 2))).toEqual(Chunk.empty())
- expect(pipe(Chunk.make(1, 2, 3), Chunk.replace(0, 2))).toEqual(Chunk.make(2, 2, 3))
+ equals(pipe(Chunk.empty(), Chunk.replace(0, 2)), Chunk.empty())
+ equals(pipe(Chunk.make(1, 2, 3), Chunk.replace(0, 2)), Chunk.make(2, 2, 3))
})
it("remove", () => {
- expect(pipe(Chunk.empty(), Chunk.remove(0))).toEqual(Chunk.empty())
- expect(pipe(Chunk.make(1, 2, 3), Chunk.remove(0))).toEqual(Chunk.make(2, 3))
+ equals(pipe(Chunk.empty(), Chunk.remove(0)), Chunk.empty())
+ equals(pipe(Chunk.make(1, 2, 3), Chunk.remove(0)), Chunk.make(2, 3))
})
it("chunksOf", () => {
- expect(pipe(Chunk.empty(), Chunk.chunksOf(2))).toEqual(Chunk.empty())
- expect(pipe(Chunk.make(1, 2, 3, 4, 5), Chunk.chunksOf(2))).toEqual(
+ equals(pipe(Chunk.empty(), Chunk.chunksOf(2)), Chunk.empty())
+ equals(
+ pipe(Chunk.make(1, 2, 3, 4, 5), Chunk.chunksOf(2)),
Chunk.make(Chunk.make(1, 2), Chunk.make(3, 4), Chunk.make(5))
)
- expect(pipe(Chunk.make(1, 2, 3, 4, 5, 6), Chunk.chunksOf(2))).toEqual(
+ equals(
+ pipe(Chunk.make(1, 2, 3, 4, 5, 6), Chunk.chunksOf(2)),
Chunk.make(Chunk.make(1, 2), Chunk.make(3, 4), Chunk.make(5, 6))
)
- expect(pipe(Chunk.make(1, 2, 3, 4, 5), Chunk.chunksOf(1))).toEqual(
+ equals(
+ pipe(Chunk.make(1, 2, 3, 4, 5), Chunk.chunksOf(1)),
Chunk.make(Chunk.make(1), Chunk.make(2), Chunk.make(3), Chunk.make(4), Chunk.make(5))
)
- expect(pipe(Chunk.make(1, 2, 3, 4, 5), Chunk.chunksOf(5))).toEqual(
- Chunk.make(Chunk.make(1, 2, 3, 4, 5))
- )
+ equals(pipe(Chunk.make(1, 2, 3, 4, 5), Chunk.chunksOf(5)), Chunk.make(Chunk.make(1, 2, 3, 4, 5)))
// out of bounds
- expect(pipe(Chunk.make(1, 2, 3, 4, 5), Chunk.chunksOf(0))).toEqual(
+ equals(
+ pipe(Chunk.make(1, 2, 3, 4, 5), Chunk.chunksOf(0)),
Chunk.make(Chunk.make(1), Chunk.make(2), Chunk.make(3), Chunk.make(4), Chunk.make(5))
)
- expect(pipe(Chunk.make(1, 2, 3, 4, 5), Chunk.chunksOf(-1))).toEqual(
+ equals(
+ pipe(Chunk.make(1, 2, 3, 4, 5), Chunk.chunksOf(-1)),
Chunk.make(Chunk.make(1), Chunk.make(2), Chunk.make(3), Chunk.make(4), Chunk.make(5))
)
- expect(pipe(Chunk.make(1, 2, 3, 4, 5), Chunk.chunksOf(10))).toEqual(
- Chunk.make(Chunk.make(1, 2, 3, 4, 5))
- )
+ equals(pipe(Chunk.make(1, 2, 3, 4, 5), Chunk.chunksOf(10)), Chunk.make(Chunk.make(1, 2, 3, 4, 5)))
})
- it(".pipe", () => {
- expect(Chunk.empty().pipe(Chunk.append(1))).toEqual(Chunk.make(1))
+ it(".pipe() method", () => {
+ equals(Chunk.empty().pipe(Chunk.append(1)), Chunk.make(1))
})
describe("toArray", () => {
it("should return an empty array for an empty chunk", () => {
- expect(Chunk.toArray(Chunk.empty())).toEqual([])
+ deepStrictEqual(Chunk.toArray(Chunk.empty()), [])
})
it("should return an array with the elements of the chunk", () => {
- expect(Chunk.toArray(Chunk.make(1, 2, 3))).toEqual([1, 2, 3])
+ deepStrictEqual(Chunk.toArray(Chunk.make(1, 2, 3)), [1, 2, 3])
})
it("should not affect the original chunk when the array is mutated", () => {
@@ -149,7 +162,7 @@ describe("Chunk", () => {
// mutate the array
arr[1] = 4
// the chunk should not be affected
- expect(Chunk.toArray(chunk)).toStrictEqual([1, 2, 3])
+ deepStrictEqual(Chunk.toArray(chunk), [1, 2, 3])
})
})
@@ -157,7 +170,7 @@ describe("Chunk", () => {
describe("Given an empty Chunk", () => {
const chunk = Chunk.empty()
it("should give back an empty readonly array", () => {
- expect(Chunk.toReadonlyArray(chunk)).toEqual([])
+ deepStrictEqual(Chunk.toReadonlyArray(chunk), [])
})
})
@@ -167,8 +180,8 @@ describe("Chunk", () => {
for (let i = 0; i < len; i++) chunk = Chunk.appendAll(Chunk.of(i), chunk)
it("gives back a readonly array", () => {
- expect(() => Chunk.toReadonlyArray(chunk)).not.toThrow()
- expect(Chunk.toReadonlyArray(chunk)).toEqual(RA.reverse(RA.range(0, len - 1)))
+ doesNotThrow(() => Chunk.toReadonlyArray(chunk))
+ deepStrictEqual(Chunk.toReadonlyArray(chunk), RA.reverse(RA.range(0, len - 1)))
})
})
@@ -181,10 +194,8 @@ describe("Chunk", () => {
lchunk = Chunk.appendAll(lchunk, Chunk.of(i))
}
it("should have depth of +/- 3", () => {
- expect(rchunk.depth)
- .toBeGreaterThanOrEqual(lchunk.depth - 3)
- expect(rchunk.depth)
- .toBeLessThanOrEqual(lchunk.depth + 3)
+ assertTrue(rchunk.depth >= lchunk.depth - 3)
+ assertTrue(rchunk.depth <= lchunk.depth + 3)
})
})
})
@@ -193,13 +204,13 @@ describe("Chunk", () => {
describe("Given a chunk", () => {
const chunk = Chunk.make(0, 1)
it("should be true", () => {
- expect(Chunk.isChunk(chunk)).toBe(true)
+ assertTrue(Chunk.isChunk(chunk))
})
})
describe("Given an object", () => {
const object = {}
it("should be false", () => {
- expect(Chunk.isChunk(object)).toBe(false)
+ assertFalse(Chunk.isChunk(object))
})
})
})
@@ -220,14 +231,14 @@ describe("Chunk", () => {
}
it("should process it", () => {
- expect(Chunk.fromIterable(myIterable)).toEqual(Chunk.unsafeFromArray([1, 2, 3, 4, 5]))
+ equals(Chunk.fromIterable(myIterable), Chunk.unsafeFromArray([1, 2, 3, 4, 5]))
})
})
it("should return the same reference if the input is a Chunk", () => {
const expected = Chunk.make(1, 2, 3)
const actual = Chunk.fromIterable(expected)
- expect(actual === expected).toEqual(true)
+ assertTrue(actual === expected)
})
})
@@ -237,10 +248,7 @@ describe("Chunk", () => {
const index = 0
it("should a Some with the value", () => {
- expect(pipe(
- chunk,
- Chunk.get(index)
- )).toEqual(Option.some(1))
+ deepStrictEqual(pipe(chunk, Chunk.get(index)), Option.some(1))
})
})
@@ -248,7 +256,7 @@ describe("Chunk", () => {
const chunk = Chunk.unsafeFromArray([1, 2, 3])
it("should return a None", () => {
- expect(pipe(chunk, Chunk.get(4))).toEqual(Option.none())
+ assertNone(pipe(chunk, Chunk.get(4)))
})
})
})
@@ -259,7 +267,7 @@ describe("Chunk", () => {
const index = 4
it("should throw", () => {
- expect(() => pipe(chunk, Chunk.unsafeGet(index))).toThrow()
+ throws(() => pipe(chunk, Chunk.unsafeGet(index)))
})
})
@@ -268,14 +276,14 @@ describe("Chunk", () => {
const index = 4
it("should throw", () => {
- expect(() => pipe(chunk, Chunk.unsafeGet(index))).toThrow()
+ throws(() => pipe(chunk, Chunk.unsafeGet(index)))
})
})
describe("Given an appended Chunk and an index in bounds", () => {
it("should return the value", () => {
const chunk = pipe(Chunk.make(0, 1, 2), Chunk.append(3))
- expect(Chunk.unsafeGet(1)(chunk)).toEqual(1)
+ strictEqual(Chunk.unsafeGet(1)(chunk), 1)
})
})
@@ -286,7 +294,7 @@ describe("Chunk", () => {
array.forEach((e) => {
chunk = pipe(chunk, Chunk.prepend(e))
})
- expect(() => pipe(chunk, Chunk.unsafeGet(array.length))).toThrow()
+ throws(() => pipe(chunk, Chunk.unsafeGet(array.length)))
}))
})
})
@@ -294,7 +302,7 @@ describe("Chunk", () => {
describe("Given a prepended Chunk and an index in bounds", () => {
it("should return the value", () => {
const chunk = pipe(Chunk.make(0, 1, 2), Chunk.prepend(3))
- expect(Chunk.unsafeGet(1)(chunk)).toEqual(0)
+ strictEqual(Chunk.unsafeGet(1)(chunk), 0)
})
})
@@ -303,7 +311,7 @@ describe("Chunk", () => {
const index = 4
it("should throw", () => {
- expect(() => pipe(chunk, Chunk.unsafeGet(index))).toThrow()
+ throws(() => pipe(chunk, Chunk.unsafeGet(index)))
})
})
@@ -312,7 +320,7 @@ describe("Chunk", () => {
const index = 4
it("should throw", () => {
- expect(() => pipe(chunk, Chunk.unsafeGet(index))).toThrow()
+ throws(() => pipe(chunk, Chunk.unsafeGet(index)))
})
})
@@ -320,7 +328,7 @@ describe("Chunk", () => {
it("should throw", () => {
fc.assert(fc.property(fc.array(fc.anything()), fc.array(fc.anything()), (arr1, arr2) => {
const chunk: Chunk.Chunk = Chunk.appendAll(Chunk.fromIterable(arr2))(Chunk.unsafeFromArray(arr1))
- expect(() => pipe(chunk, Chunk.unsafeGet(arr1.length + arr2.length))).toThrow()
+ throws(() => pipe(chunk, Chunk.unsafeGet(arr1.length + arr2.length)))
}))
})
})
@@ -330,7 +338,7 @@ describe("Chunk", () => {
const index = 1
it("should return the value", () => {
- expect(pipe(chunk, Chunk.unsafeGet(index))).toEqual(2)
+ strictEqual(pipe(chunk, Chunk.unsafeGet(index)), 2)
})
})
@@ -339,7 +347,7 @@ describe("Chunk", () => {
const index = 1
it("should return the value", () => {
- expect(pipe(chunk, Chunk.unsafeGet(index))).toEqual(2)
+ strictEqual(pipe(chunk, Chunk.unsafeGet(index)), 2)
})
})
@@ -348,7 +356,7 @@ describe("Chunk", () => {
const index = 0
it("should return the value", () => {
- expect(pipe(chunk, Chunk.unsafeGet(index))).toEqual(1)
+ strictEqual(pipe(chunk, Chunk.unsafeGet(index)), 1)
})
})
@@ -357,7 +365,7 @@ describe("Chunk", () => {
const index = 1
it("should return the value", () => {
- expect(pipe(chunk, Chunk.unsafeGet(index))).toEqual(2)
+ strictEqual(pipe(chunk, Chunk.unsafeGet(index)), 2)
})
})
@@ -367,7 +375,7 @@ describe("Chunk", () => {
const c = [...a, ...b]
const d = Chunk.appendAll(Chunk.unsafeFromArray(b))(Chunk.unsafeFromArray(a))
for (let i = 0; i < c.length; i++) {
- expect(Chunk.unsafeGet(i)(d)).toEqual(c[i])
+ deepStrictEqual(Chunk.unsafeGet(i)(d), c[i])
}
}))
})
@@ -384,21 +392,21 @@ describe("Chunk", () => {
b.forEach((e) => {
chunk = Chunk.append(e)(chunk)
})
- expect(Chunk.toReadonlyArray(chunk)).toEqual([...a, ...b])
+ deepStrictEqual(Chunk.toReadonlyArray(chunk), [...a, ...b])
}
)
)
})
it("prependAll", () => {
- expect(pipe(Chunk.empty(), Chunk.prependAll(Chunk.make(1)))).toEqual(Chunk.make(1))
- expect(pipe(Chunk.make(1), Chunk.prependAll(Chunk.empty()))).toEqual(Chunk.make(1))
+ equals(pipe(Chunk.empty(), Chunk.prependAll(Chunk.make(1))), Chunk.make(1))
+ equals(pipe(Chunk.make(1), Chunk.prependAll(Chunk.empty())), Chunk.make(1))
- expect(pipe(Chunk.empty(), Chunk.prependAll(Chunk.make(1, 2)))).toEqual(Chunk.make(1, 2))
- expect(pipe(Chunk.make(1, 2), Chunk.prependAll(Chunk.empty()))).toEqual(Chunk.make(1, 2))
+ equals(pipe(Chunk.empty(), Chunk.prependAll(Chunk.make(1, 2))), Chunk.make(1, 2))
+ equals(pipe(Chunk.make(1, 2), Chunk.prependAll(Chunk.empty())), Chunk.make(1, 2))
- expect(pipe(Chunk.make(2, 3), Chunk.prependAll(Chunk.make(1)))).toEqual(Chunk.make(1, 2, 3))
- expect(pipe(Chunk.make(3), Chunk.prependAll(Chunk.make(1, 2)))).toEqual(Chunk.make(1, 2, 3))
+ equals(pipe(Chunk.make(2, 3), Chunk.prependAll(Chunk.make(1))), Chunk.make(1, 2, 3))
+ equals(pipe(Chunk.make(3), Chunk.prependAll(Chunk.make(1, 2))), Chunk.make(1, 2, 3))
})
it("prepend", () => {
@@ -411,7 +419,7 @@ describe("Chunk", () => {
for (let i = b.length - 1; i >= 0; i--) {
chunk = Chunk.prepend(b[i])(chunk)
}
- expect(Chunk.toReadonlyArray(chunk)).toEqual([...b, ...a])
+ deepStrictEqual(Chunk.toReadonlyArray(chunk), [...b, ...a])
}
)
)
@@ -420,8 +428,7 @@ describe("Chunk", () => {
describe("take", () => {
describe("Given a Chunk with more elements than the amount taken", () => {
it("should return the subset", () => {
- expect(pipe(Chunk.unsafeFromArray([1, 2, 3]), Chunk.take(2)))
- .toEqual(Chunk.unsafeFromArray([1, 2]))
+ equals(pipe(Chunk.unsafeFromArray([1, 2, 3]), Chunk.take(2)), Chunk.unsafeFromArray([1, 2]))
})
})
@@ -430,11 +437,7 @@ describe("Chunk", () => {
const amount = 5
it("should return the available subset", () => {
- expect(pipe(chunk, Chunk.take(amount))).toEqual(Chunk.unsafeFromArray([
- 1,
- 2,
- 3
- ]))
+ equals(pipe(chunk, Chunk.take(amount)), Chunk.unsafeFromArray([1, 2, 3]))
})
})
@@ -443,11 +446,7 @@ describe("Chunk", () => {
const amount = 3
it("should return the available subset", () => {
- expect(pipe(chunk, Chunk.take(amount))).toEqual(Chunk.unsafeFromArray([
- 1,
- 2,
- 3
- ]))
+ equals(pipe(chunk, Chunk.take(amount)), Chunk.unsafeFromArray([1, 2, 3]))
})
})
@@ -456,9 +455,7 @@ describe("Chunk", () => {
const amount = 2
it("should return the available subset", () => {
- expect(pipe(chunk, Chunk.take(amount))).toEqual(Chunk.unsafeFromArray([
- 1
- ]))
+ equals(pipe(chunk, Chunk.take(amount)), Chunk.unsafeFromArray([1]))
})
})
@@ -467,46 +464,46 @@ describe("Chunk", () => {
const amount = 2
it("should return the available subset", () => {
- expect(pipe(chunk, Chunk.take(amount), Chunk.toReadonlyArray)).toEqual([1, 2])
+ deepStrictEqual(pipe(chunk, Chunk.take(amount), Chunk.toReadonlyArray), [1, 2])
})
})
describe("Given a concatenated Chunk and an amount <= self.left", () => {
it("should return the available subset", () => {
const chunk = Chunk.appendAll(Chunk.make(2, 3, 4), Chunk.of(1))
- expect(pipe(chunk, Chunk.take(2), Chunk.toReadonlyArray)).toEqual([2, 3])
- expect(pipe(chunk, Chunk.take(3), Chunk.toReadonlyArray)).toEqual([2, 3, 4])
+ deepStrictEqual(pipe(chunk, Chunk.take(2), Chunk.toReadonlyArray), [2, 3])
+ deepStrictEqual(pipe(chunk, Chunk.take(3), Chunk.toReadonlyArray), [2, 3, 4])
})
})
})
describe("make", () => {
it("should return a NonEmptyChunk", () => {
- expect(Chunk.make(0, 1).length).toStrictEqual(2)
+ strictEqual(Chunk.make(0, 1).length, 2)
})
})
describe("singleton", () => {
it("should return a NonEmptyChunk", () => {
- expect(Chunk.of(1).length).toStrictEqual(1)
+ strictEqual(Chunk.of(1).length, 1)
})
it("should return a ISingleton", () => {
- expect(Chunk.of(1).backing._tag).toEqual("ISingleton")
+ strictEqual(Chunk.of(1).backing._tag, "ISingleton")
})
})
describe("drop", () => {
it("should return self on 0", () => {
const self = Chunk.make(0, 1)
- expect(Chunk.drop(0)(self)).toStrictEqual(self)
+ strictEqual(Chunk.drop(0)(self), self)
})
it("should drop twice", () => {
const self = Chunk.make(0, 1, 2, 3)
- expect(Chunk.toReadonlyArray(Chunk.drop(1)(Chunk.drop(1)(self)))).toEqual([2, 3])
+ deepStrictEqual(Chunk.toReadonlyArray(Chunk.drop(1)(Chunk.drop(1)(self))), [2, 3])
})
it("should handle concatenated chunks", () => {
const self = pipe(Chunk.make(1), Chunk.appendAll(Chunk.make(2, 3, 4)))
- expect(pipe(self, Chunk.drop(2), Chunk.toReadonlyArray)).toEqual([3, 4])
+ deepStrictEqual(pipe(self, Chunk.drop(2), Chunk.toReadonlyArray), [3, 4])
})
})
@@ -516,7 +513,7 @@ describe("Chunk", () => {
const toDrop = 1
it("should remove the given amount of items", () => {
- expect(pipe(chunk, Chunk.dropRight(toDrop))).toEqual(Chunk.unsafeFromArray([1, 2]))
+ equals(pipe(chunk, Chunk.dropRight(toDrop)), Chunk.unsafeFromArray([1, 2]))
})
})
@@ -525,7 +522,7 @@ describe("Chunk", () => {
const toDrop = 3
it("should return an empty chunk", () => {
- expect(pipe(chunk, Chunk.dropRight(toDrop))).toEqual(Chunk.unsafeFromArray([]))
+ equals(pipe(chunk, Chunk.dropRight(toDrop)), Chunk.unsafeFromArray([]))
})
})
})
@@ -536,7 +533,7 @@ describe("Chunk", () => {
const criteria = (n: number) => n < 3
it("should return the subset that doesn't pass the criteria", () => {
- expect(pipe(chunk, Chunk.dropWhile(criteria))).toEqual(Chunk.unsafeFromArray([3]))
+ equals(pipe(chunk, Chunk.dropWhile(criteria)), Chunk.unsafeFromArray([3]))
})
})
@@ -545,7 +542,7 @@ describe("Chunk", () => {
const criteria = (n: number) => n < 4
it("should return an empty chunk", () => {
- expect(pipe(chunk, Chunk.dropWhile(criteria))).toEqual(Chunk.unsafeFromArray([]))
+ equals(pipe(chunk, Chunk.dropWhile(criteria)), Chunk.unsafeFromArray([]))
})
})
})
@@ -556,7 +553,7 @@ describe("Chunk", () => {
const chunk2 = Chunk.unsafeFromArray([2, 3])
it("should concatenate them following order", () => {
- expect(pipe(chunk1, Chunk.appendAll(chunk2))).toEqual(Chunk.unsafeFromArray([0, 1, 2, 3]))
+ equals(pipe(chunk1, Chunk.appendAll(chunk2)), Chunk.unsafeFromArray([0, 1, 2, 3]))
})
})
@@ -565,7 +562,7 @@ describe("Chunk", () => {
const chunk2 = Chunk.unsafeFromArray([3])
it("should concatenate them following order", () => {
- expect(pipe(chunk1, Chunk.appendAll(chunk2))).toEqual(Chunk.unsafeFromArray([1, 2, 3]))
+ equals(pipe(chunk1, Chunk.appendAll(chunk2)), Chunk.unsafeFromArray([1, 2, 3]))
})
})
@@ -574,7 +571,7 @@ describe("Chunk", () => {
const chunk2 = Chunk.unsafeFromArray([2, 3, 4])
it("should concatenate them following order", () => {
- expect(pipe(chunk1, Chunk.appendAll(chunk2))).toEqual(Chunk.unsafeFromArray([1, 2, 3, 4]))
+ equals(pipe(chunk1, Chunk.appendAll(chunk2)), Chunk.unsafeFromArray([1, 2, 3, 4]))
})
})
@@ -586,7 +583,7 @@ describe("Chunk", () => {
const chunk2 = Chunk.unsafeFromArray([2, 3, 4])
it("should concatenate them following order", () => {
- expect(pipe(chunk1, Chunk.appendAll(chunk2))).toEqual(Chunk.unsafeFromArray([1, 2, 3, 4]))
+ equals(pipe(chunk1, Chunk.appendAll(chunk2)), Chunk.unsafeFromArray([1, 2, 3, 4]))
})
})
@@ -598,7 +595,7 @@ describe("Chunk", () => {
)
it("should concatenate them following order", () => {
- expect(pipe(chunk1, Chunk.appendAll(chunk2))).toEqual(Chunk.unsafeFromArray([1, 2]))
+ equals(pipe(chunk1, Chunk.appendAll(chunk2)), Chunk.unsafeFromArray([1, 2]))
})
})
@@ -607,7 +604,7 @@ describe("Chunk", () => {
const chunk2 = Chunk.unsafeFromArray([1, 2])
it("should concatenate them following order", () => {
- expect(pipe(chunk1, Chunk.appendAll(chunk2))).toEqual(Chunk.unsafeFromArray([1, 2]))
+ equals(pipe(chunk1, Chunk.appendAll(chunk2)), Chunk.unsafeFromArray([1, 2]))
})
})
@@ -616,7 +613,7 @@ describe("Chunk", () => {
const chunk2 = Chunk.empty()
it("should concatenate them following order", () => {
- expect(pipe(chunk1, Chunk.appendAll(chunk2))).toEqual(Chunk.unsafeFromArray([1, 2]))
+ equals(pipe(chunk1, Chunk.appendAll(chunk2)), Chunk.unsafeFromArray([1, 2]))
})
})
@@ -628,45 +625,26 @@ describe("Chunk", () => {
const chunk5 = Chunk.unsafeFromArray([5, 6])
it("should concatenate them following order", () => {
- expect(
+ equals(
pipe(
chunk1,
Chunk.appendAll(chunk2),
Chunk.appendAll(chunk3),
Chunk.appendAll(chunk4),
Chunk.appendAll(chunk5)
- )
+ ),
+ Chunk.unsafeFromArray([1, 2, 3, 4, 5, 6])
)
- .toEqual(Chunk.unsafeFromArray([1, 2, 3, 4, 5, 6]))
})
})
// TODO add tests for 100% coverage: left & right diff depths & depth > 0
})
it("zip", () => {
- pipe(
- Chunk.empty(),
- Chunk.zip(Chunk.empty()),
- Equal.equals(Chunk.unsafeFromArray([])),
- assert.isTrue
- )
- pipe(
- Chunk.empty(),
- Chunk.zip(Chunk.of(1)),
- Equal.equals(Chunk.unsafeFromArray([])),
- assert.isTrue
- )
- pipe(
- Chunk.of(1),
- Chunk.zip(Chunk.empty()),
- Equal.equals(Chunk.unsafeFromArray([])),
- assert.isTrue
- )
- expect(pipe(
- Chunk.of(1),
- Chunk.zip(Chunk.of(2)),
- Chunk.toReadonlyArray
- )).toEqual([[1, 2]])
+ equals(Chunk.zip(Chunk.empty(), Chunk.empty()), Chunk.empty())
+ equals(Chunk.zip(Chunk.make(1), Chunk.empty()), Chunk.empty())
+ equals(Chunk.zip(Chunk.empty(), Chunk.make(1)), Chunk.empty())
+ deepStrictEqual(Chunk.toArray(Chunk.zip(Chunk.make(1), Chunk.make(2))), [[1, 2]])
})
describe("Given two non-materialized chunks of different sizes", () => {
@@ -675,203 +653,197 @@ describe("Chunk", () => {
const left = pipe(Chunk.make(-1, 0, 1), Chunk.drop(1))
const right = pipe(Chunk.make(1, 0, 0, 1), Chunk.drop(1))
const zipped = pipe(left, Chunk.zipWith(pipe(right, Chunk.take(left.length)), (a, b) => [a, b]))
- expect(Array.from(zipped)).toEqual([[0, 0], [1, 0]])
+ deepStrictEqual(Array.from(zipped), [[0, 0], [1, 0]])
})
})
it("last", () => {
- expect(Chunk.last(Chunk.empty())).toEqual(Option.none())
- expect(Chunk.last(Chunk.make(1, 2, 3))).toEqual(Option.some(3))
+ assertNone(Chunk.last(Chunk.empty()))
+ assertSome(Chunk.last(Chunk.make(1, 2, 3)), 3)
})
it("map", () => {
- expect(Chunk.map(Chunk.empty(), (n) => n + 1)).toEqual(Chunk.empty())
- expect(Chunk.map(Chunk.of(1), (n) => n + 1)).toEqual(Chunk.of(2))
- expect(Chunk.map(Chunk.make(1, 2, 3), (n) => n + 1)).toEqual(Chunk.make(2, 3, 4))
- expect(Chunk.map(Chunk.make(1, 2, 3), (n, i) => n + i)).toEqual(Chunk.make(1, 3, 5))
+ equals(Chunk.map(Chunk.empty(), (n) => n + 1), Chunk.empty())
+ equals(Chunk.map(Chunk.of(1), (n) => n + 1), Chunk.of(2))
+ equals(Chunk.map(Chunk.make(1, 2, 3), (n) => n + 1), Chunk.make(2, 3, 4))
+ equals(Chunk.map(Chunk.make(1, 2, 3), (n, i) => n + i), Chunk.make(1, 3, 5))
})
it("mapAccum", () => {
- expect(Chunk.mapAccum(Chunk.make(1, 2, 3), "-", (s, a) => [s + a, a + 1])).toEqual(["-123", Chunk.make(2, 3, 4)])
+ deepStrictEqual(Chunk.mapAccum(Chunk.make(1, 2, 3), "-", (s, a) => [s + a, a + 1]), ["-123", Chunk.make(2, 3, 4)])
})
it("partition", () => {
- expect(Chunk.partition(Chunk.empty(), (n) => n > 2)).toEqual([Chunk.empty(), Chunk.empty()])
- expect(Chunk.partition(Chunk.make(1, 3), (n) => n > 2)).toEqual([Chunk.make(1), Chunk.make(3)])
+ assertTuple(Chunk.partition(Chunk.empty(), (n) => n > 2), [Chunk.empty(), Chunk.empty()])
+ assertTuple(Chunk.partition(Chunk.make(1, 3), (n) => n > 2), [Chunk.make(1), Chunk.make(3)])
- expect(Chunk.partition(Chunk.empty(), (n, i) => n + i > 2)).toEqual([Chunk.empty(), Chunk.empty()])
- expect(Chunk.partition(Chunk.make(1, 2), (n, i) => n + i > 2)).toEqual([Chunk.make(1), Chunk.make(2)])
+ assertTuple(Chunk.partition(Chunk.empty(), (n, i) => n + i > 2), [Chunk.empty(), Chunk.empty()])
+ assertTuple(Chunk.partition(Chunk.make(1, 2), (n, i) => n + i > 2), [Chunk.make(1), Chunk.make(2)])
})
it("partitionMap", () => {
- expect(Chunk.partitionMap(Chunk.empty(), identity)).toEqual([Chunk.empty(), Chunk.empty()])
- expect(Chunk.partitionMap(Chunk.make(E.right(1), E.left("a"), E.right(2)), identity)).toEqual([
+ assertTuple(Chunk.partitionMap(Chunk.empty(), identity), [Chunk.empty(), Chunk.empty()])
+ assertTuple(Chunk.partitionMap(Chunk.make(Either.right(1), Either.left("a"), Either.right(2)), identity), [
Chunk.make("a"),
Chunk.make(1, 2)
])
})
it("separate", () => {
- expect(Chunk.separate(Chunk.empty())).toEqual([Chunk.empty(), Chunk.empty()])
- expect(Chunk.separate(Chunk.make(E.right(1), E.left("e"), E.right(2)))).toEqual([
+ assertTuple(Chunk.separate(Chunk.empty()), [Chunk.empty(), Chunk.empty()])
+ assertTuple(Chunk.separate(Chunk.make(Either.right(1), Either.left("e"), Either.right(2))), [
Chunk.make("e"),
Chunk.make(1, 2)
])
})
it("size", () => {
- expect(Chunk.size(Chunk.empty())).toEqual(0)
- expect(Chunk.size(Chunk.make(1, 2, 3))).toEqual(3)
+ strictEqual(Chunk.size(Chunk.empty()), 0)
+ strictEqual(Chunk.size(Chunk.make(1, 2, 3)), 3)
})
it("split", () => {
- expect(pipe(Chunk.empty(), Chunk.split(2))).toEqual(Chunk.empty())
- expect(pipe(Chunk.make(1), Chunk.split(2))).toEqual(
- Chunk.make(Chunk.make(1))
- )
- expect(pipe(Chunk.make(1, 2), Chunk.split(2))).toEqual(
- Chunk.make(Chunk.make(1), Chunk.make(2))
- )
- expect(pipe(Chunk.make(1, 2, 3, 4, 5), Chunk.split(2))).toEqual(
- Chunk.make(Chunk.make(1, 2, 3), Chunk.make(4, 5))
- )
- expect(pipe(Chunk.make(1, 2, 3, 4, 5), Chunk.split(3))).toEqual(
+ equals(pipe(Chunk.empty(), Chunk.split(2)), Chunk.empty())
+ equals(pipe(Chunk.make(1), Chunk.split(2)), Chunk.make(Chunk.make(1)))
+ equals(pipe(Chunk.make(1, 2), Chunk.split(2)), Chunk.make(Chunk.make(1), Chunk.make(2)))
+ equals(pipe(Chunk.make(1, 2, 3, 4, 5), Chunk.split(2)), Chunk.make(Chunk.make(1, 2, 3), Chunk.make(4, 5)))
+ equals(
+ pipe(Chunk.make(1, 2, 3, 4, 5), Chunk.split(3)),
Chunk.make(Chunk.make(1, 2), Chunk.make(3, 4), Chunk.make(5))
)
})
it("tail", () => {
- expect(Chunk.tail(Chunk.empty())).toEqual(Option.none())
- expect(Chunk.tail(Chunk.make(1, 2, 3))).toEqual(Option.some(Chunk.make(2, 3)))
+ assertNone(Chunk.tail(Chunk.empty()))
+ // TODO: use assertSome?
+ equals(Chunk.tail(Chunk.make(1, 2, 3)), Option.some(Chunk.make(2, 3)))
})
it("filter", () => {
- Util.deepStrictEqual(Chunk.filter(Chunk.make(1, 2, 3), (n) => n % 2 === 1), Chunk.make(1, 3))
- assert.deepStrictEqual(
+ equals(Chunk.filter(Chunk.make(1, 2, 3), (n) => n % 2 === 1), Chunk.make(1, 3))
+ equals(
Chunk.filter(Chunk.make(Option.some(3), Option.some(2), Option.some(1)), Option.isSome),
Chunk.make(Option.some(3), Option.some(2), Option.some(1)) as any
)
- assert.deepStrictEqual(
+ equals(
Chunk.filter(Chunk.make(Option.some(3), Option.none(), Option.some(1)), Option.isSome),
Chunk.make(Option.some(3), Option.some(1)) as any
)
})
it("filterMapWhile", () => {
- expect(Chunk.filterMapWhile(Chunk.make(1, 3, 4, 5), (n) => n % 2 === 1 ? Option.some(n) : Option.none())).toEqual(
+ equals(
+ Chunk.filterMapWhile(Chunk.make(1, 3, 4, 5), (n) => n % 2 === 1 ? Option.some(n) : Option.none()),
Chunk.make(1, 3)
)
})
it("compact", () => {
- expect(Chunk.compact(Chunk.empty())).toEqual(Chunk.empty())
- expect(Chunk.compact(Chunk.make(Option.some(1), Option.some(2), Option.some(3)))).toEqual(Chunk.make(1, 2, 3))
- expect(Chunk.compact(Chunk.make(Option.some(1), Option.none(), Option.some(3)))).toEqual(Chunk.make(1, 3))
+ equals(Chunk.compact(Chunk.empty()), Chunk.empty())
+ equals(Chunk.compact(Chunk.make(Option.some(1), Option.some(2), Option.some(3))), Chunk.make(1, 2, 3))
+ equals(Chunk.compact(Chunk.make(Option.some(1), Option.none(), Option.some(3))), Chunk.make(1, 3))
})
it("dedupeAdjacent", () => {
- expect(Chunk.dedupeAdjacent(Chunk.empty())).toEqual(Chunk.empty())
- expect(Chunk.dedupeAdjacent(Chunk.make(1, 2, 3))).toEqual(Chunk.make(1, 2, 3))
- expect(Chunk.dedupeAdjacent(Chunk.make(1, 2, 2, 3, 3))).toEqual(Chunk.make(1, 2, 3))
+ equals(Chunk.dedupeAdjacent(Chunk.empty()), Chunk.empty())
+ equals(Chunk.dedupeAdjacent(Chunk.make(1, 2, 3)), Chunk.make(1, 2, 3))
+ equals(Chunk.dedupeAdjacent(Chunk.make(1, 2, 2, 3, 3)), Chunk.make(1, 2, 3))
})
it("flatMap", () => {
- expect(Chunk.flatMap(Chunk.make(1), (n) => Chunk.make(n, n + 1))).toEqual(Chunk.make(1, 2))
- expect(Chunk.flatMap(Chunk.make(1, 2, 3), (n) => Chunk.make(n, n + 1))).toEqual(Chunk.make(1, 2, 2, 3, 3, 4))
+ equals(Chunk.flatMap(Chunk.make(1), (n) => Chunk.make(n, n + 1)), Chunk.make(1, 2))
+ equals(Chunk.flatMap(Chunk.make(1, 2, 3), (n) => Chunk.make(n, n + 1)), Chunk.make(1, 2, 2, 3, 3, 4))
})
it("union", () => {
- expect(Chunk.union(Chunk.make(1, 2, 3), Chunk.empty())).toEqual(Chunk.make(1, 2, 3))
- expect(Chunk.union(Chunk.empty(), Chunk.make(1, 2, 3))).toEqual(Chunk.make(1, 2, 3))
- expect(Chunk.union(Chunk.make(1, 2, 3), Chunk.make(2, 3, 4))).toEqual(Chunk.make(1, 2, 3, 4))
+ equals(Chunk.union(Chunk.make(1, 2, 3), Chunk.empty()), Chunk.make(1, 2, 3))
+ equals(Chunk.union(Chunk.empty(), Chunk.make(1, 2, 3)), Chunk.make(1, 2, 3))
+ equals(Chunk.union(Chunk.make(1, 2, 3), Chunk.make(2, 3, 4)), Chunk.make(1, 2, 3, 4))
})
it("intersection", () => {
- expect(Chunk.intersection(Chunk.make(1, 2, 3), Chunk.empty())).toEqual(Chunk.empty())
- expect(Chunk.intersection(Chunk.empty(), Chunk.make(2, 3, 4))).toEqual(Chunk.empty())
- expect(Chunk.intersection(Chunk.make(1, 2, 3), Chunk.make(2, 3, 4))).toEqual(Chunk.make(2, 3))
+ equals(Chunk.intersection(Chunk.make(1, 2, 3), Chunk.empty()), Chunk.empty())
+ equals(Chunk.intersection(Chunk.empty(), Chunk.make(2, 3, 4)), Chunk.empty())
+ equals(Chunk.intersection(Chunk.make(1, 2, 3), Chunk.make(2, 3, 4)), Chunk.make(2, 3))
})
it("isEmpty", () => {
- expect(Chunk.isEmpty(Chunk.empty())).toEqual(true)
- expect(Chunk.isEmpty(Chunk.make(1))).toEqual(false)
+ assertTrue(Chunk.isEmpty(Chunk.empty()))
+ assertFalse(Chunk.isEmpty(Chunk.make(1)))
})
it("unsafeLast", () => {
- expect(Chunk.unsafeLast(Chunk.make(1))).toEqual(1)
- expect(Chunk.unsafeLast(Chunk.make(1, 2, 3))).toEqual(3)
- expect(() => Chunk.unsafeLast(Chunk.empty())).toThrow(new Error("Index out of bounds"))
+ strictEqual(Chunk.unsafeLast(Chunk.make(1)), 1)
+ strictEqual(Chunk.unsafeLast(Chunk.make(1, 2, 3)), 3)
+ throws(() => Chunk.unsafeLast(Chunk.empty()), new Error("Index out of bounds"))
})
it("splitNonEmptyAt", () => {
- expect(pipe(Chunk.make(1, 2, 3, 4), Chunk.splitNonEmptyAt(2))).toStrictEqual([Chunk.make(1, 2), Chunk.make(3, 4)])
- expect(pipe(Chunk.make(1, 2, 3, 4), Chunk.splitNonEmptyAt(10))).toStrictEqual([
- Chunk.make(1, 2, 3, 4),
- Chunk.empty()
- ])
+ assertTuple(Chunk.splitNonEmptyAt(Chunk.make(1, 2, 3, 4), 2), [Chunk.make(1, 2), Chunk.make(3, 4)])
+ assertTuple(Chunk.splitNonEmptyAt(Chunk.make(1, 2, 3, 4), 10), [Chunk.make(1, 2, 3, 4), Chunk.empty()])
})
it("splitWhere", () => {
- expect(Chunk.splitWhere(Chunk.empty(), (n) => n > 1)).toEqual([Chunk.empty(), Chunk.empty()])
- expect(Chunk.splitWhere(Chunk.make(1, 2, 3), (n) => n > 1)).toEqual([Chunk.make(1), Chunk.make(2, 3)])
+ assertTuple(Chunk.splitWhere(Chunk.empty(), (n) => n > 1), [Chunk.empty(), Chunk.empty()])
+ assertTuple(Chunk.splitWhere(Chunk.make(1, 2, 3), (n) => n > 1), [Chunk.make(1), Chunk.make(2, 3)])
})
it("takeWhile", () => {
- expect(Chunk.takeWhile(Chunk.empty(), (n) => n <= 2)).toEqual(Chunk.empty())
- expect(Chunk.takeWhile(Chunk.make(1, 2, 3), (n) => n <= 2)).toEqual(Chunk.make(1, 2))
+ equals(Chunk.takeWhile(Chunk.empty(), (n) => n <= 2), Chunk.empty())
+ equals(Chunk.takeWhile(Chunk.make(1, 2, 3), (n) => n <= 2), Chunk.make(1, 2))
})
it("dedupe", () => {
- expect(Chunk.dedupe(Chunk.empty())).toEqual(Chunk.empty())
- expect(Chunk.dedupe(Chunk.make(1, 2, 3))).toEqual(Chunk.make(1, 2, 3))
- expect(Chunk.dedupe(Chunk.make(1, 2, 3, 2, 1, 3))).toEqual(Chunk.make(1, 2, 3))
+ equals(Chunk.dedupe(Chunk.empty()), Chunk.empty())
+ equals(Chunk.dedupe(Chunk.make(1, 2, 3)), Chunk.make(1, 2, 3))
+ equals(Chunk.dedupe(Chunk.make(1, 2, 3, 2, 1, 3)), Chunk.make(1, 2, 3))
})
it("unzip", () => {
- expect(Chunk.unzip(Chunk.empty())).toEqual([Chunk.empty(), Chunk.empty()])
- expect(Chunk.unzip(Chunk.make(["a", 1] as const, ["b", 2] as const))).toEqual([
+ assertTuple(Chunk.unzip(Chunk.empty()), [Chunk.empty(), Chunk.empty()])
+ assertTuple(Chunk.unzip(Chunk.make(["a", 1] as const, ["b", 2] as const)), [
Chunk.make("a", "b"),
Chunk.make(1, 2)
])
})
it("reverse", () => {
- expect(Chunk.reverse(Chunk.empty())).toEqual(Chunk.empty())
- expect(Chunk.reverse(Chunk.make(1, 2, 3))).toEqual(Chunk.make(3, 2, 1))
- expect(Chunk.reverse(Chunk.take(Chunk.make(1, 2, 3, 4), 3))).toEqual(Chunk.make(3, 2, 1))
+ equals(Chunk.reverse(Chunk.empty()), Chunk.empty())
+ equals(Chunk.reverse(Chunk.make(1, 2, 3)), Chunk.make(3, 2, 1))
+ equals(Chunk.reverse(Chunk.take(Chunk.make(1, 2, 3, 4), 3)), Chunk.make(3, 2, 1))
})
it("flatten", () => {
- expect(Chunk.flatten(Chunk.make(Chunk.make(1), Chunk.make(2), Chunk.make(3)))).toEqual(Chunk.make(1, 2, 3))
+ equals(Chunk.flatten(Chunk.make(Chunk.make(1), Chunk.make(2), Chunk.make(3))), Chunk.make(1, 2, 3))
})
it("makeBy", () => {
- expect(Chunk.makeBy(5, (n) => n * 2)).toEqual(Chunk.make(0, 2, 4, 6, 8))
- expect(Chunk.makeBy(2.2, (n) => n * 2)).toEqual(Chunk.make(0, 2))
+ equals(Chunk.makeBy(5, (n) => n * 2), Chunk.make(0, 2, 4, 6, 8))
+ equals(Chunk.makeBy(2.2, (n) => n * 2), Chunk.make(0, 2))
})
it("range", () => {
- expect(Chunk.range(0, 0)).toEqual(Chunk.make(0))
- expect(Chunk.range(0, 1)).toEqual(Chunk.make(0, 1))
- expect(Chunk.range(1, 5)).toEqual(Chunk.make(1, 2, 3, 4, 5))
- expect(Chunk.range(10, 15)).toEqual(Chunk.make(10, 11, 12, 13, 14, 15))
- expect(Chunk.range(-1, 0)).toEqual(Chunk.make(-1, 0))
- expect(Chunk.range(-5, -1)).toEqual(Chunk.make(-5, -4, -3, -2, -1))
+ equals(Chunk.range(0, 0), Chunk.make(0))
+ equals(Chunk.range(0, 1), Chunk.make(0, 1))
+ equals(Chunk.range(1, 5), Chunk.make(1, 2, 3, 4, 5))
+ equals(Chunk.range(10, 15), Chunk.make(10, 11, 12, 13, 14, 15))
+ equals(Chunk.range(-1, 0), Chunk.make(-1, 0))
+ equals(Chunk.range(-5, -1), Chunk.make(-5, -4, -3, -2, -1))
// out of bound
- expect(Chunk.range(2, 1)).toEqual(Chunk.make(2))
- expect(Chunk.range(-1, -2)).toEqual(Chunk.make(-1))
+ equals(Chunk.range(2, 1), Chunk.make(2))
+ equals(Chunk.range(-1, -2), Chunk.make(-1))
})
it("some", () => {
- const isPositive: Predicate = (n) => n > 0
- expect(Chunk.some(Chunk.make(-1, -2, 3), isPositive)).toEqual(true)
- expect(Chunk.some(Chunk.make(-1, -2, -3), isPositive)).toEqual(false)
+ const isPositive: Predicate.Predicate = (n) => n > 0
+ assertTrue(Chunk.some(Chunk.make(-1, -2, 3), isPositive))
+ assertFalse(Chunk.some(Chunk.make(-1, -2, -3), isPositive))
})
it("forEach", () => {
const as: Array = []
Chunk.forEach(Chunk.make(1, 2, 3, 4), (n) => as.push(n))
- expect(as).toEqual([1, 2, 3, 4])
+ deepStrictEqual(as, [1, 2, 3, 4])
})
it("sortWith", () => {
@@ -880,35 +852,35 @@ describe("Chunk", () => {
b: number
}
const chunk: Chunk.Chunk = Chunk.make({ a: "a", b: 2 }, { a: "b", b: 1 })
- expect(Chunk.sortWith(chunk, (x) => x.b, Order.number)).toEqual(Chunk.make({ a: "b", b: 1 }, { a: "a", b: 2 }))
+ deepStrictEqual(Chunk.sortWith(chunk, (x) => x.b, Order.number), Chunk.make({ a: "b", b: 1 }, { a: "a", b: 2 }))
})
it("getEquivalence", () => {
const equivalence = Chunk.getEquivalence(N.Equivalence)
- expect(equivalence(Chunk.empty(), Chunk.empty())).toBe(true)
- expect(equivalence(Chunk.make(1, 2, 3), Chunk.make(1, 2, 3))).toBe(true)
- expect(equivalence(Chunk.make(1, 2, 3), Chunk.make(1, 2))).toBe(false)
- expect(equivalence(Chunk.make(1, 2, 3), Chunk.make(1, 2, 4))).toBe(false)
+ assertTrue(equivalence(Chunk.empty(), Chunk.empty()))
+ assertTrue(equivalence(Chunk.make(1, 2, 3), Chunk.make(1, 2, 3)))
+ assertFalse(equivalence(Chunk.make(1, 2, 3), Chunk.make(1, 2)))
+ assertFalse(equivalence(Chunk.make(1, 2, 3), Chunk.make(1, 2, 4)))
})
it("differenceWith", () => {
const eq = (a: E, b: E) => a.id === b.id
- const diffW = pipe(eq, Chunk.differenceWith)
+ const differenceWith = pipe(eq, Chunk.differenceWith)
- const curr = Chunk.make({ id: 1 }, { id: 2 }, { id: 3 })
+ const chunk = Chunk.make({ id: 1 }, { id: 2 }, { id: 3 })
- expect(diffW(Chunk.make({ id: 1 }, { id: 2 }), curr)).toEqual(Chunk.make({ id: 3 }))
- expect(diffW(Chunk.empty(), curr)).toEqual(curr)
- expect(diffW(curr, Chunk.empty())).toEqual(Chunk.empty())
- expect(diffW(curr, curr)).toEqual(Chunk.empty())
+ deepStrictEqual(differenceWith(Chunk.make({ id: 1 }, { id: 2 }), chunk), Chunk.make({ id: 3 }))
+ equals(differenceWith(Chunk.empty(), chunk), chunk)
+ equals(differenceWith(chunk, Chunk.empty()), Chunk.empty())
+ equals(differenceWith(chunk, chunk), Chunk.empty())
})
it("difference", () => {
const curr = Chunk.make(1, 3, 5, 7, 9)
- expect(Chunk.difference(Chunk.make(1, 2, 3, 4, 5), curr)).toEqual(Chunk.make(7, 9))
- expect(Chunk.difference(Chunk.empty(), curr)).toEqual(curr)
- expect(Chunk.difference(curr, Chunk.empty())).toEqual(Chunk.empty())
- expect(Chunk.difference(curr, curr)).toEqual(Chunk.empty())
+ equals(Chunk.difference(Chunk.make(1, 2, 3, 4, 5), curr), Chunk.make(7, 9))
+ equals(Chunk.difference(Chunk.empty(), curr), curr)
+ equals(Chunk.difference(curr, Chunk.empty()), Chunk.empty())
+ equals(Chunk.difference(curr, curr), Chunk.empty())
})
})
diff --git a/packages/effect/test/Config.test.ts b/packages/effect/test/Config.test.ts
index 0b01bc82509..008b58e4b27 100644
--- a/packages/effect/test/Config.test.ts
+++ b/packages/effect/test/Config.test.ts
@@ -1,55 +1,48 @@
-import * as Chunk from "effect/Chunk"
-import * as Config from "effect/Config"
-import * as ConfigError from "effect/ConfigError"
-import * as ConfigProvider from "effect/ConfigProvider"
-import * as Duration from "effect/Duration"
-import * as Effect from "effect/Effect"
-import * as Equal from "effect/Equal"
-import * as Exit from "effect/Exit"
-import { pipe } from "effect/Function"
-import * as HashSet from "effect/HashSet"
-import * as LogLevel from "effect/LogLevel"
-import * as Option from "effect/Option"
-import * as Redacted from "effect/Redacted"
-import * as Secret from "effect/Secret"
-import { assert, describe, expect, it } from "vitest"
-
-const assertFailure = (
+import {
+ Cause,
+ Chunk,
+ Config,
+ ConfigError,
+ ConfigProvider,
+ Duration,
+ Effect,
+ Equal,
+ HashSet,
+ LogLevel,
+ Option,
+ pipe,
+ Redacted,
+ Secret
+} from "effect"
+import { assertFailure, assertSuccess, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
+import { describe, it } from "vitest"
+
+const assertConfigError = (
config: Config.Config,
map: ReadonlyArray,
error: ConfigError.ConfigError
) => {
const configProvider = ConfigProvider.fromMap(new Map(map))
- const result = Effect.runSync(Effect.exit(configProvider.load(config)))
- expect(result).toStrictEqual(Exit.fail(error))
+ const result = Effect.runSyncExit(configProvider.load(config))
+ assertFailure(result, Cause.fail(error))
}
-const assertSuccess = (
+const assertConfig = (
config: Config.Config,
map: ReadonlyArray,
a: A
) => {
const configProvider = ConfigProvider.fromMap(new Map(map))
- const result = Effect.runSync(Effect.exit(configProvider.load(config)))
- expect(result).toStrictEqual(Exit.succeed(a))
-}
-
-const assertEqualSuccess = (
- config: Config.Config,
- map: ReadonlyArray,
- a: A
-) => {
- const configProvider = ConfigProvider.fromMap(new Map(map))
- const result = Effect.runSync(Effect.exit(configProvider.load(config)))
- expect(Equal.equals(Exit.succeed(a), result)).toBe(true)
+ const result = Effect.runSyncExit(configProvider.load(config))
+ assertSuccess(result, a)
}
describe("Config", () => {
describe("boolean", () => {
it("name = undefined", () => {
const config = Config.array(Config.boolean(), "ITEMS")
- assertSuccess(config, [["ITEMS", "true"]], [true])
- assertFailure(
+ assertConfig(config, [["ITEMS", "true"]], [true])
+ assertConfigError(
config,
[["ITEMS", "value"]],
ConfigError.InvalidData(["ITEMS"], "Expected a boolean value but received value")
@@ -58,17 +51,17 @@ describe("Config", () => {
it("name != undefined", () => {
const config = Config.boolean("BOOL")
- assertSuccess(config, [["BOOL", "true"]], true)
- assertSuccess(config, [["BOOL", "yes"]], true)
- assertSuccess(config, [["BOOL", "on"]], true)
- assertSuccess(config, [["BOOL", "1"]], true)
- assertSuccess(config, [["BOOL", "false"]], false)
- assertSuccess(config, [["BOOL", "no"]], false)
- assertSuccess(config, [["BOOL", "off"]], false)
- assertSuccess(config, [["BOOL", "0"]], false)
-
- assertFailure(config, [], ConfigError.MissingData(["BOOL"], "Expected BOOL to exist in the provided map"))
- assertFailure(
+ assertConfig(config, [["BOOL", "true"]], true)
+ assertConfig(config, [["BOOL", "yes"]], true)
+ assertConfig(config, [["BOOL", "on"]], true)
+ assertConfig(config, [["BOOL", "1"]], true)
+ assertConfig(config, [["BOOL", "false"]], false)
+ assertConfig(config, [["BOOL", "no"]], false)
+ assertConfig(config, [["BOOL", "off"]], false)
+ assertConfig(config, [["BOOL", "0"]], false)
+
+ assertConfigError(config, [], ConfigError.MissingData(["BOOL"], "Expected BOOL to exist in the provided map"))
+ assertConfigError(
config,
[["BOOL", "value"]],
ConfigError.InvalidData(["BOOL"], "Expected a boolean value but received value")
@@ -79,17 +72,17 @@ describe("Config", () => {
describe("url", () => {
it("name != undefined", () => {
const config = Config.url("WEBSITE_URL")
- assertSuccess(
+ assertConfig(
config,
[["WEBSITE_URL", "https://effect.website/docs/introduction#what-is-effect"]],
new URL("https://effect.website/docs/introduction#what-is-effect")
)
- assertFailure(
+ assertConfigError(
config,
[["WEBSITE_URL", "abra-kadabra"]],
ConfigError.InvalidData(["WEBSITE_URL"], "Expected an URL value but received abra-kadabra")
)
- assertFailure(
+ assertConfigError(
config,
[],
ConfigError.MissingData(["WEBSITE_URL"], "Expected WEBSITE_URL to exist in the provided map")
@@ -100,15 +93,15 @@ describe("Config", () => {
describe("nonEmptyString", () => {
it("name = undefined", () => {
const config = Config.array(Config.nonEmptyString(), "ITEMS")
- assertSuccess(config, [["ITEMS", "foo"]], ["foo"])
- assertFailure(config, [["ITEMS", ""]], ConfigError.MissingData(["ITEMS"], "Expected a non-empty string"))
+ assertConfig(config, [["ITEMS", "foo"]], ["foo"])
+ assertConfigError(config, [["ITEMS", ""]], ConfigError.MissingData(["ITEMS"], "Expected a non-empty string"))
})
it("name != undefined", () => {
const config = Config.nonEmptyString("NON_EMPTY_STRING")
- assertSuccess(config, [["NON_EMPTY_STRING", "foo"]], "foo")
- assertSuccess(config, [["NON_EMPTY_STRING", " "]], " ")
- assertFailure(
+ assertConfig(config, [["NON_EMPTY_STRING", "foo"]], "foo")
+ assertConfig(config, [["NON_EMPTY_STRING", " "]], " ")
+ assertConfigError(
config,
[["NON_EMPTY_STRING", ""]],
ConfigError.MissingData(["NON_EMPTY_STRING"], "Expected a non-empty string")
@@ -119,13 +112,13 @@ describe("Config", () => {
describe("number", () => {
it("name = undefined", () => {
const config = Config.array(Config.number(), "ITEMS")
- assertSuccess(config, [["ITEMS", "1"]], [1])
- assertFailure(
+ assertConfig(config, [["ITEMS", "1"]], [1])
+ assertConfigError(
config,
[["ITEMS", "123qq"]],
ConfigError.InvalidData(["ITEMS"], "Expected a number value but received 123qq")
)
- assertFailure(
+ assertConfigError(
config,
[["ITEMS", "value"]],
ConfigError.InvalidData(["ITEMS"], "Expected a number value but received value")
@@ -134,15 +127,15 @@ describe("Config", () => {
it("name != undefined", () => {
const config = Config.number("NUMBER")
- assertSuccess(config, [["NUMBER", "1"]], 1)
- assertSuccess(config, [["NUMBER", "1.2"]], 1.2)
- assertSuccess(config, [["NUMBER", "-1"]], -1)
- assertSuccess(config, [["NUMBER", "-1.2"]], -1.2)
- assertSuccess(config, [["NUMBER", "0"]], 0)
- assertSuccess(config, [["NUMBER", "-0"]], -0)
-
- assertFailure(config, [], ConfigError.MissingData(["NUMBER"], "Expected NUMBER to exist in the provided map"))
- assertFailure(
+ assertConfig(config, [["NUMBER", "1"]], 1)
+ assertConfig(config, [["NUMBER", "1.2"]], 1.2)
+ assertConfig(config, [["NUMBER", "-1"]], -1)
+ assertConfig(config, [["NUMBER", "-1.2"]], -1.2)
+ assertConfig(config, [["NUMBER", "0"]], 0)
+ assertConfig(config, [["NUMBER", "-0"]], -0)
+
+ assertConfigError(config, [], ConfigError.MissingData(["NUMBER"], "Expected NUMBER to exist in the provided map"))
+ assertConfigError(
config,
[["NUMBER", "value"]],
ConfigError.InvalidData(["NUMBER"], "Expected a number value but received value")
@@ -153,8 +146,8 @@ describe("Config", () => {
describe("literal", () => {
it("name = undefined", () => {
const config = Config.array(Config.literal("a", "b")(), "ITEMS")
- assertSuccess(config, [["ITEMS", "a"]], ["a"])
- assertFailure(
+ assertConfig(config, [["ITEMS", "a"]], ["a"])
+ assertConfigError(
config,
[["ITEMS", "value"]],
ConfigError.InvalidData(["ITEMS"], "Expected one of (a, b) but received value")
@@ -163,15 +156,19 @@ describe("Config", () => {
it("name != undefined", () => {
const config = Config.literal("a", 0, -0.3, BigInt(5), false, null)("LITERAL")
- assertSuccess(config, [["LITERAL", "a"]], "a")
- assertSuccess(config, [["LITERAL", "0"]], 0)
- assertSuccess(config, [["LITERAL", "-0.3"]], -0.3)
- assertSuccess(config, [["LITERAL", "5"]], BigInt(5))
- assertSuccess(config, [["LITERAL", "false"]], false)
- assertSuccess(config, [["LITERAL", "null"]], null)
-
- assertFailure(config, [], ConfigError.MissingData(["LITERAL"], "Expected LITERAL to exist in the provided map"))
- assertFailure(
+ assertConfig(config, [["LITERAL", "a"]], "a")
+ assertConfig(config, [["LITERAL", "0"]], 0)
+ assertConfig(config, [["LITERAL", "-0.3"]], -0.3)
+ assertConfig(config, [["LITERAL", "5"]], BigInt(5))
+ assertConfig(config, [["LITERAL", "false"]], false)
+ assertConfig(config, [["LITERAL", "null"]], null)
+
+ assertConfigError(
+ config,
+ [],
+ ConfigError.MissingData(["LITERAL"], "Expected LITERAL to exist in the provided map")
+ )
+ assertConfigError(
config,
[["LITERAL", "value"]],
ConfigError.InvalidData(["LITERAL"], "Expected one of (a, 0, -0.3, 5, false, null) but received value")
@@ -182,8 +179,8 @@ describe("Config", () => {
describe("date", () => {
it("name = undefined", () => {
const config = Config.date()
- assertSuccess(config, [["", "0"]], new Date(Date.parse("0")))
- assertFailure(
+ assertConfig(config, [["", "0"]], new Date(Date.parse("0")))
+ assertConfigError(
config,
[["", "value"]],
ConfigError.InvalidData([], "Expected a Date value but received value")
@@ -192,10 +189,10 @@ describe("Config", () => {
it("name != undefined", () => {
const config = Config.date("DATE")
- assertSuccess(config, [["DATE", "0"]], new Date(Date.parse("0")))
+ assertConfig(config, [["DATE", "0"]], new Date(Date.parse("0")))
- assertFailure(config, [], ConfigError.MissingData(["DATE"], "Expected DATE to exist in the provided map"))
- assertFailure(
+ assertConfigError(config, [], ConfigError.MissingData(["DATE"], "Expected DATE to exist in the provided map"))
+ assertConfigError(
config,
[["DATE", "value"]],
ConfigError.InvalidData(["DATE"], "Expected a Date value but received value")
@@ -205,7 +202,7 @@ describe("Config", () => {
it("fail", () => {
const config = Config.fail("failure message")
- assertFailure(config, [], ConfigError.MissingData([], "failure message"))
+ assertConfigError(config, [], ConfigError.MissingData([], "failure message"))
})
it("mapAttempt", () => {
@@ -219,33 +216,33 @@ describe("Config", () => {
}
return n
}))
- assertSuccess(config, [["STRING", "1"]], 1)
- assertFailure(
+ assertConfig(config, [["STRING", "1"]], 1)
+ assertConfigError(
config,
[["STRING", "value"]],
ConfigError.InvalidData(["STRING"], "invalid number")
)
- assertFailure(
+ assertConfigError(
config,
[["STRING", "-1"]],
ConfigError.InvalidData(["STRING"], "invalid negative number")
)
- assertFailure(config, [], ConfigError.MissingData(["STRING"], "Expected STRING to exist in the provided map"))
+ assertConfigError(config, [], ConfigError.MissingData(["STRING"], "Expected STRING to exist in the provided map"))
})
describe("logLevel", () => {
it("name = undefined", () => {
const config = Config.logLevel()
- assertSuccess(config, [["", "DEBUG"]], LogLevel.Debug)
+ assertConfig(config, [["", "DEBUG"]], LogLevel.Debug)
- assertFailure(config, [["", "-"]], ConfigError.InvalidData([], "Expected a log level but received -"))
+ assertConfigError(config, [["", "-"]], ConfigError.InvalidData([], "Expected a log level but received -"))
})
it("name != undefined", () => {
const config = Config.logLevel("LOG_LEVEL")
- assertSuccess(config, [["LOG_LEVEL", "DEBUG"]], LogLevel.Debug)
+ assertConfig(config, [["LOG_LEVEL", "DEBUG"]], LogLevel.Debug)
- assertFailure(
+ assertConfigError(
config,
[["LOG_LEVEL", "-"]],
ConfigError.InvalidData(["LOG_LEVEL"], "Expected a log level but received -")
@@ -256,16 +253,16 @@ describe("Config", () => {
describe("duration", () => {
it("name = undefined", () => {
const config = Config.duration()
- assertSuccess(config, [["", "10 seconds"]], Duration.decode("10 seconds"))
+ assertConfig(config, [["", "10 seconds"]], Duration.decode("10 seconds"))
- assertFailure(config, [["", "-"]], ConfigError.InvalidData([], "Expected a duration but received -"))
+ assertConfigError(config, [["", "-"]], ConfigError.InvalidData([], "Expected a duration but received -"))
})
it("name != undefined", () => {
const config = Config.duration("DURATION")
- assertSuccess(config, [["DURATION", "10 seconds"]], Duration.decode("10 seconds"))
+ assertConfig(config, [["DURATION", "10 seconds"]], Duration.decode("10 seconds"))
- assertFailure(
+ assertConfigError(
config,
[["DURATION", "-"]],
ConfigError.InvalidData(["DURATION"], "Expected a duration but received -")
@@ -281,9 +278,9 @@ describe("Config", () => {
validation: (n) => n >= 0
})
)
- assertSuccess(flat, [["NUMBER", "1"]], 1)
- assertSuccess(flat, [["NUMBER", "1.2"]], 1.2)
- assertFailure(
+ assertConfig(flat, [["NUMBER", "1"]], 1)
+ assertConfig(flat, [["NUMBER", "1.2"]], 1.2)
+ assertConfigError(
flat,
[["NUMBER", "-1"]],
ConfigError.InvalidData(["NUMBER"], "a positive number")
@@ -292,18 +289,18 @@ describe("Config", () => {
const nested = flat.pipe(
Config.nested("NESTED1")
)
- assertSuccess(nested, [["NESTED1.NUMBER", "1"]], 1)
- assertSuccess(nested, [["NESTED1.NUMBER", "1.2"]], 1.2)
- assertFailure(
+ assertConfig(nested, [["NESTED1.NUMBER", "1"]], 1)
+ assertConfig(nested, [["NESTED1.NUMBER", "1.2"]], 1.2)
+ assertConfigError(
nested,
[["NESTED1.NUMBER", "-1"]],
ConfigError.InvalidData(["NESTED1", "NUMBER"], "a positive number")
)
const doubleNested = nested.pipe(Config.nested("NESTED2"))
- assertSuccess(doubleNested, [["NESTED2.NESTED1.NUMBER", "1"]], 1)
- assertSuccess(doubleNested, [["NESTED2.NESTED1.NUMBER", "1.2"]], 1.2)
- assertFailure(
+ assertConfig(doubleNested, [["NESTED2.NESTED1.NUMBER", "1"]], 1)
+ assertConfig(doubleNested, [["NESTED2.NESTED1.NUMBER", "1.2"]], 1.2)
+ assertConfigError(
doubleNested,
[["NESTED2.NESTED1.NUMBER", "-1"]],
ConfigError.InvalidData(["NESTED2", "NESTED1", "NUMBER"], "a positive number")
@@ -318,9 +315,9 @@ describe("Config", () => {
Config.withDefault(0)
)
// available data
- assertSuccess(config, [["key", "1"]], 1)
+ assertConfig(config, [["key", "1"]], 1)
// missing data
- assertSuccess(config, [], 0)
+ assertConfig(config, [], 0)
})
it("does not recover from other errors", () => {
@@ -328,14 +325,14 @@ describe("Config", () => {
Config.integer("key"),
Config.withDefault(0)
)
- assertSuccess(config, [["key", "1"]], 1)
- assertFailure(
+ assertConfig(config, [["key", "1"]], 1)
+ assertConfigError(
config,
[["key", "1.2"]],
// available data but not an integer
ConfigError.InvalidData(["key"], "Expected an integer value but received 1.2")
)
- assertFailure(
+ assertConfigError(
config,
[["key", "value"]],
// available data but not an integer
@@ -349,9 +346,9 @@ describe("Config", () => {
Config.zip(Config.integer("key2")),
Config.withDefault([0, 0])
)
- assertSuccess(config, [], [0, 0])
- assertSuccess(config, [["key1", "1"], ["key2", "2"]], [1, 2])
- assertFailure(
+ assertConfig(config, [], [0, 0])
+ assertConfig(config, [["key1", "1"], ["key2", "2"]], [1, 2])
+ assertConfigError(
config,
[["key2", "value"]],
ConfigError.And(
@@ -367,10 +364,10 @@ describe("Config", () => {
Config.orElse(() => Config.integer("key2")),
Config.withDefault(0)
)
- assertSuccess(config, [], 0)
- assertSuccess(config, [["key1", "1"]], 1)
- assertSuccess(config, [["key2", "2"]], 2)
- assertFailure(
+ assertConfig(config, [], 0)
+ assertConfig(config, [["key1", "1"]], 1)
+ assertConfig(config, [["key2", "2"]], 2)
+ assertConfigError(
config,
[["key2", "value"]],
ConfigError.Or(
@@ -384,13 +381,13 @@ describe("Config", () => {
describe("option", () => {
it("recovers from missing data error", () => {
const config = Config.option(Config.integer("key"))
- assertSuccess(config, [], Option.none())
- assertSuccess(config, [["key", "1"]], Option.some(1))
+ assertConfig(config, [], Option.none())
+ assertConfig(config, [["key", "1"]], Option.some(1))
})
it("does not recover from other errors", () => {
const config = Config.option(Config.integer("key"))
- assertFailure(
+ assertConfigError(
config,
[["key", "value"]],
ConfigError.InvalidData(["key"], "Expected an integer value but received value")
@@ -403,8 +400,8 @@ describe("Config", () => {
Config.zip(Config.integer("key2")),
Config.option
)
- assertSuccess(config, [["key1", "1"], ["key2", "2"]], Option.some([1, 2]))
- assertFailure(
+ assertConfig(config, [["key1", "1"], ["key2", "2"]], Option.some([1, 2]))
+ assertConfigError(
config,
[["key1", "value"]],
ConfigError.And(
@@ -412,7 +409,7 @@ describe("Config", () => {
ConfigError.MissingData(["key2"], "Expected key2 to exist in the provided map")
)
)
- assertFailure(
+ assertConfigError(
config,
[["key2", "value"]],
ConfigError.And(
@@ -428,9 +425,9 @@ describe("Config", () => {
Config.orElse(() => Config.integer("key2")),
Config.option
)
- assertSuccess(config, [["key1", "1"]], Option.some(1))
- assertSuccess(config, [["key1", "value"], ["key2", "2"]], Option.some(2))
- assertFailure(
+ assertConfig(config, [["key1", "1"]], Option.some(1))
+ assertConfig(config, [["key1", "value"], ["key2", "2"]], Option.some(2))
+ assertConfigError(
config,
[["key2", "value"]],
ConfigError.Or(
@@ -466,7 +463,7 @@ describe("Config", () => {
key2: Config.string("key2")
}
})
- assertSuccess(config, [["key1", "123"], ["items", "1,2,3"], ["option", "123"], ["secret", "sauce"], [
+ assertConfig(config, [["key1", "123"], ["items", "1,2,3"], ["option", "123"], ["secret", "sauce"], [
"key2",
"value"
]], {
@@ -478,7 +475,7 @@ describe("Config", () => {
key2: "value"
}
})
- assertFailure(
+ assertConfigError(
config,
[["key1", "123"], ["items", "1,value,3"], ["option", "123"], ["secret", "sauce"], ["key2", "value"]],
ConfigError.InvalidData(["items"], "Expected an integer value but received value")
@@ -488,30 +485,30 @@ describe("Config", () => {
it("sync", () => {
const config = Config.sync(() => 1)
- assertSuccess(config, [], 1)
+ assertConfig(config, [], 1)
})
describe("all", () => {
describe("tuple", () => {
it("length = 0", () => {
const config = Config.all([])
- assertSuccess(config, [], [])
+ assertConfig(config, [], [])
})
it("length = 1", () => {
const config = Config.all([Config.number("NUMBER")])
- assertSuccess(config, [["NUMBER", "1"]], [1])
+ assertConfig(config, [["NUMBER", "1"]], [1])
})
it("length > 1", () => {
const config = Config.all([Config.number("NUMBER"), Config.boolean("BOOL")])
- assertSuccess(config, [["NUMBER", "1"], ["BOOL", "true"]], [1, true])
- assertFailure(
+ assertConfig(config, [["NUMBER", "1"], ["BOOL", "true"]], [1, true])
+ assertConfigError(
config,
[["NUMBER", "value"], ["BOOL", "true"]],
ConfigError.InvalidData(["NUMBER"], "Expected a number value but received value")
)
- assertFailure(
+ assertConfigError(
config,
[["NUMBER", "1"], ["BOOL", "value"]],
ConfigError.InvalidData(["BOOL"], "Expected a boolean value but received value")
@@ -522,13 +519,13 @@ describe("Config", () => {
it("iterable", () => {
const set = new Set([Config.number("NUMBER"), Config.boolean("BOOL")])
const config = Config.all(set)
- assertSuccess(config, [["NUMBER", "1"], ["BOOL", "true"]], [1, true])
- assertFailure(
+ assertConfig(config, [["NUMBER", "1"], ["BOOL", "true"]], [1, true])
+ assertConfigError(
config,
[["NUMBER", "value"], ["BOOL", "true"]],
ConfigError.InvalidData(["NUMBER"], "Expected a number value but received value")
)
- assertFailure(
+ assertConfigError(
config,
[["NUMBER", "1"], ["BOOL", "value"]],
ConfigError.InvalidData(["BOOL"], "Expected a boolean value but received value")
@@ -539,17 +536,17 @@ describe("Config", () => {
describe("Config.redacted", () => {
it("name = undefined", () => {
const config = Config.array(Config.redacted(), "ITEMS")
- assertSuccess(config, [["ITEMS", "a"]], [Redacted.make("a")])
+ assertConfig(config, [["ITEMS", "a"]], [Redacted.make("a")])
})
it("name != undefined", () => {
const config = Config.redacted("SECRET")
- assertEqualSuccess(config, [["SECRET", "a"]], Redacted.make("a"))
+ assertConfig(config, [["SECRET", "a"]], Redacted.make("a"))
})
it("can wrap generic Config", () => {
const config = Config.redacted(Config.integer("NUM"))
- assertEqualSuccess(config, [["NUM", "2"]], Redacted.make(2))
+ assertConfig(config, [["NUM", "2"]], Redacted.make(2))
})
})
@@ -557,40 +554,40 @@ describe("Config", () => {
describe("Config.secret", () => {
it("name = undefined", () => {
const config = Config.array(Config.secret(), "ITEMS")
- assertSuccess(config, [["ITEMS", "a"]], [Secret.fromString("a")])
+ assertConfig(config, [["ITEMS", "a"]], [Secret.fromString("a")])
})
it("name != undefined", () => {
const config = Config.secret("SECRET")
- assertEqualSuccess(config, [["SECRET", "a"]], Secret.fromString("a"))
+ assertConfig(config, [["SECRET", "a"]], Secret.fromString("a"))
})
})
it("chunk constructor", () => {
const secret = Secret.fromIterable(Chunk.fromIterable("secret".split("")))
- assert.isTrue(Equal.equals(secret, Secret.fromString("secret")))
+ assertTrue(Equal.equals(secret, Secret.fromString("secret")))
})
it("value", () => {
const secret = Secret.fromIterable(Chunk.fromIterable("secret".split("")))
const value = Secret.value(secret)
- assert.strictEqual(value, "secret")
+ strictEqual(value, "secret")
})
it("toString", () => {
const secret = Secret.fromString("secret")
- assert.strictEqual(`${secret}`, "Secret()")
+ strictEqual(`${secret}`, "Secret()")
})
it("toJSON", () => {
const secret = Secret.fromString("secret")
- assert.strictEqual(JSON.stringify(secret), "\"\"")
+ strictEqual(JSON.stringify(secret), "\"\"")
})
it("wipe", () => {
const secret = Secret.fromString("secret")
Secret.unsafeWipe(secret)
- assert.isTrue(
+ assertTrue(
Equal.equals(
Secret.value(secret),
Array.from({ length: "secret".length }, () => String.fromCharCode(0)).join("")
@@ -601,18 +598,18 @@ describe("Config", () => {
it("withDescription", () => {
const config = Config.number("NUMBER").pipe(Config.withDescription("my description"))
- expect("description" in config).toBe(true)
+ assertTrue("description" in config)
})
describe("hashSet", () => {
it("name = undefined", () => {
const config = Config.array(Config.hashSet(Config.string()), "ITEMS")
- assertSuccess(config, [["ITEMS", "a,b,c"]], [HashSet.make("a", "b", "c")])
+ assertConfig(config, [["ITEMS", "a,b,c"]], [HashSet.make("a", "b", "c")])
})
it("name != undefined", () => {
const config = Config.hashSet(Config.string(), "HASH_SET")
- assertSuccess(config, [["HASH_SET", "a,b,c"]], HashSet.make("a", "b", "c"))
+ assertConfig(config, [["HASH_SET", "a,b,c"]], HashSet.make("a", "b", "c"))
})
})
@@ -621,7 +618,7 @@ describe("Config", () => {
Config.string("STRING"),
ConfigProvider.fromMap(new Map([["STRING", "value"]]))
))
- assert.strictEqual(result, "value")
+ strictEqual(result, "value")
})
it("array nested", () => {
@@ -633,6 +630,6 @@ describe("Config", () => {
),
Effect.runSync
)
- assert.deepStrictEqual(result, [1, 2, 3])
+ deepStrictEqual(result, [1, 2, 3])
})
})
diff --git a/packages/effect/test/ConfigProvider.test.ts b/packages/effect/test/ConfigProvider.test.ts
index d8ba6d66ff2..5c0dac4b434 100644
--- a/packages/effect/test/ConfigProvider.test.ts
+++ b/packages/effect/test/ConfigProvider.test.ts
@@ -1,19 +1,22 @@
-import * as Cause from "effect/Cause"
-import * as Chunk from "effect/Chunk"
-import * as Config from "effect/Config"
-import * as ConfigError from "effect/ConfigError"
-import * as ConfigProvider from "effect/ConfigProvider"
-import * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
-import * as Equal from "effect/Equal"
-import * as Exit from "effect/Exit"
-import * as HashMap from "effect/HashMap"
-import * as HashSet from "effect/HashSet"
-import * as LogLevel from "effect/LogLevel"
-import * as Option from "effect/Option"
-import * as Secret from "effect/Secret"
+import {
+ Cause,
+ Chunk,
+ Config,
+ ConfigError,
+ ConfigProvider,
+ Effect,
+ Either,
+ Equal,
+ Exit,
+ HashMap,
+ HashSet,
+ LogLevel,
+ Option,
+ Secret
+} from "effect"
+import { assertNone, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe, expect } from "vitest"
+import { describe } from "vitest"
interface HostPort {
readonly host: string
@@ -89,24 +92,24 @@ const provider = (map: Map): ConfigProvider.ConfigProvider => {
describe("ConfigProvider", () => {
it.effect("flat atoms", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const map = new Map([["host", "localhost"], ["port", "8080"]])
- const result = yield* $(provider(map).load(hostPortConfig))
- assert.deepStrictEqual(result, {
+ const result = yield* provider(map).load(hostPortConfig)
+ deepStrictEqual(result, {
host: "localhost",
port: 8080
})
}))
it.effect("nested atoms", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const map = new Map([
["hostPort.host", "localhost"],
["hostPort.port", "8080"],
["timeout", "1000"]
])
- const result = yield* $(provider(map).load(serviceConfigConfig))
- assert.deepStrictEqual(result, {
+ const result = yield* provider(map).load(serviceConfigConfig)
+ deepStrictEqual(result, {
hostPort: {
host: "localhost",
port: 8080
@@ -116,32 +119,32 @@ describe("ConfigProvider", () => {
}))
it.effect("top-level list with same number of elements per key", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const map = new Map([
["hostPorts.host", "localhost,localhost,localhost"],
["hostPorts.port", "8080,8080,8080"]
])
- const result = yield* $(provider(map).load(hostPortsConfig))
- assert.deepStrictEqual(result, {
+ const result = yield* provider(map).load(hostPortsConfig)
+ deepStrictEqual(result, {
hostPorts: Array.from({ length: 3 }, () => ({ host: "localhost", port: 8080 }))
})
}))
it.effect("top-level missing list", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const map = new Map()
- const result = yield* $(Effect.exit(provider(map).load(hostPortsConfig)))
- assert.isTrue(Exit.isFailure(result))
+ const result = yield* Effect.exit(provider(map).load(hostPortsConfig))
+ assertTrue(Exit.isFailure(result))
}))
it.effect("simple map", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const map = new Map([
["name", "Sherlock Holmes"],
["address", "221B Baker Street"]
])
- const result = yield* $(provider(map).load(Config.hashMap(Config.string())))
- assert.deepStrictEqual(
+ const result = yield* provider(map).load(Config.hashMap(Config.string()))
+ deepStrictEqual(
result,
HashMap.make(
["name", "Sherlock Holmes"],
@@ -151,49 +154,49 @@ describe("ConfigProvider", () => {
}))
it.effect("top-level lists with multi-character sequence delimiters", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const map = new Map([
["hostPorts.host", "localhost///localhost///localhost"],
["hostPorts.port", "8080///8080///8080"]
])
- const result = yield* $(ConfigProvider.fromMap(map, { seqDelim: "///" }).load(hostPortsConfig))
- assert.deepStrictEqual(result, {
+ const result = yield* ConfigProvider.fromMap(map, { seqDelim: "///" }).load(hostPortsConfig)
+ deepStrictEqual(result, {
hostPorts: Array.from({ length: 3 }, () => ({ host: "localhost", port: 8080 }))
})
}))
it.effect("top-level lists with special regex multi-character sequence delimiter", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const map = new Map([
["hostPorts.host", "localhost|||localhost|||localhost"],
["hostPorts.port", "8080|||8080|||8080"]
])
- const result = yield* $(ConfigProvider.fromMap(map, { seqDelim: "|||" }).load(hostPortsConfig))
- assert.deepStrictEqual(result, {
+ const result = yield* ConfigProvider.fromMap(map, { seqDelim: "|||" }).load(hostPortsConfig)
+ deepStrictEqual(result, {
hostPorts: Array.from({ length: 3 }, () => ({ host: "localhost", port: 8080 }))
})
}))
it.effect("top-level lists with special regex character sequence delimiter", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const map = new Map([
["hostPorts.host", "localhost*localhost*localhost"],
["hostPorts.port", "8080*8080*8080"]
])
- const result = yield* $(ConfigProvider.fromMap(map, { seqDelim: "*" }).load(hostPortsConfig))
- assert.deepStrictEqual(result, {
+ const result = yield* ConfigProvider.fromMap(map, { seqDelim: "*" }).load(hostPortsConfig)
+ deepStrictEqual(result, {
hostPorts: Array.from({ length: 3 }, () => ({ host: "localhost", port: 8080 }))
})
}))
it.effect("top-level list with different number of elements per key fails", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const map = new Map([
["hostPorts.host", "localhost"],
["hostPorts.port", "8080,8080,8080"]
])
- const result = yield* $(Effect.exit(provider(map).load(hostPortsConfig)))
- assert.deepStrictEqual(
+ const result = yield* Effect.exit(provider(map).load(hostPortsConfig))
+ deepStrictEqual(
result,
Exit.fail(
ConfigError.MissingData(
@@ -205,7 +208,7 @@ describe("ConfigProvider", () => {
}))
it.effect("flat atoms of different types", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const map = new Map([
["date", "2022-10-28"],
["open", "98.8"],
@@ -214,8 +217,8 @@ describe("ConfigProvider", () => {
["high", "151.5"],
["volume", "100091990"]
])
- const result = yield* $(provider(map).load(stockDayConfig))
- assert.deepStrictEqual(result, {
+ const result = yield* provider(map).load(stockDayConfig)
+ deepStrictEqual(result, {
date: new Date("2022-10-28"),
open: 98.8,
close: 150.0,
@@ -226,7 +229,7 @@ describe("ConfigProvider", () => {
}))
it.effect("tables", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const map = new Map([
["Effect.date", "2022-10-28"],
["Effect.open", "98.8"],
@@ -235,8 +238,8 @@ describe("ConfigProvider", () => {
["Effect.high", "151.5"],
["Effect.volume", "100091990"]
])
- const result = yield* $(provider(map).load(snp500Config))
- assert.deepStrictEqual(result, {
+ const result = yield* provider(map).load(snp500Config)
+ deepStrictEqual(result, {
stockDays: HashMap.make([
"Effect",
{
@@ -252,57 +255,57 @@ describe("ConfigProvider", () => {
}))
it.effect("empty tables", () =>
- Effect.gen(function*($) {
- const result = yield* $(provider(new Map()).load(snp500Config))
- assert.deepStrictEqual(result, { stockDays: HashMap.empty() })
+ Effect.gen(function*() {
+ const result = yield* provider(new Map()).load(snp500Config)
+ deepStrictEqual(result, { stockDays: HashMap.empty() })
}))
it.effect("collection of atoms", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const map = new Map([
["targets", "https://effect.website,https://github.com/Effect-TS"]
])
- const result = yield* $(provider(map).load(webScrapingTargetsConfig))
- assert.deepStrictEqual(result, {
+ const result = yield* provider(map).load(webScrapingTargetsConfig)
+ deepStrictEqual(result, {
targets: HashSet.make("https://effect.website", "https://github.com/Effect-TS")
})
}))
it.effect("collection of atoms falls back to default", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const map = new Map()
- const result = yield* $(provider(map).load(webScrapingTargetsConfigWithDefault))
- assert.deepStrictEqual(result, {
+ const result = yield* provider(map).load(webScrapingTargetsConfigWithDefault)
+ deepStrictEqual(result, {
targets: Chunk.make("https://effect.website2", "https://github.com/Effect-TS2")
})
}))
it.effect("indexed - simple", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const config = Config.array(Config.integer(), "id")
const map = new Map([
["id[0]", "1"],
["id[1]", "2"],
["id[2]", "3"]
])
- const result = yield* $(ConfigProvider.fromMap(map).load(config))
- expect(result).toEqual([1, 2, 3])
+ const result = yield* ConfigProvider.fromMap(map).load(config)
+ deepStrictEqual(result, [1, 2, 3])
}))
it.effect("indexed sequence - simple with list values", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const config = Config.array(Config.array(Config.integer()), "id")
const map = new Map([
["id[0]", "1, 2"],
["id[1]", "3, 4"],
["id[2]", "5, 6"]
])
- const result = yield* $(ConfigProvider.fromMap(map).load(config))
- expect(result).toEqual([[1, 2], [3, 4], [5, 6]])
+ const result = yield* ConfigProvider.fromMap(map).load(config)
+ deepStrictEqual(result, [[1, 2], [3, 4], [5, 6]])
}))
it.effect("indexed sequence - one product type", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const config = Config.array(
Config.all({
age: Config.integer("age"),
@@ -314,12 +317,12 @@ describe("ConfigProvider", () => {
["employees[0].age", "1"],
["employees[0].id", "1"]
])
- const result = yield* $(ConfigProvider.fromMap(map).load(config))
- expect(result).toEqual([{ age: 1, id: 1 }])
+ const result = yield* ConfigProvider.fromMap(map).load(config)
+ deepStrictEqual(result, [{ age: 1, id: 1 }])
}))
it.effect("indexed sequence - multiple product types", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const config = Config.array(
Config.all({
age: Config.integer("age"),
@@ -333,12 +336,12 @@ describe("ConfigProvider", () => {
["employees[1].age", "3"],
["employees[1].id", "4"]
])
- const result = yield* $(ConfigProvider.fromMap(map).load(config))
- expect(result).toEqual([{ age: 1, id: 2 }, { age: 3, id: 4 }])
+ const result = yield* ConfigProvider.fromMap(map).load(config)
+ deepStrictEqual(result, [{ age: 1, id: 2 }, { age: 3, id: 4 }])
}))
it.effect("indexed sequence - multiple product types with missing fields", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const config = Config.array(
Config.all({
age: Config.integer("age"),
@@ -352,10 +355,8 @@ describe("ConfigProvider", () => {
["employees[1].age", "3"],
["employees[1]", "4"]
])
- const result = yield* $(
- Effect.exit(ConfigProvider.fromMap(map).load(config))
- )
- assert.isTrue(
+ const result = yield* Effect.exit(ConfigProvider.fromMap(map).load(config))
+ assertTrue(
Exit.isFailure(result) &&
Cause.isFailType(result.effect_instruction_i0) &&
ConfigError.isMissingData(result.effect_instruction_i0.error) &&
@@ -369,7 +370,7 @@ describe("ConfigProvider", () => {
}))
it.effect("indexed sequence - multiple product types with optional fields", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const config = Config.array(
Config.all({
age: Config.option(Config.integer("age")),
@@ -382,12 +383,12 @@ describe("ConfigProvider", () => {
["employees[0].id", "2"],
["employees[1].id", "4"]
])
- const result = yield* $(ConfigProvider.fromMap(map).load(config))
- expect(result).toEqual([{ age: Option.some(1), id: 2 }, { age: Option.none(), id: 4 }])
+ const result = yield* ConfigProvider.fromMap(map).load(config)
+ deepStrictEqual(result, [{ age: Option.some(1), id: 2 }, { age: Option.none(), id: 4 }])
}))
it.effect("indexed sequence - multiple product types with sequence fields", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const config = Config.array(
Config.all({
refunds: Config.array(Config.integer(), "refunds"),
@@ -401,12 +402,12 @@ describe("ConfigProvider", () => {
["employees[1].id", "1"],
["employees[1].refunds", "4,5,6"]
])
- const result = yield* $(ConfigProvider.fromMap(map).load(config))
- expect(result).toEqual([{ refunds: [1, 2, 3], id: 0 }, { refunds: [4, 5, 6], id: 1 }])
+ const result = yield* ConfigProvider.fromMap(map).load(config)
+ deepStrictEqual(result, [{ refunds: [1, 2, 3], id: 0 }, { refunds: [4, 5, 6], id: 1 }])
}))
it.effect("indexed sequence - product type of indexed sequences with reusable config", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const idAndAge = Config.all({
id: Config.integer("id"),
age: Config.integer("age")
@@ -425,15 +426,15 @@ describe("ConfigProvider", () => {
["students[0].age", "2"],
["students[1].age", "3"]
])
- const result = yield* $(ConfigProvider.fromMap(map).load(config))
- expect(result).toEqual({
+ const result = yield* ConfigProvider.fromMap(map).load(config)
+ deepStrictEqual(result, {
employees: [{ id: 0, age: 10 }, { id: 1, age: 11 }],
students: [{ id: 20, age: 2 }, { id: 30, age: 3 }]
})
}))
it.effect("indexed sequence - map of indexed sequences", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const employee = Config.all({
age: Config.integer("age"),
id: Config.integer("id")
@@ -449,16 +450,16 @@ describe("ConfigProvider", () => {
["departments.department2.employees[1].age", "20"],
["departments.department2.employees[1].id", "1"]
])
- const result = yield* $(ConfigProvider.fromMap(map).load(config))
+ const result = yield* ConfigProvider.fromMap(map).load(config)
const expectedEmployees = [{ age: 10, id: 0 }, { age: 20, id: 1 }]
- expect(Array.from(result)).toEqual([
+ deepStrictEqual(Array.from(result), [
["department1", expectedEmployees],
["department2", expectedEmployees]
])
}))
it.effect("indexed sequence - map", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const employee = Config.hashMap(Config.integer(), "details")
const config = Config.array(employee, "employees")
const map = new Map([
@@ -467,15 +468,15 @@ describe("ConfigProvider", () => {
["employees[1].details.age", "20"],
["employees[1].details.id", "1"]
])
- const result = yield* $(ConfigProvider.fromMap(map).load(config))
- expect(result.map((table) => Array.from(table))).toEqual([
+ const result = yield* ConfigProvider.fromMap(map).load(config)
+ deepStrictEqual(result.map((table) => Array.from(table)), [
[["age", 10], ["id", 0]],
[["age", 20], ["id", 1]]
])
}))
it.effect("indexed sequence - indexed sequences", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const employee = Config.all({
age: Config.integer("age"),
id: Config.integer("id")
@@ -492,13 +493,13 @@ describe("ConfigProvider", () => {
["departments[1].employees[1].age", "20"],
["departments[1].employees[1].id", "1"]
])
- const result = yield* $(ConfigProvider.fromMap(map).load(config))
+ const result = yield* ConfigProvider.fromMap(map).load(config)
const expectedEmployees = [{ age: 10, id: 0 }, { age: 20, id: 1 }]
- expect(result).toEqual([expectedEmployees, expectedEmployees])
+ deepStrictEqual(result, [expectedEmployees, expectedEmployees])
}))
it.effect("indexed sequence - multiple product types nested", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const employee = Config.all({
age: Config.integer("age"),
id: Config.integer("id")
@@ -514,12 +515,12 @@ describe("ConfigProvider", () => {
ConfigProvider.nested("child"),
ConfigProvider.nested("parent")
)
- const result = yield* $(provider.load(config))
- expect(result).toEqual([{ age: 1, id: 2 }, { age: 3, id: 4 }])
+ const result = yield* provider.load(config)
+ deepStrictEqual(result, [{ age: 1, id: 2 }, { age: 3, id: 4 }])
}))
it.effect("indexed sequence - multiple product types unnested", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const employee = Config.all({
age: Config.integer("age"),
id: Config.integer("id")
@@ -538,28 +539,28 @@ describe("ConfigProvider", () => {
ConfigProvider.unnested("parent"),
ConfigProvider.unnested("child")
)
- const result = yield* $(provider.load(config))
- expect(result).toEqual([{ age: 1, id: 2 }, { age: 3, id: 4 }])
+ const result = yield* provider.load(config)
+ deepStrictEqual(result, [{ age: 1, id: 2 }, { age: 3, id: 4 }])
}))
it.effect("logLevel", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const config = Config.logLevel("level")
const map = new Map([["level", "ERROR"]])
- const result = yield* $(ConfigProvider.fromMap(map).load(config))
- expect(result).toEqual(LogLevel.Error)
+ const result = yield* ConfigProvider.fromMap(map).load(config)
+ strictEqual(result, LogLevel.Error)
}))
it.effect("accessing a non-existent key fails", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const map = new Map([
["k1.k3", "v"]
])
const config = Config.string("k2").pipe(
Config.nested("k1")
)
- const result = yield* $(Effect.exit(provider(map).load(config)))
- assert.deepStrictEqual(
+ const result = yield* Effect.exit(provider(map).load(config))
+ deepStrictEqual(
result,
Exit.fail(
ConfigError.MissingData(
@@ -571,64 +572,64 @@ describe("ConfigProvider", () => {
}))
it.effect("values are not split unless a sequence is expected", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const configProvider = ConfigProvider.fromMap(new Map([["greeting", "Hello, World!"]]))
- const result = yield* $(configProvider.load(Config.string("greeting")))
- assert.strictEqual(result, "Hello, World!")
+ const result = yield* configProvider.load(Config.string("greeting"))
+ strictEqual(result, "Hello, World!")
}))
it.effect("constantCase", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const configProvider = ConfigProvider.fromMap(new Map([["CONSTANT_CASE", "value"]])).pipe(
ConfigProvider.constantCase
)
- const result = yield* $(configProvider.load(Config.string("constant.case")))
- assert.strictEqual(result, "value")
+ const result = yield* configProvider.load(Config.string("constant.case"))
+ strictEqual(result, "value")
}))
it.effect("mapInputPath", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const configProvider = ConfigProvider.fromMap(new Map([["KEY", "VALUE"]])).pipe(
ConfigProvider.mapInputPath((path) => path.toUpperCase())
)
- const result = yield* $(configProvider.load(Config.string("key")))
- assert.strictEqual(result, "VALUE")
+ const result = yield* configProvider.load(Config.string("key"))
+ strictEqual(result, "VALUE")
}))
it.effect("kebabCase", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const configProvider = ConfigProvider.fromMap(new Map([["kebab-case", "value"]])).pipe(
ConfigProvider.kebabCase
)
- const result = yield* $(configProvider.load(Config.string("kebabCase")))
- assert.strictEqual(result, "value")
+ const result = yield* configProvider.load(Config.string("kebabCase"))
+ strictEqual(result, "value")
}))
it.effect("lowerCase", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const configProvider = ConfigProvider.fromMap(new Map([["lowercase", "value"]])).pipe(
ConfigProvider.lowerCase
)
- const result = yield* $(configProvider.load(Config.string("lowerCase")))
- assert.strictEqual(result, "value")
+ const result = yield* configProvider.load(Config.string("lowerCase"))
+ strictEqual(result, "value")
}))
it.effect("nested", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const configProvider1 = ConfigProvider.fromMap(new Map([["nested.key", "value"]]))
const config1 = Config.string("key").pipe(Config.nested("nested"))
const configProvider2 = ConfigProvider.fromMap(new Map([["nested.key", "value"]])).pipe(
ConfigProvider.nested("nested")
)
const config2 = Config.string("key")
- const result1 = yield* $(configProvider1.load(config1))
- const result2 = yield* $(configProvider2.load(config2))
- assert.strictEqual(result1, "value")
- assert.strictEqual(result2, "value")
+ const result1 = yield* configProvider1.load(config1)
+ const result2 = yield* configProvider2.load(config2)
+ strictEqual(result1, "value")
+ strictEqual(result2, "value")
}))
it.effect("nested - multiple layers of nesting", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const configProvider1 = ConfigProvider.fromMap(new Map([["parent.child.key", "value"]]))
const config1 = Config.string("key").pipe(
Config.nested("child"),
@@ -639,14 +640,14 @@ describe("ConfigProvider", () => {
ConfigProvider.nested("parent")
)
const config2 = Config.string("key")
- const result1 = yield* $(configProvider1.load(config1))
- const result2 = yield* $(configProvider2.load(config2))
- assert.strictEqual(result1, "value")
- assert.strictEqual(result2, "value")
+ const result1 = yield* configProvider1.load(config1)
+ const result2 = yield* configProvider2.load(config2)
+ strictEqual(result1, "value")
+ strictEqual(result2, "value")
}))
it.effect("orElse - with flat data", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const configProvider = ConfigProvider.fromMap(
new Map([
["key1", "value1"],
@@ -662,24 +663,27 @@ describe("ConfigProvider", () => {
)
)
)
- const result1 = yield* $(configProvider.load(Config.string("key1")))
- const result2 = yield* $(configProvider.load(Config.string("key2")))
- const result31 = yield* $(configProvider.load(Config.option(Config.string("key3"))))
- const result32 = yield* $(Effect.either(configProvider.load(Config.string("key3"))))
- const result4 = yield* $(configProvider.load(Config.string("key4")))
+ const result1 = yield* configProvider.load(Config.string("key1"))
+ const result2 = yield* configProvider.load(Config.string("key2"))
+ const result31 = yield* configProvider.load(Config.option(Config.string("key3")))
+ const result32 = yield* Effect.either(configProvider.load(Config.string("key3")))
+ const result4 = yield* configProvider.load(Config.string("key4"))
- expect(result1).toBe("value1")
- expect(result2).toBe("value2")
- expect(result31).toEqual(Option.none())
- expect(result32).toEqual(Either.left(ConfigError.Or(
- ConfigError.MissingData(["key3"], "Expected key3 to exist in the provided map"),
- ConfigError.MissingData(["key3"], "Expected key3 to exist in the provided map")
- )))
- expect(result4).toBe("value41")
+ strictEqual(result1, "value1")
+ strictEqual(result2, "value2")
+ assertNone(result31)
+ deepStrictEqual(
+ result32,
+ Either.left(ConfigError.Or(
+ ConfigError.MissingData(["key3"], "Expected key3 to exist in the provided map"),
+ ConfigError.MissingData(["key3"], "Expected key3 to exist in the provided map")
+ ))
+ )
+ strictEqual(result4, "value41")
}))
it.effect("orElse - with indexed sequences", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const configProvider = ConfigProvider.fromMap(
new Map([
["parent1.child.employees[0].age", "1"],
@@ -707,15 +711,15 @@ describe("ConfigProvider", () => {
const config1 = arrayConfig.pipe(Config.nested("child"), Config.nested("parent1"))
const config2 = arrayConfig.pipe(Config.nested("child"), Config.nested("parent2"))
- const result1 = yield* $(configProvider.load(config1))
- const result2 = yield* $(configProvider.load(config2))
+ const result1 = yield* configProvider.load(config1)
+ const result2 = yield* configProvider.load(config2)
- expect(result1).toEqual([[1, 2], [3, 4], [5, 6]])
- expect(result2).toEqual([[11, 21], [31, 41]])
+ deepStrictEqual(result1, [[1, 2], [3, 4], [5, 6]])
+ deepStrictEqual(result2, [[11, 21], [31, 41]])
}))
it.effect("orElse - with indexed sequences and each provider unnested", () =>
- Effect.gen(function*(_) {
+ Effect.gen(function*() {
const configProvider = ConfigProvider.fromMap(
new Map([
["employees[0].age", "1"],
@@ -747,26 +751,29 @@ describe("ConfigProvider", () => {
const config2 = arrayConfig.pipe(Config.nested("child"), Config.nested("parent2"))
const config3 = arrayConfig.pipe(Config.nested("child"), Config.nested("parent3"))
- const result1 = yield* _(configProvider.load(config1))
- const result2 = yield* _(configProvider.load(config2))
- const result3 = yield* _(Effect.either(configProvider.load(config3)))
+ const result1 = yield* configProvider.load(config1)
+ const result2 = yield* configProvider.load(config2)
+ const result3 = yield* Effect.either(configProvider.load(config3))
- expect(result1).toEqual([[1, 2], [3, 4]])
- expect(result2).toEqual([[11, 21], [31, 41]])
- expect(result3).toEqual(Either.left(ConfigError.And(
- ConfigError.MissingData(
- ["parent3", "child", "employees"],
- "Expected parent1 to be in path in ConfigProvider#unnested"
- ),
- ConfigError.MissingData(
- ["parent3", "child", "employees"],
- "Expected parent2 to be in path in ConfigProvider#unnested"
- )
- )))
+ deepStrictEqual(result1, [[1, 2], [3, 4]])
+ deepStrictEqual(result2, [[11, 21], [31, 41]])
+ deepStrictEqual(
+ result3,
+ Either.left(ConfigError.And(
+ ConfigError.MissingData(
+ ["parent3", "child", "employees"],
+ "Expected parent1 to be in path in ConfigProvider#unnested"
+ ),
+ ConfigError.MissingData(
+ ["parent3", "child", "employees"],
+ "Expected parent2 to be in path in ConfigProvider#unnested"
+ )
+ ))
+ )
}))
it.effect("orElse - with index sequences and combined provider unnested", () =>
- Effect.gen(function*(_) {
+ Effect.gen(function*() {
const configProvider = ConfigProvider.fromMap(
new Map([
["employees[0].age", "1"],
@@ -789,44 +796,44 @@ describe("ConfigProvider", () => {
const arrayConfig = Config.array(product, "employees")
const config = arrayConfig.pipe(Config.nested("child"), Config.nested("parent1"))
- const result = yield* _(configProvider.load(config))
+ const result = yield* configProvider.load(config)
- expect(result).toEqual([[1, 2], [3, 4]])
+ deepStrictEqual(result, [[1, 2], [3, 4]])
}))
it.effect("secret", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const value = "Hello, World!"
const configProvider = ConfigProvider.fromMap(new Map([["greeting", value]]))
- const result = yield* $(configProvider.load(Config.secret("greeting")))
- assert.deepStrictEqual(result, Secret.make(value.split("").map((c) => c.charCodeAt(0))))
+ const result = yield* configProvider.load(Config.secret("greeting"))
+ deepStrictEqual(result, Secret.make(value.split("").map((c) => c.charCodeAt(0))))
}))
it.effect("snakeCase", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const configProvider = ConfigProvider.fromMap(new Map([["snake_case", "value"]])).pipe(
ConfigProvider.snakeCase
)
- const result = yield* $(configProvider.load(Config.string("snakeCase")))
- assert.strictEqual(result, "value")
+ const result = yield* configProvider.load(Config.string("snakeCase"))
+ strictEqual(result, "value")
}))
it.effect("unnested", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const configProvider1 = ConfigProvider.fromMap(new Map([["key", "value"]]))
const config1 = Config.string("key")
const configProvider2 = ConfigProvider.fromMap(new Map([["key", "value"]])).pipe(
ConfigProvider.unnested("nested")
)
const config2 = Config.string("key").pipe(Config.nested("nested"))
- const result1 = yield* $(configProvider1.load(config1))
- const result2 = yield* $(configProvider2.load(config2))
- assert.strictEqual(result1, "value")
- assert.strictEqual(result2, "value")
+ const result1 = yield* configProvider1.load(config1)
+ const result2 = yield* configProvider2.load(config2)
+ strictEqual(result1, "value")
+ strictEqual(result2, "value")
}))
it.effect("unnested - multiple layers of nesting", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const configProvider1 = ConfigProvider.fromMap(new Map([["key", "value"]]))
const config1 = Config.string("key")
const configProvider2 = ConfigProvider.fromMap(new Map([["key", "value"]])).pipe(
@@ -837,37 +844,37 @@ describe("ConfigProvider", () => {
Config.nested("child"),
Config.nested("parent")
)
- const result1 = yield* $(configProvider1.load(config1))
- const result2 = yield* $(configProvider2.load(config2))
- assert.strictEqual(result1, "value")
- assert.strictEqual(result2, "value")
+ const result1 = yield* configProvider1.load(config1)
+ const result2 = yield* configProvider2.load(config2)
+ strictEqual(result1, "value")
+ strictEqual(result2, "value")
}))
it.effect("unnested - failure", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const configProvider = ConfigProvider.fromMap(new Map([["key", "value"]])).pipe(
ConfigProvider.unnested("nested")
)
const config = Config.string("key")
- const result = yield* $(Effect.exit(configProvider.load(config)))
+ const result = yield* Effect.exit(configProvider.load(config))
const error = ConfigError.MissingData(
["key"],
"Expected nested to be in path in ConfigProvider#unnested"
)
- assert.deepStrictEqual(result, Exit.fail(error))
+ deepStrictEqual(result, Exit.fail(error))
}))
it.effect("upperCase", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const configProvider = ConfigProvider.fromMap(new Map([["UPPERCASE", "value"]])).pipe(
ConfigProvider.upperCase
)
- const result = yield* $(configProvider.load(Config.string("upperCase")))
- assert.strictEqual(result, "value")
+ const result = yield* configProvider.load(Config.string("upperCase"))
+ strictEqual(result, "value")
}))
it.effect("within", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const configProvider = ConfigProvider.fromMap(new Map([["nesting1.key1", "value1"], ["nesting2.KEY2", "value2"]]))
.pipe(
ConfigProvider.within(["nesting2"], ConfigProvider.mapInputPath((s) => s.toUpperCase()))
@@ -880,12 +887,12 @@ describe("ConfigProvider", () => {
)
)
)
- const result = yield* $(configProvider.load(config))
- assert.deepStrictEqual(result, ["value1", "value2"])
+ const result = yield* configProvider.load(config)
+ deepStrictEqual(result, ["value1", "value2"])
}))
it.effect("within - multiple layers of nesting", () =>
- Effect.gen(function*($) {
+ Effect.gen(function*() {
const configProvider = ConfigProvider.fromMap(
new Map([["nesting1.key1", "value1"], ["nesting2.nesting3.KEY2", "value2"]])
).pipe(
@@ -900,41 +907,37 @@ describe("ConfigProvider", () => {
)
)
)
- const result = yield* $(configProvider.load(config))
- assert.deepStrictEqual(result, ["value1", "value2"])
+ const result = yield* configProvider.load(config)
+ deepStrictEqual(result, ["value1", "value2"])
}))
it.effect("fromJson - should load configs from flat JSON", () =>
- Effect.gen(function*($) {
- const result = yield* $(
- ConfigProvider.fromJson({
- host: "localhost",
- port: 8080
- }).load(hostPortConfig)
- )
- assert.deepStrictEqual(result, {
+ Effect.gen(function*() {
+ const result = yield* ConfigProvider.fromJson({
+ host: "localhost",
+ port: 8080
+ }).load(hostPortConfig)
+ deepStrictEqual(result, {
host: "localhost",
port: 8080
})
}))
it.effect("fromJson - should load configs from nested JSON", () =>
- Effect.gen(function*($) {
- const result = yield* $(
- ConfigProvider.fromJson({
- hostPorts: [{
- host: "localhost",
- port: 8080
- }, {
- host: "localhost",
- port: 8080
- }, {
- host: "localhost",
- port: 8080
- }]
- }).load(hostPortsConfig)
- )
- assert.deepStrictEqual(result, {
+ Effect.gen(function*() {
+ const result = yield* ConfigProvider.fromJson({
+ hostPorts: [{
+ host: "localhost",
+ port: 8080
+ }, {
+ host: "localhost",
+ port: 8080
+ }, {
+ host: "localhost",
+ port: 8080
+ }]
+ }).load(hostPortsConfig)
+ deepStrictEqual(result, {
hostPorts: Array.from({ length: 3 }, () => ({ host: "localhost", port: 8080 }))
})
}))
diff --git a/packages/effect/test/Context.test.ts b/packages/effect/test/Context.test.ts
index 4641921879e..54ee7f98d30 100644
--- a/packages/effect/test/Context.test.ts
+++ b/packages/effect/test/Context.test.ts
@@ -1,8 +1,6 @@
-import * as Context from "effect/Context"
-import * as Differ from "effect/Differ"
-import { pipe } from "effect/Function"
-import * as O from "effect/Option"
-import { assert, describe, expect, it } from "vitest"
+import { Context, Differ, Option, pipe } from "effect"
+import { assertFalse, assertNone, assertSome, assertTrue, deepStrictEqual, strictEqual, throws } from "effect/test/util"
+import { describe, it } from "vitest"
interface A {
a: number
@@ -26,24 +24,59 @@ class E extends Context.Reference()("E", {
}) {}
describe("Context", () => {
+ it("error messages", () => {
+ throws(() => {
+ Context.unsafeGet(Context.empty(), A)
+ }, (e) => e instanceof Error && e.message.includes("Service not found: A"))
+ throws(() => {
+ Context.get(Context.empty(), A as never)
+ }, (e) => e instanceof Error && e.message.includes("Service not found: A"))
+ throws(() => {
+ Context.unsafeGet(Context.empty(), C)
+ }, (e) => e instanceof Error && e.message.includes("Service not found: C"))
+ throws(() => {
+ Context.get(Context.empty(), C as never)
+ }, (e) => e instanceof Error && e.message.includes("Service not found: C"))
+ if (typeof window === "undefined") {
+ throws(
+ () => {
+ Context.get(Context.empty(), C as never)
+ },
+ (e) => {
+ return e instanceof Error &&
+ new RegExp(/Service not found: C \(defined at (.*)Context.test.ts:18:19\)/).test(e.message)
+ }
+ )
+ throws(
+ () => {
+ Context.get(Context.empty(), D as never)
+ },
+ (e) => {
+ return e instanceof Error &&
+ new RegExp(/Service not found: D \(defined at (.*)Context.test.ts:20:32\)/).test(e.message)
+ }
+ )
+ }
+ })
+
it("Tag.toJson()", () => {
const json: any = A.toJSON()
- expect(json["_id"]).toEqual("Tag")
- expect(json["key"]).toEqual("A")
- expect(typeof json["stack"]).toEqual("string")
+ strictEqual(json["_id"], "Tag")
+ strictEqual(json["key"], "A")
+ strictEqual(typeof json["stack"], "string")
})
it("TagClass.toJson()", () => {
const json: any = D.toJSON()
- expect(json["_id"]).toEqual("Tag")
- expect(json["key"]).toEqual("D")
- expect(typeof json["stack"]).toEqual("string")
+ strictEqual(json["_id"], "Tag")
+ strictEqual(json["key"], "D")
+ strictEqual(typeof json["stack"], "string")
})
it("Context.toJson()", () => {
const json: any = Context.empty().toJSON()
- expect(json["_id"]).toEqual("Context")
- expect(json["services"]).toEqual([])
+ strictEqual(json["_id"], "Context")
+ deepStrictEqual(json["services"], [])
})
it("aliased tags", () => {
@@ -58,7 +91,7 @@ describe("Context", () => {
}
const Service = Context.GenericTag("FooBar")
const context = Context.make(Service, { _tag: "Foo" })
- expect(Context.get(context, Service)).toStrictEqual({ _tag: "Foo" })
+ deepStrictEqual(Context.get(context, Service), { _tag: "Foo" })
})
it("adds and retrieve services", () => {
@@ -68,34 +101,18 @@ describe("Context", () => {
Context.add(D, { d: 2 })
)
- expect(Context.get(Services, A)).toEqual({ a: 0 })
-
- expect(pipe(
- Services,
- Context.getOption(B)
- )).toEqual(O.some({ b: 1 }))
-
- expect(pipe(
- Services,
- Context.get(D)
- )).toEqual({ d: 2 })
+ deepStrictEqual(Context.get(Services, A), { a: 0 })
+ assertSome(pipe(Services, Context.getOption(B)), { b: 1 })
+ deepStrictEqual(pipe(Services, Context.get(D)), { d: 2 })
+ assertNone(pipe(Services, Context.getOption(C)))
+ deepStrictEqual(pipe(Services, Context.get(E)), { e: 0 })
- expect(pipe(
- Services,
- Context.getOption(C)
- )).toEqual(O.none())
-
- expect(pipe(
- Services,
- Context.get(E)
- )).toEqual({ e: 0 })
-
- assert.throw(() => {
+ throws(() => {
pipe(
Services,
Context.unsafeGet(C)
)
- }, "Service not found: C")
+ }, (e) => e instanceof Error && e.message.includes("Service not found: C"))
})
it("picks services in env and merges", () => {
@@ -114,25 +131,10 @@ describe("Context", () => {
Context.pick(A, B)
)
- expect(pipe(
- pruned,
- Context.get(A)
- )).toEqual({ a: 0 })
-
- expect(pipe(
- pruned,
- Context.getOption(B)
- )).toEqual(O.some({ b: 1 }))
-
- expect(pipe(
- pruned,
- Context.getOption(C)
- )).toEqual(O.none())
-
- expect(pipe(
- env,
- Context.getOption(C)
- )).toEqual(O.some({ c: 2 }))
+ deepStrictEqual(pipe(pruned, Context.get(A)), { a: 0 })
+ assertSome(pipe(pruned, Context.getOption(B)), { b: 1 })
+ assertNone(pipe(pruned, Context.getOption(C)))
+ assertSome(pipe(env, Context.getOption(C)), { c: 2 })
})
it("omits services from env", () => {
@@ -151,15 +153,8 @@ describe("Context", () => {
Context.omit(A, B)
)
- expect(pipe(
- pruned,
- Context.getOption(A)
- )).toEqual(O.none())
-
- expect(pipe(
- env,
- Context.get(C)
- )).toEqual({ c: 2 })
+ assertNone(pipe(pruned, Context.getOption(A)))
+ deepStrictEqual(pipe(env, Context.get(C)), { c: 2 })
})
it("applies a patch to the environment", () => {
@@ -181,10 +176,10 @@ describe("Context", () => {
const patch = differ.diff(oldEnv, newEnv)
const result = differ.patch(patch, oldEnv)
- assert.isTrue(O.isSome(Context.getOption(A)(result)))
- assert.isTrue(O.isSome(Context.getOption(B)(result)))
- assert.isTrue(O.isNone(Context.getOption(C)(result)))
- assert.strictEqual(pipe(result, Context.get(B)).b, 3)
+ assertTrue(Option.isSome(Context.getOption(A)(result)))
+ assertTrue(Option.isSome(Context.getOption(B)(result)))
+ assertTrue(Option.isNone(Context.getOption(C)(result)))
+ strictEqual(pipe(result, Context.get(B)).b, 3)
})
it("creates a proper diff", () => {
@@ -203,57 +198,24 @@ describe("Context", () => {
Context.add(B, { b: 3 })
) as Context.Context
const differ = Differ.environment()
- const result = differ.diff(oldEnv, newEnv)
+ const result: any = differ.diff(oldEnv, newEnv)
- assert.deepNestedPropertyVal(result, "first._tag", "AndThen")
- assert.deepNestedPropertyVal(result, "first.first._tag", "Empty")
- assert.deepNestedPropertyVal(result, "first.second._tag", "UpdateService")
- assert.deepNestedPropertyVal(result, "first.second.key", B.key)
- assert.deepNestedPropertyVal(result, "second._tag", "RemoveService")
- assert.deepNestedPropertyVal(result, "second.key", C.key)
- })
-
- it("error messages", () => {
- assert.throw(() => {
- Context.unsafeGet(Context.empty(), A)
- }, "Service not found")
- assert.throw(() => {
- Context.get(Context.empty(), A as never)
- }, "Service not found")
- assert.throw(() => {
- Context.unsafeGet(Context.empty(), C)
- }, "Service not found: C")
- assert.throw(() => {
- Context.get(Context.empty(), C as never)
- }, "Service not found: C")
- if (typeof window === "undefined") {
- try {
- Context.get(Context.empty(), C as never)
- } catch (e) {
- assert.match(
- String(e),
- new RegExp(/Error: Service not found: C \(defined at (.*)Context.test.ts:20:19\)/)
- )
- }
- try {
- Context.get(Context.empty(), D as never)
- } catch (e) {
- assert.match(
- String(e),
- new RegExp(/Error: Service not found: D \(defined at (.*)Context.test.ts:22:32\)/)
- )
- }
- }
+ strictEqual(result.first._tag, "AndThen")
+ strictEqual(result.first.first._tag, "Empty")
+ strictEqual(result.first.second._tag, "UpdateService")
+ strictEqual(result.first.second.key, B.key)
+ strictEqual(result.second._tag, "RemoveService")
+ strictEqual(result.second.key, C.key)
})
it("pipe()", () => {
const result = Context.empty().pipe(Context.add(A, { a: 0 }))
- expect(result.pipe(Context.get(A))).toEqual({ a: 0 })
+ deepStrictEqual(result.pipe(Context.get(A)), { a: 0 })
})
it("tag pipe", () => {
const result = A.pipe((tag) => Context.make(tag, { a: 0 }))
- expect(result.pipe(Context.get(A))).toEqual({ a: 0 })
+ deepStrictEqual(result.pipe(Context.get(A)), { a: 0 })
})
it("mergeAll", () => {
@@ -268,39 +230,24 @@ describe("Context", () => {
Context.pick(A, B)
)
- expect(pipe(
- pruned,
- Context.get(A)
- )).toEqual({ a: 0 })
-
- expect(pipe(
- pruned,
- Context.getOption(B)
- )).toEqual(O.some({ b: 1 }))
-
- expect(pipe(
- pruned,
- Context.getOption(C)
- )).toEqual(O.none())
-
- expect(pipe(
- env,
- Context.getOption(C)
- )).toEqual(O.some({ c: 2 }))
+ deepStrictEqual(pipe(pruned, Context.get(A)), { a: 0 })
+ assertSome(pipe(pruned, Context.getOption(B)), { b: 1 })
+ assertNone(pipe(pruned, Context.getOption(C)))
+ assertSome(pipe(env, Context.getOption(C)), { c: 2 })
})
it("isContext", () => {
- expect(Context.isContext(Context.empty())).toEqual(true)
- expect(Context.isContext(null)).toEqual(false)
+ assertTrue(Context.isContext(Context.empty()))
+ assertFalse(Context.isContext(null))
})
it("isTag", () => {
- expect(Context.isTag(Context.GenericTag("Demo"))).toEqual(true)
- expect(Context.isContext(null)).toEqual(false)
+ assertTrue(Context.isTag(Context.GenericTag("Demo")))
+ assertFalse(Context.isContext(null))
})
it("isReference", () => {
- expect(Context.isTag(E)).toEqual(true)
- expect(Context.isReference(E)).toEqual(true)
+ assertTrue(Context.isTag(E))
+ assertTrue(Context.isReference(E))
})
})
diff --git a/packages/effect/test/Cron.test.ts b/packages/effect/test/Cron.test.ts
index 7ee935b644d..2e4e3bd3f79 100644
--- a/packages/effect/test/Cron.test.ts
+++ b/packages/effect/test/Cron.test.ts
@@ -1,17 +1,12 @@
-import * as Cron from "effect/Cron"
-import * as DateTime from "effect/DateTime"
-import * as Either from "effect/Either"
-import * as Equal from "effect/Equal"
-import { identity } from "effect/Function"
-import * as Option from "effect/Option"
-import { assertFalse, assertTrue, deepStrictEqual } from "effect/test/util"
-import { describe, expect, it } from "vitest"
-
-const parse = (input: string, tz?: DateTime.TimeZone | string) => Either.getOrThrowWith(Cron.parse(input, tz), identity)
+import { Cron, DateTime, Either, Equal, Option } from "effect"
+import { assertFalse, assertTrue, deepStrictEqual, throws } from "effect/test/util"
+import { describe, it } from "vitest"
+
const match = (input: Cron.Cron | string, date: DateTime.DateTime.Input) =>
- Cron.match(Cron.isCron(input) ? input : parse(input), date)
+ Cron.match(Cron.isCron(input) ? input : Cron.unsafeParse(input), date)
+
const next = (input: Cron.Cron | string, after?: DateTime.DateTime.Input) =>
- Cron.next(Cron.isCron(input) ? input : parse(input), after)
+ Cron.next(Cron.isCron(input) ? input : Cron.unsafeParse(input), after)
describe("Cron", () => {
it("parse", () => {
@@ -51,8 +46,14 @@ describe("Cron", () => {
})
it("unsafeParse", () => {
- expect(() => Cron.unsafeParse("")).toThrow(new Error("Invalid number of segments in cron expression"))
- expect(() => Cron.unsafeParse("0 0 4 8-14 * *", "")).toThrow(new Error("Invalid time zone in cron expression"))
+ throws(
+ () => Cron.unsafeParse(""),
+ new Cron.ParseError({ message: "Invalid number of segments in cron expression", input: "" })
+ )
+ throws(
+ () => Cron.unsafeParse("0 0 4 8-14 * *", ""),
+ new Cron.ParseError({ message: "Invalid time zone in cron expression", input: "" })
+ )
})
it("match", () => {
@@ -96,8 +97,8 @@ describe("Cron", () => {
adjustForTimeZone: true
})
- assertTrue(match(parse("15 14 1 * *", london), londonTime))
- assertTrue(match(parse("15 14 1 * *", london), amsterdamTime))
+ assertTrue(match(Cron.unsafeParse("15 14 1 * *", london), londonTime))
+ assertTrue(match(Cron.unsafeParse("15 14 1 * *", london), amsterdamTime))
})
it("next", () => {
@@ -121,13 +122,13 @@ describe("Cron", () => {
adjustForTimeZone: true
})
- deepStrictEqual(next(parse("5 0 8 2 *", london), after), DateTime.toDateUtc(londonTime))
- deepStrictEqual(next(parse("5 0 8 2 *", london), after), DateTime.toDateUtc(amsterdamTime))
+ deepStrictEqual(next(Cron.unsafeParse("5 0 8 2 *", london), after), DateTime.toDateUtc(londonTime))
+ deepStrictEqual(next(Cron.unsafeParse("5 0 8 2 *", london), after), DateTime.toDateUtc(amsterdamTime))
})
it("sequence", () => {
const start = new Date("2024-01-01 00:00:00")
- const generator = Cron.sequence(parse("23 0-20/2 * * 0"), start)
+ const generator = Cron.sequence(Cron.unsafeParse("23 0-20/2 * * 0"), start)
deepStrictEqual(generator.next().value, new Date("2024-01-07 00:23:00"))
deepStrictEqual(generator.next().value, new Date("2024-01-07 02:23:00"))
deepStrictEqual(generator.next().value, new Date("2024-01-07 04:23:00"))
@@ -136,12 +137,12 @@ describe("Cron", () => {
})
it("equal", () => {
- const cron = parse("23 0-20/2 * * 0")
+ const cron = Cron.unsafeParse("23 0-20/2 * * 0")
assertTrue(Equal.equals(cron, cron))
- assertTrue(Equal.equals(cron, parse("23 0-20/2 * * 0")))
- assertFalse(Equal.equals(cron, parse("23 0-20/2 * * 1")))
- assertFalse(Equal.equals(cron, parse("23 0-20/2 * * 0-6")))
- assertFalse(Equal.equals(cron, parse("23 0-20/2 1 * 0")))
+ assertTrue(Equal.equals(cron, Cron.unsafeParse("23 0-20/2 * * 0")))
+ assertFalse(Equal.equals(cron, Cron.unsafeParse("23 0-20/2 * * 1")))
+ assertFalse(Equal.equals(cron, Cron.unsafeParse("23 0-20/2 * * 0-6")))
+ assertFalse(Equal.equals(cron, Cron.unsafeParse("23 0-20/2 1 * 0")))
})
it("handles leap years", () => {
@@ -158,7 +159,7 @@ describe("Cron", () => {
it("handles transition into daylight savings time", () => {
const make = (date: string) => DateTime.makeZonedFromString(date).pipe(Option.getOrThrow)
const sequence = Cron.sequence(
- parse("30 * * * *", "Europe/Berlin"),
+ Cron.unsafeParse("30 * * * *", "Europe/Berlin"),
make("2024-03-31T00:00:00.000+01:00[Europe/Berlin]")
)
const next = (): DateTime.Zoned => DateTime.unsafeMakeZoned(sequence.next().value, { timeZone: "Europe/Berlin" })
@@ -177,7 +178,7 @@ describe("Cron", () => {
it("handles transition out of daylight savings time", () => {
const make = (date: string) => DateTime.makeZonedFromString(date).pipe(Option.getOrThrow)
const sequence = Cron.sequence(
- parse("30 * * * *", "Europe/Berlin"),
+ Cron.unsafeParse("30 * * * *", "Europe/Berlin"),
make("2024-10-27T00:00:00.000+02:00[Europe/Berlin]")
)
const next = (): DateTime.Zoned => DateTime.unsafeMakeZoned(sequence.next().value, { timeZone: "Europe/Berlin" })
@@ -197,7 +198,7 @@ describe("Cron", () => {
it("handles utc timezone", () => {
const utc = DateTime.zoneUnsafeMakeNamed("UTC")
const make = (date: string) => DateTime.makeZonedFromString(date).pipe(Option.getOrThrow)
- const sequence = Cron.sequence(parse("30 * * * *", utc), make("2024-10-27T00:00:00.000+00:00[UTC]"))
+ const sequence = Cron.sequence(Cron.unsafeParse("30 * * * *", utc), make("2024-10-27T00:00:00.000+00:00[UTC]"))
const next = (): DateTime.Zoned => DateTime.unsafeMakeZoned(sequence.next().value, { timeZone: utc })
const a = make("2024-10-27T00:30:00.000+00:00[UTC]")
diff --git a/packages/effect/test/Data.test.ts b/packages/effect/test/Data.test.ts
index 7fab66478ed..f2fe35d6ddf 100644
--- a/packages/effect/test/Data.test.ts
+++ b/packages/effect/test/Data.test.ts
@@ -1,59 +1,58 @@
-import * as Data from "effect/Data"
-import * as Equal from "effect/Equal"
-import { pipe } from "effect/Function"
-import { assert, describe, expect, it } from "vitest"
+import { Data, Equal, pipe } from "effect"
+import { assertFalse, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
+import { describe, it } from "vitest"
describe("Data", () => {
it("struct", () => {
const x = Data.struct({ a: 0, b: 1, c: 2 })
const y = Data.struct({ a: 0, b: 1, c: 2 })
const { a, b, c } = x
- expect(a).toBe(0)
- expect(b).toBe(1)
- expect(c).toBe(2)
- expect(Equal.equals(x, y)).toBe(true)
- expect(Equal.equals(x, Data.struct({ a: 0 }))).toBe(false)
+ strictEqual(a, 0)
+ strictEqual(b, 1)
+ strictEqual(c, 2)
+ assertTrue(Equal.equals(x, y))
+ assertFalse(Equal.equals(x, Data.struct({ a: 0 })))
// different keys length
- expect(Equal.equals(Data.struct({ a: 0, b: 1 }), Data.struct({ a: 0 }))).toBe(false)
+ assertFalse(Equal.equals(Data.struct({ a: 0, b: 1 }), Data.struct({ a: 0 })))
// same length but different keys
- expect(Equal.equals(Data.struct({ a: 0 }), Data.struct({ b: 1 }))).toBe(false)
+ assertFalse(Equal.equals(Data.struct({ a: 0 }), Data.struct({ b: 1 })))
})
it("unsafeStruct", () => {
const x = Data.unsafeStruct({ a: 0, b: 1, c: 2 })
const y = Data.unsafeStruct({ a: 0, b: 1, c: 2 })
const { a, b, c } = x
- expect(a).toBe(0)
- expect(b).toBe(1)
- expect(c).toBe(2)
- expect(Equal.equals(x, y)).toBe(true)
+ strictEqual(a, 0)
+ strictEqual(b, 1)
+ strictEqual(c, 2)
+ assertTrue(Equal.equals(x, y))
})
it("tuple", () => {
const x = Data.tuple(0, 1, 2)
const y = Data.tuple(0, 1, 2)
const [a, b, c] = x
- expect(a).toBe(0)
- expect(b).toBe(1)
- expect(c).toBe(2)
- expect(Equal.equals(x, y)).toBe(true)
- expect(Equal.equals(x, Data.tuple(0, 1))).toBe(false)
+ strictEqual(a, 0)
+ strictEqual(b, 1)
+ strictEqual(c, 2)
+ assertTrue(Equal.equals(x, y))
+ assertFalse(Equal.equals(x, Data.tuple(0, 1)))
})
it("array", () => {
const x = Data.array([0, 1, 2])
const y = Data.array([0, 1, 2])
const [a, b, c] = x
- expect(a).toBe(0)
- expect(b).toBe(1)
- expect(c).toBe(2)
- expect(Equal.equals(x, y)).toBe(true)
- expect(Equal.equals(x, Data.tuple(0, 1, 2))).toBe(true)
- expect(Equal.equals(x, Data.array([0, 1]))).toBe(false)
+ strictEqual(a, 0)
+ strictEqual(b, 1)
+ strictEqual(c, 2)
+ assertTrue(Equal.equals(x, y))
+ assertTrue(Equal.equals(x, Data.tuple(0, 1, 2)))
+ assertFalse(Equal.equals(x, Data.array([0, 1])))
// different length
- expect(Equal.equals(Data.array([0, 1, 2]), Data.array([0, 1]))).toBe(false)
+ assertFalse(Equal.equals(Data.array([0, 1, 2]), Data.array([0, 1])))
})
it("case", () => {
@@ -67,14 +66,14 @@ describe("Data", () => {
const b = Person({ name: "Mike" })
const c = Person({ name: "Foo" })
- expect(a.name).toBe("Mike")
- expect(b.name).toBe("Mike")
- expect(c.name).toBe("Foo")
- expect(Equal.equals(a, b)).toBe(true)
- expect(Equal.equals(a, c)).toBe(false)
+ strictEqual(a.name, "Mike")
+ strictEqual(b.name, "Mike")
+ strictEqual(c.name, "Foo")
+ assertTrue(Equal.equals(a, b))
+ assertFalse(Equal.equals(a, c))
const Empty = Data.case()
- expect(Equal.equals(Empty(), Empty())).toBe(true)
+ assertTrue(Equal.equals(Empty(), Empty()))
})
it("tagged", () => {
@@ -89,12 +88,12 @@ describe("Data", () => {
const b = Person({ name: "Mike" })
const c = Person({ name: "Foo" })
- expect(a._tag).toBe("Person")
- expect(a.name).toBe("Mike")
- expect(b.name).toBe("Mike")
- expect(c.name).toBe("Foo")
- expect(Equal.equals(a, b)).toBe(true)
- expect(Equal.equals(a, c)).toBe(false)
+ strictEqual(a._tag, "Person")
+ strictEqual(a.name, "Mike")
+ strictEqual(b.name, "Mike")
+ strictEqual(c.name, "Foo")
+ assertTrue(Equal.equals(a, b))
+ assertFalse(Equal.equals(a, c))
})
it("case class", () => {
@@ -103,20 +102,20 @@ describe("Data", () => {
const b = new Person({ name: "Mike" })
const c = new Person({ name: "Foo" })
- expect(a.name).toBe("Mike")
- expect(b.name).toBe("Mike")
- expect(c.name).toBe("Foo")
- expect(Equal.equals(a, b)).toBe(true)
- expect(Equal.equals(a, c)).toBe(false)
+ strictEqual(a.name, "Mike")
+ strictEqual(b.name, "Mike")
+ strictEqual(c.name, "Foo")
+ assertTrue(Equal.equals(a, b))
+ assertFalse(Equal.equals(a, c))
// different keys length
class D extends Data.Class<{ d: string; e: string }> {}
const d = new D({ d: "d", e: "e" })
- expect(Equal.equals(a, d)).toBe(false)
+ assertFalse(Equal.equals(a, d))
// same length but different keys
class E extends Data.Class<{ e: string }> {}
const e = new E({ e: "e" })
- expect(Equal.equals(a, e)).toBe(false)
+ assertFalse(Equal.equals(a, e))
})
it("date compares by value", () => {
@@ -124,7 +123,7 @@ describe("Data", () => {
const a = Data.struct({ date: new Date(date.toISOString()) })
const b = Data.struct({ date: new Date(date.toISOString()) })
- expect(Equal.equals(a, b)).toBe(true)
+ assertTrue(Equal.equals(a, b))
})
it("tagged class", () => {
@@ -133,12 +132,12 @@ describe("Data", () => {
const b = new Person({ name: "Mike" })
const c = new Person({ name: "Foo" })
- expect(a._tag).toBe("Person")
- expect(a.name).toBe("Mike")
- expect(b.name).toBe("Mike")
- expect(c.name).toBe("Foo")
- expect(Equal.equals(a, b)).toBe(true)
- expect(Equal.equals(a, c)).toBe(false)
+ strictEqual(a._tag, "Person")
+ strictEqual(a.name, "Mike")
+ strictEqual(b.name, "Mike")
+ strictEqual(c.name, "Foo")
+ assertTrue(Equal.equals(a, b))
+ assertFalse(Equal.equals(a, c))
})
it("tagged - empty", () => {
@@ -151,7 +150,7 @@ describe("Data", () => {
const a = Person()
const b = Person()
- expect(Equal.equals(a, b)).toBe(true)
+ assertTrue(Equal.equals(a, b))
})
it("TaggedClass - empty", () => {
@@ -160,7 +159,7 @@ describe("Data", () => {
const a = new Person()
const b = new Person()
- expect(Equal.equals(a, b)).toBe(true)
+ assertTrue(Equal.equals(a, b))
})
it("tagged - don't override tag", () => {
@@ -178,7 +177,7 @@ describe("Data", () => {
const foo = Foo({ value: "test" })
const bar = Bar({ ...foo, value: 10 })
- expect(bar._tag).toStrictEqual("Bar")
+ strictEqual(bar._tag, "Bar")
})
it("taggedEnum", () => {
@@ -197,23 +196,23 @@ describe("Data", () => {
const b = InternalServerError({ reason: "test" })
const c = InternalServerError({ reason: "test" })
- expect(a._tag).toBe("NotFound")
- expect(b._tag).toBe("InternalServerError")
+ strictEqual(a._tag, "NotFound")
+ strictEqual(b._tag, "InternalServerError")
- expect(b.reason).toBe("test")
- expect(c.reason).toBe("test")
+ strictEqual(b.reason, "test")
+ strictEqual(c.reason, "test")
- expect(Equal.equals(a, b)).toBe(false)
- expect(Equal.equals(b, c)).toBe(true)
+ assertFalse(Equal.equals(a, b))
+ assertTrue(Equal.equals(b, c))
- expect($is("NotFound")(a)).toBe(true)
- expect($is("InternalServerError")(a)).toBe(false)
+ assertTrue($is("NotFound")(a))
+ assertFalse($is("InternalServerError")(a))
const matcher = $match({
NotFound: () => 0,
InternalServerError: () => 1
})
- expect(matcher(a)).toEqual(0)
- expect(matcher(b)).toEqual(1)
+ strictEqual(matcher(a), 0)
+ strictEqual(matcher(b), 1)
})
it("taggedEnum - generics", () => {
@@ -233,20 +232,20 @@ describe("Data", () => {
const b = Failure({ error: "test" }) satisfies Result
const c = Success({ value: 1 }) satisfies Result
- expect(a._tag).toBe("Success")
- expect(b._tag).toBe("Failure")
- expect(c._tag).toBe("Success")
+ strictEqual(a._tag, "Success")
+ strictEqual(b._tag, "Failure")
+ strictEqual(c._tag, "Success")
- expect(a.value).toBe(1)
- expect(b.error).toBe("test")
+ strictEqual(a.value, 1)
+ strictEqual(b.error, "test")
- expect(Equal.equals(a, b)).toBe(false)
- expect(Equal.equals(a, c)).toBe(true)
+ assertFalse(Equal.equals(a, b))
+ assertTrue(Equal.equals(a, c))
const aResult = Success({ value: 1 }) as Result
const bResult = Failure({ error: "boom" }) as Result
- assert.strictEqual(
+ strictEqual(
$match(aResult, {
Success: (_) => 1,
Failure: (_) => 2
@@ -261,29 +260,29 @@ describe("Data", () => {
})
)
result satisfies string | number
- assert.strictEqual(result, "boom")
+ strictEqual(result, "boom")
- assert($is("Success")(aResult))
+ assertTrue($is("Success")(aResult))
aResult satisfies { readonly _tag: "Success"; readonly value: number }
- assert.strictEqual(aResult.value, 1)
+ strictEqual(aResult.value, 1)
- assert($is("Failure")(bResult))
+ assertTrue($is("Failure")(bResult))
bResult satisfies { readonly _tag: "Failure"; readonly error: string }
- assert.strictEqual(bResult.error, "boom")
+ strictEqual(bResult.error, "boom")
})
describe("Error", () => {
it("should support a message field", () => {
class MyError extends Data.Error<{ message: string; a: number }> {}
const e = new MyError({ message: "Oh no!", a: 1 })
- expect(e.message).toStrictEqual("Oh no!")
- expect(e.a).toStrictEqual(1)
+ strictEqual(e.message, "Oh no!")
+ strictEqual(e.a, 1)
})
it("toJSON includes all args", () => {
class MyError extends Data.Error<{ message: string; a: number; cause: string }> {}
const e = new MyError({ message: "Oh no!", a: 1, cause: "Boom" })
- assert.deepStrictEqual(e.toJSON(), { message: "Oh no!", a: 1, cause: "Boom" })
+ deepStrictEqual(e.toJSON(), { message: "Oh no!", a: 1, cause: "Boom" })
})
})
@@ -291,7 +290,7 @@ describe("Data", () => {
it("toJSON includes all args", () => {
class MyError extends Data.TaggedError("MyError")<{ message: string; a: number; cause: string }> {}
const e = new MyError({ message: "Oh no!", a: 1, cause: "Boom" })
- assert.deepStrictEqual(e.toJSON(), {
+ deepStrictEqual(e.toJSON(), {
_tag: "MyError",
message: "Oh no!",
a: 1,
diff --git a/packages/effect/test/DateTime.test.ts b/packages/effect/test/DateTime.test.ts
index ff01753b558..90999a5c84f 100644
--- a/packages/effect/test/DateTime.test.ts
+++ b/packages/effect/test/DateTime.test.ts
@@ -1,5 +1,6 @@
-import { DateTime, Duration, Effect, Either, Option, TestClock } from "effect"
-import { assert, describe, it } from "./utils/extend.js"
+import { DateTime, Duration, Effect, Option, TestClock } from "effect"
+import { assertRight, deepStrictEqual, strictEqual } from "effect/test/util"
+import { describe, it } from "./utils/extend.js"
const setTo2024NZ = TestClock.setTime(new Date("2023-12-31T11:00:00.000Z").getTime())
@@ -12,7 +13,7 @@ describe("DateTime", () => {
date.setUTCDate(date.getUTCDate() + 1)
})
const diff = DateTime.distanceDurationEither(now, tomorrow)
- assert.deepStrictEqual(diff, Either.right(Duration.decode("1 day")))
+ assertRight(diff, Duration.decode("1 day"))
}))
it.effect("correctly preserves the time zone", () =>
@@ -24,13 +25,13 @@ describe("DateTime", () => {
const future = DateTime.mutate(now, (date) => {
date.setUTCMonth(date.getUTCMonth() + 6)
})
- assert.strictEqual(DateTime.toDateUtc(future).toISOString(), "2024-06-30T12:00:00.000Z")
- assert.strictEqual(DateTime.toDate(future).toISOString(), "2024-07-01T00:00:00.000Z")
+ strictEqual(DateTime.toDateUtc(future).toISOString(), "2024-06-30T12:00:00.000Z")
+ strictEqual(DateTime.toDate(future).toISOString(), "2024-07-01T00:00:00.000Z")
const plusOne = DateTime.mutate(future, (date) => {
date.setUTCDate(date.getUTCDate() + 1)
})
- assert.strictEqual(DateTime.toDateUtc(plusOne).toISOString(), "2024-07-01T12:00:00.000Z")
- assert.strictEqual(DateTime.toDate(plusOne).toISOString(), "2024-07-02T00:00:00.000Z")
+ strictEqual(DateTime.toDateUtc(plusOne).toISOString(), "2024-07-01T12:00:00.000Z")
+ strictEqual(DateTime.toDate(plusOne).toISOString(), "2024-07-02T00:00:00.000Z")
}))
})
@@ -40,17 +41,17 @@ describe("DateTime", () => {
const now = yield* DateTime.now
const tomorrow = DateTime.add(now, { days: 1 })
const diff = DateTime.distanceDurationEither(now, tomorrow)
- assert.deepStrictEqual(diff, Either.right(Duration.decode("1 day")))
+ assertRight(diff, Duration.decode("1 day"))
}))
it("to month with less days", () => {
const jan = DateTime.unsafeMake({ year: 2023, month: 1, day: 31 })
let feb = DateTime.add(jan, { months: 1 })
- assert.strictEqual(feb.toJSON(), "2023-02-28T00:00:00.000Z")
+ strictEqual(feb.toJSON(), "2023-02-28T00:00:00.000Z")
const mar = DateTime.unsafeMake({ year: 2023, month: 3, day: 31 })
feb = DateTime.subtract(mar, { months: 1 })
- assert.strictEqual(feb.toJSON(), "2023-02-28T00:00:00.000Z")
+ strictEqual(feb.toJSON(), "2023-02-28T00:00:00.000Z")
})
it.effect("correctly preserves the time zone", () =>
@@ -60,14 +61,14 @@ describe("DateTime", () => {
DateTime.withCurrentZoneNamed("Pacific/Auckland")
)
const future = DateTime.add(now, { months: 6 })
- assert.strictEqual(DateTime.toDateUtc(future).toISOString(), "2024-06-30T12:00:00.000Z")
- assert.strictEqual(DateTime.toDate(future).toISOString(), "2024-07-01T00:00:00.000Z")
+ strictEqual(DateTime.toDateUtc(future).toISOString(), "2024-06-30T12:00:00.000Z")
+ strictEqual(DateTime.toDate(future).toISOString(), "2024-07-01T00:00:00.000Z")
const plusOne = DateTime.add(future, { days: 1 })
- assert.strictEqual(DateTime.toDateUtc(plusOne).toISOString(), "2024-07-01T12:00:00.000Z")
- assert.strictEqual(DateTime.toDate(plusOne).toISOString(), "2024-07-02T00:00:00.000Z")
+ strictEqual(DateTime.toDateUtc(plusOne).toISOString(), "2024-07-01T12:00:00.000Z")
+ strictEqual(DateTime.toDate(plusOne).toISOString(), "2024-07-02T00:00:00.000Z")
const minusOne = DateTime.subtract(plusOne, { days: 1 })
- assert.strictEqual(DateTime.toDateUtc(minusOne).toISOString(), "2024-06-30T12:00:00.000Z")
- assert.strictEqual(DateTime.toDate(minusOne).toISOString(), "2024-07-01T00:00:00.000Z")
+ strictEqual(DateTime.toDateUtc(minusOne).toISOString(), "2024-06-30T12:00:00.000Z")
+ strictEqual(DateTime.toDate(minusOne).toISOString(), "2024-07-01T00:00:00.000Z")
}))
it.effect("leap years", () =>
@@ -75,7 +76,7 @@ describe("DateTime", () => {
yield* setTo2024NZ
const now = yield* DateTime.make({ year: 2024, month: 2, day: 29 })
const future = DateTime.add(now, { years: 1 })
- assert.strictEqual(DateTime.formatIso(future), "2025-02-28T00:00:00.000Z")
+ strictEqual(DateTime.formatIso(future), "2025-02-28T00:00:00.000Z")
}))
})
@@ -83,26 +84,26 @@ describe("DateTime", () => {
it("month", () => {
const mar = DateTime.unsafeMake("2024-03-15T12:00:00.000Z")
const end = DateTime.endOf(mar, "month")
- assert.strictEqual(end.toJSON(), "2024-03-31T23:59:59.999Z")
+ strictEqual(end.toJSON(), "2024-03-31T23:59:59.999Z")
})
it("feb leap year", () => {
const feb = DateTime.unsafeMake("2024-02-15T12:00:00.000Z")
const end = DateTime.endOf(feb, "month")
- assert.strictEqual(end.toJSON(), "2024-02-29T23:59:59.999Z")
+ strictEqual(end.toJSON(), "2024-02-29T23:59:59.999Z")
})
it("week", () => {
const start = DateTime.unsafeMake("2024-03-15T12:00:00.000Z")
const end = DateTime.endOf(start, "week")
- assert.strictEqual(end.toJSON(), "2024-03-16T23:59:59.999Z")
- assert.strictEqual(DateTime.getPartUtc(end, "weekDay"), 6)
+ strictEqual(end.toJSON(), "2024-03-16T23:59:59.999Z")
+ strictEqual(DateTime.getPartUtc(end, "weekDay"), 6)
})
it("week last day", () => {
const start = DateTime.unsafeMake("2024-03-16T12:00:00.000Z")
const end = DateTime.endOf(start, "week")
- assert.strictEqual(end.toJSON(), "2024-03-16T23:59:59.999Z")
+ strictEqual(end.toJSON(), "2024-03-16T23:59:59.999Z")
})
it("week with options", () => {
@@ -110,7 +111,7 @@ describe("DateTime", () => {
const end = DateTime.endOf(start, "week", {
weekStartsOn: 1
})
- assert.strictEqual(end.toJSON(), "2024-03-17T23:59:59.999Z")
+ strictEqual(end.toJSON(), "2024-03-17T23:59:59.999Z")
})
it.effect("correctly preserves the time zone", () =>
@@ -120,8 +121,8 @@ describe("DateTime", () => {
DateTime.withCurrentZoneNamed("Pacific/Auckland")
)
const future = DateTime.endOf(now, "month")
- assert.strictEqual(DateTime.toDateUtc(future).toISOString(), "2024-01-31T10:59:59.999Z")
- assert.strictEqual(DateTime.toDate(future).toISOString(), "2024-01-31T23:59:59.999Z")
+ strictEqual(DateTime.toDateUtc(future).toISOString(), "2024-01-31T10:59:59.999Z")
+ strictEqual(DateTime.toDate(future).toISOString(), "2024-01-31T23:59:59.999Z")
}))
})
@@ -129,7 +130,7 @@ describe("DateTime", () => {
it("month", () => {
const mar = DateTime.unsafeMake("2024-03-15T12:00:00.000Z")
const end = DateTime.startOf(mar, "month")
- assert.strictEqual(end.toJSON(), "2024-03-01T00:00:00.000Z")
+ strictEqual(end.toJSON(), "2024-03-01T00:00:00.000Z")
})
it("month duplicated", () => {
@@ -137,26 +138,26 @@ describe("DateTime", () => {
const end = DateTime.startOf(mar, "month").pipe(
DateTime.startOf("month")
)
- assert.strictEqual(end.toJSON(), "2024-03-01T00:00:00.000Z")
+ strictEqual(end.toJSON(), "2024-03-01T00:00:00.000Z")
})
it("feb leap year", () => {
const feb = DateTime.unsafeMake("2024-02-15T12:00:00.000Z")
const end = DateTime.startOf(feb, "month")
- assert.strictEqual(end.toJSON(), "2024-02-01T00:00:00.000Z")
+ strictEqual(end.toJSON(), "2024-02-01T00:00:00.000Z")
})
it("week", () => {
const start = DateTime.unsafeMake("2024-03-15T12:00:00.000Z")
const end = DateTime.startOf(start, "week")
- assert.strictEqual(end.toJSON(), "2024-03-10T00:00:00.000Z")
- assert.strictEqual(DateTime.getPartUtc(end, "weekDay"), 0)
+ strictEqual(end.toJSON(), "2024-03-10T00:00:00.000Z")
+ strictEqual(DateTime.getPartUtc(end, "weekDay"), 0)
})
it("week first day", () => {
const start = DateTime.unsafeMake("2024-03-10T12:00:00.000Z")
const end = DateTime.startOf(start, "week")
- assert.strictEqual(end.toJSON(), "2024-03-10T00:00:00.000Z")
+ strictEqual(end.toJSON(), "2024-03-10T00:00:00.000Z")
})
it("week with options", () => {
@@ -164,7 +165,7 @@ describe("DateTime", () => {
const end = DateTime.startOf(start, "week", {
weekStartsOn: 1
})
- assert.strictEqual(end.toJSON(), "2024-03-11T00:00:00.000Z")
+ strictEqual(end.toJSON(), "2024-03-11T00:00:00.000Z")
})
})
@@ -172,25 +173,25 @@ describe("DateTime", () => {
it("month up", () => {
const mar = DateTime.unsafeMake("2024-03-16T12:00:00.000Z")
const end = DateTime.nearest(mar, "month")
- assert.strictEqual(end.toJSON(), "2024-04-01T00:00:00.000Z")
+ strictEqual(end.toJSON(), "2024-04-01T00:00:00.000Z")
})
it("month down", () => {
const mar = DateTime.unsafeMake("2024-03-16T11:00:00.000Z")
const end = DateTime.nearest(mar, "month")
- assert.strictEqual(end.toJSON(), "2024-03-01T00:00:00.000Z")
+ strictEqual(end.toJSON(), "2024-03-01T00:00:00.000Z")
})
it("second up", () => {
const mar = DateTime.unsafeMake("2024-03-20T12:00:00.500Z")
const end = DateTime.nearest(mar, "second")
- assert.strictEqual(end.toJSON(), "2024-03-20T12:00:01.000Z")
+ strictEqual(end.toJSON(), "2024-03-20T12:00:01.000Z")
})
it("second down", () => {
const mar = DateTime.unsafeMake("2024-03-20T12:00:00.400Z")
const end = DateTime.nearest(mar, "second")
- assert.strictEqual(end.toJSON(), "2024-03-20T12:00:00.000Z")
+ strictEqual(end.toJSON(), "2024-03-20T12:00:00.000Z")
})
})
@@ -198,7 +199,7 @@ describe("DateTime", () => {
it.effect("full", () =>
Effect.gen(function*() {
const now = yield* DateTime.now
- assert.strictEqual(
+ strictEqual(
DateTime.format(now, {
locale: "en-US",
dateStyle: "full",
@@ -213,7 +214,7 @@ describe("DateTime", () => {
it.effect("full", () =>
Effect.gen(function*() {
const now = yield* DateTime.now
- assert.strictEqual(
+ strictEqual(
DateTime.formatUtc(now, {
locale: "en-US",
dateStyle: "full",
@@ -230,7 +231,7 @@ describe("DateTime", () => {
const now = yield* DateTime.nowInCurrentZone.pipe(
DateTime.withCurrentZoneNamed("Pacific/Auckland")
)
- assert.strictEqual(
+ strictEqual(
DateTime.format(now, {
locale: "en-US",
dateStyle: "full",
@@ -251,7 +252,7 @@ describe("DateTime", () => {
timeStyle: "short"
})
)
- assert.strictEqual(formatted, "January 1, 1970 at 10:00 AM")
+ strictEqual(formatted, "January 1, 1970 at 10:00 AM")
}))
})
@@ -262,12 +263,12 @@ describe("DateTime", () => {
month: 12,
day: 25
})
- assert.strictEqual(date.toJSON(), "2024-12-25T00:00:00.000Z")
+ strictEqual(date.toJSON(), "2024-12-25T00:00:00.000Z")
})
it("month is set correctly", () => {
const date = DateTime.unsafeMake({ year: 2024 })
- assert.strictEqual(date.toJSON(), "2024-01-01T00:00:00.000Z")
+ strictEqual(date.toJSON(), "2024-01-01T00:00:00.000Z")
})
})
@@ -278,13 +279,13 @@ describe("DateTime", () => {
month: 12,
day: 25
})
- assert.strictEqual(date.toJSON(), "2024-12-25T00:00:00.000Z")
+ strictEqual(date.toJSON(), "2024-12-25T00:00:00.000Z")
const updated = DateTime.setPartsUtc(date, {
year: 2023,
month: 1
})
- assert.strictEqual(updated.toJSON(), "2023-01-25T00:00:00.000Z")
+ strictEqual(updated.toJSON(), "2023-01-25T00:00:00.000Z")
})
it("ignores time zones", () => {
@@ -293,13 +294,13 @@ describe("DateTime", () => {
month: 12,
day: 25
}).pipe(DateTime.unsafeSetZoneNamed("Pacific/Auckland"))
- assert.strictEqual(date.toJSON(), "2024-12-25T00:00:00.000Z")
+ strictEqual(date.toJSON(), "2024-12-25T00:00:00.000Z")
const updated = DateTime.setPartsUtc(date, {
year: 2023,
month: 1
})
- assert.strictEqual(updated.toJSON(), "2023-01-25T00:00:00.000Z")
+ strictEqual(updated.toJSON(), "2023-01-25T00:00:00.000Z")
})
})
@@ -310,13 +311,13 @@ describe("DateTime", () => {
month: 12,
day: 25
})
- assert.strictEqual(date.toJSON(), "2024-12-25T00:00:00.000Z")
+ strictEqual(date.toJSON(), "2024-12-25T00:00:00.000Z")
const updated = DateTime.setParts(date, {
year: 2023,
month: 1
})
- assert.strictEqual(updated.toJSON(), "2023-01-25T00:00:00.000Z")
+ strictEqual(updated.toJSON(), "2023-01-25T00:00:00.000Z")
})
it("accounts for time zone", () => {
@@ -325,21 +326,21 @@ describe("DateTime", () => {
month: 12,
day: 25
}).pipe(DateTime.unsafeSetZoneNamed("Pacific/Auckland"))
- assert.strictEqual(date.toJSON(), "2024-12-25T00:00:00.000Z")
+ strictEqual(date.toJSON(), "2024-12-25T00:00:00.000Z")
const updated = DateTime.setParts(date, {
year: 2023,
month: 6,
hours: 12
})
- assert.strictEqual(updated.toJSON(), "2023-06-25T00:00:00.000Z")
+ strictEqual(updated.toJSON(), "2023-06-25T00:00:00.000Z")
})
})
describe("formatIso", () => {
it("full", () => {
const now = DateTime.unsafeMake("2024-03-15T12:00:00.000Z")
- assert.strictEqual(DateTime.formatIso(now), "2024-03-15T12:00:00.000Z")
+ strictEqual(DateTime.formatIso(now), "2024-03-15T12:00:00.000Z")
})
})
@@ -349,7 +350,7 @@ describe("DateTime", () => {
const now = yield* DateTime.nowInCurrentZone.pipe(
DateTime.withCurrentZoneNamed("Pacific/Auckland")
)
- assert.strictEqual(DateTime.formatIsoOffset(now), "1970-01-01T12:00:00.000+12:00")
+ strictEqual(DateTime.formatIsoOffset(now), "1970-01-01T12:00:00.000+12:00")
}))
})
@@ -357,7 +358,7 @@ describe("DateTime", () => {
it.effect("correctly adds offset", () =>
Effect.gen(function*() {
const now = yield* DateTime.nowInCurrentZone
- assert.strictEqual(DateTime.formatIsoOffset(now), "1970-01-01T12:00:00.000+12:00")
+ strictEqual(DateTime.formatIsoOffset(now), "1970-01-01T12:00:00.000+12:00")
}).pipe(
Effect.provide(DateTime.layerCurrentZoneNamed("Pacific/Auckland"))
))
@@ -369,7 +370,7 @@ describe("DateTime", () => {
timeZone: "Pacific/Auckland",
adjustForTimeZone: true
}).pipe(DateTime.removeTime)
- assert.strictEqual(dt.toJSON(), "2024-01-01T00:00:00.000Z")
+ strictEqual(dt.toJSON(), "2024-01-01T00:00:00.000Z")
})
})
@@ -377,21 +378,21 @@ describe("DateTime", () => {
it.effect("parses time + zone", () =>
Effect.gen(function*() {
const dt = yield* DateTime.makeZonedFromString("2024-07-21T20:12:34.112546348+12:00[Pacific/Auckland]")
- assert.strictEqual(dt.toJSON(), "2024-07-21T08:12:34.112Z")
+ strictEqual(dt.toJSON(), "2024-07-21T08:12:34.112Z")
}))
it.effect("only offset", () =>
Effect.gen(function*() {
const dt = yield* DateTime.makeZonedFromString("2024-07-21T20:12:34.112546348+12:00")
- assert.strictEqual(dt.zone._tag, "Offset")
- assert.strictEqual(dt.toJSON(), "2024-07-21T08:12:34.112Z")
+ strictEqual(dt.zone._tag, "Offset")
+ strictEqual(dt.toJSON(), "2024-07-21T08:12:34.112Z")
}))
it.effect("only offset with 00:00", () =>
Effect.gen(function*() {
const dt = yield* DateTime.makeZonedFromString("2024-07-21T20:12:34.112546348+00:00")
- assert.strictEqual(dt.zone._tag, "Offset")
- assert.strictEqual(dt.toJSON(), "2024-07-21T20:12:34.112Z")
+ strictEqual(dt.zone._tag, "Offset")
+ strictEqual(dt.toJSON(), "2024-07-21T20:12:34.112Z")
}))
it.effect("roundtrip", () =>
@@ -400,17 +401,17 @@ describe("DateTime", () => {
Option.map(DateTime.formatIsoZoned),
Option.flatMap(DateTime.makeZonedFromString)
)
- assert.deepStrictEqual(dt.zone, DateTime.zoneUnsafeMakeNamed("Pacific/Auckland"))
- assert.strictEqual(dt.toJSON(), "2024-07-21T08:12:34.112Z")
+ deepStrictEqual(dt.zone, DateTime.zoneUnsafeMakeNamed("Pacific/Auckland"))
+ strictEqual(dt.toJSON(), "2024-07-21T08:12:34.112Z")
}))
})
it("parts equality", () => {
const d1 = DateTime.unsafeMake("2025-01-01")
const d2 = DateTime.unsafeMake("2025-01-01")
- assert.deepStrictEqual(d1, d2)
+ deepStrictEqual(d1, d2)
DateTime.toPartsUtc(d2)
- assert.deepStrictEqual(d1, d2)
+ deepStrictEqual(d1, d2)
})
// doesnt work in CI
@@ -418,6 +419,6 @@ describe("DateTime", () => {
const date = new Date("2024-07-21T20:12:34.112Z")
;(date as any).getTimezoneOffset = () => -60
const dt = DateTime.unsafeMakeZoned(date)
- assert.deepStrictEqual(dt.zone, DateTime.zoneMakeOffset(60 * 60 * 1000))
+ deepStrictEqual(dt.zone, DateTime.zoneMakeOffset(60 * 60 * 1000))
})
})
diff --git a/packages/effect/test/Deferred.test.ts b/packages/effect/test/Deferred.test.ts
index 2862b4afb2b..9076dad0908 100644
--- a/packages/effect/test/Deferred.test.ts
+++ b/packages/effect/test/Deferred.test.ts
@@ -1,10 +1,7 @@
-import * as Deferred from "effect/Deferred"
-import * as Effect from "effect/Effect"
-import * as Exit from "effect/Exit"
-import * as Option from "effect/Option"
-import * as Ref from "effect/Ref"
+import { Deferred, Effect, Exit, Option, Ref } from "effect"
+import { assertFalse, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Deferred", () => {
it.effect("complete a deferred using succeed", () =>
@@ -12,8 +9,8 @@ describe("Deferred", () => {
const deferred = yield* $(Deferred.make())
const success = yield* $(Deferred.succeed(deferred, 32))
const result = yield* $(Deferred.await(deferred))
- assert.isTrue(success)
- assert.strictEqual(result, 32)
+ assertTrue(success)
+ strictEqual(result, 32)
}))
it.effect("complete a deferred using complete", () =>
Effect.gen(function*($) {
@@ -22,8 +19,8 @@ describe("Deferred", () => {
yield* $(Deferred.complete(deferred, Ref.updateAndGet(ref, (n) => n + 1)))
const result1 = yield* $(Deferred.await(deferred))
const result2 = yield* $(Deferred.await(deferred))
- assert.strictEqual(result1, 14)
- assert.strictEqual(result2, 14)
+ strictEqual(result1, 14)
+ strictEqual(result2, 14)
}))
it.effect("complete a deferred using completeWith", () =>
Effect.gen(function*($) {
@@ -32,8 +29,8 @@ describe("Deferred", () => {
yield* $(Deferred.completeWith(deferred, Ref.updateAndGet(ref, (n) => n + 1)))
const result1 = yield* $(Deferred.await(deferred))
const result2 = yield* $(Deferred.await(deferred))
- assert.strictEqual(result1, 14)
- assert.strictEqual(result2, 15)
+ strictEqual(result1, 14)
+ strictEqual(result2, 15)
}))
it.effect("complete a deferred twice", () =>
Effect.gen(function*($) {
@@ -41,16 +38,16 @@ describe("Deferred", () => {
yield* $(Deferred.succeed(deferred, 1))
const success = yield* $(Deferred.complete(deferred, Effect.succeed(9)))
const result = yield* $(Deferred.await(deferred))
- assert.isFalse(success)
- assert.strictEqual(result, 1)
+ assertFalse(success)
+ strictEqual(result, 1)
}))
it.effect("fail a deferred using fail", () =>
Effect.gen(function*($) {
const deferred = yield* $(Deferred.make())
const success = yield* $(Deferred.fail(deferred, "error with fail"))
const result = yield* $(deferred, Deferred.await, Effect.exit)
- assert.isTrue(success)
- assert.isTrue(Exit.isFailure(result))
+ assertTrue(success)
+ assertTrue(Exit.isFailure(result))
}))
it.effect("fail a deferred using complete", () =>
Effect.gen(function*($) {
@@ -61,9 +58,9 @@ describe("Deferred", () => {
)
const result1 = yield* $(deferred, Deferred.await, Effect.exit)
const result2 = yield* $(deferred, Deferred.await, Effect.exit)
- assert.isTrue(success)
- assert.isTrue(Exit.isFailure(result1))
- assert.isTrue(Exit.isFailure(result2))
+ assertTrue(success)
+ assertTrue(Exit.isFailure(result1))
+ assertTrue(Exit.isFailure(result2))
}))
it.effect("fail a deferred using completeWith", () =>
Effect.gen(function*($) {
@@ -79,35 +76,35 @@ describe("Deferred", () => {
)
const result1 = yield* $(deferred, Deferred.await, Effect.exit)
const result2 = yield* $(deferred, Deferred.await, Effect.exit)
- assert.isTrue(success)
- assert.isTrue(Exit.isFailure(result1))
- assert.isTrue(Exit.isFailure(result2))
+ assertTrue(success)
+ assertTrue(Exit.isFailure(result1))
+ assertTrue(Exit.isFailure(result2))
}))
it.effect("is done when a deferred is completed", () =>
Effect.gen(function*($) {
const deferred = yield* $(Deferred.make())
yield* $(Deferred.succeed(deferred, 0))
const result = yield* $(Deferred.isDone(deferred))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("is done when a deferred is failed", () =>
Effect.gen(function*($) {
const deferred = yield* $(Deferred.make())
yield* $(Deferred.fail(deferred, "failure"))
const result = yield* $(Deferred.isDone(deferred))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("should interrupt a deferred", () =>
Effect.gen(function*($) {
const deferred = yield* $(Deferred.make())
const result = yield* $(Deferred.interrupt(deferred))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("poll a deferred that is not completed yet", () =>
Effect.gen(function*($) {
const deferred = yield* $(Deferred.make())
const result = yield* $(Deferred.poll(deferred))
- assert.isTrue(Option.isNone(result))
+ assertTrue(Option.isNone(result))
}))
it.effect("poll a deferred that is completed", () =>
Effect.gen(function*($) {
@@ -123,7 +120,7 @@ describe("Deferred", () => {
Effect.exit
)
)
- assert.deepStrictEqual(result, Exit.succeed(12))
+ deepStrictEqual(result, Exit.succeed(12))
}))
it.effect("poll a deferred that is failed", () =>
Effect.gen(function*($) {
@@ -139,7 +136,7 @@ describe("Deferred", () => {
Effect.exit
)
)
- assert.isTrue(Exit.isFailure(result))
+ assertTrue(Exit.isFailure(result))
}))
it.effect("poll a deferred that is interrupted", () =>
Effect.gen(function*($) {
@@ -155,7 +152,7 @@ describe("Deferred", () => {
Effect.exit
)
)
- assert.isTrue(Exit.isInterrupted(result))
+ assertTrue(Exit.isInterrupted(result))
}))
it.effect("is subtype of Effect", () =>
Effect.gen(function*() {
@@ -164,7 +161,7 @@ describe("Deferred", () => {
yield* Deferred.complete(deferred, Ref.updateAndGet(ref, (n) => n + 1))
const result1 = yield* deferred
const result2 = yield* deferred
- assert.strictEqual(result1, 14)
- assert.strictEqual(result2, 14)
+ strictEqual(result1, 14)
+ strictEqual(result2, 14)
}))
})
diff --git a/packages/effect/test/Differ.test.ts b/packages/effect/test/Differ.test.ts
index 82e7db78712..8809726bd61 100644
--- a/packages/effect/test/Differ.test.ts
+++ b/packages/effect/test/Differ.test.ts
@@ -1,11 +1,6 @@
-import * as RA from "effect/Array"
-import * as Chunk from "effect/Chunk"
-import * as Differ from "effect/Differ"
-import * as Equal from "effect/Equal"
-import { pipe } from "effect/Function"
-import * as HashMap from "effect/HashMap"
-import * as HashSet from "effect/HashSet"
-import { assert, describe, it as it_ } from "vitest"
+import { Array as Arr, Chunk, Differ, Equal, HashMap, HashSet, pipe } from "effect"
+import { assertTrue, deepStrictEqual } from "effect/test/util"
+import { describe, it as it_ } from "vitest"
function diffLaws(
differ: Differ.Differ,
@@ -30,7 +25,7 @@ function diffLaws(
const patch3 = differ.diff(value3, value4)
const left = differ.combine(differ.combine(patch1, patch2), patch3)
const right = differ.combine(patch1, differ.combine(patch2, patch3))
- assert.isTrue(equal(differ.patch(left, value1), differ.patch(right, value1)))
+ assertTrue(equal(differ.patch(left, value1), differ.patch(right, value1)))
})
it("combining a patch with an empty patch is an identity", () => {
@@ -39,25 +34,25 @@ function diffLaws(
const patch = differ.diff(oldValue, newValue)
const left = differ.combine(patch, differ.empty)
const right = differ.combine(differ.empty, patch)
- assert.isTrue(equal(differ.patch(left, oldValue), newValue))
- assert.isTrue(equal(differ.patch(right, oldValue), newValue))
+ assertTrue(equal(differ.patch(left, oldValue), newValue))
+ assertTrue(equal(differ.patch(right, oldValue), newValue))
})
it("diffing a value with itself returns an empty patch", () => {
const value = gen()
- assert.deepStrictEqual(differ.diff(value, value), differ.empty)
+ deepStrictEqual(differ.diff(value, value), differ.empty)
})
it("diffing and then patching is an identity", () => {
const oldValue = gen()
const newValue = gen()
const patch = differ.diff(oldValue, newValue)
- assert.isTrue(equal(differ.patch(patch, oldValue), newValue))
+ assertTrue(equal(differ.patch(patch, oldValue), newValue))
})
it("patching with an empty patch is an identity", () => {
const value = gen()
- assert.isTrue(equal(differ.patch(differ.empty, value), value))
+ assertTrue(equal(differ.patch(differ.empty, value), value))
})
})
}
@@ -75,8 +70,8 @@ function randomChunk(): Chunk.Chunk {
function randomHashMap(): HashMap.HashMap {
return pipe(
- RA.fromIterable(Array.from({ length: 2 }, smallInt)),
- RA.cartesian(RA.fromIterable(Array.from({ length: 2 }, smallInt))),
+ Arr.fromIterable(Array.from({ length: 2 }, smallInt)),
+ Arr.cartesian(Arr.fromIterable(Array.from({ length: 2 }, smallInt))),
HashMap.fromIterable
)
}
@@ -122,7 +117,7 @@ describe("Differ", () => {
diffLaws(
Differ.readonlyArray number>(Differ.update()),
randomReadonlyArray,
- RA.getEquivalence(Equal.equals)
+ Arr.getEquivalence(Equal.equals)
)
})
diff --git a/packages/effect/test/Duration.test.ts b/packages/effect/test/Duration.test.ts
index 118bb3ff30b..da9b2e5722d 100644
--- a/packages/effect/test/Duration.test.ts
+++ b/packages/effect/test/Duration.test.ts
@@ -1,81 +1,78 @@
-import * as Duration from "effect/Duration"
-import * as Equal from "effect/Equal"
-import { pipe } from "effect/Function"
-import * as Option from "effect/Option"
-import { deepStrictEqual } from "effect/test/util"
-import { assert, describe, expect, it } from "vitest"
+import { Duration, Equal, pipe } from "effect"
+import { assertFalse, assertNone, assertSome, assertTrue, deepStrictEqual, strictEqual, throws } from "effect/test/util"
+import { describe, it } from "vitest"
describe("Duration", () => {
it("decode", () => {
const millis100 = Duration.millis(100)
- expect(Duration.decode(millis100) === millis100).toEqual(true)
+ assertTrue(Duration.decode(millis100) === millis100)
- expect(Duration.decode(100)).toEqual(millis100)
+ deepStrictEqual(Duration.decode(100), millis100)
- expect(Duration.decode(10n)).toEqual(Duration.nanos(10n))
+ deepStrictEqual(Duration.decode(10n), Duration.nanos(10n))
- expect(Duration.decode("1 nano")).toEqual(Duration.nanos(1n))
- expect(Duration.decode("10 nanos")).toEqual(Duration.nanos(10n))
- expect(Duration.decode("1 micro")).toEqual(Duration.micros(1n))
- expect(Duration.decode("10 micros")).toEqual(Duration.micros(10n))
- expect(Duration.decode("1 milli")).toEqual(Duration.millis(1))
- expect(Duration.decode("10 millis")).toEqual(Duration.millis(10))
- expect(Duration.decode("1 second")).toEqual(Duration.seconds(1))
- expect(Duration.decode("10 seconds")).toEqual(Duration.seconds(10))
- expect(Duration.decode("1 minute")).toEqual(Duration.minutes(1))
- expect(Duration.decode("10 minutes")).toEqual(Duration.minutes(10))
- expect(Duration.decode("1 hour")).toEqual(Duration.hours(1))
- expect(Duration.decode("10 hours")).toEqual(Duration.hours(10))
- expect(Duration.decode("1 day")).toEqual(Duration.days(1))
- expect(Duration.decode("10 days")).toEqual(Duration.days(10))
- expect(Duration.decode("1 week")).toEqual(Duration.weeks(1))
- expect(Duration.decode("10 weeks")).toEqual(Duration.weeks(10))
+ deepStrictEqual(Duration.decode("1 nano"), Duration.nanos(1n))
+ deepStrictEqual(Duration.decode("10 nanos"), Duration.nanos(10n))
+ deepStrictEqual(Duration.decode("1 micro"), Duration.micros(1n))
+ deepStrictEqual(Duration.decode("10 micros"), Duration.micros(10n))
+ deepStrictEqual(Duration.decode("1 milli"), Duration.millis(1))
+ deepStrictEqual(Duration.decode("10 millis"), Duration.millis(10))
+ deepStrictEqual(Duration.decode("1 second"), Duration.seconds(1))
+ deepStrictEqual(Duration.decode("10 seconds"), Duration.seconds(10))
+ deepStrictEqual(Duration.decode("1 minute"), Duration.minutes(1))
+ deepStrictEqual(Duration.decode("10 minutes"), Duration.minutes(10))
+ deepStrictEqual(Duration.decode("1 hour"), Duration.hours(1))
+ deepStrictEqual(Duration.decode("10 hours"), Duration.hours(10))
+ deepStrictEqual(Duration.decode("1 day"), Duration.days(1))
+ deepStrictEqual(Duration.decode("10 days"), Duration.days(10))
+ deepStrictEqual(Duration.decode("1 week"), Duration.weeks(1))
+ deepStrictEqual(Duration.decode("10 weeks"), Duration.weeks(10))
- expect(Duration.decode("1.5 seconds")).toEqual(Duration.seconds(1.5))
- expect(Duration.decode("-1.5 seconds")).toEqual(Duration.zero)
+ deepStrictEqual(Duration.decode("1.5 seconds"), Duration.seconds(1.5))
+ deepStrictEqual(Duration.decode("-1.5 seconds"), Duration.zero)
- expect(Duration.decode([500, 123456789])).toEqual(Duration.nanos(500123456789n))
- expect(Duration.decode([-500, 123456789])).toEqual(Duration.zero)
+ deepStrictEqual(Duration.decode([500, 123456789]), Duration.nanos(500123456789n))
+ deepStrictEqual(Duration.decode([-500, 123456789]), Duration.zero)
- expect(() => Duration.decode("1.5 secs" as any)).toThrowError(new Error("Invalid DurationInput"))
- expect(() => Duration.decode(true as any)).toThrowError(new Error("Invalid DurationInput"))
- expect(() => Duration.decode({} as any)).toThrowError(new Error("Invalid DurationInput"))
+ throws(() => Duration.decode("1.5 secs" as any), new Error("Invalid DurationInput"))
+ throws(() => Duration.decode(true as any), new Error("Invalid DurationInput"))
+ throws(() => Duration.decode({} as any), new Error("Invalid DurationInput"))
})
it("decodeUnknown", () => {
const millis100 = Duration.millis(100)
- expect(Duration.decodeUnknown(millis100)).toEqual(Option.some(millis100))
+ assertSome(Duration.decodeUnknown(millis100), millis100)
- expect(Duration.decodeUnknown(100)).toEqual(Option.some(millis100))
+ assertSome(Duration.decodeUnknown(100), millis100)
- expect(Duration.decodeUnknown(10n)).toEqual(Option.some(Duration.nanos(10n)))
+ assertSome(Duration.decodeUnknown(10n), Duration.nanos(10n))
- expect(Duration.decodeUnknown("1 nano")).toEqual(Option.some(Duration.nanos(1n)))
- expect(Duration.decodeUnknown("10 nanos")).toEqual(Option.some(Duration.nanos(10n)))
- expect(Duration.decodeUnknown("1 micro")).toEqual(Option.some(Duration.micros(1n)))
- expect(Duration.decodeUnknown("10 micros")).toEqual(Option.some(Duration.micros(10n)))
- expect(Duration.decodeUnknown("1 milli")).toEqual(Option.some(Duration.millis(1)))
- expect(Duration.decodeUnknown("10 millis")).toEqual(Option.some(Duration.millis(10)))
- expect(Duration.decodeUnknown("1 second")).toEqual(Option.some(Duration.seconds(1)))
- expect(Duration.decodeUnknown("10 seconds")).toEqual(Option.some(Duration.seconds(10)))
- expect(Duration.decodeUnknown("1 minute")).toEqual(Option.some(Duration.minutes(1)))
- expect(Duration.decodeUnknown("10 minutes")).toEqual(Option.some(Duration.minutes(10)))
- expect(Duration.decodeUnknown("1 hour")).toEqual(Option.some(Duration.hours(1)))
- expect(Duration.decodeUnknown("10 hours")).toEqual(Option.some(Duration.hours(10)))
- expect(Duration.decodeUnknown("1 day")).toEqual(Option.some(Duration.days(1)))
- expect(Duration.decodeUnknown("10 days")).toEqual(Option.some(Duration.days(10)))
- expect(Duration.decodeUnknown("1 week")).toEqual(Option.some(Duration.weeks(1)))
- expect(Duration.decodeUnknown("10 weeks")).toEqual(Option.some(Duration.weeks(10)))
+ assertSome(Duration.decodeUnknown("1 nano"), Duration.nanos(1n))
+ assertSome(Duration.decodeUnknown("10 nanos"), Duration.nanos(10n))
+ assertSome(Duration.decodeUnknown("1 micro"), Duration.micros(1n))
+ assertSome(Duration.decodeUnknown("10 micros"), Duration.micros(10n))
+ assertSome(Duration.decodeUnknown("1 milli"), Duration.millis(1))
+ assertSome(Duration.decodeUnknown("10 millis"), Duration.millis(10))
+ assertSome(Duration.decodeUnknown("1 second"), Duration.seconds(1))
+ assertSome(Duration.decodeUnknown("10 seconds"), Duration.seconds(10))
+ assertSome(Duration.decodeUnknown("1 minute"), Duration.minutes(1))
+ assertSome(Duration.decodeUnknown("10 minutes"), Duration.minutes(10))
+ assertSome(Duration.decodeUnknown("1 hour"), Duration.hours(1))
+ assertSome(Duration.decodeUnknown("10 hours"), Duration.hours(10))
+ assertSome(Duration.decodeUnknown("1 day"), Duration.days(1))
+ assertSome(Duration.decodeUnknown("10 days"), Duration.days(10))
+ assertSome(Duration.decodeUnknown("1 week"), Duration.weeks(1))
+ assertSome(Duration.decodeUnknown("10 weeks"), Duration.weeks(10))
- expect(Duration.decodeUnknown("1.5 seconds")).toEqual(Option.some(Duration.seconds(1.5)))
- expect(Duration.decodeUnknown("-1.5 seconds")).toEqual(Option.some(Duration.zero))
+ assertSome(Duration.decodeUnknown("1.5 seconds"), Duration.seconds(1.5))
+ assertSome(Duration.decodeUnknown("-1.5 seconds"), Duration.zero)
- expect(Duration.decodeUnknown([500, 123456789])).toEqual(Option.some(Duration.nanos(500123456789n)))
- expect(Duration.decodeUnknown([-500, 123456789])).toEqual(Option.some(Duration.zero))
+ assertSome(Duration.decodeUnknown([500, 123456789]), Duration.nanos(500123456789n))
+ assertSome(Duration.decodeUnknown([-500, 123456789]), Duration.zero)
- expect(Duration.decodeUnknown("1.5 secs")).toEqual(Option.none())
- expect(Duration.decodeUnknown(true)).toEqual(Option.none())
- expect(Duration.decodeUnknown({})).toEqual(Option.none())
+ assertNone(Duration.decodeUnknown("1.5 secs"))
+ assertNone(Duration.decodeUnknown(true))
+ assertNone(Duration.decodeUnknown({}))
})
it("Order", () => {
@@ -128,194 +125,197 @@ describe("Duration", () => {
Duration.minutes(1.5)
)
- expect(Duration.clamp("1 millis", {
- minimum: "2 millis",
- maximum: "3 millis"
- })).toStrictEqual(Duration.millis(2))
+ deepStrictEqual(
+ Duration.clamp("1 millis", {
+ minimum: "2 millis",
+ maximum: "3 millis"
+ }),
+ Duration.millis(2)
+ )
})
it("equals", () => {
- assert.isTrue(pipe(Duration.hours(1), Duration.equals(Duration.minutes(60))))
- expect(Duration.equals("2 seconds", "2 seconds")).toBe(true)
- expect(Duration.equals("2 seconds", "3 seconds")).toBe(false)
+ assertTrue(pipe(Duration.hours(1), Duration.equals(Duration.minutes(60))))
+ assertTrue(Duration.equals("2 seconds", "2 seconds"))
+ assertFalse(Duration.equals("2 seconds", "3 seconds"))
})
it("between", () => {
- assert.isTrue(Duration.between(Duration.hours(1), {
+ assertTrue(Duration.between(Duration.hours(1), {
minimum: Duration.minutes(59),
maximum: Duration.minutes(61)
}))
- assert.isTrue(
+ assertTrue(
Duration.between(Duration.minutes(1), {
minimum: Duration.seconds(59),
maximum: Duration.seconds(61)
})
)
- assert.isTrue(Duration.between("1 minutes", {
+ assertTrue(Duration.between("1 minutes", {
minimum: "59 seconds",
maximum: "61 seconds"
}))
})
it("divide", () => {
- expect(Duration.divide(Duration.minutes(1), 2)).toEqual(Option.some(Duration.seconds(30)))
- expect(Duration.divide(Duration.seconds(1), 3)).toEqual(Option.some(Duration.nanos(333333333n)))
- expect(Duration.divide(Duration.nanos(2n), 2)).toEqual(Option.some(Duration.nanos(1n)))
- expect(Duration.divide(Duration.nanos(1n), 3)).toEqual(Option.some(Duration.zero))
- expect(Duration.divide(Duration.infinity, 2)).toEqual(Option.some(Duration.infinity))
- expect(Duration.divide(Duration.zero, 2)).toEqual(Option.some(Duration.zero))
- expect(Duration.divide(Duration.minutes(1), 0)).toEqual(Option.none())
- expect(Duration.divide(Duration.minutes(1), -0)).toEqual(Option.none())
- expect(Duration.divide(Duration.nanos(1n), 0)).toEqual(Option.none())
- expect(Duration.divide(Duration.nanos(1n), -0)).toEqual(Option.none())
- expect(Duration.divide(Duration.minutes(1), 0.5)).toEqual(Option.some(Duration.minutes(2)))
- expect(Duration.divide(Duration.minutes(1), 1.5)).toEqual(Option.some(Duration.seconds(40)))
- expect(Duration.divide(Duration.minutes(1), NaN)).toEqual(Option.none())
- expect(Duration.divide(Duration.nanos(1n), 0.5)).toEqual(Option.none())
- expect(Duration.divide(Duration.nanos(1n), 1.5)).toEqual(Option.none())
- expect(Duration.divide(Duration.nanos(1n), NaN)).toEqual(Option.none())
-
- expect(Duration.divide("1 minute", 2)).toEqual(Option.some(Duration.seconds(30)))
+ assertSome(Duration.divide(Duration.minutes(1), 2), Duration.seconds(30))
+ assertSome(Duration.divide(Duration.seconds(1), 3), Duration.nanos(333333333n))
+ assertSome(Duration.divide(Duration.nanos(2n), 2), Duration.nanos(1n))
+ assertSome(Duration.divide(Duration.nanos(1n), 3), Duration.zero)
+ assertSome(Duration.divide(Duration.infinity, 2), Duration.infinity)
+ assertSome(Duration.divide(Duration.zero, 2), Duration.zero)
+ assertNone(Duration.divide(Duration.minutes(1), 0))
+ assertNone(Duration.divide(Duration.minutes(1), -0))
+ assertNone(Duration.divide(Duration.nanos(1n), 0))
+ assertNone(Duration.divide(Duration.nanos(1n), -0))
+ assertSome(Duration.divide(Duration.minutes(1), 0.5), Duration.minutes(2))
+ assertSome(Duration.divide(Duration.minutes(1), 1.5), Duration.seconds(40))
+ assertNone(Duration.divide(Duration.minutes(1), NaN))
+ assertNone(Duration.divide(Duration.nanos(1n), 0.5))
+ assertNone(Duration.divide(Duration.nanos(1n), 1.5))
+ assertNone(Duration.divide(Duration.nanos(1n), NaN))
+
+ assertSome(Duration.divide("1 minute", 2), Duration.seconds(30))
})
it("unsafeDivide", () => {
- expect(Duration.unsafeDivide(Duration.minutes(1), 2)).toEqual(Duration.seconds(30))
- expect(Duration.unsafeDivide(Duration.seconds(1), 3)).toEqual(Duration.nanos(333333333n))
- expect(Duration.unsafeDivide(Duration.nanos(2n), 2)).toEqual(Duration.nanos(1n))
- expect(Duration.unsafeDivide(Duration.nanos(1n), 3)).toEqual(Duration.zero)
- expect(Duration.unsafeDivide(Duration.infinity, 2)).toEqual(Duration.infinity)
- expect(Duration.unsafeDivide(Duration.zero, 2)).toEqual(Duration.zero)
- expect(Duration.unsafeDivide(Duration.minutes(1), 0)).toEqual(Duration.infinity)
- expect(Duration.unsafeDivide(Duration.minutes(1), -0)).toEqual(Duration.zero)
- expect(Duration.unsafeDivide(Duration.nanos(1n), 0)).toEqual(Duration.infinity)
- expect(Duration.unsafeDivide(Duration.nanos(1n), -0)).toEqual(Duration.zero)
- expect(Duration.unsafeDivide(Duration.minutes(1), 0.5)).toEqual(Duration.minutes(2))
- expect(Duration.unsafeDivide(Duration.minutes(1), 1.5)).toEqual(Duration.seconds(40))
- expect(Duration.unsafeDivide(Duration.minutes(1), NaN)).toEqual(Duration.zero)
- expect(() => Duration.unsafeDivide(Duration.nanos(1n), 0.5)).toThrow()
- expect(() => Duration.unsafeDivide(Duration.nanos(1n), 1.5)).toThrow()
- expect(Duration.unsafeDivide(Duration.nanos(1n), NaN)).toEqual(Duration.zero)
-
- expect(Duration.unsafeDivide("1 minute", 2)).toEqual(Duration.seconds(30))
+ deepStrictEqual(Duration.unsafeDivide(Duration.minutes(1), 2), Duration.seconds(30))
+ deepStrictEqual(Duration.unsafeDivide(Duration.seconds(1), 3), Duration.nanos(333333333n))
+ deepStrictEqual(Duration.unsafeDivide(Duration.nanos(2n), 2), Duration.nanos(1n))
+ deepStrictEqual(Duration.unsafeDivide(Duration.nanos(1n), 3), Duration.zero)
+ deepStrictEqual(Duration.unsafeDivide(Duration.infinity, 2), Duration.infinity)
+ deepStrictEqual(Duration.unsafeDivide(Duration.zero, 2), Duration.zero)
+ deepStrictEqual(Duration.unsafeDivide(Duration.minutes(1), 0), Duration.infinity)
+ deepStrictEqual(Duration.unsafeDivide(Duration.minutes(1), -0), Duration.zero)
+ deepStrictEqual(Duration.unsafeDivide(Duration.nanos(1n), 0), Duration.infinity)
+ deepStrictEqual(Duration.unsafeDivide(Duration.nanos(1n), -0), Duration.zero)
+ deepStrictEqual(Duration.unsafeDivide(Duration.minutes(1), 0.5), Duration.minutes(2))
+ deepStrictEqual(Duration.unsafeDivide(Duration.minutes(1), 1.5), Duration.seconds(40))
+ deepStrictEqual(Duration.unsafeDivide(Duration.minutes(1), NaN), Duration.zero)
+ throws(() => Duration.unsafeDivide(Duration.nanos(1n), 0.5))
+ throws(() => Duration.unsafeDivide(Duration.nanos(1n), 1.5))
+ deepStrictEqual(Duration.unsafeDivide(Duration.nanos(1n), NaN), Duration.zero)
+
+ deepStrictEqual(Duration.unsafeDivide("1 minute", 2), Duration.seconds(30))
})
it("times", () => {
- expect(Duration.times(Duration.seconds(1), 60)).toEqual(Duration.minutes(1))
- expect(Duration.times(Duration.nanos(2n), 10)).toEqual(Duration.nanos(20n))
- expect(Duration.times(Duration.seconds(Infinity), 60)).toEqual(Duration.seconds(Infinity))
+ deepStrictEqual(Duration.times(Duration.seconds(1), 60), Duration.minutes(1))
+ deepStrictEqual(Duration.times(Duration.nanos(2n), 10), Duration.nanos(20n))
+ deepStrictEqual(Duration.times(Duration.seconds(Infinity), 60), Duration.seconds(Infinity))
- expect(Duration.times("1 seconds", 60)).toEqual(Duration.minutes(1))
+ deepStrictEqual(Duration.times("1 seconds", 60), Duration.minutes(1))
})
it("sum", () => {
- expect(Duration.sum(Duration.seconds(30), Duration.seconds(30))).toEqual(Duration.minutes(1))
- expect(Duration.sum(Duration.nanos(30n), Duration.nanos(30n))).toEqual(Duration.nanos(60n))
- expect(Duration.sum(Duration.seconds(Infinity), Duration.seconds(30))).toEqual(Duration.seconds(Infinity))
- expect(Duration.sum(Duration.seconds(30), Duration.seconds(Infinity))).toEqual(Duration.seconds(Infinity))
+ deepStrictEqual(Duration.sum(Duration.seconds(30), Duration.seconds(30)), Duration.minutes(1))
+ deepStrictEqual(Duration.sum(Duration.nanos(30n), Duration.nanos(30n)), Duration.nanos(60n))
+ deepStrictEqual(Duration.sum(Duration.seconds(Infinity), Duration.seconds(30)), Duration.seconds(Infinity))
+ deepStrictEqual(Duration.sum(Duration.seconds(30), Duration.seconds(Infinity)), Duration.seconds(Infinity))
- expect(Duration.sum("30 seconds", "30 seconds")).toEqual(Duration.minutes(1))
+ deepStrictEqual(Duration.sum("30 seconds", "30 seconds"), Duration.minutes(1))
})
it("subtract", () => {
- expect(Duration.subtract(Duration.seconds(30), Duration.seconds(10))).toEqual(Duration.seconds(20))
- expect(Duration.subtract(Duration.seconds(30), Duration.seconds(30))).toEqual(Duration.zero)
- expect(Duration.subtract(Duration.nanos(30n), Duration.nanos(10n))).toEqual(Duration.nanos(20n))
- expect(Duration.subtract(Duration.nanos(30n), Duration.nanos(30n))).toEqual(Duration.zero)
- expect(Duration.subtract(Duration.seconds(Infinity), Duration.seconds(30))).toEqual(Duration.seconds(Infinity))
- expect(Duration.subtract(Duration.seconds(30), Duration.seconds(Infinity))).toEqual(Duration.zero)
+ deepStrictEqual(Duration.subtract(Duration.seconds(30), Duration.seconds(10)), Duration.seconds(20))
+ deepStrictEqual(Duration.subtract(Duration.seconds(30), Duration.seconds(30)), Duration.zero)
+ deepStrictEqual(Duration.subtract(Duration.nanos(30n), Duration.nanos(10n)), Duration.nanos(20n))
+ deepStrictEqual(Duration.subtract(Duration.nanos(30n), Duration.nanos(30n)), Duration.zero)
+ deepStrictEqual(Duration.subtract(Duration.seconds(Infinity), Duration.seconds(30)), Duration.seconds(Infinity))
+ deepStrictEqual(Duration.subtract(Duration.seconds(30), Duration.seconds(Infinity)), Duration.zero)
- expect(Duration.subtract("30 seconds", "10 seconds")).toEqual(Duration.seconds(20))
+ deepStrictEqual(Duration.subtract("30 seconds", "10 seconds"), Duration.seconds(20))
})
it("greaterThan", () => {
- assert.isTrue(pipe(Duration.seconds(30), Duration.greaterThan(Duration.seconds(20))))
- assert.isFalse(pipe(Duration.seconds(30), Duration.greaterThan(Duration.seconds(30))))
- assert.isFalse(pipe(Duration.seconds(30), Duration.greaterThan(Duration.seconds(60))))
+ assertTrue(pipe(Duration.seconds(30), Duration.greaterThan(Duration.seconds(20))))
+ assertFalse(pipe(Duration.seconds(30), Duration.greaterThan(Duration.seconds(30))))
+ assertFalse(pipe(Duration.seconds(30), Duration.greaterThan(Duration.seconds(60))))
- assert.isTrue(pipe(Duration.nanos(30n), Duration.greaterThan(Duration.nanos(20n))))
- assert.isFalse(pipe(Duration.nanos(30n), Duration.greaterThan(Duration.nanos(30n))))
- assert.isFalse(pipe(Duration.nanos(30n), Duration.greaterThan(Duration.nanos(60n))))
+ assertTrue(pipe(Duration.nanos(30n), Duration.greaterThan(Duration.nanos(20n))))
+ assertFalse(pipe(Duration.nanos(30n), Duration.greaterThan(Duration.nanos(30n))))
+ assertFalse(pipe(Duration.nanos(30n), Duration.greaterThan(Duration.nanos(60n))))
- assert.isTrue(pipe(Duration.millis(1), Duration.greaterThan(Duration.nanos(1n))))
+ assertTrue(pipe(Duration.millis(1), Duration.greaterThan(Duration.nanos(1n))))
- expect(Duration.greaterThan("2 seconds", "2 seconds")).toBe(false)
- expect(Duration.greaterThan("3 seconds", "2 seconds")).toBe(true)
- expect(Duration.greaterThan("2 seconds", "3 seconds")).toBe(false)
+ assertFalse(Duration.greaterThan("2 seconds", "2 seconds"))
+ assertTrue(Duration.greaterThan("3 seconds", "2 seconds"))
+ assertFalse(Duration.greaterThan("2 seconds", "3 seconds"))
})
it("greaterThan - Infinity", () => {
- assert.isTrue(pipe(Duration.infinity, Duration.greaterThan(Duration.seconds(20))))
- assert.isFalse(pipe(Duration.seconds(-Infinity), Duration.greaterThan(Duration.infinity)))
- assert.isFalse(pipe(Duration.nanos(1n), Duration.greaterThan(Duration.infinity)))
+ assertTrue(pipe(Duration.infinity, Duration.greaterThan(Duration.seconds(20))))
+ assertFalse(pipe(Duration.seconds(-Infinity), Duration.greaterThan(Duration.infinity)))
+ assertFalse(pipe(Duration.nanos(1n), Duration.greaterThan(Duration.infinity)))
})
it("greaterThanOrEqualTo", () => {
- assert.isTrue(pipe(Duration.seconds(30), Duration.greaterThanOrEqualTo(Duration.seconds(20))))
- assert.isTrue(pipe(Duration.seconds(30), Duration.greaterThanOrEqualTo(Duration.seconds(30))))
- assert.isFalse(pipe(Duration.seconds(30), Duration.greaterThanOrEqualTo(Duration.seconds(60))))
+ assertTrue(pipe(Duration.seconds(30), Duration.greaterThanOrEqualTo(Duration.seconds(20))))
+ assertTrue(pipe(Duration.seconds(30), Duration.greaterThanOrEqualTo(Duration.seconds(30))))
+ assertFalse(pipe(Duration.seconds(30), Duration.greaterThanOrEqualTo(Duration.seconds(60))))
- assert.isTrue(pipe(Duration.nanos(30n), Duration.greaterThanOrEqualTo(Duration.nanos(20n))))
- assert.isTrue(pipe(Duration.nanos(30n), Duration.greaterThanOrEqualTo(Duration.nanos(30n))))
- assert.isFalse(pipe(Duration.nanos(30n), Duration.greaterThanOrEqualTo(Duration.nanos(60n))))
+ assertTrue(pipe(Duration.nanos(30n), Duration.greaterThanOrEqualTo(Duration.nanos(20n))))
+ assertTrue(pipe(Duration.nanos(30n), Duration.greaterThanOrEqualTo(Duration.nanos(30n))))
+ assertFalse(pipe(Duration.nanos(30n), Duration.greaterThanOrEqualTo(Duration.nanos(60n))))
- expect(Duration.greaterThanOrEqualTo("2 seconds", "2 seconds")).toBe(true)
- expect(Duration.greaterThanOrEqualTo("3 seconds", "2 seconds")).toBe(true)
- expect(Duration.greaterThanOrEqualTo("2 seconds", "3 seconds")).toBe(false)
+ assertTrue(Duration.greaterThanOrEqualTo("2 seconds", "2 seconds"))
+ assertTrue(Duration.greaterThanOrEqualTo("3 seconds", "2 seconds"))
+ assertFalse(Duration.greaterThanOrEqualTo("2 seconds", "3 seconds"))
})
it("lessThan", () => {
- assert.isTrue(pipe(Duration.seconds(20), Duration.lessThan(Duration.seconds(30))))
- assert.isFalse(pipe(Duration.seconds(30), Duration.lessThan(Duration.seconds(30))))
- assert.isFalse(pipe(Duration.seconds(60), Duration.lessThan(Duration.seconds(30))))
+ assertTrue(pipe(Duration.seconds(20), Duration.lessThan(Duration.seconds(30))))
+ assertFalse(pipe(Duration.seconds(30), Duration.lessThan(Duration.seconds(30))))
+ assertFalse(pipe(Duration.seconds(60), Duration.lessThan(Duration.seconds(30))))
- assert.isTrue(pipe(Duration.nanos(20n), Duration.lessThan(Duration.nanos(30n))))
- assert.isFalse(pipe(Duration.nanos(30n), Duration.lessThan(Duration.nanos(30n))))
- assert.isFalse(pipe(Duration.nanos(60n), Duration.lessThan(Duration.nanos(30n))))
+ assertTrue(pipe(Duration.nanos(20n), Duration.lessThan(Duration.nanos(30n))))
+ assertFalse(pipe(Duration.nanos(30n), Duration.lessThan(Duration.nanos(30n))))
+ assertFalse(pipe(Duration.nanos(60n), Duration.lessThan(Duration.nanos(30n))))
- assert.isTrue(pipe(Duration.nanos(1n), Duration.lessThan(Duration.millis(1))))
+ assertTrue(pipe(Duration.nanos(1n), Duration.lessThan(Duration.millis(1))))
- expect(Duration.lessThan("2 seconds", "2 seconds")).toBe(false)
- expect(Duration.lessThan("3 seconds", "2 seconds")).toBe(false)
- expect(Duration.lessThan("2 seconds", "3 seconds")).toBe(true)
+ assertFalse(Duration.lessThan("2 seconds", "2 seconds"))
+ assertFalse(Duration.lessThan("3 seconds", "2 seconds"))
+ assertTrue(Duration.lessThan("2 seconds", "3 seconds"))
})
it("lessThanOrEqualTo", () => {
- assert.isTrue(pipe(Duration.seconds(20), Duration.lessThanOrEqualTo(Duration.seconds(30))))
- assert.isTrue(pipe(Duration.seconds(30), Duration.lessThanOrEqualTo(Duration.seconds(30))))
- assert.isFalse(pipe(Duration.seconds(60), Duration.lessThanOrEqualTo(Duration.seconds(30))))
+ assertTrue(pipe(Duration.seconds(20), Duration.lessThanOrEqualTo(Duration.seconds(30))))
+ assertTrue(pipe(Duration.seconds(30), Duration.lessThanOrEqualTo(Duration.seconds(30))))
+ assertFalse(pipe(Duration.seconds(60), Duration.lessThanOrEqualTo(Duration.seconds(30))))
- assert.isTrue(pipe(Duration.nanos(20n), Duration.lessThanOrEqualTo(Duration.nanos(30n))))
- assert.isTrue(pipe(Duration.nanos(30n), Duration.lessThanOrEqualTo(Duration.nanos(30n))))
- assert.isFalse(pipe(Duration.nanos(60n), Duration.lessThanOrEqualTo(Duration.nanos(30n))))
+ assertTrue(pipe(Duration.nanos(20n), Duration.lessThanOrEqualTo(Duration.nanos(30n))))
+ assertTrue(pipe(Duration.nanos(30n), Duration.lessThanOrEqualTo(Duration.nanos(30n))))
+ assertFalse(pipe(Duration.nanos(60n), Duration.lessThanOrEqualTo(Duration.nanos(30n))))
- expect(Duration.lessThanOrEqualTo("2 seconds", "2 seconds")).toBe(true)
- expect(Duration.lessThanOrEqualTo("3 seconds", "2 seconds")).toBe(false)
- expect(Duration.lessThanOrEqualTo("2 seconds", "3 seconds")).toBe(true)
+ assertTrue(Duration.lessThanOrEqualTo("2 seconds", "2 seconds"))
+ assertFalse(Duration.lessThanOrEqualTo("3 seconds", "2 seconds"))
+ assertTrue(Duration.lessThanOrEqualTo("2 seconds", "3 seconds"))
})
it("String()", () => {
- expect(String(Duration.infinity)).toEqual(`Duration(Infinity)`)
- expect(String(Duration.nanos(10n))).toEqual(`Duration(10ns)`)
- expect(String(Duration.millis(2))).toEqual(`Duration(2ms)`)
- expect(String(Duration.millis(2.125))).toEqual(`Duration(2ms 125000ns)`)
- expect(String(Duration.seconds(2))).toEqual(`Duration(2s)`)
- expect(String(Duration.seconds(2.5))).toEqual(`Duration(2s 500ms)`)
+ strictEqual(String(Duration.infinity), `Duration(Infinity)`)
+ strictEqual(String(Duration.nanos(10n)), `Duration(10ns)`)
+ strictEqual(String(Duration.millis(2)), `Duration(2ms)`)
+ strictEqual(String(Duration.millis(2.125)), `Duration(2ms 125000ns)`)
+ strictEqual(String(Duration.seconds(2)), `Duration(2s)`)
+ strictEqual(String(Duration.seconds(2.5)), `Duration(2s 500ms)`)
})
it("format", () => {
- expect(Duration.format(Duration.infinity)).toEqual(`Infinity`)
- expect(Duration.format(Duration.minutes(5))).toEqual(`5m`)
- expect(Duration.format(Duration.minutes(5.325))).toEqual(`5m 19s 500ms`)
- expect(Duration.format(Duration.hours(3))).toEqual(`3h`)
- expect(Duration.format(Duration.hours(3.11125))).toEqual(`3h 6m 40s 500ms`)
- expect(Duration.format(Duration.days(2))).toEqual(`2d`)
- expect(Duration.format(Duration.days(2.25))).toEqual(`2d 6h`)
- expect(Duration.format(Duration.weeks(1))).toEqual(`7d`)
+ strictEqual(Duration.format(Duration.infinity), `Infinity`)
+ strictEqual(Duration.format(Duration.minutes(5)), `5m`)
+ strictEqual(Duration.format(Duration.minutes(5.325)), `5m 19s 500ms`)
+ strictEqual(Duration.format(Duration.hours(3)), `3h`)
+ strictEqual(Duration.format(Duration.hours(3.11125)), `3h 6m 40s 500ms`)
+ strictEqual(Duration.format(Duration.days(2)), `2d`)
+ strictEqual(Duration.format(Duration.days(2.25)), `2d 6h`)
+ strictEqual(Duration.format(Duration.weeks(1)), `7d`)
})
it("format", () => {
- expect(Duration.parts(Duration.infinity)).toStrictEqual({
+ deepStrictEqual(Duration.parts(Duration.infinity), {
days: Infinity,
hours: Infinity,
minutes: Infinity,
@@ -324,7 +324,7 @@ describe("Duration", () => {
nanos: Infinity
})
- expect(Duration.parts(Duration.minutes(5.325))).toStrictEqual({
+ deepStrictEqual(Duration.parts(Duration.minutes(5.325)), {
days: 0,
hours: 0,
minutes: 5,
@@ -333,7 +333,7 @@ describe("Duration", () => {
nanos: 0
})
- expect(Duration.parts(Duration.minutes(3.11125))).toStrictEqual({
+ deepStrictEqual(Duration.parts(Duration.minutes(3.11125)), {
days: 0,
hours: 0,
minutes: 3,
@@ -344,114 +344,104 @@ describe("Duration", () => {
})
it("toJSON", () => {
- expect(Duration.seconds(2).toJSON()).toEqual(
- { _id: "Duration", _tag: "Millis", millis: 2000 }
- )
+ deepStrictEqual(Duration.seconds(2).toJSON(), { _id: "Duration", _tag: "Millis", millis: 2000 })
})
it("toJSON/ non-integer millis", () => {
- expect(Duration.millis(1.5).toJSON()).toEqual(
- { _id: "Duration", _tag: "Nanos", hrtime: [0, 1_500_000] }
- )
+ deepStrictEqual(Duration.millis(1.5).toJSON(), { _id: "Duration", _tag: "Nanos", hrtime: [0, 1_500_000] })
})
it("toJSON/ nanos", () => {
- expect(Duration.nanos(5n).toJSON()).toEqual(
- { _id: "Duration", _tag: "Nanos", hrtime: [0, 5] }
- )
+ deepStrictEqual(Duration.nanos(5n).toJSON(), { _id: "Duration", _tag: "Nanos", hrtime: [0, 5] })
})
it("toJSON/ infinity", () => {
- expect(Duration.infinity.toJSON()).toEqual(
- { _id: "Duration", _tag: "Infinity" }
- )
+ deepStrictEqual(Duration.infinity.toJSON(), { _id: "Duration", _tag: "Infinity" })
})
it(`inspect`, () => {
if (typeof window === "undefined") {
// eslint-disable-next-line @typescript-eslint/no-var-requires
const { inspect } = require("node:util")
- expect(inspect(Duration.millis(1000))).toEqual(
- inspect({ _id: "Duration", _tag: "Millis", millis: 1000 })
- )
+ deepStrictEqual(inspect(Duration.millis(1000)), inspect({ _id: "Duration", _tag: "Millis", millis: 1000 }))
}
})
it("sum/ Infinity", () => {
- expect(Duration.sum(Duration.seconds(1), Duration.infinity)).toEqual(Duration.infinity)
+ deepStrictEqual(Duration.sum(Duration.seconds(1), Duration.infinity), Duration.infinity)
})
it(".pipe()", () => {
- expect(Duration.seconds(1).pipe(Duration.sum(Duration.seconds(1)))).toEqual(Duration.seconds(2))
+ deepStrictEqual(Duration.seconds(1).pipe(Duration.sum(Duration.seconds(1))), Duration.seconds(2))
})
it("isDuration", () => {
- expect(Duration.isDuration(Duration.millis(100))).toBe(true)
- expect(Duration.isDuration(null)).toBe(false)
+ assertTrue(Duration.isDuration(Duration.millis(100)))
+ assertFalse(Duration.isDuration(null))
})
it("zero", () => {
- expect(Duration.zero.value).toEqual({ _tag: "Millis", millis: 0 })
+ deepStrictEqual(Duration.zero.value, { _tag: "Millis", millis: 0 })
})
it("infinity", () => {
- expect(Duration.infinity.value).toEqual({ _tag: "Infinity" })
+ deepStrictEqual(Duration.infinity.value, { _tag: "Infinity" })
})
it("weeks", () => {
- expect(Equal.equals(Duration.weeks(1), Duration.days(7))).toBe(true)
- expect(Equal.equals(Duration.weeks(1), Duration.days(1))).toBe(false)
+ assertTrue(Equal.equals(Duration.weeks(1), Duration.days(7)))
+ assertFalse(Equal.equals(Duration.weeks(1), Duration.days(1)))
})
it("toMillis", () => {
- expect(Duration.millis(1).pipe(Duration.toMillis)).toBe(1)
- expect(Duration.nanos(1n).pipe(Duration.toMillis)).toBe(0.000001)
- expect(Duration.infinity.pipe(Duration.toMillis)).toBe(Infinity)
+ strictEqual(Duration.millis(1).pipe(Duration.toMillis), 1)
+ strictEqual(Duration.nanos(1n).pipe(Duration.toMillis), 0.000001)
+ strictEqual(Duration.infinity.pipe(Duration.toMillis), Infinity)
- expect(Duration.toMillis("1 millis")).toBe(1)
+ strictEqual(Duration.toMillis("1 millis"), 1)
})
it("toSeconds", () => {
- expect(Duration.millis(1).pipe(Duration.toSeconds)).toBe(0.001)
- expect(Duration.nanos(1n).pipe(Duration.toSeconds)).toBe(1e-9)
- expect(Duration.infinity.pipe(Duration.toSeconds)).toBe(Infinity)
+ strictEqual(Duration.millis(1).pipe(Duration.toSeconds), 0.001)
+ strictEqual(Duration.nanos(1n).pipe(Duration.toSeconds), 1e-9)
+ strictEqual(Duration.infinity.pipe(Duration.toSeconds), Infinity)
- expect(Duration.toSeconds("1 seconds")).toBe(1)
- expect(Duration.toSeconds("3 seconds")).toBe(3)
- expect(Duration.toSeconds("3 minutes")).toBe(180)
+ strictEqual(Duration.toSeconds("1 seconds"), 1)
+ strictEqual(Duration.toSeconds("3 seconds"), 3)
+ strictEqual(Duration.toSeconds("3 minutes"), 180)
})
it("toNanos", () => {
- expect(Duration.nanos(1n).pipe(Duration.toNanos)).toEqual(Option.some(1n))
- expect(Duration.infinity.pipe(Duration.toNanos)).toEqual(Option.none())
- expect(Duration.millis(1.0005).pipe(Duration.toNanos)).toEqual(Option.some(1_000_500n))
- expect(Duration.millis(100).pipe(Duration.toNanos)).toEqual(Option.some(100_000_000n))
+ assertSome(Duration.nanos(1n).pipe(Duration.toNanos), 1n)
+ assertNone(Duration.infinity.pipe(Duration.toNanos))
+ assertSome(Duration.millis(1.0005).pipe(Duration.toNanos), 1_000_500n)
+ assertSome(Duration.millis(100).pipe(Duration.toNanos), 100_000_000n)
- expect(Duration.toNanos("1 nanos")).toStrictEqual(Option.some(1n))
+ assertSome(Duration.toNanos("1 nanos"), 1n)
})
it("unsafeToNanos", () => {
- expect(Duration.nanos(1n).pipe(Duration.unsafeToNanos)).toBe(1n)
- expect(() => Duration.infinity.pipe(Duration.unsafeToNanos)).toThrow()
- expect(Duration.millis(1.0005).pipe(Duration.unsafeToNanos)).toBe(1_000_500n)
- expect(Duration.millis(100).pipe(Duration.unsafeToNanos)).toEqual(100_000_000n)
+ strictEqual(Duration.nanos(1n).pipe(Duration.unsafeToNanos), 1n)
+ throws(() => Duration.infinity.pipe(Duration.unsafeToNanos))
+ strictEqual(Duration.millis(1.0005).pipe(Duration.unsafeToNanos), 1_000_500n)
+ strictEqual(Duration.millis(100).pipe(Duration.unsafeToNanos), 100_000_000n)
- expect(Duration.unsafeToNanos("1 nanos")).toBe(1n)
+ strictEqual(Duration.unsafeToNanos("1 nanos"), 1n)
})
it("toHrTime", () => {
- expect(Duration.millis(1).pipe(Duration.toHrTime)).toEqual([0, 1_000_000])
- expect(Duration.nanos(1n).pipe(Duration.toHrTime)).toEqual([0, 1])
- expect(Duration.nanos(1_000_000_001n).pipe(Duration.toHrTime)).toEqual([1, 1])
- expect(Duration.millis(1001).pipe(Duration.toHrTime)).toEqual([1, 1_000_000])
- expect(Duration.infinity.pipe(Duration.toHrTime)).toEqual([Infinity, 0])
+ deepStrictEqual(Duration.millis(1).pipe(Duration.toHrTime), [0, 1_000_000])
+ deepStrictEqual(Duration.nanos(1n).pipe(Duration.toHrTime), [0, 1])
+ deepStrictEqual(Duration.nanos(1_000_000_001n).pipe(Duration.toHrTime), [1, 1])
+ deepStrictEqual(Duration.millis(1001).pipe(Duration.toHrTime), [1, 1_000_000])
+ deepStrictEqual(Duration.infinity.pipe(Duration.toHrTime), [Infinity, 0])
- expect(Duration.toHrTime("1 millis")).toEqual([0, 1_000_000])
+ deepStrictEqual(Duration.toHrTime("1 millis"), [0, 1_000_000])
})
it("floor is 0", () => {
- expect(Duration.millis(-1)).toEqual(Duration.zero)
- expect(Duration.nanos(-1n)).toEqual(Duration.zero)
+ deepStrictEqual(Duration.millis(-1), Duration.zero)
+ deepStrictEqual(Duration.nanos(-1n), Duration.zero)
})
it("match", () => {
@@ -459,65 +449,65 @@ describe("Duration", () => {
onMillis: () => "millis",
onNanos: () => "nanos"
})
- expect(match(Duration.decode("100 millis"))).toEqual("millis")
- expect(match(Duration.decode("10 nanos"))).toEqual("nanos")
- expect(match(Duration.decode(Infinity))).toEqual("millis")
+ strictEqual(match(Duration.decode("100 millis")), "millis")
+ strictEqual(match(Duration.decode("10 nanos")), "nanos")
+ strictEqual(match(Duration.decode(Infinity)), "millis")
- expect(match("100 millis")).toEqual("millis")
+ strictEqual(match("100 millis"), "millis")
})
it("isFinite", () => {
- expect(Duration.isFinite(Duration.millis(100))).toBe(true)
- expect(Duration.isFinite(Duration.nanos(100n))).toBe(true)
- expect(Duration.isFinite(Duration.infinity)).toBe(false)
+ assertTrue(Duration.isFinite(Duration.millis(100)))
+ assertTrue(Duration.isFinite(Duration.nanos(100n)))
+ assertFalse(Duration.isFinite(Duration.infinity))
})
it("isZero", () => {
- expect(Duration.isZero(Duration.zero)).toBe(true)
- expect(Duration.isZero(Duration.millis(0))).toBe(true)
- expect(Duration.isZero(Duration.nanos(0n))).toBe(true)
- expect(Duration.isZero(Duration.infinity)).toBe(false)
- expect(Duration.isZero(Duration.millis(1))).toBe(false)
- expect(Duration.isZero(Duration.nanos(1n))).toBe(false)
+ assertTrue(Duration.isZero(Duration.zero))
+ assertTrue(Duration.isZero(Duration.millis(0)))
+ assertTrue(Duration.isZero(Duration.nanos(0n)))
+ assertFalse(Duration.isZero(Duration.infinity))
+ assertFalse(Duration.isZero(Duration.millis(1)))
+ assertFalse(Duration.isZero(Duration.nanos(1n)))
})
it("toMinutes", () => {
- expect(Duration.millis(60000).pipe(Duration.toMinutes)).toBe(1)
- expect(Duration.nanos(60000000000n).pipe(Duration.toMinutes)).toBe(1)
- expect(Duration.infinity.pipe(Duration.toMinutes)).toBe(Infinity)
+ strictEqual(Duration.millis(60000).pipe(Duration.toMinutes), 1)
+ strictEqual(Duration.nanos(60000000000n).pipe(Duration.toMinutes), 1)
+ strictEqual(Duration.infinity.pipe(Duration.toMinutes), Infinity)
- expect(Duration.toMinutes("1 minute")).toBe(1)
- expect(Duration.toMinutes("2 minutes")).toBe(2)
- expect(Duration.toMinutes("1 hour")).toBe(60)
+ strictEqual(Duration.toMinutes("1 minute"), 1)
+ strictEqual(Duration.toMinutes("2 minutes"), 2)
+ strictEqual(Duration.toMinutes("1 hour"), 60)
})
it("toHours", () => {
- expect(Duration.millis(3_600_000).pipe(Duration.toHours)).toBe(1)
- expect(Duration.nanos(3_600_000_000_000n).pipe(Duration.toHours)).toBe(1)
- expect(Duration.infinity.pipe(Duration.toHours)).toBe(Infinity)
+ strictEqual(Duration.millis(3_600_000).pipe(Duration.toHours), 1)
+ strictEqual(Duration.nanos(3_600_000_000_000n).pipe(Duration.toHours), 1)
+ strictEqual(Duration.infinity.pipe(Duration.toHours), Infinity)
- expect(Duration.toHours("1 hour")).toBe(1)
- expect(Duration.toHours("2 hours")).toBe(2)
- expect(Duration.toHours("1 day")).toBe(24)
+ strictEqual(Duration.toHours("1 hour"), 1)
+ strictEqual(Duration.toHours("2 hours"), 2)
+ strictEqual(Duration.toHours("1 day"), 24)
})
it("toDays", () => {
- expect(Duration.millis(86_400_000).pipe(Duration.toDays)).toBe(1)
- expect(Duration.nanos(86_400_000_000_000n).pipe(Duration.toDays)).toBe(1)
- expect(Duration.infinity.pipe(Duration.toDays)).toBe(Infinity)
+ strictEqual(Duration.millis(86_400_000).pipe(Duration.toDays), 1)
+ strictEqual(Duration.nanos(86_400_000_000_000n).pipe(Duration.toDays), 1)
+ strictEqual(Duration.infinity.pipe(Duration.toDays), Infinity)
- expect(Duration.toDays("1 day")).toBe(1)
- expect(Duration.toDays("2 days")).toBe(2)
- expect(Duration.toDays("1 week")).toBe(7)
+ strictEqual(Duration.toDays("1 day"), 1)
+ strictEqual(Duration.toDays("2 days"), 2)
+ strictEqual(Duration.toDays("1 week"), 7)
})
it("toWeeks", () => {
- expect(Duration.millis(604_800_000).pipe(Duration.toWeeks)).toBe(1)
- expect(Duration.nanos(604_800_000_000_000n).pipe(Duration.toWeeks)).toBe(1)
- expect(Duration.infinity.pipe(Duration.toWeeks)).toBe(Infinity)
+ strictEqual(Duration.millis(604_800_000).pipe(Duration.toWeeks), 1)
+ strictEqual(Duration.nanos(604_800_000_000_000n).pipe(Duration.toWeeks), 1)
+ strictEqual(Duration.infinity.pipe(Duration.toWeeks), Infinity)
- expect(Duration.toWeeks("1 week")).toBe(1)
- expect(Duration.toWeeks("2 weeks")).toBe(2)
- expect(Duration.toWeeks("14 days")).toBe(2)
+ strictEqual(Duration.toWeeks("1 week"), 1)
+ strictEqual(Duration.toWeeks("2 weeks"), 2)
+ strictEqual(Duration.toWeeks("14 days"), 2)
})
})
diff --git a/packages/effect/test/Effect/acquire-release.test.ts b/packages/effect/test/Effect/acquire-release.test.ts
index 04d12e26c61..3c806769a31 100644
--- a/packages/effect/test/Effect/acquire-release.test.ts
+++ b/packages/effect/test/Effect/acquire-release.test.ts
@@ -5,8 +5,9 @@ import { equals } from "effect/Equal"
import * as Exit from "effect/Exit"
import { pipe } from "effect/Function"
import * as Ref from "effect/Ref"
+import { assertTrue, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("acquireUseRelease - happy path", () =>
@@ -20,8 +21,8 @@ describe("Effect", () => {
)
)
const released = yield* $(Ref.get(release))
- assert.strictEqual(result, 43)
- assert.isTrue(released)
+ strictEqual(result, 43)
+ assertTrue(released)
}))
it.effect("acquireUseRelease - happy path + disconnect", () =>
Effect.gen(function*($) {
@@ -35,8 +36,8 @@ describe("Effect", () => {
Effect.disconnect
)
const released = yield* $(Ref.get(release))
- assert.strictEqual(result, 43)
- assert.isTrue(released)
+ strictEqual(result, 43)
+ assertTrue(released)
}))
it.effect("acquireUseRelease - error handling", () =>
Effect.gen(function*($) {
@@ -53,8 +54,8 @@ describe("Effect", () => {
exit,
Exit.matchEffect({ onFailure: Effect.succeed, onSuccess: () => Effect.fail("effect should have failed") })
)
- assert.isTrue(equals(Cause.failures(result), Chunk.of("use failed")))
- assert.isTrue(equals(Cause.defects(result), Chunk.of(releaseDied)))
+ assertTrue(equals(Cause.failures(result), Chunk.of("use failed")))
+ assertTrue(equals(Cause.defects(result), Chunk.of(releaseDied)))
}))
it.effect("acquireUseRelease - error handling + disconnect", () =>
Effect.gen(function*($) {
@@ -75,8 +76,8 @@ describe("Effect", () => {
onSuccess: () => Effect.fail("effect should have failed")
})
)
- assert.isTrue(equals(Cause.failures(result), Chunk.of("use failed")))
- assert.isTrue(equals(Cause.defects(result), Chunk.of(releaseDied)))
+ assertTrue(equals(Cause.failures(result), Chunk.of("use failed")))
+ assertTrue(equals(Cause.defects(result), Chunk.of(releaseDied)))
}))
it.effect("acquireUseRelease - beast mode error handling + disconnect", () =>
Effect.gen(function*($) {
@@ -105,7 +106,7 @@ describe("Effect", () => {
)
)
const released = yield* $(Ref.get(release))
- assert.isTrue(equals(Cause.defects(result), Chunk.of(useDied)))
- assert.isTrue(released)
+ assertTrue(equals(Cause.defects(result), Chunk.of(useDied)))
+ assertTrue(released)
}))
})
diff --git a/packages/effect/test/Effect/applicative.test.ts b/packages/effect/test/Effect/applicative.test.ts
index 1d38ee58ce5..b3a55b9a6fd 100644
--- a/packages/effect/test/Effect/applicative.test.ts
+++ b/packages/effect/test/Effect/applicative.test.ts
@@ -1,7 +1,7 @@
import * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
+import { assertLeft, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
const add = (a: number) => (b: number) => a + b
@@ -9,7 +9,7 @@ describe("Effect", () => {
it.effect("two successes should succeed", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.succeed(add).pipe(Effect.ap(Effect.succeed(1)), Effect.ap(Effect.succeed(2))))
- assert.strictEqual(result, 3)
+ strictEqual(result, 3)
}))
it.effect("one failure in data-last position should fail", () =>
@@ -18,7 +18,7 @@ describe("Effect", () => {
Effect.succeed(add).pipe(Effect.ap(Effect.succeed(1)), Effect.ap(Effect.fail("c"))),
Effect.either
)
- assert.deepStrictEqual(result, Either.left("c"))
+ assertLeft(result, "c")
}))
it.effect("one failure in data-first position should fail", () =>
@@ -27,7 +27,7 @@ describe("Effect", () => {
Effect.succeed(add).pipe(Effect.ap(Effect.fail("b")), Effect.ap(Effect.fail("c"))),
Effect.either
)
- assert.deepStrictEqual(result, Either.left("b"))
+ assertLeft(result, "b")
}))
it.effect("an applicative operation that starts with a failure should fail", () =>
@@ -39,6 +39,6 @@ describe("Effect", () => {
),
Effect.either
)
- assert.deepStrictEqual(result, Either.left("a"))
+ assertLeft(result, "a")
}))
})
diff --git a/packages/effect/test/Effect/async.test.ts b/packages/effect/test/Effect/async.test.ts
index f82be95de52..33353ae4d03 100644
--- a/packages/effect/test/Effect/async.test.ts
+++ b/packages/effect/test/Effect/async.test.ts
@@ -9,7 +9,8 @@ import { pipe } from "effect/Function"
import * as Option from "effect/Option"
import * as Ref from "effect/Ref"
import * as Runtime from "effect/Runtime"
-import { assert, describe, it } from "effect/test/utils/extend"
+import { assertNone, assertSome, deepStrictEqual, strictEqual } from "effect/test/util"
+import { describe, it } from "effect/test/utils/extend"
describe("Effect", () => {
it.effect("simple async must return", () =>
@@ -17,14 +18,14 @@ describe("Effect", () => {
const result = yield* $(Effect.async((cb) => {
cb(Effect.succeed(42))
}))
- assert.strictEqual(result, 42)
+ strictEqual(result, 42)
}))
it.effect("simple asyncEffect must return", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.asyncEffect((resume) => {
return Effect.succeed(resume(Effect.succeed(42)))
}))
- assert.strictEqual(result, 42)
+ strictEqual(result, 42)
}))
if (typeof window === "undefined") {
// eslint-disable-next-line @typescript-eslint/no-var-requires
@@ -45,7 +46,7 @@ describe("Effect", () => {
}
const procNum = Effect.sync(() => os.cpus().length)
const result = yield* $(procNum, Effect.flatMap(stackIOs))
- assert.strictEqual(result, 42)
+ strictEqual(result, 42)
}))
}
it.effect("interrupt of asyncEffect register", () =>
@@ -68,7 +69,7 @@ describe("Effect", () => {
yield* $(Deferred.await(acquire))
yield* $(Fiber.interruptFork(fiber))
const result = yield* $(Deferred.await(release))
- assert.isUndefined(result)
+ strictEqual(result, undefined)
}))
it.live("async should not resume fiber twice after interruption", () =>
Effect.gen(function*($) {
@@ -91,8 +92,8 @@ describe("Effect", () => {
)
const result = yield* $(Fiber.interrupt(fiber), Effect.timeout(Duration.seconds(1)), Effect.option)
const unexpected = yield* $(Ref.get(unexpectedPlace))
- assert.deepStrictEqual(unexpected, Chunk.empty())
- assert.deepStrictEqual(result, Option.none()) // the timeout should happen
+ deepStrictEqual(unexpected, Chunk.empty())
+ assertNone(result) // the timeout should happen
}))
it.live("async should not resume fiber twice after synchronous result", () =>
Effect.gen(function*($) {
@@ -119,13 +120,13 @@ describe("Effect", () => {
)
const result = yield* $(Fiber.interrupt(fiber), Effect.timeout(Duration.seconds(1)), Effect.option)
const unexpected = yield* $(Ref.get(unexpectedPlace))
- assert.deepStrictEqual(unexpected, Chunk.empty())
- assert.deepStrictEqual(result, Option.none()) // timeout should happen
+ deepStrictEqual(unexpected, Chunk.empty())
+ assertNone(result) // timeout should happen
}))
it.effect("sleep 0 must return", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.sleep(Duration.zero))
- assert.isUndefined(result)
+ strictEqual(result, undefined)
}))
it.effect("shallow bind of async chain", () =>
Effect.gen(function*($) {
@@ -139,7 +140,7 @@ describe("Effect", () => {
})
)
), Effect.succeed(0)))
- assert.strictEqual(result, 10)
+ strictEqual(result, 10)
}))
it.effect("asyncEffect can fail before registering", () =>
Effect.gen(function*($) {
@@ -149,7 +150,7 @@ describe("Effect", () => {
}),
Effect.flip
)
- assert.strictEqual(result, "ouch")
+ strictEqual(result, "ouch")
}))
it.effect("asyncEffect can defect before registering", () =>
Effect.gen(function*($) {
@@ -170,6 +171,6 @@ describe("Effect", () => {
onSuccess: () => Option.none()
}))
)
- assert.deepStrictEqual(result, Option.some("ouch"))
+ assertSome(result, "ouch")
}))
})
diff --git a/packages/effect/test/Effect/caching.test.ts b/packages/effect/test/Effect/caching.test.ts
index 3c783ad80d4..a2e2318108e 100644
--- a/packages/effect/test/Effect/caching.test.ts
+++ b/packages/effect/test/Effect/caching.test.ts
@@ -2,9 +2,10 @@ import * as Duration from "effect/Duration"
import * as Effect from "effect/Effect"
import { pipe } from "effect/Function"
import * as Ref from "effect/Ref"
+import { assertTrue, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
import * as TestClock from "effect/TestClock"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("cached - returns new instances after duration", () =>
@@ -21,9 +22,9 @@ describe("Effect", () => {
const c = yield* $(cache)
yield* $(TestClock.adjust(Duration.minutes(59)))
const d = yield* $(cache)
- assert.strictEqual(a, b)
- assert.notStrictEqual(b, c)
- assert.strictEqual(c, d)
+ strictEqual(a, b)
+ assertTrue(b !== c)
+ strictEqual(c, d)
}))
it.effect("cached - correctly handles an infinite duration time to live", () =>
Effect.gen(function*($) {
@@ -35,9 +36,9 @@ describe("Effect", () => {
const a = yield* $(cached)
const b = yield* $(cached)
const c = yield* $(cached)
- assert.strictEqual(a, 0)
- assert.strictEqual(b, 0)
- assert.strictEqual(c, 0)
+ strictEqual(a, 0)
+ strictEqual(b, 0)
+ strictEqual(c, 0)
}))
it.effect("cachedInvalidate - returns new instances after duration", () =>
Effect.gen(function*($) {
@@ -57,9 +58,9 @@ describe("Effect", () => {
const d = yield* $(cached)
yield* $(TestClock.adjust(Duration.minutes(59)))
const e = yield* $(cached)
- assert.strictEqual(a, b)
- assert.notStrictEqual(b, c)
- assert.strictEqual(c, d)
- assert.notStrictEqual(d, e)
+ strictEqual(a, b)
+ assertTrue(b !== c)
+ strictEqual(c, d)
+ assertTrue(d !== e)
}))
})
diff --git a/packages/effect/test/Effect/cause-rendering.test.ts b/packages/effect/test/Effect/cause-rendering.test.ts
index 80cf8d8ca98..085a619c72a 100644
--- a/packages/effect/test/Effect/cause-rendering.test.ts
+++ b/packages/effect/test/Effect/cause-rendering.test.ts
@@ -1,8 +1,7 @@
-import * as Cause from "effect/Cause"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
+import { Cause, Effect, Option } from "effect"
+import { assertFalse, assertTrue, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("Cause should include span data", () =>
@@ -15,10 +14,10 @@ describe("Effect", () => {
)
)))
const rendered = Cause.pretty(cause)
- assert.include(rendered, "spanA")
- assert.include(rendered, "cause-rendering.test.ts:12")
- assert.include(rendered, "spanB")
- assert.include(rendered, "cause-rendering.test.ts:11")
+ assertTrue(rendered.includes("spanA"))
+ assertTrue(rendered.includes("cause-rendering.test.ts:11:18"))
+ assertTrue(rendered.includes("spanB"))
+ assertTrue(rendered.includes("cause-rendering.test.ts:10:16"))
}))
it.effect("catchTag should not invalidate traces", () =>
Effect.gen(function*($) {
@@ -39,12 +38,12 @@ describe("Effect", () => {
).pipe(Effect.catchTag("E2", (e) => Effect.die(e)))
const cause = yield* $(Effect.flip(Effect.sandbox(effect)))
const rendered = Cause.pretty(cause)
- assert.include(rendered, "spanA")
- assert.include(rendered, "spanB")
+ assertTrue(rendered.includes("spanA"))
+ assertTrue(rendered.includes("spanB"))
const obj = Option.getOrThrow(Cause.failureOption(cause))
- assert.isTrue(obj instanceof E1)
- assert.isFalse(err === obj)
- assert.isTrue(err === Cause.originalError(obj))
+ assertTrue(obj instanceof E1)
+ assertFalse(err === obj)
+ assertTrue(err === Cause.originalError(obj))
}))
it.effect("refail should not invalidate traces", () =>
Effect.gen(function*($) {
@@ -64,8 +63,8 @@ describe("Effect", () => {
).pipe(Effect.catchAll((e) => Effect.fail(e)))
const cause = yield* $(Effect.flip(Effect.sandbox(effect)))
const rendered = Cause.pretty(cause)
- assert.include(rendered, "spanA")
- assert.include(rendered, "spanB")
+ assertTrue(rendered.includes("spanA"))
+ assertTrue(rendered.includes("spanB"))
}))
it.effect("catchTags should not invalidate traces", () =>
Effect.gen(function*($) {
@@ -85,8 +84,8 @@ describe("Effect", () => {
).pipe(Effect.catchTags({ E2: (e) => Effect.die(e) }))
const cause = yield* $(Effect.flip(Effect.sandbox(effect)))
const rendered = Cause.pretty(cause)
- assert.include(rendered, "spanA")
- assert.include(rendered, "spanB")
+ assertTrue(rendered.includes("spanA"))
+ assertTrue(rendered.includes("spanB"))
}))
it.effect("shows line where error was created", () =>
Effect.gen(function*($) {
@@ -98,7 +97,7 @@ describe("Effect", () => {
Effect.flip
)
const pretty = Cause.pretty(cause)
- assert.include(pretty, "cause-rendering.test.ts")
+ assertTrue(pretty.includes("cause-rendering.test.ts"))
}))
it.effect("functionWithSpan PrettyError stack", () =>
@@ -109,13 +108,13 @@ describe("Effect", () => {
})
const cause = yield* fail(123).pipe(Effect.sandbox, Effect.flip)
const prettyErrors = Cause.prettyErrors(cause)
- assert.strictEqual(prettyErrors.length, 1)
+ strictEqual(prettyErrors.length, 1)
const error = prettyErrors[0]
- assert.strictEqual(error.name, "Error")
- assert.notInclude(error.stack, "/internal/")
- assert.include(error.stack, "cause-rendering.test.ts:107")
- assert.include(error.stack, "span-123")
- assert.include(error.stack, "cause-rendering.test.ts:110")
+ strictEqual(error.name, "Error")
+ assertTrue(!error.stack?.includes("/internal/"))
+ assertTrue(error.stack?.includes("cause-rendering.test.ts:106"))
+ assertTrue(error.stack?.includes("span-123"))
+ assertTrue(error.stack?.includes("cause-rendering.test.ts:109"))
}))
it.effect("includes span name in stack", () =>
@@ -124,7 +123,7 @@ describe("Effect", () => {
options: (n) => ({ name: `fn-${n}` }),
body: (a: number) =>
Effect.sync(() => {
- assert.strictEqual(a, 2)
+ strictEqual(a, 2)
})
})
const cause = yield* fn(0).pipe(
@@ -132,7 +131,7 @@ describe("Effect", () => {
Effect.flip
)
const prettyErrors = Cause.prettyErrors(cause)
- assert.include(prettyErrors[0].stack ?? "", "at fn-0 ")
+ assertTrue(prettyErrors[0].stack?.includes("at fn-0 "))
}))
// ENABLE TO TEST EXPECT OUTPUT
@@ -149,7 +148,7 @@ describe("Effect", () => {
Effect.flip
)
const pretty = Cause.pretty(cause)
- assert.isTrue(pretty.startsWith(`Error: Multi-line
+ assertTrue(pretty.startsWith(`Error: Multi-line
error
message
at`))
@@ -162,7 +161,7 @@ message
Effect.flip
)
const pretty = Cause.pretty(cause, { renderErrorCause: true })
- assert.include(pretty, "[cause]: Error: child")
+ assertTrue(pretty.includes("[cause]: Error: child"))
}))
it.effect("pretty nested cause", () =>
@@ -174,7 +173,7 @@ message
Effect.flip
)
const pretty = Cause.pretty(cause, { renderErrorCause: true })
- assert.include(pretty, "[cause]: Error: child")
- assert.include(pretty, "[cause]: Error: child2")
+ assertTrue(pretty.includes("[cause]: Error: child"))
+ assertTrue(pretty.includes("[cause]: Error: child2"))
}))
})
diff --git a/packages/effect/test/Effect/collecting.test.ts b/packages/effect/test/Effect/collecting.test.ts
index 1abd7cde3f8..d6c9bbc2884 100644
--- a/packages/effect/test/Effect/collecting.test.ts
+++ b/packages/effect/test/Effect/collecting.test.ts
@@ -1,8 +1,9 @@
import * as Cause from "effect/Cause"
import * as Effect from "effect/Effect"
import * as Ref from "effect/Ref"
+import { deepStrictEqual, notDeepStrictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
describe("all", () => {
@@ -12,7 +13,7 @@ describe("Effect", () => {
const result = yield* $(Effect.all([1, 2, 3].map(Effect.succeed), {
concurrency: "unbounded"
}))
- assert.deepStrictEqual(Array.from(result), [1, 2, 3])
+ deepStrictEqual(Array.from(result), [1, 2, 3])
}))
it.effect("concurrency > 1", () =>
@@ -20,7 +21,7 @@ describe("Effect", () => {
const result = yield* $(Effect.all([1, 2, 3].map(Effect.succeed), {
concurrency: 2
}))
- assert.deepStrictEqual(Array.from(result), [1, 2, 3])
+ deepStrictEqual(Array.from(result), [1, 2, 3])
}))
})
@@ -30,7 +31,7 @@ describe("Effect", () => {
const op = Ref.getAndUpdate(counter, (n) => n + 1)
const ops3 = Effect.all([op, op, op], { concurrency: "unbounded" })
const result = yield* $(ops3, Effect.zip(ops3, { concurrent: true }))
- assert.notDeepEqual(Array.from(result[0]), Array.from(result[1]))
+ notDeepStrictEqual(Array.from(result[0]), Array.from(result[1]))
}))
it.effect("preserves failures", () =>
@@ -42,7 +43,7 @@ describe("Effect", () => {
}),
Effect.flip
)
- assert.deepStrictEqual(result, new Cause.RuntimeException())
+ deepStrictEqual(result, new Cause.RuntimeException())
}))
})
})
diff --git a/packages/effect/test/Effect/concurrency.test.ts b/packages/effect/test/Effect/concurrency.test.ts
index 4ed3586f665..b848738364a 100644
--- a/packages/effect/test/Effect/concurrency.test.ts
+++ b/packages/effect/test/Effect/concurrency.test.ts
@@ -6,10 +6,11 @@ import * as Exit from "effect/Exit"
import * as Fiber from "effect/Fiber"
import { pipe } from "effect/Function"
import * as Ref from "effect/Ref"
+import { assertFalse, assertLeft, assertRight, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
import { withLatch } from "effect/test/utils/latch"
import { adjust } from "effect/TestClock"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
export const ExampleError = new Error("Oh noes!")
@@ -37,12 +38,12 @@ describe("Effect", () => {
it.effect("shallow fork/join identity", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.succeed(42), Effect.fork, Effect.flatMap(Fiber.join))
- assert.strictEqual(result, 42)
+ strictEqual(result, 42)
}))
it.effect("deep fork/join identity", () =>
Effect.gen(function*($) {
const result = yield* $(concurrentFib(20))
- assert.strictEqual(result, fib(20))
+ strictEqual(result, fib(20))
}))
it.effect("asyncEffect creation is interruptible", () =>
Effect.gen(function*($) {
@@ -62,7 +63,7 @@ describe("Effect", () => {
yield* $(Deferred.await(acquire))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Deferred.await(release))
- assert.strictEqual(result, 42)
+ strictEqual(result, 42)
}))
it.effect("daemon fiber is unsupervised", () =>
Effect.gen(function*($) {
@@ -80,7 +81,7 @@ describe("Effect", () => {
const fiber2 = yield* $(Fiber.join(fiber1))
const result = yield* $(Ref.get(ref))
yield* $(Fiber.interrupt(fiber2))
- assert.isFalse(result)
+ assertFalse(result)
}))
it.effect("daemon fiber race interruption", () =>
Effect.gen(function*($) {
@@ -106,7 +107,7 @@ describe("Effect", () => {
)
)
const result = yield* $(Ref.get(interruptionRef))
- assert.strictEqual(result, 2)
+ strictEqual(result, 2)
}))
it.effect("race in daemon is executed", () =>
Effect.gen(function*($) {
@@ -130,8 +131,8 @@ describe("Effect", () => {
yield* $(Fiber.interrupt(fiber))
const res1 = yield* $(Deferred.await(deferred1))
const res2 = yield* $(Deferred.await(deferred2))
- assert.isUndefined(res1)
- assert.isUndefined(res2)
+ strictEqual(res1, undefined)
+ strictEqual(res2, undefined)
}))
it.live("supervise fibers", () =>
Effect.gen(function*($) {
@@ -155,27 +156,27 @@ describe("Effect", () => {
)
)
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 2)
+ strictEqual(result, 2)
}))
it.effect("race of fail with success", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.fail(42), Effect.race(Effect.succeed(24)), Effect.either)
- assert.deepStrictEqual(result, Either.right(24))
+ assertRight(result, 24)
}))
it.effect("race of terminate with success", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.dieSync(() => new Error()), Effect.race(Effect.succeed(24)))
- assert.strictEqual(result, 24)
+ strictEqual(result, 24)
}))
it.effect("race of fail with fail", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.fail(42), Effect.race(Effect.fail(24)), Effect.either)
- assert.deepStrictEqual(result, Either.left(42))
+ assertLeft(result, 42)
}))
it.effect("race of value and never", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.succeed(42), Effect.race(Effect.never))
- assert.strictEqual(result, 42)
+ strictEqual(result, 42)
}))
it.effect("race in uninterruptible region", () =>
Effect.gen(function*($) {
@@ -188,9 +189,9 @@ describe("Effect", () => {
)
yield* $(Deferred.await(latch))
yield* $(adjust("30 seconds"))
- assert.isTrue(fiber.unsafePoll() === null)
+ strictEqual(fiber.unsafePoll(), null)
yield* $(adjust("60 seconds"))
- assert.isFalse(fiber.unsafePoll() === null)
+ assertTrue(fiber.unsafePoll() !== null)
}), 20_000)
it.effect("race of two forks does not interrupt winner", () =>
Effect.gen(function*($) {
@@ -225,7 +226,7 @@ describe("Effect", () => {
Effect.zipRight(Ref.get(interrupted))
)
)
- assert.equal(count, 2)
+ strictEqual(count, 2)
}))
it.effect("firstSuccessOf of values", () =>
Effect.gen(function*($) {
@@ -236,7 +237,7 @@ describe("Effect", () => {
]),
Effect.either
)
- assert.deepStrictEqual(result, Either.right(100))
+ assertRight(result, 100)
}))
it.live("firstSuccessOf of failures", () =>
Effect.gen(function*($) {
@@ -248,7 +249,7 @@ describe("Effect", () => {
Effect.either
)
- assert.deepStrictEqual(result, Either.left(101))
+ assertLeft(result, 101)
}))
it.live("firstSuccessOf of failures & 1 success", () =>
Effect.gen(function*($) {
@@ -259,7 +260,7 @@ describe("Effect", () => {
]),
Effect.either
)
- assert.deepStrictEqual(result, Either.right(102))
+ assertRight(result, 102)
}))
it.effect("raceFirst interrupts loser on success", () =>
Effect.gen(function*($) {
@@ -273,7 +274,7 @@ describe("Effect", () => {
)
yield* $(winner, Effect.raceFirst(loser))
const result = yield* $(Deferred.await(effect))
- assert.strictEqual(result, 42)
+ strictEqual(result, 42)
}))
it.effect("raceFirst interrupts loser on failure", () =>
Effect.gen(function*($) {
@@ -287,28 +288,28 @@ describe("Effect", () => {
)
yield* $(winner, Effect.raceFirst(loser), Effect.either)
const result = yield* $(Deferred.await(effect))
- assert.strictEqual(result, 42)
+ strictEqual(result, 42)
}))
it.effect("mergeAll", () =>
Effect.gen(function*($) {
const result = yield* $(
pipe(["a", "aa", "aaa", "aaaa"].map((a) => Effect.succeed(a)), Effect.mergeAll(0, (b, a) => b + a.length))
)
- assert.strictEqual(result, 10)
+ strictEqual(result, 10)
}))
it.effect("mergeAll - empty", () =>
Effect.gen(function*($) {
const result = yield* $(
pipe([] as ReadonlyArray>, Effect.mergeAll(0, (b, a) => b + a))
)
- assert.strictEqual(result, 0)
+ strictEqual(result, 0)
}))
it.effect("reduceEffect", () =>
Effect.gen(function*($) {
const result = yield* $(
pipe([2, 3, 4].map((n) => Effect.succeed(n)), Effect.reduceEffect(Effect.succeed(1), (acc, a) => acc + a))
)
- assert.strictEqual(result, 10)
+ strictEqual(result, 10)
}))
it.effect("reduceEffect - empty list", () =>
Effect.gen(function*($) {
@@ -318,16 +319,16 @@ describe("Effect", () => {
Effect.reduceEffect(Effect.succeed(1), (acc, a) => acc + a)
)
)
- assert.strictEqual(result, 1)
+ strictEqual(result, 1)
}))
it.effect("timeout of failure", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.fail("uh oh"), Effect.timeout(Duration.hours(1)), Effect.exit)
- assert.deepStrictEqual(result, Exit.fail("uh oh"))
+ deepStrictEqual(result, Exit.fail("uh oh"))
}))
it.effect("timeout of terminate", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.die(ExampleError), Effect.timeout(Duration.hours(1)), Effect.exit)
- assert.deepStrictEqual(result, Exit.die(ExampleError))
+ deepStrictEqual(result, Exit.die(ExampleError))
}))
})
diff --git a/packages/effect/test/Effect/constructors.test.ts b/packages/effect/test/Effect/constructors.test.ts
index 386264f60bc..cc98b6c119e 100644
--- a/packages/effect/test/Effect/constructors.test.ts
+++ b/packages/effect/test/Effect/constructors.test.ts
@@ -1,18 +1,18 @@
import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
+import { assertNone, assertSome, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("can lift a value to an option", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.succeedSome(42))
- assert.deepStrictEqual(result, Option.some(42))
+ assertSome(result, 42)
}))
it.effect("using the none value", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.succeedNone)
- assert.deepStrictEqual(result, Option.none())
+ assertNone(result)
}))
it.effect("can use .pipe for composition", () =>
Effect.gen(function*(_) {
@@ -26,7 +26,7 @@ describe("Effect", () => {
),
Effect.tap((n) =>
Effect.sync(() => {
- assert.strictEqual(n, 3)
+ strictEqual(n, 3)
})
)
))
@@ -40,7 +40,7 @@ describe("Effect", () => {
const instance = new MyService()
return Effect.map(instance.compute, (n) => {
- assert.strictEqual(n, 2)
+ strictEqual(n, 2)
})
})
})
diff --git a/packages/effect/test/Effect/destructors.test.ts b/packages/effect/test/Effect/destructors.test.ts
index 24717e2e177..d658327d7da 100644
--- a/packages/effect/test/Effect/destructors.test.ts
+++ b/packages/effect/test/Effect/destructors.test.ts
@@ -1,10 +1,18 @@
import * as Cause from "effect/Cause"
import * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
-import * as Exit from "effect/Exit"
import * as Option from "effect/Option"
+import {
+ assertFailure,
+ assertFalse,
+ assertLeft,
+ assertNone,
+ assertRight,
+ assertSome,
+ assertTrue,
+ strictEqual
+} from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
const ExampleError = new Error("Oh noes!")
@@ -12,72 +20,72 @@ describe("Effect", () => {
it.effect("head - on non empty list", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.succeed([1, 2, 3]), Effect.head, Effect.either)
- assert.deepStrictEqual(result, Either.right(1))
+ assertRight(result, 1)
}))
it.effect("head - on empty list", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.succeed([] as ReadonlyArray), Effect.head, Effect.option)
- assert.deepStrictEqual(result, Option.none())
+ assertNone(result)
}))
it.effect("head - on failure", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.fail("fail"), Effect.head, Effect.either)
- assert.deepStrictEqual(result, Either.left("fail"))
+ assertLeft(result, "fail")
}))
it.effect("isFailure - returns true when the effect is a failure", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.isFailure(Effect.fail("fail")))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("isFailure - returns false when the effect is a success", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.isFailure(Effect.succeed("succeed")))
- assert.isFalse(result)
+ assertFalse(result)
}))
it.effect("isSuccess - returns false when the effect is a failure", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.isSuccess(Effect.fail("fail")))
- assert.isFalse(result)
+ assertFalse(result)
}))
it.effect("isSuccess - returns true when the effect is a success", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.isSuccess(Effect.succeed("succeed")))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("none - on Some fails with NoSuchElementException", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.exit(Effect.none(Effect.succeed(Option.some(1)))))
- assert.deepStrictEqual(result, Exit.fail(new Cause.NoSuchElementException()))
+ assertFailure(result, Cause.fail(new Cause.NoSuchElementException()))
}))
it.effect("none - on None succeeds with undefined", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.none(Effect.succeed(Option.none())))
- assert.isUndefined(result)
+ strictEqual(result, undefined)
}))
it.effect("none - fails with ex when effect fails with ex", () =>
Effect.gen(function*($) {
const error = new Cause.RuntimeException("failed task")
const result = yield* $(Effect.exit(Effect.none(Effect.fail(error))))
- assert.deepStrictEqual(result, Exit.fail(error))
+ assertFailure(result, Cause.fail(error))
}))
it.effect("option - return success in Some", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.option(Effect.succeed(11)))
- assert.deepStrictEqual(result, Option.some(11))
+ assertSome(result, 11)
}))
it.effect("option - return failure as None", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.option(Effect.fail(123)))
- assert.deepStrictEqual(result, Option.none())
+ assertNone(result)
}))
it.effect("option - not catch throwable", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.exit(Effect.option(Effect.die(ExampleError))))
- assert.deepStrictEqual(result, Exit.die(ExampleError))
+ assertFailure(result, Cause.die(ExampleError))
}))
it.effect("option - catch throwable after sandboxing", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.option(Effect.sandbox(Effect.die(ExampleError))))
- assert.deepStrictEqual(result, Option.none())
+ assertNone(result)
}))
})
diff --git a/packages/effect/test/Effect/environment.test.ts b/packages/effect/test/Effect/environment.test.ts
index 67b2941c193..c5dbed9f1bc 100644
--- a/packages/effect/test/Effect/environment.test.ts
+++ b/packages/effect/test/Effect/environment.test.ts
@@ -2,8 +2,9 @@ import * as Context from "effect/Context"
import * as Effect from "effect/Effect"
import { pipe } from "effect/Function"
import * as Layer from "effect/Layer"
+import { deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe, expect } from "vitest"
+import { describe } from "vitest"
interface NumberService {
readonly n: number
@@ -55,7 +56,7 @@ describe("Effect", () => {
Effect.provide(runtime),
Effect.provideService(NumberService, { n: 1 })
)
- expect(env).toStrictEqual({ n: 1 })
+ deepStrictEqual(env, { n: 1 })
}))
describe("and Then", () => {
it.effect("effect tag", () =>
@@ -65,9 +66,9 @@ describe("Effect", () => {
Effect.andThen(Effect.succeed("a"), DemoTag.strings),
Effect.andThen(Effect.succeed("a"), DemoTag.fn)
]))
- expect(n).toEqual([0, 1])
- expect(s).toEqual(["a", "b"])
- expect(z).toEqual(["a"])
+ deepStrictEqual(n, [0, 1])
+ deepStrictEqual(s, ["a", "b"])
+ deepStrictEqual(z, ["a"])
}).pipe(Effect.provideService(DemoTag, {
getNumbers: () => [0, 1],
strings: ["a", "b"],
@@ -86,12 +87,12 @@ describe("Effect", () => {
]))
const s2 = yield* $(DemoTag.pipe(Effect.map((_) => _.strings)))
const s3 = yield* $(DemoTag.use((_) => _.fnGen("hello")))
- expect(n).toEqual([0, 1])
- expect(s).toEqual(["a", "b"])
- expect(z).toEqual(["a", "b", "c"])
- expect(zUnion).toEqual([1])
- expect(s2).toEqual(["a", "b"])
- expect(s3).toEqual(["hello"])
+ deepStrictEqual(n, [0, 1])
+ deepStrictEqual(s, ["a", "b"])
+ deepStrictEqual(z, ["a", "b", "c"])
+ deepStrictEqual(zUnion, [1])
+ deepStrictEqual(s2, ["a", "b"])
+ deepStrictEqual(s3, ["hello"])
}).pipe(Effect.provideService(DemoTag, {
getNumbers: () => [0, 1],
strings: ["a", "b"],
@@ -101,12 +102,12 @@ describe("Effect", () => {
})))
it.effect("effect tag with primitives", () =>
Effect.gen(function*($) {
- expect(yield* $(DateTag.getTime())).toEqual(DateTag.date.getTime())
- expect(yield* $(NumberTag)).toEqual(100)
- expect(Array.from(yield* $(MapTag.keys()))).toEqual([])
+ strictEqual(yield* $(DateTag.getTime()), DateTag.date.getTime())
+ strictEqual(yield* $(NumberTag), 100)
+ deepStrictEqual(Array.from(yield* $(MapTag.keys())), [])
yield* $(MapTag.set("foo", "bar"))
- expect(Array.from(yield* $(MapTag.keys()))).toEqual(["foo"])
- expect(yield* $(MapTag.get("foo"))).toEqual("bar")
+ deepStrictEqual(Array.from(yield* $(MapTag.keys())), ["foo"])
+ strictEqual(yield* $(MapTag.get("foo")), "bar")
}).pipe(
Effect.provide(Layer.mergeAll(
DateTag.Live,
@@ -133,9 +134,9 @@ describe("Effect", () => {
)
)
const v3 = yield* $(NumberService)
- assert.strictEqual(v1.n, 4)
- assert.strictEqual(v2.n, 2)
- assert.strictEqual(v3.n, 4)
+ strictEqual(v1.n, 4)
+ strictEqual(v2.n, 2)
+ strictEqual(v3.n, 4)
}),
Effect.provide(Context.make(NumberService, { n: 4 }))
))
@@ -144,8 +145,8 @@ describe("Effect", () => {
Effect.gen(function*($) {
const v1 = yield* $(NumberService)
const v2 = yield* $(StringService)
- assert.strictEqual(v1.n, 1)
- assert.strictEqual(v2.s, "ok")
+ strictEqual(v1.n, 1)
+ strictEqual(v2.s, "ok")
}),
Effect.provide(Context.make(NumberService, { n: 1 })),
Effect.provide(Context.make(NumberService, { n: 2 })),
@@ -157,7 +158,7 @@ describe("Effect", () => {
Effect.async((cb) => cb(Effect.map(NumberService, ({ n }) => n))),
Effect.provide(Context.make(NumberService, { n: 10 }))
)
- assert.strictEqual(result, 10)
+ strictEqual(result, 10)
}))
it.effect("serviceWith - effectfully accesses a service in the environment", () =>
Effect.gen(function*($) {
@@ -165,7 +166,7 @@ describe("Effect", () => {
Effect.flatMap(NumberService, ({ n }) => Effect.succeed(n + 3)),
Effect.provide(Context.make(NumberService, { n: 0 }))
)
- assert.strictEqual(result, 3)
+ strictEqual(result, 3)
}))
// TODO: remove
// it.effect("serviceWith - traced tag", () =>
@@ -174,15 +175,15 @@ describe("Effect", () => {
// Effect.flatMap(NumberService.traced(sourceLocation(new Error())), ({ n }) => Effect.succeed(n + 3)),
// Effect.provide(Context.make(NumberService, { n: 0 }))
// )
- // assert.strictEqual(result, 3)
+ // strictEqual(result, 3)
// }))
it.effect("updateService - updates a service in the environment", () =>
pipe(
Effect.gen(function*($) {
const a = yield* $(NumberService, Effect.updateService(NumberService, ({ n }) => ({ n: n + 1 })))
const b = yield* $(NumberService)
- assert.strictEqual(a.n, 1)
- assert.strictEqual(b.n, 0)
+ strictEqual(a.n, 1)
+ strictEqual(b.n, 0)
}),
Effect.provide(pipe(Context.make(NumberService, { n: 0 })))
))
@@ -195,7 +196,7 @@ describe("Effect", () => {
const { foo } = Effect.serviceFunctions(Service)
return pipe(
Effect.gen(function*(_) {
- expect(yield* _(foo("a", 3))).toEqual("a3")
+ strictEqual(yield* _(foo("a", 3)), "a3")
}),
Effect.provideService(
Service,
@@ -214,7 +215,7 @@ describe("Effect", () => {
const { baz } = Effect.serviceConstants(Service)
return pipe(
Effect.gen(function*(_) {
- expect(yield* _(baz)).toEqual("42!")
+ strictEqual(yield* _(baz), "42!")
}),
Effect.provideService(
Service,
@@ -234,8 +235,8 @@ describe("Effect", () => {
const { constants, functions } = Effect.serviceMembers(Service)
return pipe(
Effect.gen(function*(_) {
- expect(yield* _(constants.baz)).toEqual("42!")
- expect(yield* _(functions.foo("a", 3))).toEqual("a3")
+ strictEqual(yield* _(constants.baz), "42!")
+ strictEqual(yield* _(functions.foo("a", 3)), "a3")
}),
Effect.provideService(
Service,
diff --git a/packages/effect/test/Effect/error-handling.test.ts b/packages/effect/test/Effect/error-handling.test.ts
index 1cd3eb2dfa9..f0cead0b84e 100644
--- a/packages/effect/test/Effect/error-handling.test.ts
+++ b/packages/effect/test/Effect/error-handling.test.ts
@@ -7,11 +7,12 @@ import * as Fiber from "effect/Fiber"
import * as FiberId from "effect/FiberId"
import { constFalse, constTrue, identity, pipe } from "effect/Function"
import * as Option from "effect/Option"
+import { assertLeft, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
import { causesArb } from "effect/test/utils/cause"
import * as it from "effect/test/utils/extend"
import { assertType, satisfies } from "effect/test/utils/types"
import * as fc from "fast-check"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
const ExampleError = new Error("Oh noes!")
@@ -46,25 +47,25 @@ describe("Effect", () => {
}),
Effect.flip
)
- assert.deepStrictEqual(result.error, ExampleError)
+ deepStrictEqual(result.error, ExampleError)
}))
it.effect("attempt - fail", () =>
Effect.gen(function*($) {
const io1 = Effect.either(ExampleErrorFail)
const io2 = Effect.suspend(() => Effect.either(Effect.suspend(() => ExampleErrorFail)))
const [first, second] = yield* $(io1, Effect.zip(io2))
- assert.deepStrictEqual(first, Either.left(ExampleError))
- assert.deepStrictEqual(second, Either.left(ExampleError))
+ assertLeft(first, ExampleError)
+ assertLeft(second, ExampleError)
}))
it.effect("attempt - deep attempt sync effect error", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.flip(deepErrorEffect(100)))
- assert.deepStrictEqual(result.error, ExampleError)
+ deepStrictEqual(result.error, ExampleError)
}))
it.effect("attempt - deep attempt fail error", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.either(deepErrorFail(100)))
- assert.deepStrictEqual(result, Either.left(ExampleError))
+ assertLeft(result, ExampleError)
}))
it.effect("attempt - sandbox -> terminate", () =>
Effect.gen(function*($) {
@@ -75,7 +76,7 @@ describe("Effect", () => {
Effect.sandbox,
Effect.either
)
- assert.deepStrictEqual(result, Either.left(Cause.die(ExampleError)))
+ assertLeft(result, Cause.die(ExampleError))
}))
it.effect("catch - sandbox terminate", () =>
Effect.gen(function*($) {
@@ -86,7 +87,7 @@ describe("Effect", () => {
Effect.sandbox,
Effect.merge
)
- assert.deepStrictEqual(result, Cause.die(ExampleError))
+ deepStrictEqual(result, Cause.die(ExampleError))
}))
it.effect("catch failing finalizers with fail", () =>
Effect.gen(function*($) {
@@ -110,7 +111,7 @@ describe("Effect", () => {
),
Cause.die(InterruptError3)
)
- assert.deepStrictEqual(result, Exit.failCause(expected))
+ deepStrictEqual(result, Exit.failCause(expected))
}))
it.effect("catch failing finalizers with terminate", () =>
Effect.gen(function*($) {
@@ -134,14 +135,14 @@ describe("Effect", () => {
),
Cause.die(InterruptError3)
)
- assert.deepStrictEqual(result, Exit.failCause(expected))
+ deepStrictEqual(result, Exit.failCause(expected))
}))
it.effect("catchAllCause", () =>
Effect.gen(function*($) {
const result = yield* $(
pipe(Effect.succeed(42), Effect.zipRight(Effect.fail("uh oh")), Effect.catchAllCause(Effect.succeed))
)
- assert.deepStrictEqual(result, Cause.fail("uh oh"))
+ deepStrictEqual(result, Cause.fail("uh oh"))
}))
it.effect("catchAllDefect - recovers from all defects", () =>
Effect.gen(function*($) {
@@ -150,7 +151,7 @@ describe("Effect", () => {
Effect.die(new Cause.IllegalArgumentException(message)),
Effect.catchAllDefect((e) => Effect.succeed((e as Error).message))
)
- assert.strictEqual(result, message)
+ strictEqual(result, message)
}))
it.effect("catchAllDefect - leaves errors", () =>
Effect.gen(function*($) {
@@ -158,7 +159,7 @@ describe("Effect", () => {
const result = yield* $(
pipe(Effect.fail(error), Effect.catchAllDefect((e) => Effect.succeed((e as Error).message)), Effect.exit)
)
- assert.deepStrictEqual(result, Exit.fail(error))
+ deepStrictEqual(result, Exit.fail(error))
}))
it.effect("catchAllDefect - leaves values", () =>
Effect.gen(function*($) {
@@ -166,7 +167,7 @@ describe("Effect", () => {
const result = yield* $(
pipe(Effect.succeed(error), Effect.catchAllDefect((e) => Effect.succeed((e as Error).message)))
)
- assert.deepStrictEqual(result, error)
+ deepStrictEqual(result, error)
}))
it.effect("catchSomeDefect - recovers from some defects", () =>
Effect.gen(function*($) {
@@ -179,7 +180,7 @@ describe("Effect", () => {
: Option.none()
)
)
- assert.strictEqual(result, message)
+ strictEqual(result, message)
}))
it.effect("catchSomeDefect - leaves the rest", () =>
Effect.gen(function*($) {
@@ -193,7 +194,7 @@ describe("Effect", () => {
),
Effect.exit
)
- assert.deepStrictEqual(result, Exit.die(error))
+ deepStrictEqual(result, Exit.die(error))
}))
it.effect("catchSomeDefect - leaves errors", () =>
Effect.gen(function*($) {
@@ -207,7 +208,7 @@ describe("Effect", () => {
),
Effect.exit
)
- assert.deepStrictEqual(result, Exit.fail(error))
+ deepStrictEqual(result, Exit.fail(error))
}))
it.effect("catchSomeDefect - leaves values", () =>
Effect.gen(function*($) {
@@ -220,7 +221,7 @@ describe("Effect", () => {
: Option.none()
)
)
- assert.deepStrictEqual(result, error)
+ deepStrictEqual(result, error)
}))
it.effect("catch - recovers from one of several tagged errors", () =>
Effect.gen(function*($) {
@@ -235,7 +236,7 @@ describe("Effect", () => {
failure: "ErrorA",
onFailure: Effect.succeed
}))
- assert.deepStrictEqual(result, { _tag: "ErrorA" })
+ deepStrictEqual(result, { _tag: "ErrorA" })
}))
it.effect("catch - does not recover from one of several tagged errors", () =>
Effect.gen(function*($) {
@@ -253,7 +254,7 @@ describe("Effect", () => {
}),
Effect.exit
)
- assert.deepStrictEqual(result, Exit.fail({ _tag: "ErrorB" as const }))
+ deepStrictEqual(result, Exit.fail({ _tag: "ErrorB" as const }))
}))
it.effect("catchIf - does not recover from one of several tagged errors", () =>
Effect.gen(function*($) {
@@ -268,7 +269,7 @@ describe("Effect", () => {
Effect.catchIf(effect, (e): e is ErrorA => e._tag === "ErrorA", Effect.succeed),
Effect.exit
)
- assert.deepStrictEqual(result, Exit.fail({ _tag: "ErrorB" as const }))
+ deepStrictEqual(result, Exit.fail({ _tag: "ErrorB" as const }))
satisfies(assertType>()(result))
}))
it.effect("catchTags - recovers from one of several tagged errors", () =>
@@ -283,7 +284,7 @@ describe("Effect", () => {
const result = yield* $(Effect.catchTags(effect, {
ErrorA: (e) => Effect.succeed(e)
}))
- assert.deepStrictEqual(result, { _tag: "ErrorA" })
+ deepStrictEqual(result, { _tag: "ErrorA" })
}))
it.effect("catchTags - does not recover from one of several tagged errors", () =>
Effect.gen(function*($) {
@@ -299,7 +300,7 @@ describe("Effect", () => {
ErrorA: (e) => Effect.succeed(e)
})
))
- assert.deepStrictEqual(result, Exit.fail({ _tag: "ErrorB" }))
+ deepStrictEqual(result, Exit.fail({ _tag: "ErrorB" }))
}))
it.effect("catchTags - recovers from all tagged errors", () =>
Effect.gen(function*($) {
@@ -314,7 +315,7 @@ describe("Effect", () => {
ErrorA: (e) => Effect.succeed(e),
ErrorB: (e) => Effect.succeed(e)
}))
- assert.deepStrictEqual(result, { _tag: "ErrorB" })
+ deepStrictEqual(result, { _tag: "ErrorB" })
}))
it.effect("fold - sandbox -> terminate", () =>
Effect.gen(function*($) {
@@ -328,22 +329,22 @@ describe("Effect", () => {
onSuccess: () => Option.none() as Option.Option>
})
)
- assert.deepStrictEqual(result, Option.some(Cause.die(ExampleError)))
+ deepStrictEqual(result, Option.some(Cause.die(ExampleError)))
}))
it.effect("ignore - return success as unit", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.ignore(Effect.succeed(11)))
- assert.isUndefined(result)
+ strictEqual(result, undefined)
}))
it.effect("ignore - return failure as unit", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.ignore(Effect.fail(123)))
- assert.isUndefined(result)
+ strictEqual(result, undefined)
}))
it.effect("ignore - not catch throwable", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.exit(Effect.ignore(Effect.die(ExampleError))))
- assert.deepStrictEqual(result, Exit.die(ExampleError))
+ deepStrictEqual(result, Exit.die(ExampleError))
}))
it.effect("orElse - does not recover from defects", () =>
Effect.gen(function*($) {
@@ -355,10 +356,10 @@ describe("Effect", () => {
const both = yield* $(Effect.failCause(bothCause), Effect.orElse(() => Effect.void), Effect.exit)
const then = yield* $(Effect.failCause(thenCause), Effect.orElse(() => Effect.void), Effect.exit)
const fail = yield* $(Effect.fail(error), Effect.orElse(() => Effect.void), Effect.exit)
- assert.deepStrictEqual(plain, Exit.die(error))
- assert.deepStrictEqual(both, Exit.die(error))
- assert.deepStrictEqual(then, Exit.die(error))
- assert.deepStrictEqual(fail, Exit.succeed(void 0))
+ deepStrictEqual(plain, Exit.die(error))
+ deepStrictEqual(both, Exit.die(error))
+ deepStrictEqual(then, Exit.die(error))
+ deepStrictEqual(fail, Exit.succeed(void 0))
}))
it.effect("orElse - left failed and right died with kept cause", () =>
Effect.gen(function*($) {
@@ -378,7 +379,7 @@ describe("Effect", () => {
return Effect.succeed(false)
})
)
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("orElse - left failed and right failed with kept cause", () =>
Effect.gen(function*($) {
@@ -398,7 +399,7 @@ describe("Effect", () => {
return Effect.succeed(false)
})
)
- assert.isTrue(result)
+ assertTrue(result)
}))
it.it("orElse - is associative", async () => {
const smallInts = fc.integer({ min: 0, max: 100 })
@@ -420,42 +421,42 @@ describe("Effect", () => {
return { left, right }
})
const { left, right } = await Effect.runPromise(program)
- assert.deepStrictEqual(left, right)
+ deepStrictEqual(left, right)
}))
})
it.effect("orElseFail - executes this effect and returns its value if it succeeds", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.succeed(true), Effect.orElseFail(constFalse))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("orElseFail - otherwise fails with the specified error", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.fail(false), Effect.orElseFail(constTrue), Effect.flip)
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("orElseSucceed - executes this effect and returns its value if it succeeds", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.succeed(true), Effect.orElseSucceed(constFalse))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("orElseSucceed - otherwise succeeds with the specified value", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.fail(false), Effect.orElseSucceed(constTrue))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("parallelErrors - one failure", () =>
Effect.gen(function*($) {
const fiber1 = yield* $(Effect.fork(Effect.fail("error1")))
const fiber2 = yield* $(Effect.fork(Effect.succeed("success1")))
const result = yield* $(fiber1, Fiber.zip(fiber2), Fiber.join, Effect.parallelErrors, Effect.flip)
- assert.deepStrictEqual(Array.from(result), ["error1"])
+ deepStrictEqual(Array.from(result), ["error1"])
}))
it.effect("parallelErrors - all failures", () =>
Effect.gen(function*($) {
const fiber1 = yield* $(Effect.fork(Effect.fail("error1")))
const fiber2 = yield* $(Effect.fork(Effect.fail("error2")))
const result = yield* $(fiber1, Fiber.zip(fiber2), Fiber.join, Effect.parallelErrors, Effect.flip)
- assert.deepStrictEqual(Array.from(result), ["error1", "error2"])
+ deepStrictEqual(Array.from(result), ["error1", "error2"])
}))
it.effect("promise - exception does not kill fiber", () =>
Effect.gen(function*($) {
@@ -465,7 +466,7 @@ describe("Effect", () => {
}),
Effect.exit
)
- assert.deepStrictEqual(result, Exit.die(ExampleError))
+ deepStrictEqual(result, Exit.die(ExampleError))
}))
it.effect("try = handles exceptions", () =>
Effect.gen(function*($) {
@@ -480,12 +481,12 @@ describe("Effect", () => {
Effect.exit
)
- assert.deepStrictEqual(result, Exit.fail(message))
+ deepStrictEqual(result, Exit.fail(message))
}))
it.effect("uncaught - fail", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.exit(ExampleErrorFail))
- assert.deepStrictEqual(result, Exit.fail(ExampleError))
+ deepStrictEqual(result, Exit.fail(ExampleError))
}))
it.effect("uncaught - sync effect error", () =>
Effect.gen(function*($) {
@@ -496,12 +497,12 @@ describe("Effect", () => {
Effect.exit
)
- assert.deepStrictEqual(result, Exit.die(ExampleError))
+ deepStrictEqual(result, Exit.die(ExampleError))
}))
it.effect("uncaught - deep sync effect error", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.flip(deepErrorEffect(100)))
- assert.deepStrictEqual(result.error, ExampleError)
+ deepStrictEqual(result.error, ExampleError)
}))
it.effect("unwraps exception", () =>
Effect.gen(function*($) {
@@ -516,8 +517,8 @@ describe("Effect", () => {
})
)
const result = yield* $(Effect.unsandbox(success))
- assert.strictEqual(message, "fail")
- assert.strictEqual(result, 100)
+ strictEqual(message, "fail")
+ strictEqual(result, 100)
}))
it.effect("no information is lost during composition", () =>
Effect.gen(function*($) {
@@ -526,6 +527,6 @@ describe("Effect", () => {
}
const expectedCause = Cause.fail("oh no")
const result = yield* $(cause(pipe(Effect.failCause(expectedCause), Effect.sandbox, Effect.unsandbox)))
- assert.deepStrictEqual(result, expectedCause)
+ deepStrictEqual(result, expectedCause)
}))
})
diff --git a/packages/effect/test/Effect/error.test.ts b/packages/effect/test/Effect/error.test.ts
index 42fbebe1bee..6cf81f6af26 100644
--- a/packages/effect/test/Effect/error.test.ts
+++ b/packages/effect/test/Effect/error.test.ts
@@ -1,8 +1,7 @@
-import * as Cause from "effect/Cause"
-import * as Data from "effect/Data"
-import * as Effect from "effect/Effect"
+import { Cause, Data, Effect } from "effect"
+import { assertTrue, deepStrictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe, expect } from "vitest"
+import { describe } from "vitest"
class TestError extends Data.TaggedError("TestError")<{}> {}
@@ -11,11 +10,11 @@ describe("Effect", () => {
Effect.gen(function*($) {
const cause = yield* $(Effect.flip(Effect.sandbox(Effect.withSpan("A")(new TestError()))))
const log = Cause.pretty(cause)
- expect(log).includes("TestError")
+ assertTrue(log.includes("TestError"))
if (typeof window === "undefined") {
- expect(log.replaceAll("\\", "/")).includes("test/Effect/error.test.ts:12:78")
+ assertTrue(log.replaceAll("\\", "/").includes("test/Effect/error.test.ts:11:78"))
}
- expect(log).includes("at A")
+ assertTrue(log.includes("at A"))
}))
it.effect("tryPromise", () =>
@@ -31,9 +30,9 @@ describe("Effect", () => {
)
const log = Cause.pretty(cause)
if (typeof window === "undefined") {
- expect(log.replaceAll("\\", "/")).includes("test/Effect/error.test.ts:26")
+ assertTrue(log.replaceAll("\\", "/").includes("test/Effect/error.test.ts:25"))
}
- expect(log).includes("at A")
+ assertTrue(log.includes("at A"))
}))
it.effect("allow message prop", () =>
@@ -52,11 +51,11 @@ describe("Effect", () => {
Effect.flip
)
const log = Cause.pretty(cause)
- expect(log).includes("Failure: some message")
+ assertTrue(log.includes("Failure: some message"))
if (typeof window === "undefined") {
- expect(log.replaceAll("\\", "/")).includes("test/Effect/error.test.ts:48")
+ assertTrue(log.replaceAll("\\", "/").includes("test/Effect/error.test.ts:47"))
}
- expect(log).includes("at A")
+ assertTrue(log.includes("at A"))
}))
if (typeof window === "undefined") {
@@ -70,8 +69,8 @@ describe("Effect", () => {
}
}
const err = new MessageError()
- expect(inspect(err)).include("MessageError: fail")
- expect(inspect(err).replaceAll("\\", "/")).include("test/Effect/error.test.ts:72")
+ assertTrue(inspect(err).includes("MessageError: fail"))
+ assertTrue(inspect(err).replaceAll("\\", "/").includes("test/Effect/error.test.ts:71"))
})
it.it("toString", () => {
@@ -80,20 +79,20 @@ describe("Effect", () => {
return "fail"
}
}
- expect(inspect(new MessageError()).startsWith("fail\n")).toBe(true)
- assert.deepStrictEqual(new MessageError().toJSON(), { _tag: "MessageError" })
+ assertTrue(inspect(new MessageError()).startsWith("fail\n"))
+ deepStrictEqual(new MessageError().toJSON(), { _tag: "MessageError" })
})
it.it("cause", () => {
class MessageError extends Data.TaggedError("MessageError")<{
cause: unknown
}> {}
- expect(inspect(new MessageError({ cause: new Error("boom") }))).includes("[cause]: Error: boom")
+ assertTrue(inspect(new MessageError({ cause: new Error("boom") })).includes("[cause]: Error: boom"))
})
}
it.it("toJSON", () => {
class MessageError extends Data.TaggedError("MessageError")<{}> {}
- assert.deepStrictEqual(new MessageError().toJSON(), { _tag: "MessageError" })
+ deepStrictEqual(new MessageError().toJSON(), { _tag: "MessageError" })
})
})
diff --git a/packages/effect/test/Effect/filtering.test.ts b/packages/effect/test/Effect/filtering.test.ts
index 6e3e3de12cb..a90792a4b73 100644
--- a/packages/effect/test/Effect/filtering.test.ts
+++ b/packages/effect/test/Effect/filtering.test.ts
@@ -3,8 +3,9 @@ import * as Effect from "effect/Effect"
import * as Either from "effect/Either"
import { pipe } from "effect/Function"
import * as Ref from "effect/Ref"
+import { assertLeft, assertRight, deepStrictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
const exactlyOnce = (
value: A,
@@ -30,8 +31,8 @@ describe("Effect", () => {
)
)
const effects = yield* $(Ref.get(ref))
- assert.deepStrictEqual(Array.from(results), [2, 4, 6, 6])
- assert.deepStrictEqual(Array.from(effects), [2, 4, 6, 3, 5, 6])
+ deepStrictEqual(Array.from(results), [2, 4, 6, 6])
+ deepStrictEqual(Array.from(effects), [2, 4, 6, 3, 5, 6])
}))
it.effect("filter/negate - filters a collection using an effectual predicate, removing all elements that satisfy the predicate", () =>
Effect.gen(function*($) {
@@ -43,8 +44,8 @@ describe("Effect", () => {
)
)
const effects = yield* $(Ref.get(ref))
- assert.deepStrictEqual(Array.from(results), [3, 5])
- assert.deepStrictEqual(Array.from(effects), [2, 4, 6, 3, 5, 6])
+ deepStrictEqual(Array.from(results), [3, 5])
+ deepStrictEqual(Array.from(effects), [2, 4, 6, 3, 5, 6])
}))
it.effect("filter/concurrency - filters a collection in parallel using an effectual predicate", () =>
Effect.gen(function*($) {
@@ -54,7 +55,7 @@ describe("Effect", () => {
Effect.filter((n) => Effect.succeed(n % 2 === 0), { concurrency: "unbounded" })
)
)
- assert.deepStrictEqual(Array.from(result), [2, 4, 6, 6, 10, 20, 22, 28])
+ deepStrictEqual(Array.from(result), [2, 4, 6, 6, 10, 20, 22, 28])
}))
it.effect("filter/concurrency+negate - filters a collection in parallel using an effectual predicate, removing all elements that satisfy the predicate", () =>
Effect.gen(function*($) {
@@ -67,7 +68,7 @@ describe("Effect", () => {
})
)
)
- assert.deepStrictEqual(Array.from(result), [3, 5, 11, 15, 17, 23, 25])
+ deepStrictEqual(Array.from(result), [3, 5, 11, 15, 17, 23, 25])
}))
it.effect("filterOrElse - returns checked failure from held value", () =>
Effect.gen(function*($) {
@@ -96,8 +97,8 @@ describe("Effect", () => {
Effect.either,
Effect.map(Either.mapLeft(Cause.failureOrCause))
)
- assert.deepStrictEqual(goodCase, Either.right(0 as const))
- assert.deepStrictEqual(badCase, Either.left(Either.left("1 was not 0")))
+ assertRight(goodCase, 0)
+ assertLeft(badCase, Either.left("1 was not 0"))
}))
it.effect("filterOrElse - returns checked failure ignoring value", () =>
Effect.gen(function*($) {
@@ -126,8 +127,8 @@ describe("Effect", () => {
Effect.either,
Effect.map(Either.mapLeft(Cause.failureOrCause))
)
- assert.deepStrictEqual(goodCase, Either.right(0 as const))
- assert.deepStrictEqual(badCase, Either.left(Either.left("predicate failed!")))
+ assertRight(goodCase, 0)
+ assertLeft(badCase, Either.left("predicate failed!"))
}))
it.effect("filterOrFail - returns failure ignoring value", () =>
Effect.gen(function*($) {
@@ -156,8 +157,8 @@ describe("Effect", () => {
Effect.either,
Effect.map(Either.mapLeft(Cause.failureOrCause))
)
- assert.deepStrictEqual(goodCase, Either.right(0 as const))
- assert.deepStrictEqual(badCase, Either.left(Either.left("predicate failed!")))
+ assertRight(goodCase, 0)
+ assertLeft(badCase, Either.left("predicate failed!"))
}))
it.effect("filterOrFail - returns failure", () =>
Effect.gen(function*($) {
@@ -186,8 +187,8 @@ describe("Effect", () => {
Effect.either,
Effect.map(Either.mapLeft(Cause.failureOrCause))
)
- assert.deepStrictEqual(goodCase, Either.right(0 as const))
- assert.deepStrictEqual(badCase, Either.left(Either.left("predicate failed, got 1!")))
+ assertRight(goodCase, 0)
+ assertLeft(badCase, Either.left("predicate failed, got 1!"))
}))
it.effect("filterOrFail - without orFailWith", () =>
Effect.gen(function*($) {
@@ -203,8 +204,8 @@ describe("Effect", () => {
Effect.filterOrFail((n) => n === 0),
Effect.flip
)
- assert.deepStrictEqual(goodCase, 0)
- assert.deepStrictEqual(goodCaseDataFirst, 0)
- assert.deepStrictEqual(badCase, new Cause.NoSuchElementException())
+ deepStrictEqual(goodCase, 0)
+ deepStrictEqual(goodCaseDataFirst, 0)
+ deepStrictEqual(badCase, new Cause.NoSuchElementException())
}))
})
diff --git a/packages/effect/test/Effect/finalization.test.ts b/packages/effect/test/Effect/finalization.test.ts
index 32f866ebac5..590acbe345a 100644
--- a/packages/effect/test/Effect/finalization.test.ts
+++ b/packages/effect/test/Effect/finalization.test.ts
@@ -9,8 +9,9 @@ import * as Fiber from "effect/Fiber"
import { identity, pipe } from "effect/Function"
import * as Option from "effect/Option"
import * as Ref from "effect/Ref"
+import { assertFalse, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
const ExampleError = new Error("Oh noes!")
@@ -37,8 +38,8 @@ describe("Effect", () => {
})),
Effect.exit
)
- assert.deepStrictEqual(result, Exit.fail(ExampleError))
- assert.isTrue(finalized)
+ deepStrictEqual(result, Exit.fail(ExampleError))
+ assertTrue(finalized)
}))
it.effect("fail on error", () =>
Effect.gen(function*($) {
@@ -52,8 +53,8 @@ describe("Effect", () => {
),
Effect.exit
)
- assert.deepStrictEqual(result, Exit.fail(ExampleError))
- assert.isTrue(finalized)
+ deepStrictEqual(result, Exit.fail(ExampleError))
+ assertTrue(finalized)
}))
it.effect("finalizer errors not caught", () =>
Effect.gen(function*($) {
@@ -70,7 +71,7 @@ describe("Effect", () => {
)
)
const expected = Cause.sequential(Cause.sequential(Cause.fail(ExampleError), Cause.die(e2)), Cause.die(e3))
- assert.deepStrictEqual(result, expected)
+ deepStrictEqual(result, expected)
}))
it.effect("finalizer errors reported", () =>
Effect.gen(function*($) {
@@ -92,8 +93,8 @@ describe("Effect", () => {
)
)
)
- assert.isUndefined(result)
- assert.isFalse(reported !== undefined && Exit.isSuccess(reported))
+ strictEqual(result, undefined)
+ assertFalse(reported !== undefined && Exit.isSuccess(reported))
}))
it.effect("acquireUseRelease exit.effect() is usage result", () =>
Effect.gen(function*($) {
@@ -102,7 +103,7 @@ describe("Effect", () => {
() => Effect.succeed(42),
() => Effect.void
))
- assert.strictEqual(result, 42)
+ strictEqual(result, 42)
}))
it.effect("error in just acquisition", () =>
Effect.gen(function*($) {
@@ -116,7 +117,7 @@ describe("Effect", () => {
Effect.exit
)
)
- assert.deepStrictEqual(result, Exit.fail(ExampleError))
+ deepStrictEqual(result, Exit.fail(ExampleError))
}))
it.effect("error in just release", () =>
Effect.gen(function*($) {
@@ -130,7 +131,7 @@ describe("Effect", () => {
Effect.exit
)
)
- assert.deepStrictEqual(result, Exit.die(ExampleError))
+ deepStrictEqual(result, Exit.die(ExampleError))
}))
it.effect("error in just usage", () =>
Effect.gen(function*($) {
@@ -144,7 +145,7 @@ describe("Effect", () => {
Effect.exit
)
)
- assert.deepStrictEqual(result, Exit.fail(ExampleError))
+ deepStrictEqual(result, Exit.fail(ExampleError))
}))
it.effect("rethrown caught error in acquisition", () =>
Effect.gen(function*($) {
@@ -158,7 +159,7 @@ describe("Effect", () => {
Effect.flatMap(identity),
Effect.flip
)
- assert.deepEqual(result, ExampleError)
+ deepStrictEqual(result, ExampleError)
}))
it.effect("rethrown caught error in release", () =>
Effect.gen(function*($) {
@@ -172,7 +173,7 @@ describe("Effect", () => {
Effect.exit
)
)
- assert.deepStrictEqual(result, Exit.die(ExampleError))
+ deepStrictEqual(result, Exit.die(ExampleError))
}))
it.effect("rethrown caught error in usage", () =>
Effect.gen(function*($) {
@@ -184,7 +185,7 @@ describe("Effect", () => {
),
Effect.exit
)
- assert.deepEqual(result, Exit.fail(ExampleError))
+ deepStrictEqual(result, Exit.fail(ExampleError))
}))
it.effect("test eval of async fail", () =>
Effect.gen(function*($) {
@@ -202,10 +203,10 @@ describe("Effect", () => {
const a2 = yield* $(Effect.exit(io2))
const a3 = yield* $(io1, Effect.exit)
const a4 = yield* $(io2, Effect.exit)
- assert.deepStrictEqual(a1, Exit.fail(ExampleError))
- assert.deepStrictEqual(a2, Exit.fail(ExampleError))
- assert.deepStrictEqual(a3, Exit.fail(ExampleError))
- assert.deepStrictEqual(a4, Exit.fail(ExampleError))
+ deepStrictEqual(a1, Exit.fail(ExampleError))
+ deepStrictEqual(a2, Exit.fail(ExampleError))
+ deepStrictEqual(a3, Exit.fail(ExampleError))
+ deepStrictEqual(a4, Exit.fail(ExampleError))
}))
it.live("acquireUseRelease regression 1", () =>
Effect.gen(function*($) {
@@ -250,18 +251,18 @@ describe("Effect", () => {
Effect.repeat({ until: (list) => pipe(list, Array.findFirst((s) => s === "release 2"), Option.isSome) })
)
const result = yield* $(Ref.get(ref))
- assert.isTrue(pipe(
+ assertTrue(pipe(
result,
Array.findFirst((s) => s === "start 1"),
Option.isSome
))
- assert.isTrue(pipe(
+ assertTrue(pipe(
result,
Array.findFirst((s) => s === "release 1"),
Option.isSome
))
- assert.isTrue(pipe(result, Array.findFirst((s) => s === "start 2"), Option.isSome))
- assert.isTrue(pipe(result, Array.findFirst((s) => s === "release 2"), Option.isSome))
+ assertTrue(pipe(result, Array.findFirst((s) => s === "start 2"), Option.isSome))
+ assertTrue(pipe(result, Array.findFirst((s) => s === "release 2"), Option.isSome))
}))
it.live("interrupt waits for finalizer", () =>
Effect.gen(function*($) {
@@ -279,7 +280,7 @@ describe("Effect", () => {
yield* $(Deferred.await(deferred1))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Ref.get(ref))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("onExit - executes that a cleanup function runs when effect succeeds", () =>
Effect.gen(function*($) {
@@ -292,7 +293,7 @@ describe("Effect", () => {
}))
)
const result = yield* $(Ref.get(ref))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("onExit - ensures that a cleanup function runs when an effect fails", () =>
Effect.gen(function*($) {
@@ -308,7 +309,7 @@ describe("Effect", () => {
Effect.ignore
)
const result = yield* $(Ref.get(ref))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("onExit - ensures that a cleanup function runs when an effect is interrupted", () =>
Effect.gen(function*($) {
@@ -329,6 +330,6 @@ describe("Effect", () => {
yield* $(Deferred.await(latch1))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Deferred.await(latch2))
- assert.isUndefined(result)
+ strictEqual(result, undefined)
}))
})
diff --git a/packages/effect/test/Effect/fn.test.ts b/packages/effect/test/Effect/fn.test.ts
index 7a1725ea909..8023127e713 100644
--- a/packages/effect/test/Effect/fn.test.ts
+++ b/packages/effect/test/Effect/fn.test.ts
@@ -1,5 +1,6 @@
import { Cause, Effect } from "effect"
-import { assert, describe, it } from "effect/test/utils/extend"
+import { assertTrue, strictEqual } from "effect/test/util"
+import { describe, it } from "effect/test/utils/extend"
describe("Effect.fn", () => {
it.effect("catches defects in the function", () =>
@@ -18,9 +19,9 @@ describe("Effect.fn", () => {
Effect.sandbox,
Effect.flip
)
- assert(Cause.isDieType(cause))
- assert.isTrue(cause.defect instanceof Error && cause.defect.message === "test")
- assert.strictEqual(caught, cause)
+ assertTrue(Cause.isDieType(cause))
+ assertTrue(cause.defect instanceof Error && cause.defect.message === "test")
+ strictEqual(caught, cause)
}))
it.effect("catches defects in pipeline", () =>
@@ -35,8 +36,8 @@ describe("Effect.fn", () => {
Effect.sandbox,
Effect.flip
)
- assert(Cause.isDieType(cause))
- assert.isTrue(cause.defect instanceof Error && cause.defect.message === "test")
+ assertTrue(Cause.isDieType(cause))
+ assertTrue(cause.defect instanceof Error && cause.defect.message === "test")
}))
it.effect("catches defects in both fn & pipeline", () =>
@@ -53,10 +54,10 @@ describe("Effect.fn", () => {
Effect.sandbox,
Effect.flip
)
- assert(Cause.isSequentialType(cause))
- assert(Cause.isDieType(cause.left))
- assert(Cause.isDieType(cause.right))
- assert.isTrue(cause.left.defect instanceof Error && cause.left.defect.message === "test")
- assert.isTrue(cause.right.defect instanceof Error && cause.right.defect.message === "test2")
+ assertTrue(Cause.isSequentialType(cause))
+ assertTrue(Cause.isDieType(cause.left))
+ assertTrue(Cause.isDieType(cause.right))
+ assertTrue(cause.left.defect instanceof Error && cause.left.defect.message === "test")
+ assertTrue(cause.right.defect instanceof Error && cause.right.defect.message === "test2")
}))
})
diff --git a/packages/effect/test/Effect/foreign.test.ts b/packages/effect/test/Effect/foreign.test.ts
index f460ca9ac7b..5d0de722505 100644
--- a/packages/effect/test/Effect/foreign.test.ts
+++ b/packages/effect/test/Effect/foreign.test.ts
@@ -5,9 +5,10 @@ import * as Either from "effect/Either"
import * as Exit from "effect/Exit"
import * as Option from "effect/Option"
import { nextInt } from "effect/Random"
+import { assertLeft, deepStrictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
import { unify } from "effect/Unify"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Foreign", () => {
it.effect("Unify", () =>
@@ -16,16 +17,16 @@ describe("Foreign", () => {
const unifiedExit = unify((yield* $(nextInt)) > 1 ? Exit.succeed(0) : Exit.fail(1))
const unifiedEither = unify((yield* $(nextInt)) > 1 ? Either.right(0) : Either.left(1))
const unifiedOption = unify((yield* $(nextInt)) > 1 ? Option.some(0) : Option.none())
- assert.deepEqual(yield* $(unifiedEffect), 0)
- assert.deepEqual(yield* $(unifiedExit), 0)
- assert.deepEqual(yield* $(unifiedEither), 0)
- assert.deepEqual(yield* $(unifiedOption), 0)
+ deepStrictEqual(yield* $(unifiedEffect), 0)
+ deepStrictEqual(yield* $(unifiedExit), 0)
+ deepStrictEqual(yield* $(unifiedEither), 0)
+ deepStrictEqual(yield* $(unifiedOption), 0)
}))
it.effect("Tag", () =>
Effect.gen(function*($) {
const tag = Context.GenericTag("number")
const result = yield* $(tag, Effect.provideService(tag, 10))
- assert.deepEqual(result, 10)
+ deepStrictEqual(result, 10)
}))
it.effect("Either", () =>
Effect.gen(function*($) {
@@ -37,9 +38,9 @@ describe("Foreign", () => {
(n) => Effect.succeed(n + 1)
)
)
- assert.deepEqual(a, 10)
- assert.deepEqual(b, Either.left(10))
- assert.deepEqual(c, 3)
+ deepStrictEqual(a, 10)
+ assertLeft(b, 10)
+ deepStrictEqual(c, 3)
}))
it.effect("Option", () =>
Effect.gen(function*($) {
@@ -51,8 +52,8 @@ describe("Foreign", () => {
(n) => Effect.succeed(n + 1)
)
)
- assert.deepEqual(a, 10)
- assert.deepEqual(b, Either.left(new Cause.NoSuchElementException()))
- assert.deepEqual(c, 3)
+ deepStrictEqual(a, 10)
+ assertLeft(b, new Cause.NoSuchElementException())
+ deepStrictEqual(c, 3)
}))
})
diff --git a/packages/effect/test/Effect/forking.test.ts b/packages/effect/test/Effect/forking.test.ts
index 787cc2b9f30..65054386659 100644
--- a/packages/effect/test/Effect/forking.test.ts
+++ b/packages/effect/test/Effect/forking.test.ts
@@ -6,14 +6,15 @@ import * as Fiber from "effect/Fiber"
import { pipe } from "effect/Function"
import * as Option from "effect/Option"
import * as Ref from "effect/Ref"
+import { assertFalse, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("fork - propagates interruption", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.never, Effect.fork, Effect.flatMap(Fiber.interrupt))
- assert.isTrue(Exit.isInterrupted(result))
+ assertTrue(Exit.isInterrupted(result))
}))
it.effect("fork - propagates interruption with zip of defect", () =>
Effect.gen(function*($) {
@@ -27,7 +28,7 @@ describe("Effect", () => {
yield* $(Deferred.await(latch))
const result = yield* $(Fiber.interrupt(fiber), Effect.map(Exit.mapErrorCause((cause) => cause)))
- assert.isTrue(Exit.isInterrupted(result))
+ assertTrue(Exit.isInterrupted(result))
}))
it.effect("fork - interruption status is heritable", () =>
Effect.gen(function*($) {
@@ -43,7 +44,7 @@ describe("Effect", () => {
)
const result = yield* $(Ref.get(ref))
- assert.isFalse(result)
+ assertFalse(result)
}))
it.effect("forkWithErrorHandler - calls provided function when task fails", () =>
Effect.gen(function*($) {
@@ -53,12 +54,12 @@ describe("Effect", () => {
Effect.forkWithErrorHandler((e) => pipe(Deferred.succeed(deferred, e), Effect.asVoid))
)
const result = yield* $(Deferred.await(deferred))
- assert.isUndefined(result)
+ strictEqual(result, undefined)
}))
it.effect("forkAll - returns the list of results in the same order", () =>
Effect.gen(function*($) {
const result = yield* $([1, 2, 3].map(Effect.succeed), Effect.forkAll(), Effect.flatMap(Fiber.join))
- assert.deepStrictEqual(Array.from(result), [1, 2, 3])
+ deepStrictEqual(Array.from(result), [1, 2, 3])
}))
it.effect("forkAll - happy-path", () =>
Effect.gen(function*($) {
@@ -67,7 +68,7 @@ describe("Effect", () => {
Effect.forkAll(),
Effect.flatMap(Fiber.join)
)
- assert.deepStrictEqual(
+ deepStrictEqual(
Array.from(result),
Array.from({ length: 1000 }, (_, i) => i + 1)
)
@@ -77,14 +78,14 @@ describe("Effect", () => {
const result = yield* $(
pipe([] as ReadonlyArray>, Effect.forkAll(), Effect.flatMap(Fiber.join))
)
- assert.strictEqual(result.length, 0)
+ strictEqual(result.length, 0)
}))
it.effect("forkAll - propagate failures", () =>
Effect.gen(function*($) {
const boom = new Error()
const fail = Effect.fail(boom)
const result = yield* $([fail], Effect.forkAll(), Effect.flatMap((fiber) => Effect.flip(Fiber.join(fiber))))
- assert.strictEqual(result, boom)
+ strictEqual(result, boom)
}))
it.effect("forkAll - propagates defects", () =>
Effect.gen(function*($) {
@@ -99,10 +100,10 @@ describe("Effect", () => {
const result1 = yield* $(joinDefect(fiber1), Effect.map((cause) => cause))
const result2 = yield* $(joinDefect(fiber2), Effect.map((cause) => cause))
const result3 = yield* $(joinDefect(fiber3), Effect.map((cause) => cause))
- assert.deepStrictEqual(Cause.dieOption(result1), Option.some(boom))
- assert.deepStrictEqual(Cause.dieOption(result2), Option.some(boom))
- assert.deepStrictEqual(Cause.dieOption(result3), Option.some(boom))
- assert.isTrue(Cause.isInterrupted(result3))
+ deepStrictEqual(Cause.dieOption(result1), Option.some(boom))
+ deepStrictEqual(Cause.dieOption(result2), Option.some(boom))
+ deepStrictEqual(Cause.dieOption(result3), Option.some(boom))
+ assertTrue(Cause.isInterrupted(result3))
}))
it.effect("forkAll - infers correctly", () =>
Effect.gen(function*($) {
@@ -112,7 +113,7 @@ describe("Effect", () => {
const fiber = yield* $(Effect.forkAll(workers))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 0)
+ strictEqual(result, 0)
}))
it.effect("forkAll - infers correctly with error type", () =>
Effect.gen(function*($) {
@@ -122,6 +123,6 @@ describe("Effect", () => {
const fiber = yield* $(Effect.forkAll(workers))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 0)
+ strictEqual(result, 0)
}))
})
diff --git a/packages/effect/test/Effect/interruption.test.ts b/packages/effect/test/Effect/interruption.test.ts
index 2e8c8897fed..da85465c767 100644
--- a/packages/effect/test/Effect/interruption.test.ts
+++ b/packages/effect/test/Effect/interruption.test.ts
@@ -13,23 +13,24 @@ import * as HashSet from "effect/HashSet"
import * as MutableRef from "effect/MutableRef"
import * as Option from "effect/Option"
import * as Ref from "effect/Ref"
+import { assertFalse, assertSome, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
import { withLatch, withLatchAwait } from "effect/test/utils/latch"
import * as TestClock from "effect/TestClock"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("sync forever is interruptible", () =>
Effect.gen(function*($) {
const fiber = yield* $(Effect.succeed(1), Effect.forever, Effect.fork)
const result = yield* $(Fiber.interrupt(fiber))
- assert.isTrue(Exit.isFailure(result) && Cause.isInterruptedOnly(result.effect_instruction_i0))
+ assertTrue(Exit.isFailure(result) && Cause.isInterruptedOnly(result.effect_instruction_i0))
}))
it.effect("interrupt of never is interrupted with cause", () =>
Effect.gen(function*($) {
const fiber = yield* $(Effect.never, Effect.fork)
const result = yield* $(Fiber.interrupt(fiber))
- assert.isTrue(Exit.isFailure(result) && Cause.isInterruptedOnly(result.effect_instruction_i0))
+ assertTrue(Exit.isFailure(result) && Cause.isInterruptedOnly(result.effect_instruction_i0))
}))
it.effect("asyncEffect is interruptible", () =>
Effect.gen(function*($) {
@@ -37,13 +38,13 @@ describe("Effect", () => {
pipe(Effect.asyncEffect(() => Effect.never), Effect.fork)
)
const result = yield* $(Fiber.interrupt(fiber))
- assert.isTrue(Exit.isFailure(result) && Cause.isInterruptedOnly(result.effect_instruction_i0))
+ assertTrue(Exit.isFailure(result) && Cause.isInterruptedOnly(result.effect_instruction_i0))
}))
it.effect("async is interruptible", () =>
Effect.gen(function*($) {
const fiber = yield* $(Effect.async(constVoid), Effect.fork)
const result = yield* $(Fiber.interrupt(fiber))
- assert.isTrue(Exit.isFailure(result) && Cause.isInterruptedOnly(result.effect_instruction_i0))
+ assertTrue(Exit.isFailure(result) && Cause.isInterruptedOnly(result.effect_instruction_i0))
}))
it.effect("acquireUseRelease - acquire is uninterruptible", () =>
Effect.gen(function*($) {
@@ -77,7 +78,7 @@ describe("Effect", () => {
})
const result = yield* $(program)
yield* $(Deferred.succeed(awaiter, void 0))
- assert.strictEqual(result, 42)
+ strictEqual(result, 42)
}))
it.effect("acquireUseRelease - use is interruptible", () =>
Effect.gen(function*($) {
@@ -91,7 +92,7 @@ describe("Effect", () => {
)
)
const result = yield* $(Fiber.interrupt(fiber))
- assert.isTrue(Exit.isInterrupted(result))
+ assertTrue(Exit.isInterrupted(result))
}))
it.effect("acquireUseRelease - release is called on interrupt", () =>
Effect.gen(function*($) {
@@ -116,7 +117,7 @@ describe("Effect", () => {
duration: Duration.seconds(1)
})
)
- assert.strictEqual(result, 0)
+ strictEqual(result, 0)
}))
it.effect("acquireUseRelease acquire returns immediately on interrupt", () =>
Effect.gen(function*($) {
@@ -137,7 +138,7 @@ describe("Effect", () => {
yield* $(Deferred.await(deferred1))
const result = yield* $(Fiber.interrupt(fiber))
yield* $(Deferred.succeed(deferred3, void 0))
- assert.isTrue(Exit.isInterrupted(result))
+ assertTrue(Exit.isInterrupted(result))
}))
it.effect("acquireUseRelease disconnect use is interruptible", () =>
Effect.gen(function*($) {
@@ -151,7 +152,7 @@ describe("Effect", () => {
Effect.fork
)
const result = yield* $(Fiber.interrupt(fiber))
- assert.isTrue(Exit.isInterrupted(result))
+ assertTrue(Exit.isInterrupted(result))
}))
it.effect("acquireUseRelease disconnect release called on interrupt in separate fiber", () =>
Effect.gen(function*($) {
@@ -180,7 +181,7 @@ describe("Effect", () => {
})
)
)
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("catchAll + ensuring + interrupt", () =>
Effect.gen(function*($) {
@@ -198,7 +199,7 @@ describe("Effect", () => {
yield* $(Deferred.await(latch))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Deferred.await(deferred))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("finalizer can detect interruption", () =>
Effect.gen(function*($) {
@@ -220,7 +221,7 @@ describe("Effect", () => {
yield* $(Deferred.await(deferred2))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Deferred.await(deferred1))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("interrupted cause persists after catching", () =>
Effect.gen(function*($) {
@@ -250,8 +251,8 @@ describe("Effect", () => {
)
yield* $(Deferred.await(latch1), Effect.zipRight(Fiber.interrupt(fiber)))
const result = yield* $(Ref.get(exits), Effect.map(process))
- assert.strictEqual(Chunk.size(result), 2)
- assert.isTrue(pipe(
+ strictEqual(Chunk.size(result), 2)
+ assertTrue(pipe(
result,
Array.reduce(true, (acc, curr) =>
acc && Exit.isFailure(curr) && Cause.isInterruptedOnly(curr.effect_instruction_i0))
@@ -273,7 +274,7 @@ describe("Effect", () => {
yield* $(Deferred.await(latch1), Effect.zipRight(Deferred.await(latch2)))
yield* $(Fiber.interrupt(raced))
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 2)
+ strictEqual(result, 2)
}))
it.effect("recovery of error in finalizer", () =>
Effect.gen(function*($) {
@@ -292,7 +293,7 @@ describe("Effect", () => {
))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Ref.get(recovered))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("recovery of interruptible", () =>
Effect.gen(function*($) {
@@ -311,7 +312,7 @@ describe("Effect", () => {
))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Ref.get(recovered))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("sandbox of interruptible", () =>
Effect.gen(function*($) {
@@ -331,7 +332,7 @@ describe("Effect", () => {
))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Ref.get(recovered))
- assert.deepStrictEqual(result, Option.some(Either.left(true)))
+ assertSome(result, Either.left(true))
}))
it.effect("run of interruptible", () =>
Effect.gen(function*($) {
@@ -348,7 +349,7 @@ describe("Effect", () => {
))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Ref.get(recovered))
- assert.deepStrictEqual(result, Option.some(true))
+ assertSome(result, true)
}))
it.effect("alternating interruptibility", () =>
Effect.gen(function*($) {
@@ -368,7 +369,7 @@ describe("Effect", () => {
))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Ref.get(counter))
- assert.strictEqual(result, 2)
+ strictEqual(result, 2)
}))
it.effect("interruption after defect", () =>
Effect.gen(function*($) {
@@ -387,7 +388,7 @@ describe("Effect", () => {
))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Ref.get(ref))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("interruption after defect 2", () =>
Effect.gen(function*($) {
@@ -406,7 +407,7 @@ describe("Effect", () => {
))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Ref.get(ref))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("disconnect returns immediately on interrupt", () =>
Effect.gen(function*($) {
@@ -422,7 +423,7 @@ describe("Effect", () => {
)
yield* $(Deferred.await(deferred))
const result = yield* $(Fiber.interrupt(fiber))
- assert.isTrue(Exit.isInterrupted(result))
+ assertTrue(Exit.isInterrupted(result))
}))
it.live("disconnected effect that is then interrupted eventually performs interruption", () =>
Effect.gen(function*($) {
@@ -448,7 +449,7 @@ describe("Effect", () => {
yield* $(Fiber.interrupt(fiber))
yield* $(Deferred.await(deferred2))
const result = yield* $(Ref.get(ref))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("cause reflects interruption", () =>
Effect.gen(function*($) {
@@ -456,7 +457,7 @@ describe("Effect", () => {
withLatch((release) => pipe(release, Effect.zipRight(Effect.fail("foo")), Effect.fork)),
Effect.flatMap(Fiber.interrupt)
)
- assert.deepStrictEqual(result, Exit.fail("foo"))
+ deepStrictEqual(result, Exit.fail("foo"))
}))
it.live("acquireRelease use inherits interrupt status", () =>
Effect.gen(function*($) {
@@ -484,7 +485,7 @@ describe("Effect", () => {
))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Ref.get(ref))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.live("acquireRelease use inherits interrupt status 2", () =>
Effect.gen(function*($) {
@@ -510,7 +511,7 @@ describe("Effect", () => {
yield* $(Deferred.succeed(latch2, void 0))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Ref.get(ref))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.live("async can be uninterruptible", () =>
Effect.gen(function*($) {
@@ -526,7 +527,7 @@ describe("Effect", () => {
))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Ref.get(ref))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.live("closing scope is uninterruptible", () =>
Effect.gen(function*($) {
@@ -542,7 +543,7 @@ describe("Effect", () => {
yield* $(Deferred.await(deferred))
yield* $(Fiber.interrupt(fiber))
const result = yield* $(Ref.get(ref))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("async cancelation", () =>
Effect.gen(function*($) {
@@ -555,7 +556,7 @@ describe("Effect", () => {
})
yield* $(Effect.void, Effect.race(effect))
const result = MutableRef.get(ref)
- assert.strictEqual(result, 0)
+ strictEqual(result, 0)
}))
it.effect("interruption status is inheritable", () =>
Effect.gen(function*($) {
@@ -570,7 +571,7 @@ describe("Effect", () => {
Effect.uninterruptible
)
const result = yield* $(Ref.get(ref))
- assert.isFalse(result)
+ assertFalse(result)
}))
it.effect("running an effect preserves interruption status", () =>
Effect.gen(function*($) {
@@ -580,7 +581,7 @@ describe("Effect", () => {
)
yield* $(Deferred.await(deferred))
const result = yield* $(Fiber.interrupt(fiber))
- assert.isTrue(
+ assertTrue(
Exit.isFailure(result) && Exit.isInterrupted(result) && Cause.isInterruptedOnly(result.effect_instruction_i0)
)
}))
@@ -589,7 +590,7 @@ describe("Effect", () => {
const deferred = yield* $(Deferred.make())
yield* $(Effect.interrupt, Effect.exit, Effect.zipRight(Deferred.succeed(deferred, 42)))
const result = yield* $(Deferred.await(deferred))
- assert.strictEqual(result, 42)
+ strictEqual(result, 42)
}))
it.effect("AbortSignal is aborted", () =>
Effect.gen(function*($) {
@@ -602,6 +603,6 @@ describe("Effect", () => {
)
yield* $(Effect.yieldNow())
yield* $(Fiber.interrupt(fiber))
- assert.strictEqual(signal!.aborted, true)
+ strictEqual(signal!.aborted, true)
}))
})
diff --git a/packages/effect/test/Effect/join-order.test.ts b/packages/effect/test/Effect/join-order.test.ts
index 8befb3920ea..207afec6746 100644
--- a/packages/effect/test/Effect/join-order.test.ts
+++ b/packages/effect/test/Effect/join-order.test.ts
@@ -1,9 +1,10 @@
import * as Effect from "effect/Effect"
import * as Fiber from "effect/Fiber"
import * as FiberRef from "effect/FiberRef"
+import { strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
import * as TestClock from "effect/TestClock"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("zip/all joins fibers in the correct order", () =>
@@ -16,6 +17,6 @@ describe("Effect", () => {
)))
yield* $(TestClock.adjust("3 seconds"))
yield* $(Fiber.join(fiber))
- assert.strictEqual(yield* $(FiberRef.get(ref)), 10)
+ strictEqual(yield* $(FiberRef.get(ref)), 10)
}).pipe(Effect.scoped))
})
diff --git a/packages/effect/test/Effect/latch.test.ts b/packages/effect/test/Effect/latch.test.ts
index 019cd8c8d98..8685a685c6f 100644
--- a/packages/effect/test/Effect/latch.test.ts
+++ b/packages/effect/test/Effect/latch.test.ts
@@ -1,5 +1,6 @@
import { Effect, Exit } from "effect"
-import { assert, describe, it } from "effect/test/utils/extend"
+import { deepStrictEqual, strictEqual } from "effect/test/util"
+import { describe, it } from "effect/test/utils/extend"
describe("Latch", () => {
it.effect("open works", () =>
@@ -9,15 +10,15 @@ describe("Latch", () => {
Effect.fork
)
yield* Effect.yieldNow()
- assert.isNull(fiber.unsafePoll())
+ strictEqual(fiber.unsafePoll(), null)
yield* latch.open
- assert.deepStrictEqual(yield* fiber.await, Exit.void)
+ deepStrictEqual(yield* fiber.await, Exit.void)
fiber = yield* latch.await.pipe(
Effect.fork
)
yield* Effect.yieldNow()
- assert.deepStrictEqual(fiber.unsafePoll(), Exit.void)
+ deepStrictEqual(fiber.unsafePoll(), Exit.void)
yield* latch.close
fiber = yield* Effect.void.pipe(
@@ -25,10 +26,10 @@ describe("Latch", () => {
Effect.fork
)
yield* Effect.yieldNow()
- assert.isNull(fiber.unsafePoll())
+ strictEqual(fiber.unsafePoll(), null)
yield* latch.release
- assert.deepStrictEqual(yield* fiber.await, Exit.void)
+ deepStrictEqual(yield* fiber.await, Exit.void)
}))
it.effect("subtype of Effect", () =>
@@ -38,6 +39,6 @@ describe("Latch", () => {
yield* latch.open
- assert.deepStrictEqual(yield* fiber.await, Exit.void)
+ deepStrictEqual(yield* fiber.await, Exit.void)
}))
})
diff --git a/packages/effect/test/Effect/lifting.test.ts b/packages/effect/test/Effect/lifting.test.ts
index 48e49fe8830..d6bc295a946 100644
--- a/packages/effect/test/Effect/lifting.test.ts
+++ b/packages/effect/test/Effect/lifting.test.ts
@@ -1,7 +1,8 @@
import * as Effect from "effect/Effect"
import { pipe } from "effect/Function"
+import { strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("liftPredicate", () => {
@@ -11,35 +12,35 @@ describe("Effect", () => {
const onNumberRefinementError = (n: string | number) => `${n} is not a number`
return Effect.gen(function*() {
- assert.deepStrictEqual(
+ strictEqual(
yield* pipe(1, Effect.liftPredicate(isPositivePredicate, onPositivePredicateError)),
1
)
- assert.deepStrictEqual(
+ strictEqual(
yield* pipe(-1, Effect.liftPredicate(isPositivePredicate, onPositivePredicateError), Effect.flip),
`-1 is not positive`
)
- assert.deepStrictEqual(
+ strictEqual(
yield* pipe(1, Effect.liftPredicate(isNumberRefinement, onNumberRefinementError)),
1
)
- assert.deepStrictEqual(
+ strictEqual(
yield* pipe("string", Effect.liftPredicate(isNumberRefinement, onNumberRefinementError), Effect.flip),
`string is not a number`
)
- assert.deepStrictEqual(
+ strictEqual(
yield* Effect.liftPredicate(1, isPositivePredicate, onPositivePredicateError),
1
)
- assert.deepStrictEqual(
+ strictEqual(
yield* Effect.liftPredicate(-1, isPositivePredicate, onPositivePredicateError).pipe(Effect.flip),
`-1 is not positive`
)
- assert.deepStrictEqual(
+ strictEqual(
yield* Effect.liftPredicate(1, isNumberRefinement, onNumberRefinementError),
1
)
- assert.deepStrictEqual(
+ strictEqual(
yield* Effect.liftPredicate("string", isNumberRefinement, onNumberRefinementError).pipe(Effect.flip),
`string is not a number`
)
diff --git a/packages/effect/test/Effect/mapping.test.ts b/packages/effect/test/Effect/mapping.test.ts
index 2e8e7315927..fb043028885 100644
--- a/packages/effect/test/Effect/mapping.test.ts
+++ b/packages/effect/test/Effect/mapping.test.ts
@@ -1,11 +1,11 @@
import * as Cause from "effect/Cause"
import * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
import * as Exit from "effect/Exit"
import { identity, pipe } from "effect/Function"
import * as Ref from "effect/Ref"
+import { assertFalse, assertLeft, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
const ExampleError = new Error("Oh noes!")
@@ -28,17 +28,17 @@ describe("Effect", () => {
it.effect("flip must make error into value", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.flip(Effect.fail(ExampleError)))
- assert.deepStrictEqual(result, ExampleError)
+ deepStrictEqual(result, ExampleError)
}))
it.effect("flip must make value into error", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.either(Effect.flip(Effect.succeed(42))))
- assert.deepStrictEqual(result, Either.left(42))
+ assertLeft(result, 42)
}))
it.effect("flipping twice returns the identical value", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.flip(Effect.flip(Effect.succeed(42))))
- assert.strictEqual(result, 42)
+ strictEqual(result, 42)
}))
it.effect("mapBoth - maps over both error and value channels", () =>
Effect.gen(function*($) {
@@ -50,34 +50,34 @@ describe("Effect", () => {
}),
Effect.either
)
- assert.deepStrictEqual(result, Either.left("10"))
+ assertLeft(result, "10")
}))
it.effect("mapAccum", () =>
Effect.gen(function*($) {
const result = yield* $(
Effect.mapAccum(["a", "b"], "", (prev, cur, i) => Effect.succeed([prev + cur + i, cur]))
)
- assert.deepStrictEqual(result, ["a0b1", ["a", "b"]])
+ deepStrictEqual(result, ["a0b1", ["a", "b"]])
}))
it.effect("tryMap - returns an effect whose success is mapped by the specified side effecting function", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.succeed("123"), Effect.tryMap({ try: parseInt, catch: identity }))
- assert.strictEqual(result, 123)
+ strictEqual(result, 123)
}))
it.effect("tryMap - translates any thrown exceptions into typed failed effects", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.succeed("hello"), Effect.tryMap({ try: parseInt, catch: identity }), Effect.exit)
- assert.deepStrictEqual(result, Exit.fail(new Cause.IllegalArgumentException()))
+ deepStrictEqual(result, Exit.fail(new Cause.IllegalArgumentException()))
}))
it.effect("negate - on true returns false", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.negate(Effect.succeed(true)))
- assert.isFalse(result)
+ assertFalse(result)
}))
it.effect("negate - on false returns true", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.negate(Effect.succeed(false)))
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("summarized - returns summary and value", () =>
Effect.gen(function*($) {
@@ -86,9 +86,9 @@ describe("Effect", () => {
const [[start, end], value] = yield* $(
pipe(increment, Effect.summarized(increment, (start, end) => [start, end] as const))
)
- assert.strictEqual(start, 1)
- assert.strictEqual(value, 2)
- assert.strictEqual(end, 3)
+ strictEqual(start, 1)
+ strictEqual(value, 2)
+ strictEqual(end, 3)
}))
it.effect("point, bind, map", () =>
Effect.gen(function*($) {
@@ -99,7 +99,7 @@ describe("Effect", () => {
return pipe(fibEffect(n - 1), Effect.zipWith(fibEffect(n - 2), (a, b) => a + b))
}
const result = yield* $(fibEffect(10))
- assert.strictEqual(result, fib(10))
+ strictEqual(result, fib(10))
}))
it.effect("effect, bind, map", () =>
Effect.gen(function*($) {
@@ -110,7 +110,7 @@ describe("Effect", () => {
return pipe(fibEffect(n - 1), Effect.zipWith(fibEffect(n - 2), (a, b) => a + b))
}
const result = yield* $(fibEffect(10))
- assert.strictEqual(result, fib(10))
+ strictEqual(result, fib(10))
}))
it.effect("effect, bind, map, redeem", () =>
Effect.gen(function*($) {
@@ -126,6 +126,6 @@ describe("Effect", () => {
return pipe(fibEffect(n - 1), Effect.zipWith(fibEffect(n - 2), (a, b) => a + b))
}
const result = yield* $(fibEffect(10))
- assert.strictEqual(result, fib(10))
+ strictEqual(result, fib(10))
}))
})
diff --git a/packages/effect/test/Effect/memoization.test.ts b/packages/effect/test/Effect/memoization.test.ts
index 82055caba87..4c20cf25e8f 100644
--- a/packages/effect/test/Effect/memoization.test.ts
+++ b/packages/effect/test/Effect/memoization.test.ts
@@ -1,22 +1,24 @@
+import { notStrictEqual } from "assert"
import * as Effect from "effect/Effect"
import { pipe } from "effect/Function"
import * as Random from "effect/Random"
import * as Ref from "effect/Ref"
+import { strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("non-memoized returns new instances on repeated calls", () =>
it.flakyTest(Effect.gen(function*($) {
const random = Random.nextInt
const [first, second] = yield* $(random, Effect.zip(random))
- assert.notStrictEqual(first, second)
+ notStrictEqual(first, second)
})))
it.effect("memoized returns the same instance on repeated calls", () =>
it.flakyTest(Effect.gen(function*($) {
const memo = Effect.cached(Random.nextInt)
const [first, second] = yield* $(memo, Effect.flatMap((effect) => pipe(effect, Effect.zip(effect))))
- assert.strictEqual(first, second)
+ strictEqual(first, second)
})))
it.effect("memoized function returns the same instance on repeated calls", () =>
it.flakyTest(Effect.gen(function*($) {
@@ -26,9 +28,9 @@ describe("Effect", () => {
const b = yield* $(memoized(10))
const c = yield* $(memoized(11))
const d = yield* $(memoized(11))
- assert.strictEqual(a, b)
- assert.notStrictEqual(b, c)
- assert.strictEqual(c, d)
+ strictEqual(a, b)
+ notStrictEqual(b, c)
+ strictEqual(c, d)
})))
it.effect("once returns an effect that will only be executed once", () =>
Effect.gen(function*($) {
@@ -41,6 +43,6 @@ describe("Effect", () => {
})
)
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 1)
+ strictEqual(result, 1)
}))
})
diff --git a/packages/effect/test/Effect/promise.test.ts b/packages/effect/test/Effect/promise.test.ts
index 54db63dcb8c..c14cf6a33f6 100644
--- a/packages/effect/test/Effect/promise.test.ts
+++ b/packages/effect/test/Effect/promise.test.ts
@@ -1,6 +1,6 @@
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import { describe, expect, it } from "vitest"
+import { Cause, Effect, Option } from "effect"
+import { assertFailure, assertSuccess, assertTrue } from "effect/test/util"
+import { describe, it } from "vitest"
const succeedPromiseLike: PromiseLike = {
// @ts-ignore
@@ -40,8 +40,8 @@ describe("Effect", () => {
Effect.option
)
const exit = await Effect.runPromiseExit(program)
- expect(exit._tag).toBe("Success")
- expect(aborted).toBe(true)
+ assertSuccess(exit, Option.none())
+ assertTrue(aborted)
})
it("PromiseLike - succeed", async () => {
@@ -51,11 +51,7 @@ describe("Effect", () => {
Effect.option
)
const exit = await Effect.runPromiseExit(program)
- expect(exit._tag).toBe("Success")
-
- if (exit._tag === "Success") {
- expect(exit.value).toEqual(Option.some("succeed"))
- }
+ assertSuccess(exit, Option.some("succeed"))
})
it("PromiseLike - fail", async () => {
@@ -65,10 +61,6 @@ describe("Effect", () => {
Effect.option
)
const exit = await Effect.runPromiseExit(program)
- expect(exit._tag).toBe("Failure")
-
- if (exit._tag === "Failure") {
- expect(exit.cause.toString()).toEqual("Error: fail")
- }
+ assertFailure(exit, Cause.die("fail"))
})
})
diff --git a/packages/effect/test/Effect/provide-runtime.test.ts b/packages/effect/test/Effect/provide-runtime.test.ts
index 3642424c233..55fbac89cc5 100644
--- a/packages/effect/test/Effect/provide-runtime.test.ts
+++ b/packages/effect/test/Effect/provide-runtime.test.ts
@@ -6,8 +6,9 @@ import * as FiberRef from "effect/FiberRef"
import * as Layer from "effect/Layer"
import * as RuntimeFlags from "effect/RuntimeFlags"
import * as Scope from "effect/Scope"
+import { assertFalse, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
interface A {
readonly value: number
@@ -35,7 +36,7 @@ describe("Effect", () => {
const pre = yield* _(Effect.context())
yield* _(Effect.provide(Effect.void, rt))
const post = yield* _(Effect.context())
- assert.isTrue(Equal.equals(pre, post))
+ assertTrue(Equal.equals(pre, post))
}).pipe(
Effect.scoped,
Effect.provide(Layer.succeed(SomeService, someServiceImpl))
@@ -71,10 +72,10 @@ describe("Effect", () => {
await Effect.runPromise(Scope.close(scope, Exit.void))
- assert.deepStrictEqual(all[0].a, 2)
- assert.deepStrictEqual(all[0].b, { value: 1 })
- assert.deepStrictEqual(all[0].c, true)
- assert.deepStrictEqual(all[1].a, 0)
- assert.deepStrictEqual(all[1].c, false)
+ strictEqual(all[0].a, 2)
+ deepStrictEqual(all[0].b, { value: 1 })
+ assertTrue(all[0].c)
+ strictEqual(all[1].a, 0)
+ assertFalse(all[1].c)
})
})
diff --git a/packages/effect/test/Effect/query-nested.test.ts b/packages/effect/test/Effect/query-nested.test.ts
index 1ca05bdebee..a18b6c4527f 100644
--- a/packages/effect/test/Effect/query-nested.test.ts
+++ b/packages/effect/test/Effect/query-nested.test.ts
@@ -5,8 +5,9 @@ import * as Effect from "effect/Effect"
import * as Layer from "effect/Layer"
import * as Request from "effect/Request"
import * as Resolver from "effect/RequestResolver"
+import { strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { describe, expect } from "vitest"
+import { describe } from "vitest"
interface Counter {
readonly _: unique symbol
@@ -171,8 +172,8 @@ describe("Effect", () => {
const count = yield* $(Counter)
const requests = yield* $(Requests)
- expect(count.count).toBe(3)
- expect(requests.count).toBe(7)
+ strictEqual(count.count, 3)
+ strictEqual(requests.count, 7)
}).pipe(
Effect.provide(EnvLive)
))
diff --git a/packages/effect/test/Effect/query-repro.test.ts b/packages/effect/test/Effect/query-repro.test.ts
index 53a3e5ca4ae..305a45054fe 100644
--- a/packages/effect/test/Effect/query-repro.test.ts
+++ b/packages/effect/test/Effect/query-repro.test.ts
@@ -2,8 +2,9 @@ import * as Effect from "effect/Effect"
import * as Layer from "effect/Layer"
import * as Request from "effect/Request"
import * as RequestResolver from "effect/RequestResolver"
+import { strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { describe, expect } from "vitest"
+import { describe } from "vitest"
export class FindIntraday extends Request.TaggedClass("FindIntraday") {}
@@ -41,6 +42,6 @@ describe("interruption", () => {
Effect.provide(Svc.Live),
Effect.exit
))
- expect(exit._tag).toEqual("Success")
+ strictEqual(exit._tag, "Success")
}))
})
diff --git a/packages/effect/test/Effect/query.test.ts b/packages/effect/test/Effect/query.test.ts
index 72f53c2edd9..a78723d01d4 100644
--- a/packages/effect/test/Effect/query.test.ts
+++ b/packages/effect/test/Effect/query.test.ts
@@ -9,10 +9,11 @@ import * as FiberRef from "effect/FiberRef"
import * as Layer from "effect/Layer"
import * as Request from "effect/Request"
import * as Resolver from "effect/RequestResolver"
+import { assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
import * as TestClock from "effect/TestClock"
import type { Concurrency } from "effect/Types"
-import { describe, expect } from "vitest"
+import { describe } from "vitest"
import { pipe } from "../../src/index.js"
interface Counter {
@@ -174,16 +175,16 @@ describe("Effect", () => {
Effect.withRequestCaching(true),
Effect.repeatN(3)
)
- expect(count).toBe(1)
+ strictEqual(count, 1)
}))
it.effect("requests are executed correctly", () =>
provideEnv(
Effect.gen(function*($) {
const names = yield* $(getAllUserNames)
const count = yield* $(Counter)
- expect(count.count).toEqual(3)
- expect(names.length).toBeGreaterThan(2)
- expect(names).toEqual(userIds.map((id) => userNames.get(id)))
+ strictEqual(count.count, 3)
+ assertTrue(names.length > 2)
+ deepStrictEqual(names, userIds.map((id) => userNames.get(id)))
})
))
it.effect("requests with dual syntax are executed correctly", () =>
@@ -191,9 +192,9 @@ describe("Effect", () => {
Effect.gen(function*($) {
const names = yield* $(getAllUserNamesPiped)
const count = yield* $(Counter)
- expect(count.count).toEqual(3)
- expect(names.length).toBeGreaterThan(2)
- expect(names).toEqual(userIds.map((id) => userNames.get(id)))
+ strictEqual(count.count, 3)
+ assertTrue(names.length > 2)
+ deepStrictEqual(names, userIds.map((id) => userNames.get(id)))
})
))
it.effect("requests are executed correctly with fromEffectTagged", () =>
@@ -201,9 +202,9 @@ describe("Effect", () => {
Effect.gen(function*($) {
const names = yield* $(getAllUserNamesTagged)
const count = yield* $(Counter)
- expect(count.count).toEqual(3)
- expect(names.length).toBeGreaterThan(2)
- expect(names).toEqual(userIds.map((id) => userNames.get(id)))
+ strictEqual(count.count, 3)
+ assertTrue(names.length > 2)
+ deepStrictEqual(names, userIds.map((id) => userNames.get(id)))
})
))
it.effect("batching composes", () =>
@@ -216,10 +217,10 @@ describe("Effect", () => {
batching: true
}))
const count = yield* $(Counter)
- expect(count.count).toEqual(3)
- expect(names[0].length).toBeGreaterThan(2)
- expect(names[0]).toEqual(userIds.map((id) => userNames.get(id)))
- expect(names[0]).toEqual(names[1])
+ strictEqual(count.count, 3)
+ assertTrue(names[0].length > 2)
+ deepStrictEqual(names[0], userIds.map((id) => userNames.get(id)))
+ deepStrictEqual(names[0], names[1])
})
))
it.effect("withSpan doesn't break batching", () =>
@@ -234,7 +235,7 @@ describe("Effect", () => {
Effect.withRequestCaching(false)
)
const count = yield* $(Counter)
- expect(count.count).toEqual(1)
+ strictEqual(count.count, 1)
})
))
it.effect("batching is independent from parallelism", () =>
@@ -242,9 +243,9 @@ describe("Effect", () => {
Effect.gen(function*($) {
const names = yield* $(getAllUserNamesN(5))
const count = yield* $(Counter)
- expect(count.count).toEqual(3)
- expect(names.length).toBeGreaterThan(2)
- expect(names).toEqual(userIds.map((id) => userNames.get(id)))
+ strictEqual(count.count, 3)
+ assertTrue(names.length > 2)
+ deepStrictEqual(names, userIds.map((id) => userNames.get(id)))
})
))
it.effect("batching doesn't break interruption", () =>
@@ -259,15 +260,15 @@ describe("Effect", () => {
}),
Effect.exit
)
- expect(exit._tag).toEqual("Failure")
+ strictEqual(exit._tag, "Failure")
if (exit._tag === "Failure") {
- expect(Cause.isInterruptedOnly(exit.cause)).toEqual(true)
+ assertTrue(Cause.isInterruptedOnly(exit.cause))
}
const cache = yield* $(FiberRef.get(FiberRef.currentRequestCache))
const values = yield* $(cache.values)
- expect(values[0].handle.state.current._tag).toEqual("Done")
- expect(yield* $(Counter)).toEqual({ count: 0 })
- expect(yield* $(FiberRef.get(interrupts))).toEqual({ interrupts: 1 })
+ strictEqual(values[0].handle.state.current._tag, "Done")
+ deepStrictEqual(yield* $(Counter), { count: 0 })
+ deepStrictEqual(yield* $(FiberRef.get(interrupts)), { interrupts: 1 })
})
)
))
@@ -279,12 +280,12 @@ describe("Effect", () => {
yield* $(Effect.yieldNow())
yield* $(Fiber.interrupt(fiber))
const exit = yield* $(Fiber.await(fiber))
- expect(exit._tag).toEqual("Failure")
+ strictEqual(exit._tag, "Failure")
if (exit._tag === "Failure") {
- expect(Cause.isInterruptedOnly(exit.cause)).toEqual(true)
+ assertTrue(Cause.isInterruptedOnly(exit.cause))
}
- expect(yield* $(Counter)).toEqual({ count: 0 })
- expect(yield* $(FiberRef.get(interrupts))).toEqual({ interrupts: 1 })
+ deepStrictEqual(yield* $(Counter), { count: 0 })
+ deepStrictEqual(yield* $(FiberRef.get(interrupts)), { interrupts: 1 })
})
)
))
@@ -296,12 +297,12 @@ describe("Effect", () => {
yield* $(Effect.yieldNow())
yield* $(Fiber.interrupt(fiber))
const exit = yield* $(Fiber.await(fiber))
- expect(exit._tag).toEqual("Failure")
+ strictEqual(exit._tag, "Failure")
if (exit._tag === "Failure") {
- expect(Cause.isInterruptedOnly(exit.cause)).toEqual(true)
+ assertTrue(Cause.isInterruptedOnly(exit.cause))
}
- expect(yield* $(Counter)).toEqual({ count: 3 })
- expect(yield* $(FiberRef.get(interrupts))).toEqual({ interrupts: 0 })
+ deepStrictEqual(yield* $(Counter), { count: 3 })
+ deepStrictEqual(yield* $(FiberRef.get(interrupts)), { interrupts: 0 })
})
)
))
@@ -317,12 +318,12 @@ describe("Effect", () => {
}),
Effect.exit
)
- expect(exit._tag).toEqual("Failure")
+ strictEqual(exit._tag, "Failure")
if (exit._tag === "Failure") {
- expect(Cause.isInterruptedOnly(exit.cause)).toEqual(true)
+ assertTrue(Cause.isInterruptedOnly(exit.cause))
}
- expect(yield* $(Counter)).toEqual({ count: 0 })
- expect(yield* $(FiberRef.get(interrupts))).toEqual({ interrupts: 1 })
+ deepStrictEqual(yield* $(Counter), { count: 0 })
+ deepStrictEqual(yield* $(FiberRef.get(interrupts)), { interrupts: 1 })
})
)
))
@@ -341,9 +342,9 @@ describe("Effect", () => {
Effect.withRequestBatching(true)
)
const count = yield* $(Counter)
- expect(count.count).toEqual(2)
- expect(a).toEqual(userNames.get(userIds[0]))
- expect(b).toEqual(userNames.get(userIds[1]))
+ strictEqual(count.count, 2)
+ deepStrictEqual(a, userNames.get(userIds[0]))
+ deepStrictEqual(b, userNames.get(userIds[1]))
})
))
it.effect("zip/parallel is batched by default", () =>
@@ -360,9 +361,9 @@ describe("Effect", () => {
)
)
const count = yield* $(Counter)
- expect(count.count).toEqual(1)
- expect(a).toEqual(userNames.get(userIds[0]))
- expect(b).toEqual(userNames.get(userIds[1]))
+ strictEqual(count.count, 1)
+ deepStrictEqual(a, userNames.get(userIds[0]))
+ deepStrictEqual(b, userNames.get(userIds[1]))
})
))
it.effect("cache respects ttl", () =>
@@ -370,15 +371,15 @@ describe("Effect", () => {
Effect.gen(function*($) {
yield* $(getAllUserIds)
yield* $(getAllUserIds)
- expect(yield* $(Counter)).toEqual({ count: 1 })
+ deepStrictEqual(yield* $(Counter), { count: 1 })
yield* $(TestClock.adjust(seconds(10)))
yield* $(getAllUserIds)
yield* $(getAllUserIds)
- expect(yield* $(Counter)).toEqual({ count: 1 })
+ deepStrictEqual(yield* $(Counter), { count: 1 })
yield* $(TestClock.adjust(seconds(60)))
yield* $(getAllUserIds)
yield* $(getAllUserIds)
- expect(yield* $(Counter)).toEqual({ count: 2 })
+ deepStrictEqual(yield* $(Counter), { count: 2 })
})
))
it.effect("cache can be warmed up", () =>
@@ -387,11 +388,11 @@ describe("Effect", () => {
yield* $(Effect.cacheRequestResult(GetAllIds({}), Exit.succeed(userIds)))
yield* $(getAllUserIds)
yield* $(getAllUserIds)
- expect(yield* $(Counter)).toEqual({ count: 0 })
+ deepStrictEqual(yield* $(Counter), { count: 0 })
yield* $(TestClock.adjust(seconds(65)))
yield* $(getAllUserIds)
yield* $(getAllUserIds)
- expect(yield* $(Counter)).toEqual({ count: 1 })
+ deepStrictEqual(yield* $(Counter), { count: 1 })
})
))
it.effect("cache can be disabled", () =>
@@ -399,15 +400,15 @@ describe("Effect", () => {
Effect.withRequestCaching(false)(Effect.gen(function*($) {
yield* $(getAllUserIds)
yield* $(getAllUserIds)
- expect(yield* $(Counter)).toEqual({ count: 2 })
+ deepStrictEqual(yield* $(Counter), { count: 2 })
yield* $(TestClock.adjust(seconds(10)))
yield* $(getAllUserIds)
yield* $(getAllUserIds)
- expect(yield* $(Counter)).toEqual({ count: 4 })
+ deepStrictEqual(yield* $(Counter), { count: 4 })
yield* $(TestClock.adjust(seconds(60)))
yield* $(getAllUserIds)
yield* $(getAllUserIds)
- expect(yield* $(Counter)).toEqual({ count: 6 })
+ deepStrictEqual(yield* $(Counter), { count: 6 })
}))
))
@@ -424,8 +425,8 @@ describe("Effect", () => {
)
const requests = yield* $(Requests)
const invocations = yield* $(Counter)
- expect(requests.count).toEqual(2)
- expect(invocations.count).toEqual(1)
+ deepStrictEqual(requests.count, 2)
+ deepStrictEqual(invocations.count, 1)
})
))
})
diff --git a/packages/effect/test/Effect/racing.test.ts b/packages/effect/test/Effect/racing.test.ts
index 2d97b46b401..f11be811e89 100644
--- a/packages/effect/test/Effect/racing.test.ts
+++ b/packages/effect/test/Effect/racing.test.ts
@@ -1,14 +1,15 @@
import * as Duration from "effect/Duration"
import * as Effect from "effect/Effect"
import { pipe } from "effect/Function"
+import { strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("returns first success", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.raceAll([Effect.fail("fail"), Effect.succeed(24)]))
- assert.strictEqual(result, 24)
+ strictEqual(result, 24)
}))
it.live("returns last failure", () =>
Effect.gen(function*($) {
@@ -18,7 +19,7 @@ describe("Effect", () => {
Effect.flip
)
)
- assert.strictEqual(result, 24)
+ strictEqual(result, 24)
}))
it.live("returns success when it happens after failure", () =>
Effect.gen(function*($) {
@@ -28,6 +29,6 @@ describe("Effect", () => {
pipe(Effect.succeed(24), Effect.zipLeft(Effect.sleep(Duration.millis(100))))
])
)
- assert.strictEqual(result, 24)
+ strictEqual(result, 24)
}))
})
diff --git a/packages/effect/test/Effect/rendezvous.test.ts b/packages/effect/test/Effect/rendezvous.test.ts
index c2e895f8411..eeca876e1ee 100644
--- a/packages/effect/test/Effect/rendezvous.test.ts
+++ b/packages/effect/test/Effect/rendezvous.test.ts
@@ -1,9 +1,10 @@
import * as Effect from "effect/Effect"
import * as Fiber from "effect/Fiber"
import * as Queue from "effect/Queue"
+import { deepStrictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
import * as TestClock from "effect/TestClock"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("bounded 0 is rendezvous", () =>
@@ -38,7 +39,7 @@ describe("Effect", () => {
yield* _(Fiber.join(Fiber.zip(fiber, fiber2)))
- assert.deepEqual(logs, [
+ deepStrictEqual(logs, [
"sending message",
"receiving message",
"received message",
diff --git a/packages/effect/test/Effect/repeating.test.ts b/packages/effect/test/Effect/repeating.test.ts
index 7620ca57958..0ae2864b140 100644
--- a/packages/effect/test/Effect/repeating.test.ts
+++ b/packages/effect/test/Effect/repeating.test.ts
@@ -2,8 +2,9 @@ import * as Effect from "effect/Effect"
import { constFalse, constTrue, pipe } from "effect/Function"
import * as Ref from "effect/Ref"
import * as Schedule from "effect/Schedule"
+import { deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("succeeds eventually", () =>
@@ -20,7 +21,7 @@ describe("Effect", () => {
}
const ref = yield* $(Ref.make(0))
const result = yield* $(Effect.eventually(effect(ref)))
- assert.strictEqual(result, 10)
+ strictEqual(result, 10)
}))
it.effect("repeat/until - repeats until condition is true", () =>
@@ -33,7 +34,7 @@ describe("Effect", () => {
Effect.repeat({ until: (n) => n === 0 })
)
const result = yield* $(Ref.get(output))
- assert.strictEqual(result, 10)
+ strictEqual(result, 10)
}))
it.effect("repeat/until - preserves return value", () =>
@@ -43,7 +44,7 @@ describe("Effect", () => {
Ref.updateAndGet(input, (n) => n - 1),
Effect.repeat({ until: (n) => n === 0 })
)
- assert.strictEqual(result, 0)
+ strictEqual(result, 0)
}))
it.effect("repeat/until - always evaluates effect at least once", () =>
@@ -51,7 +52,7 @@ describe("Effect", () => {
const ref = yield* $(Ref.make(0))
yield* $(Ref.update(ref, (n) => n + 1), Effect.repeat({ until: constTrue }))
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 1)
+ strictEqual(result, 1)
}))
it.effect("repeat/until - repeats until the effectful condition is true", () =>
Effect.gen(function*($) {
@@ -63,14 +64,14 @@ describe("Effect", () => {
Effect.repeat({ until: (n) => Effect.succeed(n === 0) })
)
const result = yield* $(Ref.get(output))
- assert.strictEqual(result, 10)
+ strictEqual(result, 10)
}))
it.effect("repeat/until - always evaluates the effect at least once", () =>
Effect.gen(function*($) {
const ref = yield* $(Ref.make(0))
yield* $(Ref.update(ref, (n) => n + 1), Effect.repeat({ until: () => Effect.succeed(true) }))
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 1)
+ strictEqual(result, 1)
}))
it.effect("repeat/while - repeats while the condition is true", () =>
Effect.gen(function*($) {
@@ -82,14 +83,14 @@ describe("Effect", () => {
Effect.repeat({ while: (n) => n >= 0 })
)
const result = yield* $(Ref.get(output))
- assert.strictEqual(result, 11)
+ strictEqual(result, 11)
}))
it.effect("repeat/while - always evaluates the effect at least once", () =>
Effect.gen(function*($) {
const ref = yield* $(Ref.make(0))
yield* $(Ref.update(ref, (n) => n + 1), Effect.repeat({ while: constFalse }))
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 1)
+ strictEqual(result, 1)
}))
it.effect("repeat/while - repeats while condition is true", () =>
Effect.gen(function*($) {
@@ -101,14 +102,14 @@ describe("Effect", () => {
Effect.repeat({ while: (v) => Effect.succeed(v >= 0) })
)
const result = yield* $(Ref.get(output))
- assert.strictEqual(result, 11)
+ strictEqual(result, 11)
}))
it.effect("repeat/while - always evaluates effect at least once", () =>
Effect.gen(function*($) {
const ref = yield* $(Ref.make(0))
yield* $(Ref.update(ref, (n) => n + 1), Effect.repeat({ while: () => Effect.succeed(false) }))
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 1)
+ strictEqual(result, 1)
}))
it.effect("repeat/schedule", () =>
@@ -116,7 +117,7 @@ describe("Effect", () => {
const ref = yield* $(Ref.make(0))
yield* $(Ref.update(ref, (n) => n + 1), Effect.repeat(Schedule.recurs(3)))
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 4)
+ strictEqual(result, 4)
}))
it.effect("repeat/schedule + until", () =>
@@ -127,7 +128,7 @@ describe("Effect", () => {
Effect.repeat({ schedule: Schedule.recurs(3), until: (n) => n === 3 })
)
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 3)
+ strictEqual(result, 3)
}))
it.effect("repeat/schedule + while", () =>
@@ -138,7 +139,7 @@ describe("Effect", () => {
Effect.repeat({ schedule: Schedule.recurs(3), while: (n) => n < 3 })
)
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 3)
+ strictEqual(result, 3)
}))
it.effect("repeat/times ", () =>
@@ -152,7 +153,7 @@ describe("Effect", () => {
Effect.repeat({ times: 2 })
)
const result = yield* $(Ref.get(ref))
- assert.deepStrictEqual(result, [0, 1, 2])
- assert.deepStrictEqual(effectResult, [0, 1, 2])
+ deepStrictEqual(result, [0, 1, 2])
+ deepStrictEqual(effectResult, [0, 1, 2])
}))
})
diff --git a/packages/effect/test/Effect/retrying.test.ts b/packages/effect/test/Effect/retrying.test.ts
index 1e34603256d..84585ff4b97 100644
--- a/packages/effect/test/Effect/retrying.test.ts
+++ b/packages/effect/test/Effect/retrying.test.ts
@@ -2,8 +2,9 @@ import * as Effect from "effect/Effect"
import { constFalse, constTrue } from "effect/Function"
import * as Ref from "effect/Ref"
import * as Schedule from "effect/Schedule"
+import { strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("retry/until - retries until condition is true", () =>
@@ -16,14 +17,14 @@ describe("Effect", () => {
Effect.flipWith(Effect.retry({ until: (n) => n === 0 }))
)
const result = yield* $(Ref.get(output))
- assert.strictEqual(result, 10)
+ strictEqual(result, 10)
}))
it.effect("retry/until - runs at least once", () =>
Effect.gen(function*($) {
const ref = yield* $(Ref.make(0))
yield* $(Ref.update(ref, (n) => n + 1), Effect.flipWith(Effect.retry({ until: constTrue })))
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 1)
+ strictEqual(result, 1)
}))
it.effect("retry/until - retries until condition is true", () =>
Effect.gen(function*($) {
@@ -35,7 +36,7 @@ describe("Effect", () => {
Effect.flipWith(Effect.retry({ until: (n) => Effect.succeed(n === 0) }))
)
const result = yield* $(Ref.get(output))
- assert.strictEqual(result, 10)
+ strictEqual(result, 10)
}))
it.effect("retry/until - runs at least once", () =>
Effect.gen(function*($) {
@@ -45,7 +46,7 @@ describe("Effect", () => {
Effect.flipWith(Effect.retry({ until: () => Effect.succeed(true) }))
)
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 1)
+ strictEqual(result, 1)
}))
it.effect("retry/while - retries while condition is true", () =>
Effect.gen(function*($) {
@@ -57,14 +58,14 @@ describe("Effect", () => {
Effect.flipWith(Effect.retry({ while: (n) => n >= 0 }))
)
const result = yield* $(Ref.get(output))
- assert.strictEqual(result, 11)
+ strictEqual(result, 11)
}))
it.effect("retry/while - runs at least once", () =>
Effect.gen(function*($) {
const ref = yield* $(Ref.make(0))
yield* $(Ref.update(ref, (n) => n + 1), Effect.flipWith(Effect.retry({ while: constFalse })))
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 1)
+ strictEqual(result, 1)
}))
it.effect("retry/while - retries while condition is true", () =>
Effect.gen(function*($) {
@@ -76,7 +77,7 @@ describe("Effect", () => {
Effect.flipWith(Effect.retry({ while: (n) => Effect.succeed(n >= 0) }))
)
const result = yield* $(Ref.get(output))
- assert.strictEqual(result, 11)
+ strictEqual(result, 11)
}))
it.effect("retry/while - runs at least once", () =>
Effect.gen(function*($) {
@@ -86,7 +87,7 @@ describe("Effect", () => {
Effect.flipWith(Effect.retry({ while: () => Effect.succeed(false) }))
)
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 1)
+ strictEqual(result, 1)
}))
it.effect("retry/schedule", () =>
Effect.gen(function*($) {
@@ -96,7 +97,7 @@ describe("Effect", () => {
Effect.flipWith(Effect.retry(Schedule.recurs(3)))
)
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 4)
+ strictEqual(result, 4)
}))
it.effect("retry/schedule + until", () =>
@@ -110,7 +111,7 @@ describe("Effect", () => {
}))
)
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 3)
+ strictEqual(result, 3)
}))
it.effect("retry/schedule + until effect", () =>
@@ -124,7 +125,7 @@ describe("Effect", () => {
}))
)
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 3)
+ strictEqual(result, 3)
}))
it.effect("retry/schedule + until error", () =>
@@ -137,7 +138,7 @@ describe("Effect", () => {
until: (_n) => Effect.fail("err" as const)
}))
)
- assert.strictEqual(result, "err")
+ strictEqual(result, "err")
}))
it.effect("retry/schedule + while", () =>
@@ -151,7 +152,7 @@ describe("Effect", () => {
}))
)
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 3)
+ strictEqual(result, 3)
}))
it.effect("retry/schedule + while error", () =>
@@ -164,7 +165,7 @@ describe("Effect", () => {
while: (_n) => Effect.fail("err" as const)
}))
)
- assert.strictEqual(result, "err")
+ strictEqual(result, "err")
}))
it.effect("retry/schedule + while effect", () =>
@@ -178,6 +179,6 @@ describe("Effect", () => {
}))
)
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 3)
+ strictEqual(result, 3)
}))
})
diff --git a/packages/effect/test/Effect/runtimeFlags.test.ts b/packages/effect/test/Effect/runtimeFlags.test.ts
index 60fb62f43cb..583ea970e2a 100644
--- a/packages/effect/test/Effect/runtimeFlags.test.ts
+++ b/packages/effect/test/Effect/runtimeFlags.test.ts
@@ -1,25 +1,26 @@
import * as Effect from "effect/Effect"
import * as Flags from "effect/RuntimeFlags"
import * as Patch from "effect/RuntimeFlagsPatch"
+import { assertFalse, assertTrue } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.it("should enable flags in the current fiber", () =>
Effect.runPromise(Effect.gen(function*($) {
const before = yield* $(Effect.getRuntimeFlags)
- assert.isFalse(Flags.isEnabled(before, Flags.OpSupervision))
+ assertFalse(Flags.isEnabled(before, Flags.OpSupervision))
yield* $(Effect.patchRuntimeFlags(Patch.enable(Flags.OpSupervision)))
const after = yield* $(Effect.getRuntimeFlags)
- assert.isTrue(Flags.isEnabled(after, Flags.OpSupervision))
+ assertTrue(Flags.isEnabled(after, Flags.OpSupervision))
})))
it.it("should enable flags in the wrapped effect", () =>
Effect.runPromise(Effect.gen(function*($) {
const before = yield* $(Effect.getRuntimeFlags)
- assert.isFalse(Flags.isEnabled(before, Flags.OpSupervision))
+ assertFalse(Flags.isEnabled(before, Flags.OpSupervision))
const inside = yield* $(Effect.getRuntimeFlags, Effect.withRuntimeFlagsPatch(Patch.enable(Flags.OpSupervision)))
const after = yield* $(Effect.getRuntimeFlags)
- assert.isFalse(Flags.isEnabled(after, Flags.OpSupervision))
- assert.isTrue(Flags.isEnabled(inside, Flags.OpSupervision))
+ assertFalse(Flags.isEnabled(after, Flags.OpSupervision))
+ assertTrue(Flags.isEnabled(inside, Flags.OpSupervision))
})))
})
diff --git a/packages/effect/test/Effect/scheduler.test.ts b/packages/effect/test/Effect/scheduler.test.ts
index 59a5c0cdfc5..898c28a46aa 100644
--- a/packages/effect/test/Effect/scheduler.test.ts
+++ b/packages/effect/test/Effect/scheduler.test.ts
@@ -1,7 +1,8 @@
import * as Effect from "effect/Effect"
import * as Scheduler from "effect/Scheduler"
+import { deepStrictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("matrix schedules according to priority", () =>
@@ -42,33 +43,33 @@ describe("Effect", () => {
Effect.yieldNow(),
Effect.withScheduler(scheduler)
)
- assert.deepEqual(ps000, [0])
+ deepStrictEqual(ps000, [0])
yield* $(
Effect.yieldNow({ priority: 50 }),
Effect.withScheduler(scheduler)
)
- assert.deepEqual(ps000, [0, 0])
+ deepStrictEqual(ps000, [0, 0])
yield* $(
Effect.yieldNow({ priority: 100 }),
Effect.withScheduler(scheduler)
)
- assert.deepEqual(ps100, [100])
+ deepStrictEqual(ps100, [100])
yield* $(
Effect.yieldNow({ priority: 150 }),
Effect.withScheduler(scheduler)
)
- assert.deepEqual(ps100, [100, 100])
+ deepStrictEqual(ps100, [100, 100])
yield* $(
Effect.yieldNow({ priority: 200 }),
Effect.withScheduler(scheduler)
)
- assert.deepEqual(ps100, [100, 100])
- assert.deepEqual(ps200, [200])
+ deepStrictEqual(ps100, [100, 100])
+ deepStrictEqual(ps200, [200])
yield* $(
Effect.yieldNow({ priority: 300 }),
Effect.withScheduler(scheduler)
)
- assert.deepEqual(ps100, [100, 100])
- assert.deepEqual(ps200, [200])
+ deepStrictEqual(ps100, [100, 100])
+ deepStrictEqual(ps200, [200])
}))
})
diff --git a/packages/effect/test/Effect/scheduling.test.ts b/packages/effect/test/Effect/scheduling.test.ts
index 418dae821a9..91f22ca3a5e 100644
--- a/packages/effect/test/Effect/scheduling.test.ts
+++ b/packages/effect/test/Effect/scheduling.test.ts
@@ -4,9 +4,10 @@ import * as Effect from "effect/Effect"
import { pipe } from "effect/Function"
import * as Ref from "effect/Ref"
import * as Schedule from "effect/Schedule"
+import { deepStrictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
import * as TestClock from "effect/TestClock"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("schedule - runs effect for each recurrence of the schedule", () =>
@@ -21,6 +22,6 @@ describe("Effect", () => {
yield* $(TestClock.adjust(Duration.seconds(5)))
const value = yield* $(Ref.get(ref))
const expected = [1, 2, 3, 4, 5].map(Duration.seconds)
- assert.deepStrictEqual(value, expected)
+ deepStrictEqual(value, expected)
}))
})
diff --git a/packages/effect/test/Effect/scope-ref.test.ts b/packages/effect/test/Effect/scope-ref.test.ts
index 8bc6d44b539..8550a2a03dc 100644
--- a/packages/effect/test/Effect/scope-ref.test.ts
+++ b/packages/effect/test/Effect/scope-ref.test.ts
@@ -4,8 +4,9 @@ import * as FiberRef from "effect/FiberRef"
import * as Layer from "effect/Layer"
import * as List from "effect/List"
import * as Logger from "effect/Logger"
+import { deepStrictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
const ref = FiberRef.unsafeMake(List.empty())
const env = GenericTag<"context", number>("context")
@@ -45,7 +46,7 @@ describe("Effect", () => {
withValue("EXTERN")
)
- assert.deepStrictEqual(messages, [
+ deepStrictEqual(messages, [
["1 | acquire | A > INNER > OUTER > EXTERN"],
["1 | release | R > INNER > OUTER > EXTERN"]
])
diff --git a/packages/effect/test/Effect/semaphore.test.ts b/packages/effect/test/Effect/semaphore.test.ts
index 483cc67230a..9d01566ce27 100644
--- a/packages/effect/test/Effect/semaphore.test.ts
+++ b/packages/effect/test/Effect/semaphore.test.ts
@@ -1,8 +1,9 @@
import * as D from "effect/Duration"
import * as Effect from "effect/Effect"
+import { strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
import * as TestClock from "effect/TestClock"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("semaphore works", () =>
@@ -18,9 +19,9 @@ describe("Effect", () => {
))
)
yield* $(TestClock.adjust(D.seconds(3)))
- assert.equal(messages.length, 2)
+ strictEqual(messages.length, 2)
yield* $(TestClock.adjust(D.seconds(3)))
- assert.equal(messages.length, 4)
+ strictEqual(messages.length, 4)
yield* $(
Effect.fork(Effect.all(
[0, 1, 2, 3].map((n) =>
@@ -30,9 +31,9 @@ describe("Effect", () => {
))
)
yield* $(TestClock.adjust(D.seconds(3)))
- assert.equal(messages.length, 6)
+ strictEqual(messages.length, 6)
yield* $(TestClock.adjust(D.seconds(3)))
- assert.equal(messages.length, 8)
+ strictEqual(messages.length, 8)
}))
it.effect("releaseAll", () =>
diff --git a/packages/effect/test/Effect/sequencing.test.ts b/packages/effect/test/Effect/sequencing.test.ts
index 1aeb59a094a..b5cbbf0abfa 100644
--- a/packages/effect/test/Effect/sequencing.test.ts
+++ b/packages/effect/test/Effect/sequencing.test.ts
@@ -8,8 +8,9 @@ import { constFalse, constTrue, pipe } from "effect/Function"
import * as HashSet from "effect/HashSet"
import * as Option from "effect/Option"
import * as Ref from "effect/Ref"
+import { assertFalse, assertLeft, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("andThen", () =>
@@ -24,16 +25,16 @@ describe("Effect", () => {
const a7 = Effect.andThen(Effect.succeed(0), "ok")
const a8 = Effect.andThen(Effect.succeed(0), () => Promise.resolve("ok"))
const a9 = Effect.andThen(Effect.succeed(0), Promise.resolve("ok"))
- assert.strictEqual(yield* $(a0), 1)
- assert.strictEqual(yield* $(a1), 1)
- assert.strictEqual(yield* $(a2), 1)
- assert.strictEqual(yield* $(a3), 1)
- assert.strictEqual(yield* $(a4), "ok")
- assert.strictEqual(yield* $(a5), "ok")
- assert.strictEqual(yield* $(a6), "ok")
- assert.strictEqual(yield* $(a7), "ok")
- assert.strictEqual(yield* $(a8), "ok")
- assert.strictEqual(yield* $(a9), "ok")
+ strictEqual(yield* $(a0), 1)
+ strictEqual(yield* $(a1), 1)
+ strictEqual(yield* $(a2), 1)
+ strictEqual(yield* $(a3), 1)
+ strictEqual(yield* $(a4), "ok")
+ strictEqual(yield* $(a5), "ok")
+ strictEqual(yield* $(a6), "ok")
+ strictEqual(yield* $(a7), "ok")
+ strictEqual(yield* $(a8), "ok")
+ strictEqual(yield* $(a9), "ok")
}))
it.effect("tap", () =>
Effect.gen(function*() {
@@ -50,27 +51,27 @@ describe("Effect", () => {
const a10 = Effect.tap(Effect.succeed(0), "ok")
const a11 = Effect.tap(Effect.succeed(0), () => Promise.resolve("ok"))
const a12 = Effect.tap(Effect.succeed(0), Promise.resolve("ok"))
- assert.strictEqual(yield* a0, 0)
- assert.strictEqual(yield* a1, 0)
- assert.strictEqual(yield* a2, 0)
- assert.strictEqual(yield* a3, 0)
- assert.strictEqual(yield* a4, 0)
- assert.strictEqual(yield* a5, 0)
- assert.strictEqual(yield* a6, 0)
- assert.strictEqual(yield* a7, 0)
- assert.strictEqual(yield* a8, 0)
- assert.strictEqual(yield* a9, 0)
- assert.strictEqual(yield* a10, 0)
- assert.strictEqual(yield* a11, 0)
- assert.strictEqual(yield* a12, 0)
+ strictEqual(yield* a0, 0)
+ strictEqual(yield* a1, 0)
+ strictEqual(yield* a2, 0)
+ strictEqual(yield* a3, 0)
+ strictEqual(yield* a4, 0)
+ strictEqual(yield* a5, 0)
+ strictEqual(yield* a6, 0)
+ strictEqual(yield* a7, 0)
+ strictEqual(yield* a8, 0)
+ strictEqual(yield* a9, 0)
+ strictEqual(yield* a10, 0)
+ strictEqual(yield* a11, 0)
+ strictEqual(yield* a12, 0)
}))
it.effect("flattens nested effects", () =>
Effect.gen(function*($) {
const effect = Effect.succeed(Effect.succeed("test"))
const flatten1 = yield* $(Effect.flatten(effect))
const flatten2 = yield* $(Effect.flatten(effect))
- assert.strictEqual(flatten1, "test")
- assert.strictEqual(flatten2, "test")
+ strictEqual(flatten1, "test")
+ strictEqual(flatten2, "test")
}))
it.effect("if - runs `onTrue` if result of `b` is `true`", () =>
Effect.gen(function*($) {
@@ -81,7 +82,7 @@ describe("Effect", () => {
onFalse: () => Effect.succeed(false)
})
)
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("if - runs `onFalse` if result of `b` is `false`", () =>
Effect.gen(function*($) {
@@ -92,7 +93,7 @@ describe("Effect", () => {
onTrue: () => Effect.succeed(false)
})
)
- assert.isTrue(result)
+ assertTrue(result)
}))
describe("", () => {
it.effect("tapErrorCause - effectually peeks at the cause of the failure of this effect", () =>
@@ -102,8 +103,8 @@ describe("Effect", () => {
pipe(Effect.dieMessage("die"), Effect.tapErrorCause(() => Ref.set(ref, true)), Effect.exit)
)
const effect = yield* $(Ref.get(ref))
- assert.isTrue(Exit.isFailure(result) && Option.isSome(Cause.dieOption(result.effect_instruction_i0)))
- assert.isTrue(effect)
+ assertTrue(Exit.isFailure(result) && Option.isSome(Cause.dieOption(result.effect_instruction_i0)))
+ assertTrue(effect)
}))
})
it.effect("tapDefect - effectually peeks at defects", () =>
@@ -115,8 +116,8 @@ describe("Effect", () => {
Effect.exit
)
const effect = yield* $(Ref.get(ref))
- assert.isTrue(Exit.isFailure(result) && Option.isSome(Cause.dieOption(result.effect_instruction_i0)))
- assert.isTrue(effect)
+ assertTrue(Exit.isFailure(result) && Option.isSome(Cause.dieOption(result.effect_instruction_i0)))
+ assertTrue(effect)
}))
it.effect("tapDefect - leaves failures", () =>
Effect.gen(function*($) {
@@ -127,8 +128,8 @@ describe("Effect", () => {
Effect.exit
)
const effect = yield* $(Ref.get(ref))
- assert.deepStrictEqual(result, Exit.fail("fail"))
- assert.isFalse(effect)
+ deepStrictEqual(result, Exit.fail("fail"))
+ assertFalse(effect)
}))
it.effect("unless - executes correct branch only", () =>
Effect.gen(function*($) {
@@ -140,9 +141,9 @@ describe("Effect", () => {
const failure = new Error("expected")
yield* $(Effect.fail(failure), Effect.unless(constTrue))
const failed = yield* $(Effect.fail(failure), Effect.unless(constFalse), Effect.either)
- assert.strictEqual(v1, 0)
- assert.strictEqual(v2, 2)
- assert.deepStrictEqual(failed, Either.left(failure))
+ strictEqual(v1, 0)
+ strictEqual(v2, 2)
+ assertLeft(failed, failure)
}))
it.effect("unlessEffect - executes condition effect and correct branch", () =>
Effect.gen(function*($) {
@@ -159,11 +160,11 @@ describe("Effect", () => {
const failure = new Error("expected")
yield* $(Effect.fail(failure), Effect.unlessEffect(conditionTrue))
const failed = yield* $(Effect.fail(failure), Effect.unlessEffect(conditionFalse), Effect.either)
- assert.strictEqual(v1, 0)
- assert.strictEqual(c1, 1)
- assert.strictEqual(v2, 2)
- assert.strictEqual(c2, 2)
- assert.deepStrictEqual(failed, Either.left(failure))
+ strictEqual(v1, 0)
+ strictEqual(c1, 1)
+ strictEqual(v2, 2)
+ strictEqual(c2, 2)
+ assertLeft(failed, failure)
}))
it.effect("when - executes correct branch only", () =>
Effect.gen(function*($) {
@@ -175,9 +176,9 @@ describe("Effect", () => {
const failure = new Error("expected")
yield* $(Effect.fail(failure), Effect.when(constFalse))
const failed = yield* $(Effect.fail(failure), Effect.when(constTrue), Effect.either)
- assert.strictEqual(v1, 0)
- assert.strictEqual(v2, 2)
- assert.deepStrictEqual(failed, Either.left(failure))
+ strictEqual(v1, 0)
+ strictEqual(v2, 2)
+ assertLeft(failed, failure)
}))
it.effect("whenEffect - executes condition effect and correct branch", () =>
Effect.gen(function*($) {
@@ -194,11 +195,11 @@ describe("Effect", () => {
const failure = new Error("expected")
yield* $(Effect.fail(failure), Effect.whenEffect(conditionFalse))
const failed = yield* $(Effect.fail(failure), Effect.whenEffect(conditionTrue), Effect.either)
- assert.strictEqual(v1, 0)
- assert.strictEqual(c1, 1)
- assert.strictEqual(v2, 2)
- assert.strictEqual(c2, 2)
- assert.deepStrictEqual(failed, Either.left(failure))
+ strictEqual(v1, 0)
+ strictEqual(c1, 1)
+ strictEqual(v2, 2)
+ strictEqual(c2, 2)
+ assertLeft(failed, failure)
}))
it.effect("zip/parallel - combines results", () =>
Effect.gen(function*($) {
@@ -208,7 +209,7 @@ describe("Effect", () => {
Effect.flatMap((tuple) => Effect.succeed(tuple[0] + tuple[1])),
Effect.map((n) => n === 3)
)
- assert.isTrue(result)
+ assertTrue(result)
}))
it.effect("zip/parallel - does not swallow exit causes of loser", () =>
Effect.gen(function*($) {
@@ -222,7 +223,7 @@ describe("Effect", () => {
)
)
)
- assert.isAbove(HashSet.size(result), 0)
+ assertTrue(HashSet.size(result) > 0)
}))
it.effect("zip/parallel - does not report failure when interrupting loser after it succeeded", () =>
Effect.gen(function*($) {
@@ -235,7 +236,7 @@ describe("Effect", () => {
Effect.map(Either.mapLeft(Cause.isInterrupted))
)
)
- assert.deepStrictEqual(result, Either.left(true))
+ assertLeft(result, true)
}))
it.effect("zip/parallel - paralellizes simple success values", () =>
Effect.gen(function*($) {
@@ -249,7 +250,7 @@ describe("Effect", () => {
)
}
const result = yield* $(countdown(50))
- assert.strictEqual(result, 150)
+ strictEqual(result, 150)
}))
it.effect("zip/parallel - does not kill fiber when forked on parent scope", () =>
Effect.gen(function*($) {
@@ -277,8 +278,8 @@ describe("Effect", () => {
const rightResult = result[1]
const leftResult = yield* $(Fiber.await(leftInnerFiber))
const interrupted = yield* $(Ref.get(ref))
- assert.isFalse(interrupted)
- assert.deepStrictEqual(leftResult, Exit.succeed("foo"))
- assert.strictEqual(rightResult, 42)
+ assertFalse(interrupted)
+ deepStrictEqual(leftResult, Exit.succeed("foo"))
+ strictEqual(rightResult, 42)
}))
})
diff --git a/packages/effect/test/Effect/service.test.ts b/packages/effect/test/Effect/service.test.ts
index 07a05ba01b3..af6db511d7b 100644
--- a/packages/effect/test/Effect/service.test.ts
+++ b/packages/effect/test/Effect/service.test.ts
@@ -4,7 +4,8 @@ import * as Effect from "effect/Effect"
import { pipe } from "effect/Function"
import * as Layer from "effect/Layer"
import * as Scope from "effect/Scope"
-import { describe, expect, it } from "effect/test/utils/extend"
+import { assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
+import { describe, it } from "effect/test/utils/extend"
class Prefix extends Effect.Service()("Prefix", {
sync: () => ({
@@ -55,23 +56,23 @@ class Scoped extends Effect.Service()("Scoped", {
describe("Effect.Service", () => {
it("make is a function", () => {
- expect(pipe({ prefix: "OK" }, Prefix.make)).toBeInstanceOf(Prefix)
+ assertTrue(pipe({ prefix: "OK" }, Prefix.make) instanceof Prefix)
})
it("tags is a tag and default is a layer", () => {
- expect(Layer.isLayer(Logger.Default)).toBe(true)
- expect(Layer.isLayer(Logger.DefaultWithoutDependencies)).toBe(true)
- expect(Context.isTag(Logger)).toBe(true)
+ assertTrue(Layer.isLayer(Logger.Default))
+ assertTrue(Layer.isLayer(Logger.DefaultWithoutDependencies))
+ assertTrue(Context.isTag(Logger))
})
it.effect("correctly wires dependencies", () =>
Effect.gen(function*() {
yield* Logger.info("Ok")
- expect(messages).toEqual(["[PRE][Ok][POST]"])
+ deepStrictEqual(messages, ["[PRE][Ok][POST]"])
const { prefix } = yield* Prefix
- expect(prefix).toEqual("PRE")
+ strictEqual(prefix, "PRE")
const { postfix } = yield* Postfix
- expect(postfix).toEqual("POST")
- expect(yield* Prefix.use((_) => _._tag)).toBe("Prefix")
+ strictEqual(postfix, "POST")
+ strictEqual(yield* Prefix.use((_) => _._tag), "Prefix")
}).pipe(
Effect.provide([
Logger.Default,
@@ -92,7 +93,7 @@ describe("Effect.Service", () => {
}
return Effect.gen(function*() {
const time = yield* Time.use((_) => _.now)
- expect(time).toBeInstanceOf(Date)
+ assertTrue(time instanceof Date)
}).pipe(Effect.provide(Time.Default))
})
@@ -114,7 +115,7 @@ describe("Effect.Service", () => {
return Effect.gen(function*() {
const time = yield* Time.use((_) => _.now)
const time2 = yield* Time.use((_) => _.now2)
- expect(time).toStrictEqual(time2)
+ strictEqual(time, time2)
}).pipe(Effect.provide(Time.Default))
})
@@ -137,9 +138,9 @@ describe("Effect.Service", () => {
return Effect.gen(function*() {
const time = yield* Time
const date = yield* Time.use((_) => _.now)
- expect(date).toBeInstanceOf(Date)
- expect(time).toBeInstanceOf(Time)
- expect(time).toBeInstanceOf(TimeLive)
+ assertTrue(date instanceof Date)
+ assertTrue(time instanceof Time)
+ assertTrue(time instanceof TimeLive)
}).pipe(Effect.provide(Time.Default))
})
@@ -154,15 +155,15 @@ describe("Effect.Service", () => {
Effect.provide(MapThing.Default)
)
- expect(map).toBeInstanceOf(MapThing)
- expect(map).toBeInstanceOf(Map)
+ assertTrue(map instanceof MapThing)
+ assertTrue(map instanceof Map)
const map2 = yield* MapThing.set("a", 1).pipe(
Effect.provide(MapThing.Default)
)
- expect(map2).toBeInstanceOf(MapThing)
- expect(map2).toBeInstanceOf(Map)
+ assertTrue(map2 instanceof MapThing)
+ assertTrue(map2 instanceof Map)
}))
it.effect("scoped", () =>
@@ -181,12 +182,18 @@ describe("Effect.Service", () => {
}) {}
const withUse = yield* Service.foo().pipe(Effect.flip, Effect.provide(Service.Default))
- expect(withUse).toEqual(new Cause.UnknownException(new Error("foo")))
+ deepStrictEqual(
+ withUse,
+ new Cause.UnknownException(new Error("foo"), "An unknown error occurred in Effect.andThen")
+ )
const accessor = yield* Service.foo().pipe(Effect.flip, Effect.provide(Service.Default))
- expect(accessor).toEqual(new Cause.UnknownException(new Error("foo")))
+ deepStrictEqual(
+ accessor,
+ new Cause.UnknownException(new Error("foo"), "An unknown error occurred in Effect.andThen")
+ )
const accessorSuccess = yield* Service.bar().pipe(Effect.provide(Service.Default))
- expect(accessorSuccess).toEqual("bar")
+ strictEqual(accessorSuccess, "bar")
}))
})
diff --git a/packages/effect/test/Effect/stack-safety.test.ts b/packages/effect/test/Effect/stack-safety.test.ts
index 169f76d6996..c0579d4dd06 100644
--- a/packages/effect/test/Effect/stack-safety.test.ts
+++ b/packages/effect/test/Effect/stack-safety.test.ts
@@ -1,8 +1,9 @@
import * as Effect from "effect/Effect"
import { constVoid, identity, pipe } from "effect/Function"
import * as Ref from "effect/Ref"
+import { assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
const deepMapEffect = (n: number): Effect.Effect => {
const loop = (n: number, acc: Effect.Effect): Effect.Effect => {
@@ -18,7 +19,7 @@ describe("Effect", () => {
it.effect("deep map of sync effect", () =>
Effect.gen(function*($) {
const result = yield* $(deepMapEffect(10000))
- assert.strictEqual(result, 10000)
+ strictEqual(result, 10000)
}))
it.effect("deep attempt", () =>
Effect.gen(function*($) {
@@ -27,7 +28,7 @@ describe("Effect", () => {
(acc, _) => pipe(Effect.orDie(acc), Effect.either, Effect.asVoid),
Effect.orDie(Effect.try(constVoid))
))
- assert.isUndefined(result)
+ strictEqual(result, undefined)
}))
it.effect("deep flatMap", () =>
Effect.gen(function*($) {
@@ -45,7 +46,7 @@ describe("Effect", () => {
const expected = BigInt(
"113796925398360272257523782552224175572745930353730513145086634176691092536145985470146129334641866902783673042322088625863396052888690096969577173696370562180400527049497109023054114771394568040040412172632376"
)
- assert.deepEqual(result, expected)
+ deepStrictEqual(result, expected)
}))
it.effect("deep absolve/attempt is identity", () =>
Effect.gen(function*($) {
@@ -53,7 +54,7 @@ describe("Effect", () => {
const result = yield* $(
array.reduce((acc, _) => Effect.flatMap(Effect.either(acc), identity), Effect.succeed(42))
)
- assert.strictEqual(result, 42)
+ strictEqual(result, 42)
}))
it.effect("deep async absolve/attempt is identity", () =>
Effect.gen(function*($) {
@@ -64,7 +65,7 @@ describe("Effect", () => {
cb(Effect.succeed(42))
})
))
- assert.strictEqual(result, 42)
+ strictEqual(result, 42)
}))
it.effect("deep effects", () =>
Effect.gen(function*($) {
@@ -83,6 +84,6 @@ describe("Effect", () => {
const left = pipe(Ref.make(0), Effect.flatMap((ref) => incLeft(100, ref)), Effect.map((n) => n === 0))
const right = pipe(Ref.make(0), Effect.flatMap((ref) => incRight(1000, ref)), Effect.map((n) => n === 1000))
const result = yield* $(left, Effect.zipWith(right, (a, b) => a && b))
- assert.isTrue(result)
+ assertTrue(result)
}))
})
diff --git a/packages/effect/test/Effect/structural.test.ts b/packages/effect/test/Effect/structural.test.ts
index 82c803ec2d5..c1593c2cd1d 100644
--- a/packages/effect/test/Effect/structural.test.ts
+++ b/packages/effect/test/Effect/structural.test.ts
@@ -1,37 +1,38 @@
import * as Effect from "effect/Effect"
import * as Either from "effect/Either"
import * as Option from "effect/Option"
+import { assertLeft, assertNone, assertRight, assertSome, deepStrictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
import { assertType, satisfies } from "effect/test/utils/types"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
describe("all", () => {
it.effect("should work with one array argument", () =>
Effect.gen(function*($) {
const res = yield* $(Effect.all([Effect.succeed(0), Effect.succeed(1)]))
- assert.deepEqual(res, [0, 1])
+ deepStrictEqual(res, [0, 1])
satisfies(assertType<[number, number]>()(res))
}))
it.effect("should work with one empty array argument", () =>
Effect.gen(function*($) {
const x = yield* $(Effect.all([]))
- assert.deepEqual(x, [])
+ deepStrictEqual(x, [])
satisfies(assertType<[]>()(x))
}))
it.effect("should work with an array argument", () =>
Effect.gen(function*($) {
const y = Effect.all([0, 1, 2].map((n) => Effect.succeed(n + 1)))
const x = yield* $(y)
- assert.deepEqual(x, [1, 2, 3])
+ deepStrictEqual(x, [1, 2, 3])
satisfies(assertType>()(x))
}))
it.effect("should work with one record argument", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.all({ a: Effect.succeed(0), b: Effect.succeed(1) }))
const { a, b } = result
- assert.deepEqual(a, 0)
- assert.deepEqual(b, 1)
+ deepStrictEqual(a, 0)
+ deepStrictEqual(b, 1)
satisfies(
assertType<{
readonly a: number
@@ -42,13 +43,13 @@ describe("Effect", () => {
it.effect("should work with one iterable argument", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.all(new Set([Effect.succeed(0), Effect.succeed(1)])))
- assert.deepEqual(result, [0, 1])
+ deepStrictEqual(result, [0, 1])
satisfies(assertType>()(result))
}))
it.effect("should work with one empty record", () =>
Effect.gen(function*($) {
const x = yield* $(Effect.all({}))
- assert.deepEqual(x, {})
+ deepStrictEqual(x, {})
satisfies(assertType<{}>()(x))
}))
})
@@ -58,7 +59,7 @@ describe("Effect", () => {
const res = yield* $(Effect.all([Effect.succeed(0), Effect.succeed(1)], {
concurrency: "unbounded"
}))
- assert.deepEqual(res, [0, 1])
+ deepStrictEqual(res, [0, 1])
satisfies(assertType<[number, number]>()(res))
}))
it.effect("should work with one empty array argument", () =>
@@ -66,7 +67,7 @@ describe("Effect", () => {
const x = yield* $(Effect.all([], {
concurrency: "unbounded"
}))
- assert.deepEqual(x, [])
+ deepStrictEqual(x, [])
satisfies(assertType<[]>()(x))
}))
it.effect("should work with one record argument", () =>
@@ -75,8 +76,8 @@ describe("Effect", () => {
concurrency: "unbounded"
}))
const { a, b } = result
- assert.deepEqual(a, 0)
- assert.deepEqual(b, 1)
+ deepStrictEqual(a, 0)
+ deepStrictEqual(b, 1)
satisfies(
assertType<{
a: number
@@ -87,7 +88,7 @@ describe("Effect", () => {
it.effect("should work with one empty record", () =>
Effect.gen(function*($) {
const x = yield* $(Effect.all({}, { concurrency: "unbounded" }))
- assert.deepEqual(x, {})
+ deepStrictEqual(x, {})
satisfies(assertType<{}>()(x))
}))
})
@@ -95,21 +96,21 @@ describe("Effect", () => {
it.effect("should work with one array argument", () =>
Effect.gen(function*($) {
const res = yield* $(Effect.all([Effect.succeed(0), Effect.succeed(1)], { mode: "validate" }))
- assert.deepEqual(res, [0, 1])
+ deepStrictEqual(res, [0, 1])
satisfies(assertType<[number, number]>()(res))
}))
it.effect("failure should work with one array argument", () =>
Effect.gen(function*($) {
const res = yield* $(Effect.flip(Effect.all([Effect.fail(0), Effect.succeed(1)], { mode: "validate" })))
- assert.deepEqual(res, [Option.some(0), Option.none()])
+ deepStrictEqual(res, [Option.some(0), Option.none()])
satisfies(assertType<[Option.Option, Option.Option]>()(res))
}))
it.effect("should work with one record argument", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.all({ a: Effect.succeed(0), b: Effect.succeed(1) }, { mode: "validate" }))
const { a, b } = result
- assert.deepEqual(a, 0)
- assert.deepEqual(b, 1)
+ deepStrictEqual(a, 0)
+ deepStrictEqual(b, 1)
satisfies(
assertType<{
readonly a: number
@@ -123,8 +124,8 @@ describe("Effect", () => {
Effect.flip(Effect.all({ a: Effect.fail(0), b: Effect.succeed(1) }, { mode: "validate" }))
)
const { a, b } = result
- assert.deepEqual(a, Option.some(0))
- assert.deepEqual(b, Option.none())
+ assertSome(a, 0)
+ assertNone(b)
satisfies(
assertType<{
readonly a: Option.Option
@@ -135,7 +136,7 @@ describe("Effect", () => {
it.effect("should work with one iterable argument", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.all(new Set([Effect.succeed(0), Effect.succeed(1)]), { mode: "validate" }))
- assert.deepEqual(result, [0, 1])
+ deepStrictEqual(result, [0, 1])
satisfies(assertType>()(result))
}))
})
@@ -143,21 +144,21 @@ describe("Effect", () => {
it.effect("should work with one array argument", () =>
Effect.gen(function*($) {
const res = yield* $(Effect.all([Effect.succeed(0), Effect.succeed(1)], { mode: "either" }))
- assert.deepEqual(res, [Either.right(0), Either.right(1)])
+ deepStrictEqual(res, [Either.right(0), Either.right(1)])
satisfies(assertType<[Either.Either, Either.Either]>()(res))
}))
it.effect("failure should work with one array argument", () =>
Effect.gen(function*($) {
const res = yield* $(Effect.all([Effect.fail(0), Effect.succeed(1)], { mode: "either" }))
- assert.deepEqual(res, [Either.left(0), Either.right(1)])
+ deepStrictEqual(res, [Either.left(0), Either.right(1)])
satisfies(assertType<[Either.Either, Either.Either]>()(res))
}))
it.effect("should work with one record argument", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.all({ a: Effect.succeed(0), b: Effect.succeed(1) }, { mode: "either" }))
const { a, b } = result
- assert.deepEqual(a, Either.right(0))
- assert.deepEqual(b, Either.right(1))
+ assertRight(a, 0)
+ assertRight(b, 1)
satisfies(
assertType<{
readonly a: Either.Either
@@ -171,8 +172,8 @@ describe("Effect", () => {
Effect.all({ a: Effect.fail(0), b: Effect.succeed(1) }, { mode: "either" })
)
const { a, b } = result
- assert.deepEqual(a, Either.left(0))
- assert.deepEqual(b, Either.right(1))
+ assertLeft(a, 0)
+ assertRight(b, 1)
satisfies(
assertType<{
readonly a: Either.Either
@@ -183,7 +184,7 @@ describe("Effect", () => {
it.effect("should work with one iterable argument", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.all(new Set([Effect.succeed(0), Effect.succeed(1)]), { mode: "either" }))
- assert.deepEqual(result, [Either.right(0), Either.right(1)])
+ deepStrictEqual(result, [Either.right(0), Either.right(1)])
satisfies(assertType>>()(result))
}))
})
@@ -194,7 +195,7 @@ describe("Effect", () => {
[Effect.succeed(0), Effect.succeed(1)] as const,
Effect.allWith()
)
- assert.deepEqual(res, [0, 1])
+ deepStrictEqual(res, [0, 1])
satisfies(assertType<[number, number]>()(res))
}))
})
diff --git a/packages/effect/test/Effect/sync.test.ts b/packages/effect/test/Effect/sync.test.ts
index ec47cc75673..be193c12cb1 100644
--- a/packages/effect/test/Effect/sync.test.ts
+++ b/packages/effect/test/Effect/sync.test.ts
@@ -1,10 +1,10 @@
import * as Cause from "effect/Cause"
import * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
import * as Exit from "effect/Exit"
import { pipe } from "effect/Function"
+import { assertLeft, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
const sum = (n: number): number => {
if (n < 0) {
@@ -33,7 +33,7 @@ describe("Effect", () => {
return pipe(Effect.sync(() => n), Effect.flatMap((b) => pipe(sumEffect(n - 1), Effect.map((a) => a + b))))
}
const result = yield* $(sumEffect(1000))
- assert.strictEqual(result, sum(1000))
+ strictEqual(result, sum(1000))
}))
it.it("sync - must be lazy", async () => {
let program
@@ -46,7 +46,7 @@ describe("Effect", () => {
program = Effect.succeed(false)
}
const result = await Effect.runPromise(program)
- assert.isTrue(result)
+ assertTrue(result)
})
it.it("suspend - must be lazy", async () => {
let program
@@ -59,7 +59,7 @@ describe("Effect", () => {
program = Effect.succeed(false)
}
const result = await Effect.runPromise(program)
- assert.isTrue(result)
+ assertTrue(result)
})
it.effect("suspend - must catch throwable", () =>
Effect.gen(function*($) {
@@ -70,12 +70,12 @@ describe("Effect", () => {
}),
Effect.exit
)
- assert.deepStrictEqual(result, Exit.die(error))
+ deepStrictEqual(result, Exit.die(error))
}))
it.effect("suspendSucceed - must be evaluatable", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.suspend(() => Effect.succeed(42)))
- assert.strictEqual(result, 42)
+ strictEqual(result, 42)
}))
it.effect("suspendSucceed - must not catch throwable", () =>
Effect.gen(function*($) {
@@ -87,6 +87,6 @@ describe("Effect", () => {
Effect.sandbox,
Effect.either
)
- assert.deepStrictEqual(result, Either.left(Cause.die(error)))
+ assertLeft(result, Cause.die(error))
}))
})
diff --git a/packages/effect/test/Effect/tapping.test.ts b/packages/effect/test/Effect/tapping.test.ts
index ce3e1f27794..06a39df9616 100644
--- a/packages/effect/test/Effect/tapping.test.ts
+++ b/packages/effect/test/Effect/tapping.test.ts
@@ -1,6 +1,7 @@
import * as Effect from "effect/Effect"
import { pipe } from "effect/Function"
-import { describe, expect, it } from "vitest"
+import { strictEqual } from "effect/test/util"
+import { describe, it } from "vitest"
class TestError1 {
readonly _tag = "TestError1"
@@ -24,6 +25,6 @@ describe("Effect", () => {
Effect.runPromise
)
- expect(val).toBe(1)
+ strictEqual(val, 1)
})
})
diff --git a/packages/effect/test/Effect/timeout.test.ts b/packages/effect/test/Effect/timeout.test.ts
index 810f1531699..7ca71a76161 100644
--- a/packages/effect/test/Effect/timeout.test.ts
+++ b/packages/effect/test/Effect/timeout.test.ts
@@ -4,10 +4,10 @@ import * as Effect from "effect/Effect"
import * as Exit from "effect/Exit"
import * as Fiber from "effect/Fiber"
import { constFalse, pipe } from "effect/Function"
-import * as Option from "effect/Option"
+import { assertNone, assertTrue, deepStrictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
import * as TestClock from "effect/TestClock"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("timeout produces a useful error message", () =>
@@ -20,9 +20,10 @@ describe("Effect", () => {
)
yield* TestClock.adjust(Duration.millis(2000))
const result = yield* Fiber.join(fiber)
- assert.include(
- result.toString(),
- "TimeoutException: Operation timed out before the specified duration of '1s 500ms' elapsed"
+ assertTrue(
+ result.toString().includes(
+ "TimeoutException: Operation timed out before the specified duration of '1s 500ms' elapsed"
+ )
)
}))
it.live("timeout a long computation", () =>
@@ -38,7 +39,7 @@ describe("Effect", () => {
Effect.exit
)
)
- assert.deepStrictEqual(result, Exit.fail(false))
+ deepStrictEqual(result, Exit.fail(false))
}))
it.live("timeout a long computation with a cause", () =>
Effect.gen(function*($) {
@@ -55,24 +56,24 @@ describe("Effect", () => {
Effect.flip
)
)
- assert.deepStrictEqual(result, cause)
+ deepStrictEqual(result, cause)
}))
it.live("timeout repetition of uninterruptible effect", () =>
Effect.gen(function*($) {
const result = yield* $(
pipe(Effect.void, Effect.uninterruptible, Effect.forever, Effect.timeout(Duration.millis(10)), Effect.option)
)
- assert.deepStrictEqual(result, Option.none())
+ assertNone(result)
}))
it.effect("timeout in uninterruptible region", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.void, Effect.timeout(Duration.seconds(20)), Effect.uninterruptible)
- assert.deepStrictEqual(result, void 0)
+ deepStrictEqual(result, void 0)
}))
it.effect("timeout - disconnect - returns with the produced value if the effect completes before the timeout elapses", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.void, Effect.disconnect, Effect.timeout(Duration.millis(100)))
- assert.deepStrictEqual(result, void 0)
+ deepStrictEqual(result, void 0)
}))
it.effect("timeout - disconnect - returns `NoSuchElementException` otherwise", () =>
Effect.gen(function*($) {
@@ -88,6 +89,6 @@ describe("Effect", () => {
)
yield* $(TestClock.adjust(Duration.millis(100)))
const result = yield* $(Fiber.join(fiber))
- assert.deepStrictEqual(result, Option.none())
+ assertNone(result)
}))
})
diff --git a/packages/effect/test/Effect/traversing.test.ts b/packages/effect/test/Effect/traversing.test.ts
index 0515385af96..b062793881f 100644
--- a/packages/effect/test/Effect/traversing.test.ts
+++ b/packages/effect/test/Effect/traversing.test.ts
@@ -3,13 +3,13 @@ import * as Cause from "effect/Cause"
import * as Chunk from "effect/Chunk"
import * as Deferred from "effect/Deferred"
import * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
import * as Exit from "effect/Exit"
import * as Fiber from "effect/Fiber"
import { constVoid, identity, pipe } from "effect/Function"
import * as Ref from "effect/Ref"
+import { assertFalse, assertLeft, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("dropWhile - happy path", () =>
@@ -20,7 +20,7 @@ describe("Effect", () => {
Effect.dropWhile((n) => Effect.succeed(n % 2 === 1))
)
)
- assert.deepStrictEqual(result, [2, 3, 4, 5])
+ deepStrictEqual(result, [2, 3, 4, 5])
}))
it.effect("dropWhile - error", () =>
Effect.gen(function*() {
@@ -29,7 +29,7 @@ describe("Effect", () => {
Effect.dropWhile(() => Effect.fail("Ouch")),
Effect.either
)
- assert.deepStrictEqual(result, Either.left("Ouch"))
+ assertLeft(result, "Ouch")
}))
it.effect("exists - determines whether any element satisfies the effectual predicate", () =>
Effect.gen(function*($) {
@@ -41,16 +41,16 @@ describe("Effect", () => {
concurrency: "unbounded"
})
)
- assert.isTrue(result1)
- assert.isFalse(result2)
+ assertTrue(result1)
+ assertFalse(result2)
}))
it.effect("forAll - determines whether all elements satisfy the effectual predicate", () =>
Effect.gen(function*($) {
const array = [1, 2, 3, 4, 5, 6]
const result1 = yield* $(array, Effect.every((n) => Effect.succeed(n > 3)))
const result2 = yield* $(array, Effect.every((n) => Effect.succeed(n > 0)))
- assert.isFalse(result1)
- assert.isTrue(result2)
+ assertFalse(result1)
+ assertTrue(result2)
}))
it.effect("iterate - iterates with the specified effectual function", () =>
Effect.gen(function*($) {
@@ -58,7 +58,7 @@ describe("Effect", () => {
while: (n) => n > 0,
body: (n) => Effect.succeed(n - 1)
}))
- assert.strictEqual(result, 0)
+ strictEqual(result, 0)
}))
it.effect("loop - loops with the specified effectual function", () =>
Effect.gen(function*($) {
@@ -71,7 +71,7 @@ describe("Effect", () => {
})
)
const result = yield* $(Ref.get(ref))
- assert.deepStrictEqual(result, [0, 1, 2, 3, 4])
+ deepStrictEqual(result, [0, 1, 2, 3, 4])
}))
it.effect("loop/discard - loops with the specified effectual function", () =>
Effect.gen(function*($) {
@@ -83,27 +83,27 @@ describe("Effect", () => {
discard: true
}))
const result = yield* $(Ref.get(ref))
- assert.deepStrictEqual(result, [0, 1, 2, 3, 4])
+ deepStrictEqual(result, [0, 1, 2, 3, 4])
}))
it.effect("replicate - zero", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.all(pipe(Effect.succeed(12), Effect.replicate(0))))
- assert.strictEqual(result.length, 0)
+ strictEqual(result.length, 0)
}))
it.effect("replicate - negative", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.all(pipe(Effect.succeed(12), Effect.replicate(-2))))
- assert.strictEqual(result.length, 0)
+ strictEqual(result.length, 0)
}))
it.effect("replicate - positive", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.all(pipe(Effect.succeed(12), Effect.replicate(2))))
- assert.deepStrictEqual(result, [12, 12])
+ deepStrictEqual(result, [12, 12])
}))
it.effect(" - returns the list of results", () =>
Effect.gen(function*($) {
const result = yield* $([1, 2, 3, 4, 5, 6], Effect.forEach((n) => Effect.succeed(n + 1)))
- assert.deepStrictEqual(result, [2, 3, 4, 5, 6, 7])
+ deepStrictEqual(result, [2, 3, 4, 5, 6, 7])
}))
it.effect("forEach - both evaluates effects and returns results in the same order", () =>
Effect.gen(function*($) {
@@ -118,8 +118,8 @@ describe("Effect", () => {
)
)
const effects = yield* $(Ref.get(ref), Effect.map(Chunk.reverse))
- assert.deepStrictEqual(Chunk.toReadonlyArray(effects), ["1", "2", "3"])
- assert.deepStrictEqual(result, [1, 2, 3])
+ deepStrictEqual(Chunk.toReadonlyArray(effects), ["1", "2", "3"])
+ deepStrictEqual(result, [1, 2, 3])
}))
it.effect("forEach - fails if one of the effects fails", () =>
Effect.gen(function*($) {
@@ -137,14 +137,14 @@ describe("Effect", () => {
Effect.exit
)
- assert.deepStrictEqual(result, Exit.die(new Cause.IllegalArgumentException()))
+ deepStrictEqual(result, Exit.die(new Cause.IllegalArgumentException()))
}))
it.effect("forEach/discard - runs effects in order", () =>
Effect.gen(function*($) {
const ref = yield* $(Ref.make(Array.empty()))
yield* $([1, 2, 3, 4, 5], Effect.forEach((n) => Ref.update(ref, Array.append(n)), { discard: true }))
const result = yield* $(Ref.get(ref))
- assert.deepStrictEqual(result, [1, 2, 3, 4, 5])
+ deepStrictEqual(result, [1, 2, 3, 4, 5])
}))
it.effect("forEach/discard - can be run twice", () =>
Effect.gen(function*($) {
@@ -153,23 +153,23 @@ describe("Effect", () => {
yield* $(effect)
yield* $(effect)
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 30)
+ strictEqual(result, 30)
}))
it.effect("forEach/concurrency - runs single task", () =>
Effect.gen(function*($) {
const result = yield* $([2], Effect.forEach((n) => Effect.succeed(n * 2), { concurrency: "unbounded" }))
- assert.deepStrictEqual(result, [4])
+ deepStrictEqual(result, [4])
}))
it.effect("forEach/concurrency - runs two tasks", () =>
Effect.gen(function*($) {
const result = yield* $([2, 3], Effect.forEach((n) => Effect.succeed(n * 2), { concurrency: "unbounded" }))
- assert.deepStrictEqual(result, [4, 6])
+ deepStrictEqual(result, [4, 6])
}))
it.effect("forEach/concurrency - runs many tasks", () =>
Effect.gen(function*($) {
const array = Array.makeBy(100, (i) => i + 1)
const result = yield* $(array, Effect.forEach((n) => Effect.succeed(n * 2), { concurrency: "unbounded" }))
- assert.deepStrictEqual(result, array.map((n) => n * 2))
+ deepStrictEqual(result, array.map((n) => n * 2))
}))
it.effect("forEach/concurrency - runs a task that fails", () =>
Effect.gen(function*($) {
@@ -178,7 +178,7 @@ describe("Effect", () => {
Effect.forEach((n) => n === 5 ? Effect.fail("boom") : Effect.succeed(n * 2), { concurrency: "unbounded" }),
Effect.flip
)
- assert.strictEqual(result, "boom")
+ strictEqual(result, "boom")
}))
it.effect("forEach/concurrency - runs two failed tasks", () =>
Effect.gen(function*($) {
@@ -192,7 +192,7 @@ describe("Effect", () => {
: Effect.succeed(n * 2), { concurrency: "unbounded" }),
Effect.flip
)
- assert.isTrue(result === "boom1" || result === "boom2")
+ assertTrue(result === "boom1" || result === "boom2")
}))
it.effect("forEach/concurrency - runs a task that dies", () =>
Effect.gen(function*($) {
@@ -203,7 +203,7 @@ describe("Effect", () => {
}),
Effect.exit
)
- assert.isTrue(Exit.isFailure(result) && Cause.isDie(result.effect_instruction_i0))
+ assertTrue(Exit.isFailure(result) && Cause.isDie(result.effect_instruction_i0))
}))
it.effect("forEach/concurrency - runs a task that is interrupted", () =>
Effect.gen(function*($) {
@@ -212,7 +212,7 @@ describe("Effect", () => {
Effect.forEach((n) => n === 5 ? Effect.interrupt : Effect.succeed(n * 2), { concurrency: "unbounded" }),
Effect.exit
)
- assert.isTrue(Exit.isInterrupted(result))
+ assertTrue(Exit.isInterrupted(result))
}))
it.effect("forEach/concurrency - runs a task that throws an unsuspended exception", () =>
Effect.gen(function*($) {
@@ -224,7 +224,7 @@ describe("Effect", () => {
}), { concurrency: "unbounded" }),
Effect.exit
)
- assert.deepStrictEqual(result, Exit.die(new Error("1")))
+ deepStrictEqual(result, Exit.die(new Error("1")))
}))
it.effect("forEach/concurrency - returns results in the same order", () =>
Effect.gen(function*($) {
@@ -232,7 +232,7 @@ describe("Effect", () => {
["1", "2", "3"],
Effect.forEach((s) => Effect.sync(() => Number.parseInt(s)), { concurrency: "unbounded" })
)
- assert.deepStrictEqual(result, [1, 2, 3])
+ deepStrictEqual(result, [1, 2, 3])
}))
it.effect("forEach/concurrency - runs effects in parallel", () =>
Effect.gen(function*($) {
@@ -245,7 +245,7 @@ describe("Effect", () => {
)
)
const result = yield* $(Deferred.await(deferred))
- assert.isUndefined(result)
+ strictEqual(result, undefined)
}))
it.effect("forEach/concurrency - propagates error", () =>
Effect.gen(function*($) {
@@ -254,7 +254,7 @@ describe("Effect", () => {
Effect.forEach((n) => n % 2 !== 0 ? Effect.succeed(n) : Effect.fail("not odd"), { concurrency: "unbounded" }),
Effect.flip
)
- assert.strictEqual(result, "not odd")
+ strictEqual(result, "not odd")
}))
it.effect("forEach/concurrency - interrupts effects on first failure", () =>
Effect.gen(function*($) {
@@ -268,8 +268,8 @@ describe("Effect", () => {
]
const error = yield* $(actions, Effect.forEach(identity, { concurrency: "unbounded" }), Effect.flip)
const value = yield* $(Ref.get(ref))
- assert.strictEqual(error, "C")
- assert.isFalse(value)
+ strictEqual(error, "C")
+ assertFalse(value)
}))
it.effect("forEach/concurrency - does not kill fiber when forked on the parent scope", () =>
Effect.gen(function*($) {
@@ -280,7 +280,7 @@ describe("Effect", () => {
)
yield* $(fibers, Effect.forEach(Fiber.await))
const result = yield* $(Ref.get(ref))
- assert.strictEqual(result, 100)
+ strictEqual(result, 100)
}))
it.effect("forEach/concurrency - parallelism - returns the results in the appropriate order", () =>
Effect.gen(function*($) {
@@ -290,7 +290,7 @@ describe("Effect", () => {
Effect.forEach((n) => Effect.succeed(n.toString()), { concurrency: 2 })
)
)
- assert.deepStrictEqual(result, ["1", "2", "3"])
+ deepStrictEqual(result, ["1", "2", "3"])
}))
it.effect("forEach/concurrency - parallelism - works on large lists", () =>
Effect.gen(function*($) {
@@ -302,7 +302,7 @@ describe("Effect", () => {
Effect.forEach((n) => Effect.succeed(n), { concurrency: parallelism })
)
)
- assert.deepStrictEqual(result, array)
+ deepStrictEqual(result, array)
}))
it.effect("forEach/concurrency - parallelism - runs effects in parallel", () =>
Effect.gen(function*($) {
@@ -315,7 +315,7 @@ describe("Effect", () => {
)
)
const result = yield* $(Deferred.await(deferred))
- assert.isUndefined(result)
+ strictEqual(result, undefined)
}))
it.effect("forEach/concurrency - parallelism - propagates error", () =>
Effect.gen(function*($) {
@@ -324,7 +324,7 @@ describe("Effect", () => {
Effect.forEach((n) => n % 2 !== 0 ? Effect.succeed(n) : Effect.fail("not odd"), { concurrency: 4 }),
Effect.either
)
- assert.deepStrictEqual(result, Either.left("not odd"))
+ assertLeft(result, "not odd")
}))
it.effect("forEach/concurrency - parallelism - interrupts effects on first failure", () =>
Effect.gen(function*($) {
@@ -338,7 +338,7 @@ describe("Effect", () => {
Effect.forEach(identity, { concurrency: 4 }),
Effect.either
)
- assert.deepStrictEqual(result, Either.left("C"))
+ assertLeft(result, "C")
}))
it.effect("forEach/concurrency+discard - accumulates errors", () =>
Effect.gen(function*($) {
@@ -372,7 +372,7 @@ describe("Effect", () => {
onSuccess: () => Chunk.empty()
})
)
- assert.deepStrictEqual(Chunk.toReadonlyArray(result), [1, 2, 3])
+ deepStrictEqual(Chunk.toReadonlyArray(result), [1, 2, 3])
}))
it.effect("forEach/concurrency+discard - runs all effects", () =>
Effect.gen(function*($) {
@@ -385,7 +385,7 @@ describe("Effect", () => {
})
)
const result = yield* $(Ref.get(ref), Effect.map(Chunk.reverse))
- assert.deepStrictEqual(Chunk.toReadonlyArray(result), [1, 2, 3, 4, 5])
+ deepStrictEqual(Chunk.toReadonlyArray(result), [1, 2, 3, 4, 5])
}))
it.effect("forEach/concurrency+discard - completes on empty input", () =>
Effect.gen(function*($) {
@@ -396,7 +396,7 @@ describe("Effect", () => {
discard: true
})
)
- assert.isUndefined(result)
+ strictEqual(result, undefined)
}))
it.effect("forEach/concurrency+discard - parallelism - runs all effects", () =>
Effect.gen(function*($) {
@@ -409,14 +409,14 @@ describe("Effect", () => {
})
)
const result = yield* $(Ref.get(ref), Effect.map(Chunk.reverse))
- assert.deepStrictEqual(Chunk.toReadonlyArray(result), [1, 2, 3, 4, 5])
+ deepStrictEqual(Chunk.toReadonlyArray(result), [1, 2, 3, 4, 5])
}))
it.effect("merge - on flipped result", () =>
Effect.gen(function*($) {
const effect: Effect.Effect = Effect.succeed(1)
const a = yield* $(Effect.merge(effect))
const b = yield* $(Effect.merge(Effect.flip(effect)))
- assert.strictEqual(a, b)
+ strictEqual(a, b)
}))
it.effect("mergeAll - return zero element on empty input", () =>
Effect.gen(function*($) {
@@ -425,28 +425,28 @@ describe("Effect", () => {
const result = yield* $(
pipe([] as ReadonlyArray>, Effect.mergeAll(zeroElement, () => nonZero))
)
- assert.strictEqual(result, zeroElement)
+ strictEqual(result, zeroElement)
}))
it.effect("mergeAll - merge list using function", () =>
Effect.gen(function*($) {
const result = yield* $([3, 5, 7].map(Effect.succeed), Effect.mergeAll(1, (b, a) => b + a))
- assert.strictEqual(result, 1 + 3 + 5 + 7)
+ strictEqual(result, 1 + 3 + 5 + 7)
}))
it.effect("mergeAll - should work when Z is an interable", () =>
Effect.gen(function*($) {
const result = yield* $([3, 5, 7].map(Effect.succeed), Effect.mergeAll([] as Array, (b, a) => [...b, a]))
- assert.deepStrictEqual(result, [3, 5, 7])
+ deepStrictEqual(result, [3, 5, 7])
}))
it.effect("mergeAll - should work when Z is a function", () =>
Effect.gen(function*($) {
const result = yield* $([3, 5, 7].map(Effect.succeed), Effect.mergeAll(() => 1, (_b, a) => () => a))
- assert.deepStrictEqual(result(), 7)
+ deepStrictEqual(result(), 7)
}))
it.effect("mergeAll - return error if it exists in list", () =>
Effect.gen(function*($) {
const effects: ReadonlyArray> = [Effect.void, Effect.fail(1)]
const result = yield* $(effects, Effect.mergeAll(void 0 as void, constVoid), Effect.exit)
- assert.deepStrictEqual(result, Exit.fail(1))
+ deepStrictEqual(result, Exit.fail(1))
}))
it.effect("mergeAll/concurrency - return zero element on empty input", () =>
Effect.gen(function*($) {
@@ -460,7 +460,7 @@ describe("Effect", () => {
})
)
)
- assert.strictEqual(result, zeroElement)
+ strictEqual(result, zeroElement)
}))
it.effect("mergeAll/concurrency - merge list using function", () =>
Effect.gen(function*($) {
@@ -470,7 +470,7 @@ describe("Effect", () => {
concurrency: "unbounded"
})
)
- assert.strictEqual(result, 1 + 3 + 5 + 7)
+ strictEqual(result, 1 + 3 + 5 + 7)
}))
it.effect("mergeAll/concurrency - return error if it exists in list", () =>
Effect.gen(function*($) {
@@ -482,21 +482,21 @@ describe("Effect", () => {
}),
Effect.exit
)
- assert.deepStrictEqual(result, Exit.failCause(Cause.fail(1)))
+ deepStrictEqual(result, Exit.failCause(Cause.fail(1)))
}))
it.effect("partition - collects only successes", () =>
Effect.gen(function*($) {
const array = Array.makeBy(10, (i) => i)
const [left, right] = yield* $(array, Effect.partition(Effect.succeed))
- assert.deepStrictEqual(left, [])
- assert.deepStrictEqual(right, array)
+ deepStrictEqual(left, [])
+ deepStrictEqual(right, array)
}))
it.effect("partition - collects only failures", () =>
Effect.gen(function*($) {
const array = Array.makeBy(10, () => 0)
const [left, right] = yield* $(array, Effect.partition(Effect.fail))
- assert.deepStrictEqual(left, array)
- assert.deepStrictEqual(right, [])
+ deepStrictEqual(left, array)
+ deepStrictEqual(right, [])
}))
it.effect("partition - collects failures and successes", () =>
Effect.gen(function*($) {
@@ -504,8 +504,8 @@ describe("Effect", () => {
const [left, right] = yield* $(
pipe(array, Effect.partition((n) => n % 2 === 0 ? Effect.fail(n) : Effect.succeed(n)))
)
- assert.deepStrictEqual(left, [0, 2, 4, 6, 8])
- assert.deepStrictEqual(right, [1, 3, 5, 7, 9])
+ deepStrictEqual(left, [0, 2, 4, 6, 8])
+ deepStrictEqual(right, [1, 3, 5, 7, 9])
}))
it.effect("partition - evaluates effects in correct order", () =>
Effect.gen(function*($) {
@@ -513,7 +513,7 @@ describe("Effect", () => {
const ref = yield* $(Ref.make(Chunk.empty()))
yield* $(array, Effect.partition((n) => Ref.update(ref, Chunk.prepend(n))))
const result = yield* $(Ref.get(ref), Effect.map(Chunk.reverse))
- assert.deepStrictEqual(Chunk.toReadonlyArray(result), [2, 4, 6, 3, 5, 6])
+ deepStrictEqual(Chunk.toReadonlyArray(result), [2, 4, 6, 3, 5, 6])
}))
it.effect("partition/concurrency - collects successes", () =>
Effect.gen(function*($) {
@@ -524,8 +524,8 @@ describe("Effect", () => {
concurrency: "unbounded"
})
)
- assert.deepStrictEqual(left, [])
- assert.deepStrictEqual(right, array)
+ deepStrictEqual(left, [])
+ deepStrictEqual(right, array)
}))
it.effect("partition/concurrency - collects failures", () =>
Effect.gen(function*($) {
@@ -536,8 +536,8 @@ describe("Effect", () => {
concurrency: "unbounded"
})
)
- assert.deepStrictEqual(left, array)
- assert.deepStrictEqual(right, [])
+ deepStrictEqual(left, array)
+ deepStrictEqual(right, [])
}))
it.effect("partition/concurrency - collects failures and successes", () =>
Effect.gen(function*($) {
@@ -550,8 +550,8 @@ describe("Effect", () => {
})
)
)
- assert.deepStrictEqual(left, [0, 2, 4, 6, 8])
- assert.deepStrictEqual(right, [1, 3, 5, 7, 9])
+ deepStrictEqual(left, [0, 2, 4, 6, 8])
+ deepStrictEqual(right, [1, 3, 5, 7, 9])
}))
it.effect("partition/concurrency - parallelism - collects successes", () =>
Effect.gen(function*($) {
@@ -562,8 +562,8 @@ describe("Effect", () => {
concurrency: 3
})
)
- assert.deepStrictEqual(left, [])
- assert.deepStrictEqual(right, array)
+ deepStrictEqual(left, [])
+ deepStrictEqual(right, array)
}))
it.effect("partition/concurrency - parallelism - collects failures", () =>
Effect.gen(function*($) {
@@ -572,8 +572,8 @@ describe("Effect", () => {
array,
Effect.partition(Effect.fail, { concurrency: 3 })
)
- assert.deepStrictEqual(left, array)
- assert.deepStrictEqual(right, [])
+ deepStrictEqual(left, array)
+ deepStrictEqual(right, [])
}))
it.effect("partition/concurrency - parallelism - collects failures and successes", () =>
Effect.gen(function*($) {
@@ -584,35 +584,35 @@ describe("Effect", () => {
concurrency: 3
})
)
- assert.deepStrictEqual(left, [0, 2, 4, 6, 8])
- assert.deepStrictEqual(right, [1, 3, 5, 7, 9])
+ deepStrictEqual(left, [0, 2, 4, 6, 8])
+ deepStrictEqual(right, [1, 3, 5, 7, 9])
}))
it.effect("reduce - with a successful step function sums the list properly", () =>
Effect.gen(function*($) {
const result = yield* $([1, 2, 3, 4, 5], Effect.reduce(0, (acc, curr) => Effect.succeed(acc + curr)))
- assert.strictEqual(result, 15)
+ strictEqual(result, 15)
}))
it.effect("reduce - with a failing step function returns a failed IO", () =>
Effect.gen(function*($) {
const result = yield* $([1, 2, 3, 4, 5], Effect.reduce(0, () => Effect.fail("fail")), Effect.exit)
- assert.deepStrictEqual(result, Exit.fail("fail"))
+ deepStrictEqual(result, Exit.fail("fail"))
}))
it.effect("reduce - run sequentially from left to right", () =>
Effect.gen(function*($) {
const result = yield* $(
pipe([1, 2, 3, 4, 5], Effect.reduce([] as ReadonlyArray, (acc, curr) => Effect.succeed([...acc, curr])))
)
- assert.deepStrictEqual(result, [1, 2, 3, 4, 5])
+ deepStrictEqual(result, [1, 2, 3, 4, 5])
}))
it.effect("reduceRight - with a successful step function sums the list properly", () =>
Effect.gen(function*($) {
const result = yield* $([1, 2, 3, 4, 5], Effect.reduceRight(0, (acc, curr) => Effect.succeed(acc + curr)))
- assert.strictEqual(result, 15)
+ strictEqual(result, 15)
}))
it.effect("reduceRight - with a failing step function returns a failed IO", () =>
Effect.gen(function*($) {
const result = yield* $([1, 2, 3, 4, 5], Effect.reduceRight(0, () => Effect.fail("fail")), Effect.exit)
- assert.deepStrictEqual(result, Exit.fail("fail"))
+ deepStrictEqual(result, Exit.fail("fail"))
}))
it.effect("reduceRight - run sequentially from right to left", () =>
Effect.gen(function*($) {
@@ -620,7 +620,7 @@ describe("Effect", () => {
[1, 2, 3, 4, 5],
Effect.reduceRight([] as ReadonlyArray, (curr, acc) => Effect.succeed([curr, ...acc]))
)
- assert.deepStrictEqual(result, [1, 2, 3, 4, 5])
+ deepStrictEqual(result, [1, 2, 3, 4, 5])
}))
it.effect("reduceEffect/concurrency - return zero element on empty input", () =>
Effect.gen(function*($) {
@@ -634,7 +634,7 @@ describe("Effect", () => {
})
)
)
- assert.strictEqual(result, zeroElement)
+ strictEqual(result, zeroElement)
}))
it.effect("reduceEffect/concurrency - reduce list using function", () =>
Effect.gen(function*($) {
@@ -644,7 +644,7 @@ describe("Effect", () => {
concurrency: "unbounded"
})
)
- assert.strictEqual(result, 1 + 3 + 5 + 7)
+ strictEqual(result, 1 + 3 + 5 + 7)
}))
it.effect("reduceEffect/concurrency - return error if zero is an error", () =>
Effect.gen(function*($) {
@@ -657,7 +657,7 @@ describe("Effect", () => {
Effect.exit
)
)
- assert.deepStrictEqual(result, Exit.failCause(Cause.fail(1)))
+ deepStrictEqual(result, Exit.failCause(Cause.fail(1)))
}))
it.effect("reduceEffect/concurrency - return error if it exists in list", () =>
Effect.gen(function*($) {
@@ -671,7 +671,7 @@ describe("Effect", () => {
Effect.exit
)
)
- assert.deepStrictEqual(result, Exit.failCause(Cause.fail(1)))
+ deepStrictEqual(result, Exit.failCause(Cause.fail(1)))
}))
it.effect("takeUntil - happy path", () =>
Effect.gen(function*($) {
@@ -681,7 +681,7 @@ describe("Effect", () => {
(n) => Effect.succeed(n >= 3)
)
)
- assert.deepStrictEqual(result, [1, 2, 3])
+ deepStrictEqual(result, [1, 2, 3])
}))
it.effect("takeUntil - error", () =>
Effect.gen(function*($) {
@@ -692,7 +692,7 @@ describe("Effect", () => {
Effect.either
)
)
- assert.deepStrictEqual(result, Either.left("Ouch"))
+ assertLeft(result, "Ouch")
}))
it.effect("takeWhile - happy path", () =>
Effect.gen(function*($) {
@@ -702,7 +702,7 @@ describe("Effect", () => {
Effect.takeWhile((n) => Effect.succeed(n % 2 === 1))
)
)
- assert.deepStrictEqual(result, [1])
+ deepStrictEqual(result, [1])
}))
it.effect("takeWhile - error", () =>
Effect.gen(function*($) {
@@ -713,6 +713,6 @@ describe("Effect", () => {
Effect.either
)
)
- assert.deepStrictEqual(result, Either.left("Ouch"))
+ assertLeft(result, "Ouch")
}))
})
diff --git a/packages/effect/test/Effect/tryPromise.test.ts b/packages/effect/test/Effect/tryPromise.test.ts
index ae9ac41de10..7e9f463d802 100644
--- a/packages/effect/test/Effect/tryPromise.test.ts
+++ b/packages/effect/test/Effect/tryPromise.test.ts
@@ -1,7 +1,6 @@
-import * as Cause from "effect/Cause"
-import * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
-import { describe, expect, it } from "effect/test/utils/extend"
+import { Cause, Effect, Option } from "effect"
+import { assertLeft, assertSuccess, assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
+import { describe, it } from "effect/test/utils/extend"
describe("Effect", () => {
it("tryPromise - success, no catch, no AbortSignal", async () => {
@@ -13,7 +12,7 @@ describe("Effect", () => {
})
)
const n = await Effect.runPromise(effect)
- expect(n).toBe(1)
+ strictEqual(n, 1)
})
it("tryPromise - failure, no catch, no AbortSignal", async () => {
@@ -25,7 +24,7 @@ describe("Effect", () => {
})
)
const either = await Effect.runPromise(Effect.either(effect))
- expect(either).toStrictEqual(Either.left(new Cause.UnknownException("error")))
+ assertLeft(either, new Cause.UnknownException("error", "An unknown error occurred in Effect.tryPromise"))
})
it("tryPromise - failure, catch, no AbortSignal", async () => {
@@ -39,7 +38,7 @@ describe("Effect", () => {
catch: (error) => new Error(String(error))
})
const either = await Effect.runPromise(Effect.either(effect))
- expect(either).toStrictEqual(Either.left(new Error("error")))
+ assertLeft(either, new Error("error"))
})
it("tryPromise - success, no catch, AbortSignal", async () => {
@@ -60,8 +59,8 @@ describe("Effect", () => {
Effect.catchTag("TimeoutException", () => Effect.succeedNone)
)
const exit = await Effect.runPromiseExit(program)
- expect(exit._tag).toBe("Success")
- expect(aborted).toBe(true)
+ assertSuccess(exit, Option.none())
+ assertTrue(aborted)
})
it("tryPromise - success, catch, AbortSignal", async () => {
@@ -85,8 +84,8 @@ describe("Effect", () => {
Effect.catchTag("TimeoutException", () => Effect.succeedNone)
)
const exit = await Effect.runPromiseExit(program)
- expect(exit._tag).toBe("Success")
- expect(aborted).toBe(true)
+ assertSuccess(exit, Option.none())
+ assertTrue(aborted)
})
it.effect("tryPromise - defects in catch", () =>
@@ -100,6 +99,6 @@ describe("Effect", () => {
Effect.sandbox,
Effect.flip
)
- expect(cause).toStrictEqual(Cause.die(new Error("error")))
+ deepStrictEqual(cause, Cause.die(new Error("error")))
}))
})
diff --git a/packages/effect/test/Effect/validation.test.ts b/packages/effect/test/Effect/validation.test.ts
index 906f9627596..45c3b307f05 100644
--- a/packages/effect/test/Effect/validation.test.ts
+++ b/packages/effect/test/Effect/validation.test.ts
@@ -3,8 +3,9 @@ import * as Effect from "effect/Effect"
import * as Either from "effect/Either"
import { pipe } from "effect/Function"
import * as Ref from "effect/Ref"
+import { assertLeft, deepStrictEqual, strictEqual } from "effect/test/util"
import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
describe("Effect", () => {
it.effect("validate - fails", () =>
@@ -17,7 +18,7 @@ describe("Effect", () => {
Effect.either
)
)
- assert.deepStrictEqual(result, Either.left(Cause.fail(2)))
+ assertLeft(result, Cause.fail(2))
}))
it.effect("validate - combines both cause", () =>
Effect.gen(function*($) {
@@ -29,24 +30,24 @@ describe("Effect", () => {
Effect.either
)
)
- assert.deepStrictEqual(result, Either.left(Cause.sequential(Cause.fail(1), Cause.fail(2))))
+ deepStrictEqual(result, Either.left(Cause.sequential(Cause.fail(1), Cause.fail(2))))
}))
it.effect("validateWith - succeeds", () =>
Effect.gen(function*($) {
const result = yield* $(Effect.succeed(1), Effect.validateWith(Effect.succeed(2), (a, b) => a + b))
- assert.strictEqual(result, 3)
+ strictEqual(result, 3)
}))
it.effect("validateAll - accumulate successes", () =>
Effect.gen(function*($) {
const array = Array.from({ length: 10 }, (_, i) => i)
const result = yield* $(array, Effect.validateAll(Effect.succeed))
- assert.deepStrictEqual(Array.from(result), array)
+ deepStrictEqual(Array.from(result), array)
}))
it.effect("validateAll - returns all errors if never valid", () =>
Effect.gen(function*($) {
const array = Array.from({ length: 10 }, () => 0)
const result = yield* $(array, Effect.validateAll(Effect.fail), Effect.flip)
- assert.deepStrictEqual(Array.from(result), array)
+ deepStrictEqual(Array.from(result), array)
}))
it.effect("validateAll - accumulate errors and ignore successes", () =>
Effect.gen(function*($) {
@@ -54,19 +55,19 @@ describe("Effect", () => {
const result = yield* $(
pipe(array, Effect.validateAll((n) => n % 2 === 0 ? Effect.succeed(n) : Effect.fail(n)), Effect.flip)
)
- assert.deepStrictEqual(Array.from(result), [1, 3, 5, 7, 9])
+ deepStrictEqual(Array.from(result), [1, 3, 5, 7, 9])
}))
it.effect("validateAll/discard - returns all errors if never valid", () =>
Effect.gen(function*($) {
const array = Array.from({ length: 10 }, () => 0)
const result = yield* $(array, Effect.validateAll(Effect.fail, { discard: true }), Effect.flip)
- assert.deepStrictEqual(Array.from(result), array)
+ deepStrictEqual(Array.from(result), array)
}))
it.effect("validateAll/concurrency - returns all errors if never valid", () =>
Effect.gen(function*($) {
const array = Array.from({ length: 1000 }, () => 0)
const result = yield* $(array, Effect.validateAll(Effect.fail, { concurrency: "unbounded" }), Effect.flip)
- assert.deepStrictEqual(Array.from(result), array)
+ deepStrictEqual(Array.from(result), array)
}))
it.effect("validateAll/concurrency - accumulate errors and ignore successes", () =>
Effect.gen(function*($) {
@@ -80,13 +81,13 @@ describe("Effect", () => {
Effect.flip
)
)
- assert.deepStrictEqual(Array.from(result), [1, 3, 5, 7, 9])
+ deepStrictEqual(Array.from(result), [1, 3, 5, 7, 9])
}))
it.effect("validateAll/concurrency - accumulate successes", () =>
Effect.gen(function*($) {
const array = Array.from({ length: 10 }, (_, i) => i)
const result = yield* $(array, Effect.validateAll(Effect.succeed, { concurrency: "unbounded" }))
- assert.deepStrictEqual(Array.from(result), array)
+ deepStrictEqual(Array.from(result), array)
}))
it.effect("validateAll/concurrency+discard - returns all errors if never valid", () =>
Effect.gen(function*($) {
@@ -99,18 +100,18 @@ describe("Effect", () => {
}),
Effect.flip
)
- assert.deepStrictEqual(Array.from(result), array)
+ deepStrictEqual(Array.from(result), array)
}))
it.effect("validateFirst - returns all errors if never valid", () =>
Effect.gen(function*($) {
const array = Array.from({ length: 10 }, () => 0)
const result = yield* $(array, Effect.validateFirst(Effect.fail), Effect.flip)
- assert.deepStrictEqual(Array.from(result), array)
+ deepStrictEqual(Array.from(result), array)
}))
it.effect("validateFirst - returns [] as error if the input is empty", () =>
Effect.gen(function*($) {
const result = yield* $([], Effect.validateFirst(Effect.succeed), Effect.flip)
- assert.deepStrictEqual(result, [])
+ deepStrictEqual(result, [])
}))
it.effect("validateFirst - runs sequentially and short circuits on first success validation", () =>
Effect.gen(function*($) {
@@ -131,20 +132,20 @@ describe("Effect", () => {
)
)
const count = yield* $(Ref.get(counter))
- assert.strictEqual(result, 6)
- assert.strictEqual(count, 6)
+ strictEqual(result, 6)
+ strictEqual(count, 6)
}))
it.effect("validateFirst - returns errors in correct order", () =>
Effect.gen(function*($) {
const result = yield* $([2, 4, 6, 3, 5, 6], Effect.validateFirst(Effect.fail), Effect.flip)
- assert.deepStrictEqual(Array.from(result), [2, 4, 6, 3, 5, 6])
+ deepStrictEqual(Array.from(result), [2, 4, 6, 3, 5, 6])
}))
describe("", () => {
it.effect("validateFirst/concurrency - returns all errors if never valid", () =>
Effect.gen(function*($) {
const array = Array.from({ length: 1000 }, () => 0)
const result = yield* $(array, Effect.validateFirst(Effect.fail, { concurrency: "unbounded" }), Effect.flip)
- assert.deepStrictEqual(Array.from(result), array)
+ deepStrictEqual(Array.from(result), array)
}))
it.effect("validateFirst/concurrency - returns success if valid", () =>
Effect.gen(function*($) {
@@ -153,7 +154,7 @@ describe("Effect", () => {
}
const array = Array.from({ length: 10 }, (_, i) => i + 1)
const result = yield* $(array, Effect.validateFirst(f, { concurrency: "unbounded" }))
- assert.strictEqual(result, 6)
+ strictEqual(result, 6)
}))
})
})
diff --git a/packages/effect/test/Either.test.ts b/packages/effect/test/Either.test.ts
index dd6784813bb..ce9414265c4 100644
--- a/packages/effect/test/Either.test.ts
+++ b/packages/effect/test/Either.test.ts
@@ -1,19 +1,16 @@
-import * as Chunk from "effect/Chunk"
-import * as Either from "effect/Either"
-import { flow, pipe } from "effect/Function"
-import * as Num from "effect/Number"
-import * as Option from "effect/Option"
-import * as Str from "effect/String"
-import * as Util from "effect/test/util"
-import { describe, expect, it } from "vitest"
-
-const expectRight = (e: Either.Either, expected: R) => {
- Util.deepStrictEqual(e, Either.right(expected))
-}
-
-const expectLeft = (e: Either.Either, expected: L) => {
- Util.deepStrictEqual(e, Either.left(expected))
-}
+import { Chunk, Either, flow, Number as Num, Option, pipe, String as Str } from "effect"
+import {
+ assertFalse,
+ assertLeft,
+ assertNone,
+ assertRight,
+ assertSome,
+ assertTrue,
+ deepStrictEqual,
+ strictEqual,
+ throws
+} from "effect/test/util"
+import { describe, it } from "vitest"
describe("Either", () => {
it("gen", () => {
@@ -51,32 +48,36 @@ describe("Either", () => {
return x + y
})
- expect(a).toEqual(Either.right(3))
- expect(b).toEqual(Either.right(10))
- expect(c).toEqual(Either.right(undefined))
- expect(d).toEqual(Either.right(2))
- expect(e).toEqual(Either.left("err"))
- expect(f).toEqual(Either.left("err"))
- expect(g).toEqual(Either.right("testContext"))
- expect(h).toEqual(Either.right(3))
- })
-
- it("exports", () => {
- expect(Either.TypeId).exist
+ assertRight(a, 3)
+ assertRight(b, 10)
+ assertRight(c, undefined)
+ assertRight(d, 2)
+ assertLeft(e, "err")
+ assertLeft(f, "err")
+ assertRight(g, "testContext")
+ assertRight(h, 3)
})
it("toString", () => {
- expect(String(Either.right(1))).toEqual(`{
+ strictEqual(
+ String(Either.right(1)),
+ `{
"_id": "Either",
"_tag": "Right",
"right": 1
-}`)
- expect(String(Either.left("e"))).toEqual(`{
+}`
+ )
+ strictEqual(
+ String(Either.left("e")),
+ `{
"_id": "Either",
"_tag": "Left",
"left": "e"
-}`)
- expect(String(Either.right(Chunk.make(1, 2, 3)))).toEqual(`{
+}`
+ )
+ strictEqual(
+ String(Either.right(Chunk.make(1, 2, 3))),
+ `{
"_id": "Either",
"_tag": "Right",
"right": {
@@ -87,8 +88,11 @@ describe("Either", () => {
3
]
}
-}`)
- expect(String(Either.left(Chunk.make(1, 2, 3)))).toEqual(`{
+}`
+ )
+ strictEqual(
+ String(Either.left(Chunk.make(1, 2, 3))),
+ `{
"_id": "Either",
"_tag": "Left",
"left": {
@@ -99,47 +103,44 @@ describe("Either", () => {
3
]
}
-}`)
+}`
+ )
})
it("toJSON", () => {
- expect(Either.right(1).toJSON()).toEqual(
- { _id: "Either", _tag: "Right", right: 1 }
- )
- expect(Either.left("e").toJSON()).toEqual(
- { _id: "Either", _tag: "Left", left: "e" }
- )
+ deepStrictEqual(Either.right(1).toJSON(), { _id: "Either", _tag: "Right", right: 1 })
+ deepStrictEqual(Either.left("e").toJSON(), { _id: "Either", _tag: "Left", left: "e" })
})
it("inspect", () => {
if (typeof window === "undefined") {
// eslint-disable-next-line @typescript-eslint/no-var-requires
const { inspect } = require("node:util")
- expect(inspect(Either.right(1))).toEqual(inspect({ _id: "Either", _tag: "Right", right: 1 }))
- expect(inspect(Either.left("e"))).toEqual(inspect({ _id: "Either", _tag: "Left", left: "e" }))
+ deepStrictEqual(inspect(Either.right(1)), inspect({ _id: "Either", _tag: "Right", right: 1 }))
+ deepStrictEqual(inspect(Either.left("e")), inspect({ _id: "Either", _tag: "Left", left: "e" }))
}
})
it("isEither", () => {
- Util.deepStrictEqual(pipe(Either.right(1), Either.isEither), true)
- Util.deepStrictEqual(pipe(Either.left("e"), Either.isEither), true)
- Util.deepStrictEqual(pipe(Option.some(1), Either.isEither), false)
+ assertTrue(pipe(Either.right(1), Either.isEither))
+ assertTrue(pipe(Either.left("e"), Either.isEither))
+ assertFalse(pipe(Option.some(1), Either.isEither))
})
it("getRight", () => {
- Util.deepStrictEqual(pipe(Either.right(1), Either.getRight), Option.some(1))
- Util.deepStrictEqual(pipe(Either.left("a"), Either.getRight), Option.none())
+ assertSome(pipe(Either.right(1), Either.getRight), 1)
+ assertNone(pipe(Either.left("a"), Either.getRight))
})
it("getLeft", () => {
- Util.deepStrictEqual(pipe(Either.right(1), Either.getLeft), Option.none())
- Util.deepStrictEqual(pipe(Either.left("e"), Either.getLeft), Option.some("e"))
+ assertNone(pipe(Either.right(1), Either.getLeft))
+ assertSome(pipe(Either.left("e"), Either.getLeft), "e")
})
it("map", () => {
const f = Either.map(Str.length)
- Util.deepStrictEqual(pipe(Either.right("abc"), f), Either.right(3))
- Util.deepStrictEqual(pipe(Either.left("s"), f), Either.left("s"))
+ assertRight(pipe(Either.right("abc"), f), 3)
+ assertLeft(pipe(Either.left("s"), f), "s")
})
it("mapBoth", () => {
@@ -147,37 +148,37 @@ describe("Either", () => {
onLeft: Str.length,
onRight: (n: number) => n > 2
})
- Util.deepStrictEqual(pipe(Either.right(1), f), Either.right(false))
- Util.deepStrictEqual(pipe(Either.left("a"), f), Either.left(1))
+ assertRight(pipe(Either.right(1), f), false)
+ assertLeft(pipe(Either.left("a"), f), 1)
})
it("mapLeft", () => {
- const f = Either.mapLeft(Util.double)
- Util.deepStrictEqual(pipe(Either.right("a"), f), Either.right("a"))
- Util.deepStrictEqual(pipe(Either.left(1), f), Either.left(2))
+ const f = Either.mapLeft((n: number) => n * 2)
+ assertRight(pipe(Either.right("a"), f), "a")
+ assertLeft(pipe(Either.left(1), f), 2)
})
it("match", () => {
const onLeft = (s: string) => `left${s.length}`
const onRight = (s: string) => `right${s.length}`
const match = Either.match({ onLeft, onRight })
- Util.deepStrictEqual(match(Either.left("abc")), "left3")
- Util.deepStrictEqual(match(Either.right("abc")), "right3")
+ strictEqual(match(Either.left("abc")), "left3")
+ strictEqual(match(Either.right("abc")), "right3")
})
it("isLeft", () => {
- Util.deepStrictEqual(Either.isLeft(Either.right(1)), false)
- Util.deepStrictEqual(Either.isLeft(Either.left(1)), true)
+ assertFalse(Either.isLeft(Either.right(1)))
+ assertTrue(Either.isLeft(Either.left(1)))
})
it("isRight", () => {
- Util.deepStrictEqual(Either.isRight(Either.right(1)), true)
- Util.deepStrictEqual(Either.isRight(Either.left(1)), false)
+ assertTrue(Either.isRight(Either.right(1)))
+ assertFalse(Either.isRight(Either.left(1)))
})
it("flip", () => {
- Util.deepStrictEqual(Either.flip(Either.right("a")), Either.left("a"))
- Util.deepStrictEqual(Either.flip(Either.left("b")), Either.right("b"))
+ assertLeft(Either.flip(Either.right("a")), "a")
+ assertRight(Either.flip(Either.left("b")), "b")
})
it("liftPredicate", () => {
@@ -186,91 +187,91 @@ describe("Either", () => {
const isNumberRefinement = (n: string | number): n is number => typeof n === "number"
const onNumberRefinementError = (n: string | number) => `${n} is not a number`
- Util.deepStrictEqual(
+ assertRight(
pipe(1, Either.liftPredicate(isPositivePredicate, onPositivePredicateError)),
- Either.right(1)
+ 1
)
- Util.deepStrictEqual(
+ assertLeft(
pipe(-1, Either.liftPredicate(isPositivePredicate, onPositivePredicateError)),
- Either.left(`-1 is not positive`)
+ "-1 is not positive"
)
- Util.deepStrictEqual(
+ assertRight(
pipe(1, Either.liftPredicate(isNumberRefinement, onNumberRefinementError)),
- Either.right(1)
+ 1
)
- Util.deepStrictEqual(
+ assertLeft(
pipe("string", Either.liftPredicate(isNumberRefinement, onNumberRefinementError)),
- Either.left(`string is not a number`)
+ "string is not a number"
)
- Util.deepStrictEqual(
+ assertRight(
Either.liftPredicate(1, isPositivePredicate, onPositivePredicateError),
- Either.right(1)
+ 1
)
- Util.deepStrictEqual(
+ assertLeft(
Either.liftPredicate(-1, isPositivePredicate, onPositivePredicateError),
- Either.left(`-1 is not positive`)
+ "-1 is not positive"
)
- Util.deepStrictEqual(
+ assertRight(
Either.liftPredicate(1, isNumberRefinement, onNumberRefinementError),
- Either.right(1)
+ 1
)
- Util.deepStrictEqual(
+ assertLeft(
Either.liftPredicate("string", isNumberRefinement, onNumberRefinementError),
- Either.left(`string is not a number`)
+ "string is not a number"
)
})
it("filterOrLeft", () => {
- Util.deepStrictEqual(Either.filterOrLeft(Either.right(1), (n) => n > 0, () => "a"), Either.right(1))
- Util.deepStrictEqual(Either.filterOrLeft(Either.right(1), (n) => n > 1, () => "a"), Either.left("a"))
- Util.deepStrictEqual(Either.filterOrLeft(Either.left(1), (n) => n > 0, () => "a"), Either.left(1))
+ deepStrictEqual(Either.filterOrLeft(Either.right(1), (n) => n > 0, () => "a"), Either.right(1))
+ deepStrictEqual(Either.filterOrLeft(Either.right(1), (n) => n > 1, () => "a"), Either.left("a"))
+ deepStrictEqual(Either.filterOrLeft(Either.left(1), (n) => n > 0, () => "a"), Either.left(1))
- Util.deepStrictEqual(Either.right(1).pipe(Either.filterOrLeft((n) => n > 0, () => "a")), Either.right(1))
- Util.deepStrictEqual(Either.right(1).pipe(Either.filterOrLeft((n) => n > 1, () => "a")), Either.left("a"))
- Util.deepStrictEqual(Either.left(1).pipe(Either.filterOrLeft((n) => n > 0, () => "a")), Either.left(1))
+ deepStrictEqual(Either.right(1).pipe(Either.filterOrLeft((n) => n > 0, () => "a")), Either.right(1))
+ deepStrictEqual(Either.right(1).pipe(Either.filterOrLeft((n) => n > 1, () => "a")), Either.left("a"))
+ deepStrictEqual(Either.left(1).pipe(Either.filterOrLeft((n) => n > 0, () => "a")), Either.left(1))
})
it("merge", () => {
- Util.deepStrictEqual(Either.merge(Either.right(1)), 1)
- Util.deepStrictEqual(Either.merge(Either.left("a")), "a")
+ deepStrictEqual(Either.merge(Either.right(1)), 1)
+ deepStrictEqual(Either.merge(Either.left("a")), "a")
})
it("getEquivalence", () => {
const isEquivalent = Either.getEquivalence({ right: Num.Equivalence, left: Str.Equivalence })
- Util.deepStrictEqual(isEquivalent(Either.right(1), Either.right(1)), true)
- Util.deepStrictEqual(isEquivalent(Either.right(1), Either.right(2)), false)
- Util.deepStrictEqual(isEquivalent(Either.right(1), Either.left("foo")), false)
- Util.deepStrictEqual(isEquivalent(Either.left("foo"), Either.left("foo")), true)
- Util.deepStrictEqual(isEquivalent(Either.left("foo"), Either.left("bar")), false)
- Util.deepStrictEqual(isEquivalent(Either.left("foo"), Either.right(1)), false)
+ deepStrictEqual(isEquivalent(Either.right(1), Either.right(1)), true)
+ deepStrictEqual(isEquivalent(Either.right(1), Either.right(2)), false)
+ deepStrictEqual(isEquivalent(Either.right(1), Either.left("foo")), false)
+ deepStrictEqual(isEquivalent(Either.left("foo"), Either.left("foo")), true)
+ deepStrictEqual(isEquivalent(Either.left("foo"), Either.left("bar")), false)
+ deepStrictEqual(isEquivalent(Either.left("foo"), Either.right(1)), false)
})
it("pipe()", () => {
- expect(Either.right(1).pipe(Either.map((n) => n + 1))).toEqual(Either.right(2))
+ assertRight(Either.right(1).pipe(Either.map((n) => n + 1)), 2)
})
it("fromNullable", () => {
- Util.deepStrictEqual(Either.fromNullable(null, () => "fallback"), Either.left("fallback"))
- Util.deepStrictEqual(Either.fromNullable(undefined, () => "fallback"), Either.left("fallback"))
- Util.deepStrictEqual(Either.fromNullable(1, () => "fallback"), Either.right(1))
+ deepStrictEqual(Either.fromNullable(null, () => "fallback"), Either.left("fallback"))
+ deepStrictEqual(Either.fromNullable(undefined, () => "fallback"), Either.left("fallback"))
+ deepStrictEqual(Either.fromNullable(1, () => "fallback"), Either.right(1))
})
it("fromOption", () => {
- Util.deepStrictEqual(Either.fromOption(Option.none(), () => "none"), Either.left("none"))
- Util.deepStrictEqual(Either.fromOption(Option.some(1), () => "none"), Either.right(1))
+ deepStrictEqual(Either.fromOption(Option.none(), () => "none"), Either.left("none"))
+ deepStrictEqual(Either.fromOption(Option.some(1), () => "none"), Either.right(1))
})
it("try", () => {
- Util.deepStrictEqual(Either.try(() => 1), Either.right(1))
- Util.deepStrictEqual(
+ deepStrictEqual(Either.try(() => 1), Either.right(1))
+ deepStrictEqual(
Either.try(() => {
throw "b"
}),
Either.left("b")
)
- Util.deepStrictEqual(Either.try({ try: () => 1, catch: (e) => new Error(String(e)) }), Either.right(1))
- Util.deepStrictEqual(
+ deepStrictEqual(Either.try({ try: () => 1, catch: (e) => new Error(String(e)) }), Either.right(1))
+ deepStrictEqual(
Either.try({
try: () => {
throw "b"
@@ -282,130 +283,119 @@ describe("Either", () => {
})
it("getOrElse", () => {
- Util.deepStrictEqual(Either.getOrElse(Either.right(1), (error) => error + "!"), 1)
- Util.deepStrictEqual(Either.getOrElse(Either.left("not a number"), (error) => error + "!"), "not a number!")
+ strictEqual(Either.getOrElse(Either.right(1), (error) => error + "!"), 1)
+ strictEqual(Either.getOrElse(Either.left("not a number"), (error) => error + "!"), "not a number!")
})
it("getOrNull", () => {
- Util.deepStrictEqual(Either.getOrNull(Either.right(1)), 1)
- Util.deepStrictEqual(Either.getOrNull(Either.left("a")), null)
+ strictEqual(Either.getOrNull(Either.right(1)), 1)
+ strictEqual(Either.getOrNull(Either.left("a")), null)
})
it("getOrUndefined", () => {
- Util.deepStrictEqual(Either.getOrUndefined(Either.right(1)), 1)
- Util.deepStrictEqual(Either.getOrUndefined(Either.left("a")), undefined)
+ strictEqual(Either.getOrUndefined(Either.right(1)), 1)
+ strictEqual(Either.getOrUndefined(Either.left("a")), undefined)
})
it("getOrThrowWith", () => {
- expect(pipe(Either.right(1), Either.getOrThrowWith((e) => new Error(`Unexpected Left: ${e}`)))).toEqual(1)
- expect(() => pipe(Either.left("e"), Either.getOrThrowWith((e) => new Error(`Unexpected Left: ${e}`))))
- .toThrowError(
- new Error("Unexpected Left: e")
- )
+ strictEqual(pipe(Either.right(1), Either.getOrThrowWith((e) => new Error(`Unexpected Left: ${e}`))), 1)
+ throws(() => pipe(Either.left("e"), Either.getOrThrowWith((e) => new Error(`Unexpected Left: ${e}`)))),
+ new Error("Unexpected Left: e")
})
it("getOrThrow", () => {
- expect(pipe(Either.right(1), Either.getOrThrow)).toEqual(1)
- expect(() => pipe(Either.left("e"), Either.getOrThrow)).toThrowError(
- new Error("getOrThrow called on a Left")
- )
+ strictEqual(pipe(Either.right(1), Either.getOrThrow), 1)
+ throws(() => pipe(Either.left("e"), Either.getOrThrow), new Error("getOrThrow called on a Left"))
})
it("flatMap", () => {
const f = Either.flatMap(flow(Str.length, Either.right))
- Util.deepStrictEqual(pipe(Either.right("abc"), f), Either.right(3))
- Util.deepStrictEqual(pipe(Either.left("maError"), f), Either.left("maError"))
+ assertRight(pipe(Either.right("abc"), f), 3)
+ assertLeft(pipe(Either.left("maError"), f), "maError")
})
it("andThen", () => {
- expect(pipe(Either.right(1), Either.andThen(() => Either.right(2)))).toStrictEqual(Either.right(2))
- expect(pipe(Either.right(1), Either.andThen(Either.right(2)))).toStrictEqual(Either.right(2))
- expect(pipe(Either.right(1), Either.andThen(2))).toStrictEqual(Either.right(2))
- expect(pipe(Either.right(1), Either.andThen(() => 2))).toStrictEqual(Either.right(2))
- expect(pipe(Either.right(1), Either.andThen((a) => a))).toStrictEqual(Either.right(1))
- expect(Either.andThen(Either.right(1), () => Either.right(2))).toStrictEqual(Either.right(2))
- expect(Either.andThen(Either.right(1), Either.right(2))).toStrictEqual(Either.right(2))
- expect(Either.andThen(Either.right(1), () => 2)).toStrictEqual(Either.right(2))
- expect(Either.andThen(Either.right(1), 2)).toStrictEqual(Either.right(2))
- expect(Either.andThen(Either.right(1), (a) => a)).toStrictEqual(Either.right(1))
+ assertRight(pipe(Either.right(1), Either.andThen(() => Either.right(2))), 2)
+ assertRight(pipe(Either.right(1), Either.andThen(Either.right(2))), 2)
+ assertRight(pipe(Either.right(1), Either.andThen(2)), 2)
+ assertRight(pipe(Either.right(1), Either.andThen(() => 2)), 2)
+ assertRight(pipe(Either.right(1), Either.andThen((a) => a)), 1)
+ assertRight(Either.andThen(Either.right(1), () => Either.right(2)), 2)
+ assertRight(Either.andThen(Either.right(1), Either.right(2)), 2)
+ assertRight(Either.andThen(Either.right(1), () => 2), 2)
+ assertRight(Either.andThen(Either.right(1), 2), 2)
+ assertRight(Either.andThen(Either.right(1), (a) => a), 1)
})
it("ap", () => {
const add = (a: number) => (b: number) => a + b
- expect(Either.right(add).pipe(Either.ap(Either.right(1)), Either.ap(Either.right(2)))).toStrictEqual(
- Either.right(3)
- )
- expect(Either.right(add).pipe(Either.ap(Either.left("b")), Either.ap(Either.right(2)))).toStrictEqual(
- Either.left("b")
- )
- expect(Either.right(add).pipe(Either.ap(Either.right(1)), Either.ap(Either.left("c")))).toStrictEqual(
- Either.left("c")
- )
- expect(Either.right(add).pipe(Either.ap(Either.left("b")), Either.ap(Either.left("c")))).toStrictEqual(
- Either.left("b")
- )
- expect(
+ assertRight(Either.right(add).pipe(Either.ap(Either.right(1)), Either.ap(Either.right(2))), 3)
+ assertLeft(Either.right(add).pipe(Either.ap(Either.left("b")), Either.ap(Either.right(2))), "b")
+ assertLeft(Either.right(add).pipe(Either.ap(Either.right(1)), Either.ap(Either.left("c"))), "c")
+ assertLeft(Either.right(add).pipe(Either.ap(Either.left("b")), Either.ap(Either.left("c"))), "b")
+ assertLeft(
(Either.left("a") as Either.Either).pipe(
Either.ap(Either.right(1)),
Either.ap(Either.right(2))
- )
- ).toStrictEqual(Either.left("a"))
+ ),
+ "a"
+ )
})
it("zipWith", () => {
- expect(pipe(Either.left(0), Either.zipWith(Either.right(2), (a, b) => a + b))).toEqual(Either.left(0))
- expect(pipe(Either.right(1), Either.zipWith(Either.left(0), (a, b) => a + b))).toEqual(Either.left(0))
- expect(pipe(Either.right(1), Either.zipWith(Either.right(2), (a, b) => a + b))).toEqual(Either.right(3))
+ assertLeft(pipe(Either.left(0), Either.zipWith(Either.right(2), (a, b) => a + b)), 0)
+ assertLeft(pipe(Either.right(1), Either.zipWith(Either.left(0), (a, b) => a + b)), 0)
+ assertRight(pipe(Either.right(1), Either.zipWith(Either.right(2), (a, b) => a + b)), 3)
})
it("all", () => {
// tuples and arrays
- Util.deepStrictEqual(Either.all([]), Either.right([]))
- Util.deepStrictEqual(Either.all([Either.right(1)]), Either.right([1]))
- Util.deepStrictEqual(Either.all([Either.right(1), Either.right(true)]), Either.right([1, true]))
- Util.deepStrictEqual(Either.all([Either.right(1), Either.left("e")]), Either.left("e"))
+ assertRight(Either.all([]), [])
+ assertRight(Either.all([Either.right(1)]), [1])
+ assertRight(Either.all([Either.right(1), Either.right(true)]), [1, true])
+ assertLeft(Either.all([Either.right(1), Either.left("e")]), "e")
// structs and records
- Util.deepStrictEqual(Either.all({}), Either.right({}))
- Util.deepStrictEqual(Either.all({ a: Either.right(1) }), Either.right({ a: 1 }))
- Util.deepStrictEqual(Either.all({ a: Either.right(1), b: Either.right(true) }), Either.right({ a: 1, b: true }))
- Util.deepStrictEqual(Either.all({ a: Either.right(1), b: Either.left("e") }), Either.left("e"))
+ assertRight(Either.all({}), {})
+ assertRight(Either.all({ a: Either.right(1) }), { a: 1 })
+ assertRight(Either.all({ a: Either.right(1), b: Either.right(true) }), { a: 1, b: true })
+ assertLeft(Either.all({ a: Either.right(1), b: Either.left("e") }), "e")
})
it("orElse", () => {
- Util.deepStrictEqual(pipe(Either.right(1), Either.orElse(() => Either.right(2))), Either.right(1))
- Util.deepStrictEqual(pipe(Either.right(1), Either.orElse(() => Either.left("b"))), Either.right(1))
- Util.deepStrictEqual(pipe(Either.left("a"), Either.orElse(() => Either.right(2))), Either.right(2))
- Util.deepStrictEqual(pipe(Either.left("a"), Either.orElse(() => Either.left("b"))), Either.left("b"))
+ assertRight(pipe(Either.right(1), Either.orElse(() => Either.right(2))), 1)
+ assertRight(pipe(Either.right(1), Either.orElse(() => Either.left("b"))), 1)
+ assertRight(pipe(Either.left("a"), Either.orElse(() => Either.right(2))), 2)
+ assertLeft(pipe(Either.left("a"), Either.orElse(() => Either.left("b"))), "b")
})
describe("do notation", () => {
it("Do", () => {
- expectRight(Either.Do, {})
+ assertRight(Either.Do, {})
})
it("bindTo", () => {
- expectRight(pipe(Either.right(1), Either.bindTo("a")), { a: 1 })
- expectLeft(pipe(Either.left("left"), Either.bindTo("a")), "left")
+ assertRight(pipe(Either.right(1), Either.bindTo("a")), { a: 1 })
+ assertLeft(pipe(Either.left("left"), Either.bindTo("a")), "left")
})
it("bind", () => {
- expectRight(pipe(Either.right(1), Either.bindTo("a"), Either.bind("b", ({ a }) => Either.right(a + 1))), {
+ assertRight(pipe(Either.right(1), Either.bindTo("a"), Either.bind("b", ({ a }) => Either.right(a + 1))), {
a: 1,
b: 2
})
- expectLeft(
+ assertLeft(
pipe(Either.right(1), Either.bindTo("a"), Either.bind("b", () => Either.left("left"))),
"left"
)
- expectLeft(
+ assertLeft(
pipe(Either.left("left"), Either.bindTo("a"), Either.bind("b", () => Either.right(2))),
"left"
)
})
it("let", () => {
- expectRight(pipe(Either.right(1), Either.bindTo("a"), Either.let("b", ({ a }) => a + 1)), { a: 1, b: 2 })
- expectLeft(
+ assertRight(pipe(Either.right(1), Either.bindTo("a"), Either.let("b", ({ a }) => a + 1)), { a: 1, b: 2 })
+ assertLeft(
pipe(Either.left("left"), Either.bindTo("a"), Either.let("b", () => 2)),
"left"
)
diff --git a/packages/effect/test/Encoding.test.ts b/packages/effect/test/Encoding.test.ts
index 8c477c8d6f4..5bee34daa28 100644
--- a/packages/effect/test/Encoding.test.ts
+++ b/packages/effect/test/Encoding.test.ts
@@ -1,7 +1,6 @@
-import * as Either from "effect/Either"
-import * as Encoding from "effect/Encoding"
-import { deepStrictEqual, strictEqual } from "effect/test/util"
-import { assert, describe, it } from "vitest"
+import { Either, Encoding } from "effect"
+import { assertTrue, deepStrictEqual, strictEqual } from "effect/test/util"
+import { describe, it } from "vitest"
describe("Base64", () => {
const valid: Array<[string, string]> = [
@@ -38,13 +37,13 @@ describe("Base64", () => {
it.each(valid)(`should decode %j <= %j`, (raw: string, b64: string) => {
const bytes = new TextEncoder().encode(raw)
const decoded = Encoding.decodeBase64(b64)
- assert(Either.isRight(decoded))
+ assertTrue(Either.isRight(decoded))
deepStrictEqual(decoded.right, bytes)
})
it.each(valid)(`should decode %j <= %j (to string)`, (raw: string, b64: string) => {
const decoded = Encoding.decodeBase64String(b64)
- assert(Either.isRight(decoded))
+ assertTrue(Either.isRight(decoded))
deepStrictEqual(decoded.right, raw)
})
@@ -55,8 +54,8 @@ describe("Base64", () => {
it.each(invalid)(`should refuse to decode %j`, (b64: string) => {
const result = Encoding.decodeBase64(b64)
- assert(Either.isLeft(result))
- assert(Encoding.isDecodeException(result.left))
+ assertTrue(Either.isLeft(result))
+ assertTrue(Encoding.isDecodeException(result.left))
})
})
@@ -83,13 +82,13 @@ describe("Base64Url", () => {
it.each(valid)(`should decode %j <= %j`, (raw: string, b64url: string) => {
const bytes = new TextEncoder().encode(raw)
const decoded = Encoding.decodeBase64Url(b64url)
- assert(Either.isRight(decoded))
+ assertTrue(Either.isRight(decoded))
deepStrictEqual(decoded.right, bytes)
})
it.each(valid)(`should decode %j <= %j (to string)`, (raw: string, b64: string) => {
const decoded = Encoding.decodeBase64UrlString(b64)
- assert(Either.isRight(decoded))
+ assertTrue(Either.isRight(decoded))
deepStrictEqual(decoded.right, raw)
})
@@ -100,8 +99,8 @@ describe("Base64Url", () => {
it.each(invalid)(`should refuse to decode %j`, (b64url: string) => {
const result = Encoding.decodeBase64Url(b64url)
- assert(Either.isLeft(result))
- assert(Encoding.isDecodeException(result.left))
+ assertTrue(Either.isLeft(result))
+ assertTrue(Encoding.isDecodeException(result.left))
})
})
@@ -137,13 +136,13 @@ describe("Hex", () => {
it.each(valid)(`should decode %j => %o`, (hex: string, bytes: Uint8Array) => {
const decoded = Encoding.decodeHex(hex)
- assert(Either.isRight(decoded))
+ assertTrue(Either.isRight(decoded))
deepStrictEqual(decoded.right, bytes)
})
it.each(strings)(`should decode %j => %j to string`, (hex: string, str: string) => {
const decoded = Encoding.decodeHexString(hex)
- assert(Either.isRight(decoded))
+ assertTrue(Either.isRight(decoded))
deepStrictEqual(decoded.right, str)
})
@@ -157,8 +156,8 @@ describe("Hex", () => {
it.each(invalid)(`should refuse to decode %j`, (hex: string) => {
const result = Encoding.decodeHex(hex)
- assert(Either.isLeft(result))
- assert(Encoding.isDecodeException(result.left))
+ assertTrue(Either.isLeft(result))
+ assertTrue(Encoding.isDecodeException(result.left))
})
})
@@ -183,25 +182,25 @@ describe("UriComponent", () => {
it.each(valid)(`should decode %j => %j`, (uri: string, raw: string) => {
const decoded = Encoding.decodeUriComponent(uri)
- assert(Either.isRight(decoded))
+ assertTrue(Either.isRight(decoded))
deepStrictEqual(decoded.right, raw)
})
it.each(valid)(`should encode %j => %j`, (uri: string, raw: string) => {
const encoded = Encoding.encodeUriComponent(raw)
- assert(Either.isRight(encoded))
+ assertTrue(Either.isRight(encoded))
deepStrictEqual(encoded.right, uri)
})
it.each(invalidDecode)(`should refuse to decode %j`, (uri: string) => {
const result = Encoding.decodeUriComponent(uri)
- assert(Either.isLeft(result))
- assert(Encoding.isDecodeException(result.left))
+ assertTrue(Either.isLeft(result))
+ assertTrue(Encoding.isDecodeException(result.left))
})
it.each(invalidEncode)(`should refuse to encode %j`, (raw: string) => {
const result = Encoding.encodeUriComponent(raw)
- assert(Either.isLeft(result))
- assert(Encoding.isEncodeException(result.left))
+ assertTrue(Either.isLeft(result))
+ assertTrue(Encoding.isEncodeException(result.left))
})
})
diff --git a/packages/effect/test/Equivalence.test.ts b/packages/effect/test/Equivalence.test.ts
index 00a6a4cc1b5..9c2bbe9a3fe 100644
--- a/packages/effect/test/Equivalence.test.ts
+++ b/packages/effect/test/Equivalence.test.ts
@@ -1,22 +1,22 @@
-import * as _ from "effect/Equivalence"
-import { pipe } from "effect/Function"
-import { describe, expect, it } from "vitest"
+import { Equivalence, pipe } from "effect"
+import { assertFalse, assertTrue } from "effect/test/util"
+import { describe, it } from "vitest"
describe("Equivalence", () => {
it("array", () => {
- const eq = _.array(_.number)
+ const eq = Equivalence.array(Equivalence.number)
- expect(eq([], [])).toEqual(true)
- expect(eq([1, 2, 3], [1, 2, 3])).toEqual(true)
- expect(eq([1, 2, 3], [1, 2, 4])).toEqual(false)
- expect(eq([1, 2, 3], [1, 2])).toEqual(false)
+ assertTrue(eq([], []))
+ assertTrue(eq([1, 2, 3], [1, 2, 3]))
+ assertFalse(eq([1, 2, 3], [1, 2, 4]))
+ assertFalse(eq([1, 2, 3], [1, 2]))
})
it("strict returns an Equivalence that uses strict equality (===) to compare values", () => {
- const eq = _.strict<{ a: number }>()
+ const eq = Equivalence.strict<{ a: number }>()
const a = { a: 1 }
- expect(eq(a, a)).toBe(true)
- expect(eq({ a: 1 }, { a: 1 })).toBe(false)
+ assertTrue(eq(a, a))
+ assertFalse(eq({ a: 1 }, { a: 1 }))
})
it("mapInput", () => {
@@ -24,88 +24,88 @@ describe("Equivalence", () => {
readonly name: string
readonly age: number
}
- const eqPerson = pipe(_.string, _.mapInput((p: Person) => p.name))
- expect(eqPerson({ name: "a", age: 1 }, { name: "a", age: 2 })).toEqual(true)
- expect(eqPerson({ name: "a", age: 1 }, { name: "a", age: 1 })).toEqual(true)
- expect(eqPerson({ name: "a", age: 1 }, { name: "b", age: 1 })).toEqual(false)
- expect(eqPerson({ name: "a", age: 1 }, { name: "b", age: 2 })).toEqual(false)
+ const eqPerson = pipe(Equivalence.string, Equivalence.mapInput((p: Person) => p.name))
+ assertTrue(eqPerson({ name: "a", age: 1 }, { name: "a", age: 2 }))
+ assertTrue(eqPerson({ name: "a", age: 1 }, { name: "a", age: 1 }))
+ assertFalse(eqPerson({ name: "a", age: 1 }, { name: "b", age: 1 }))
+ assertFalse(eqPerson({ name: "a", age: 1 }, { name: "b", age: 2 }))
})
it("Date", () => {
- const eq = _.Date
- expect(eq(new Date(0), new Date(0))).toEqual(true)
- expect(eq(new Date(0), new Date(1))).toEqual(false)
- expect(eq(new Date(1), new Date(0))).toEqual(false)
+ const eq = Equivalence.Date
+ assertTrue(eq(new Date(0), new Date(0)))
+ assertFalse(eq(new Date(0), new Date(1)))
+ assertFalse(eq(new Date(1), new Date(0)))
})
it("product", () => {
- const eq = _.product(_.string, _.string)
- expect(eq(["a", "b"], ["a", "b"])).toEqual(true)
- expect(eq(["a", "b"], ["c", "b"])).toEqual(false)
- expect(eq(["a", "b"], ["a", "c"])).toEqual(false)
+ const eq = Equivalence.product(Equivalence.string, Equivalence.string)
+ assertTrue(eq(["a", "b"], ["a", "b"]))
+ assertFalse(eq(["a", "b"], ["c", "b"]))
+ assertFalse(eq(["a", "b"], ["a", "c"]))
})
it("productMany", () => {
- const eq = _.productMany(_.string, [_.string])
- expect(eq(["a", "b"], ["a", "b"])).toEqual(true)
- expect(eq(["a", "b"], ["a", "b", "c"])).toEqual(true)
- expect(eq(["a", "b", "c"], ["a", "b"])).toEqual(true)
- expect(eq(["a", "b"], ["c", "b"])).toEqual(false)
- expect(eq(["a", "b"], ["a", "c"])).toEqual(false)
+ const eq = Equivalence.productMany(Equivalence.string, [Equivalence.string])
+ assertTrue(eq(["a", "b"], ["a", "b"]))
+ assertTrue(eq(["a", "b"], ["a", "b", "c"]))
+ assertTrue(eq(["a", "b", "c"], ["a", "b"]))
+ assertFalse(eq(["a", "b"], ["c", "b"]))
+ assertFalse(eq(["a", "b"], ["a", "c"]))
})
it("all", () => {
- const eq = _.all([_.string, _.string])
- expect(eq([], [])).toEqual(true)
- expect(eq([], ["a"])).toEqual(true)
- expect(eq(["a"], [])).toEqual(true)
- expect(eq(["a"], ["a"])).toEqual(true)
- expect(eq(["a"], ["b"])).toEqual(false)
- expect(eq(["a"], ["a", "b"])).toEqual(true)
- expect(eq(["a", "b"], ["a"])).toEqual(true)
- expect(eq(["a", "b"], ["a", "b"])).toEqual(true)
- expect(eq(["a", "b"], ["a", "c"])).toEqual(false)
+ const eq = Equivalence.all([Equivalence.string, Equivalence.string])
+ assertTrue(eq([], []))
+ assertTrue(eq([], ["a"]))
+ assertTrue(eq(["a"], []))
+ assertTrue(eq(["a"], ["a"]))
+ assertFalse(eq(["a"], ["b"]))
+ assertTrue(eq(["a"], ["a", "b"]))
+ assertTrue(eq(["a", "b"], ["a"]))
+ assertTrue(eq(["a", "b"], ["a", "b"]))
+ assertFalse(eq(["a", "b"], ["a", "c"]))
})
it("combine", () => {
type T = readonly [string, number, boolean]
- const E0: _.Equivalence = _.mapInput((x: T) => x[0])(_.string)
- const E1: _.Equivalence = _.mapInput((x: T) => x[1])(_.number)
- const eqE0E1 = _.combine(E0, E1)
- expect(eqE0E1(["a", 1, true], ["a", 1, true])).toEqual(true)
- expect(eqE0E1(["a", 1, true], ["a", 1, false])).toEqual(true)
- expect(eqE0E1(["a", 1, true], ["b", 1, true])).toEqual(false)
- expect(eqE0E1(["a", 1, true], ["a", 2, false])).toEqual(false)
+ const E0: Equivalence.Equivalence = Equivalence.mapInput((x: T) => x[0])(Equivalence.string)
+ const E1: Equivalence.Equivalence = Equivalence.mapInput((x: T) => x[1])(Equivalence.number)
+ const eqE0E1 = Equivalence.combine(E0, E1)
+ assertTrue(eqE0E1(["a", 1, true], ["a", 1, true]))
+ assertTrue(eqE0E1(["a", 1, true], ["a", 1, false]))
+ assertFalse(eqE0E1(["a", 1, true], ["b", 1, true]))
+ assertFalse(eqE0E1(["a", 1, true], ["a", 2, false]))
})
it("combineMany", () => {
type T = readonly [string, number, boolean]
- const E0: _.Equivalence = _.mapInput((x: T) => x[0])(_.string)
- const E1: _.Equivalence = _.mapInput((x: T) => x[1])(_.number)
- const E2: _.Equivalence = _.mapInput((x: T) => x[2])(_.boolean)
- const eqE0E1E2 = _.combineMany(E0, [E1, E2])
- expect(eqE0E1E2(["a", 1, true], ["a", 1, true])).toEqual(true)
- expect(eqE0E1E2(["a", 1, true], ["b", 1, true])).toEqual(false)
- expect(eqE0E1E2(["a", 1, true], ["a", 2, true])).toEqual(false)
- expect(eqE0E1E2(["a", 1, true], ["a", 1, false])).toEqual(false)
+ const E0: Equivalence.Equivalence = Equivalence.mapInput((x: T) => x[0])(Equivalence.string)
+ const E1: Equivalence.Equivalence = Equivalence.mapInput((x: T) => x[1])(Equivalence.number)
+ const E2: Equivalence.Equivalence = Equivalence.mapInput((x: T) => x[2])(Equivalence.boolean)
+ const eqE0E1E2 = Equivalence.combineMany(E0, [E1, E2])
+ assertTrue(eqE0E1E2(["a", 1, true], ["a", 1, true]))
+ assertFalse(eqE0E1E2(["a", 1, true], ["b", 1, true]))
+ assertFalse(eqE0E1E2(["a", 1, true], ["a", 2, true]))
+ assertFalse(eqE0E1E2(["a", 1, true], ["a", 1, false]))
})
it("combineAll", () => {
type T = readonly [string, number, boolean]
- const E0: _.Equivalence = _.mapInput((x: T) => x[0])(_.string)
- const E1: _.Equivalence = _.mapInput((x: T) => x[1])(_.number)
- const E2: _.Equivalence = _.mapInput((x: T) => x[2])(_.boolean)
- const eqE0E1E2 = _.combineAll([E0, E1, E2])
- expect(eqE0E1E2(["a", 1, true], ["a", 1, true])).toEqual(true)
- expect(eqE0E1E2(["a", 1, true], ["b", 1, true])).toEqual(false)
- expect(eqE0E1E2(["a", 1, true], ["a", 2, true])).toEqual(false)
- expect(eqE0E1E2(["a", 1, true], ["a", 1, false])).toEqual(false)
+ const E0: Equivalence.Equivalence = Equivalence.mapInput((x: T) => x[0])(Equivalence.string)
+ const E1: Equivalence.Equivalence = Equivalence.mapInput((x: T) => x[1])(Equivalence.number)
+ const E2: Equivalence.Equivalence