remove assert

Effect-TS · Jan 29, 2025 · c6a32ea · c6a32ea
1 parent ef145d3
commit c6a32ea
Show file tree

Hide file tree

Showing 63 changed files with 779 additions and 722 deletions.
diff --git a/packages/effect/test/Sink/collecting.test.ts b/packages/effect/test/Sink/collecting.test.ts
@@ -4,8 +4,9 @@ import { constTrue, pipe } from "effect/Function"
 import * as Option from "effect/Option"
 import * as Sink from "effect/Sink"
 import * as Stream from "effect/Stream"
+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("Sink", () => {
   it.effect("collectAllN - respects the given limit", () =>
@@ -15,7 +16,7 @@ describe("Sink", () => {
         Stream.transduce(Sink.collectAllN<number>(3))
       )
       const result = yield* $(Stream.runCollect(stream))
-      assert.deepStrictEqual(
+      deepStrictEqual(
         Array.from(Chunk.map(result, (chunk) => Array.from(chunk))),
         [[1, 2, 3], [4]]
       )
@@ -28,7 +29,7 @@ describe("Sink", () => {
         Stream.transduce(Sink.collectAllN<number>(4))
       )
       const result = yield* $(Stream.runCollect(stream))
-      assert.deepStrictEqual(
+      deepStrictEqual(
         Array.from(Chunk.map(result, (chunk) => Array.from(chunk))),
         [[1, 2, 3, 4], []]
       )
@@ -41,7 +42,7 @@ describe("Sink", () => {
         Stream.transduce(Sink.collectAllN<number>(3))
       )
       const result = yield* $(Stream.runCollect(stream))
-      assert.deepStrictEqual(
+      deepStrictEqual(
         Array.from(Chunk.map(result, (chunk) => Array.from(chunk))),
         [[]]
       )
@@ -51,7 +52,7 @@ describe("Sink", () => {
     Effect.gen(function*($) {
       const stream = Stream.make(1, 2, 3, 3, 4)
       const result = yield* $(stream, Stream.run(Sink.collectAllToSet()))
-      assert.deepStrictEqual(Array.from(result), [1, 2, 3, 4])
+      deepStrictEqual(Array.from(result), [1, 2, 3, 4])
     }))
 
   it.effect("collectAllToSetN - respects the given limit", () =>
@@ -61,7 +62,7 @@ describe("Sink", () => {
         Stream.transduce(Sink.collectAllToSetN<number>(3))
       )
       const result = yield* $(Stream.runCollect(stream))
-      assert.deepStrictEqual(
+      deepStrictEqual(
         Array.from(Chunk.map(result, (set) => Array.from(set))),
         [[1, 2, 3], [4]]
       )
@@ -74,7 +75,7 @@ describe("Sink", () => {
         Stream.transduce(Sink.collectAllToSetN<number>(3))
       )
       const result = yield* $(Stream.runCollect(stream))
-      assert.deepStrictEqual(
+      deepStrictEqual(
         Array.from(Chunk.map(result, (set) => Array.from(set))),
         [[]]
       )
@@ -89,7 +90,7 @@ describe("Sink", () => {
           (x, y) => x + y
         ))
       )
-      assert.deepStrictEqual(
+      deepStrictEqual(
         Array.from(result),
         [[0, 18], [1, 12], [2, 15]]
       )
@@ -106,7 +107,7 @@ describe("Sink", () => {
         )),
         Stream.runCollect
       )
-      assert.deepStrictEqual(
+      deepStrictEqual(
         Array.from(Chunk.map(result, (chunk) => Array.from(chunk))),
         [[[1, 2], [2, 4]], [[0, 3], [2, 2]], [[1, 4], [2, 5]]]
       )
@@ -123,7 +124,7 @@ describe("Sink", () => {
         )),
         Stream.runCollect
       )
-      assert.deepStrictEqual(
+      deepStrictEqual(
         Array.from(Chunk.map(result, (chunk) => Array.from(chunk))),
         [[[0, 18], [1, 12], [2, 15]]]
       )
@@ -140,7 +141,7 @@ describe("Sink", () => {
         )),
         Stream.runCollect
       )
-      assert.deepStrictEqual(
+      deepStrictEqual(
         Array.from(Chunk.map(result, (chunk) => Array.from(chunk))),
         [[]]
       )
@@ -156,7 +157,7 @@ describe("Sink", () => {
         Chunk.empty<number>()
       )
       const result = yield* $(Stream.fromChunks(...input), Stream.transduce(sink), Stream.runCollect)
-      assert.deepStrictEqual(
+      deepStrictEqual(
         Array.from(result).map((chunk) => Array.from(chunk)),
         [[3, 4, 5], [6], [7], [2, 3, 4, 5], [6], [5], [4, 3, 2]]
       )
@@ -172,7 +173,7 @@ describe("Sink", () => {
         Chunk.empty<number>()
       )
       const result = yield* $(Stream.fromChunks(...input), Stream.transduce(sink), Stream.runCollect)
-      assert.deepStrictEqual(
+      deepStrictEqual(
         Array.from(result).map((chunk) => Array.from(chunk)),
         [[3, 4, 5], [6], [7], [2, 3, 4, 5], [6], [5], [4, 3, 2]]
       )
@@ -191,7 +192,7 @@ describe("Sink", () => {
         Chunk.empty<number>()
       )
       const result = yield* $(Stream.fromChunks(...input), Stream.transduce(sink), Stream.runCollect)
-      assert.deepStrictEqual(
+      deepStrictEqual(
         Array.from(result).map((chunk) => Array.from(chunk)),
         [[3, 4], [2, 3, 4], [4, 3, 2]]
       )
@@ -210,7 +211,7 @@ describe("Sink", () => {
         Chunk.empty<number>()
       )
       const result = yield* $(Stream.fromChunks(...input), Stream.transduce(sink), Stream.runCollect)
-      assert.deepStrictEqual(
+      deepStrictEqual(
         Array.from(result).map((chunk) => Array.from(chunk)),
         [[3, 4], [2, 3, 4], [4, 3, 2]]
       )
@@ -234,9 +235,9 @@ describe("Sink", () => {
       const result1 = yield* $(program(1))
       const result2 = yield* $(program(3))
       const result3 = yield* $(program(20))
-      assert.strictEqual(result1, 54)
-      assert.strictEqual(result2, 54)
-      assert.strictEqual(result3, 54)
+      strictEqual(result1, 54)
+      strictEqual(result2, 54)
+      strictEqual(result3, 54)
     }))
 
   it.effect("collectAllWhileWith - example 2", () =>
@@ -259,6 +260,6 @@ describe("Sink", () => {
         Stream.rechunk(3),
         Stream.run(sink)
       )
-      assert.deepStrictEqual(Array.from(result), [1, 2, 3, 4])
+      deepStrictEqual(Array.from(result), [1, 2, 3, 4])
     }))
 })
diff --git a/packages/effect/test/Sink/constructors.test.ts b/packages/effect/test/Sink/constructors.test.ts
@@ -14,8 +14,9 @@ import * as PubSub from "effect/PubSub"
 import * as Queue from "effect/Queue"
 import * as Sink from "effect/Sink"
 import * as Stream from "effect/Stream"
+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("Sink", () => {
   it.effect("drain - fails if upstream fails", () =>
@@ -25,22 +26,22 @@ describe("Sink", () => {
         Stream.mapEffect(() => Effect.fail("boom!"))
       )
       const result = yield* $(stream, Stream.run(Sink.drain), Effect.exit)
-      assert.deepStrictEqual(result, Exit.fail("boom!"))
+      deepStrictEqual(result, Exit.fail("boom!"))
     }))
 
   it.effect("fromEffect", () =>
     Effect.gen(function*($) {
       const sink = Sink.fromEffect(Effect.succeed("ok"))
       const result = yield* $(Stream.make(1, 2, 3), Stream.run(sink))
-      assert.deepStrictEqual(result, "ok")
+      deepStrictEqual(result, "ok")
     }))
 
   it.effect("fromQueue - should enqueue all elements", () =>
     Effect.gen(function*($) {
       const queue = yield* $(Queue.unbounded<number>())
       yield* $(Stream.make(1, 2, 3), Stream.run(Sink.fromQueue(queue)))
       const result = yield* $(Queue.takeAll(queue))
-      assert.deepStrictEqual(Array.from(result), [1, 2, 3])
+      deepStrictEqual(Array.from(result), [1, 2, 3])
     }))
 
   it.effect("fromQueueWithShutdown - should enqueue all elements and shutdown the queue", () =>
@@ -49,8 +50,8 @@ describe("Sink", () => {
       yield* $(Stream.make(1, 2, 3), Stream.run(Sink.fromQueue(queue, { shutdown: true })))
       const enqueuedValues = yield* $(Queue.takeAll(queue))
       const isShutdown = yield* $(Queue.isShutdown(queue))
-      assert.deepStrictEqual(Array.from(enqueuedValues), [1, 2, 3])
-      assert.isTrue(isShutdown)
+      deepStrictEqual(Array.from(enqueuedValues), [1, 2, 3])
+      assertTrue(isShutdown)
     }))
 
   it.effect("fromPubSub - should publish all elements", () =>
@@ -74,15 +75,15 @@ describe("Sink", () => {
       yield* $(Stream.make(1, 2, 3), Stream.run(Sink.fromPubSub(pubsub)))
       yield* $(Deferred.succeed(deferred2, void 0))
       const result = yield* $(Fiber.join(fiber))
-      assert.deepStrictEqual(Array.from(result), [1, 2, 3])
+      deepStrictEqual(Array.from(result), [1, 2, 3])
     }))
 
   it.effect("fromPubSub(_, { shutdown: true }) - should shutdown the pubsub", () =>
     Effect.gen(function*($) {
       const pubsub = yield* $(PubSub.unbounded<number>())
       yield* $(Stream.make(1, 2, 3), Stream.run(Sink.fromPubSub(pubsub, { shutdown: true })))
       const isShutdown = yield* $(PubSub.isShutdown(pubsub))
-      assert.isTrue(isShutdown)
+      assertTrue(isShutdown)
     }))
 })
 

diff --git a/packages/effect/test/Sink/dropping.test.ts b/packages/effect/test/Sink/dropping.test.ts
@@ -2,8 +2,9 @@ import * as Effect from "effect/Effect"
 import * as Either from "effect/Either"
 import * as Sink from "effect/Sink"
 import * as Stream from "effect/Stream"
+import { deepStrictEqual } from "effect/test/util"
 import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
 
 describe("Sink", () => {
   it.effect("dropUntil", () =>
@@ -13,7 +14,7 @@ describe("Sink", () => {
         Stream.pipeThrough(Sink.dropUntil<number>((n) => n >= 3)),
         Stream.runCollect
       )
-      assert.deepStrictEqual(Array.from(result), [4, 5, 1, 2, 3, 4, 5])
+      deepStrictEqual(Array.from(result), [4, 5, 1, 2, 3, 4, 5])
     }))
 
   it.effect("dropUntilEffect - happy path", () =>
@@ -23,7 +24,7 @@ describe("Sink", () => {
         Stream.pipeThrough(Sink.dropUntilEffect((n) => Effect.succeed(n >= 3))),
         Stream.runCollect
       )
-      assert.deepStrictEqual(Array.from(result), [4, 5, 1, 2, 3, 4, 5])
+      deepStrictEqual(Array.from(result), [4, 5, 1, 2, 3, 4, 5])
     }))
 
   it.effect("dropUntilEffect - error", () =>
@@ -36,7 +37,7 @@ describe("Sink", () => {
         Stream.either,
         Stream.runCollect
       )
-      assert.deepStrictEqual(Array.from(result), [Either.right(3), Either.left("Aie")])
+      deepStrictEqual(Array.from(result), [Either.right(3), Either.left("Aie")])
     }))
 
   it.effect("dropWhile", () =>
@@ -46,7 +47,7 @@ describe("Sink", () => {
         Stream.pipeThrough(Sink.dropWhile<number>((n) => n < 3)),
         Stream.runCollect
       )
-      assert.deepStrictEqual(Array.from(result), [3, 4, 5, 1, 2, 3, 4, 5])
+      deepStrictEqual(Array.from(result), [3, 4, 5, 1, 2, 3, 4, 5])
     }))
 
   it.effect("dropWhileEffect - happy path", () =>
@@ -56,7 +57,7 @@ describe("Sink", () => {
         Stream.pipeThrough(Sink.dropWhileEffect((n) => Effect.succeed(n < 3))),
         Stream.runCollect
       )
-      assert.deepStrictEqual(Array.from(result), [3, 4, 5, 1, 2, 3, 4, 5])
+      deepStrictEqual(Array.from(result), [3, 4, 5, 1, 2, 3, 4, 5])
     }))
 
   it.effect("dropWhileEffect - error", () =>
@@ -71,6 +72,6 @@ describe("Sink", () => {
         Stream.either,
         Stream.runCollect
       )
-      assert.deepStrictEqual(Array.from(result), [Either.right(3), Either.left("Aie")])
+      deepStrictEqual(Array.from(result), [Either.right(3), Either.left("Aie")])
     }))
 })
diff --git a/packages/effect/test/Sink/elements.test.ts b/packages/effect/test/Sink/elements.test.ts
@@ -4,8 +4,9 @@ import { pipe } from "effect/Function"
 import * as Option from "effect/Option"
 import * as Sink from "effect/Sink"
 import * as Stream from "effect/Stream"
+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("Sink", () => {
   it.effect("every", () =>
@@ -16,7 +17,7 @@ describe("Sink", () => {
         Stream.fromChunk(chunk),
         Stream.run(Sink.every(predicate))
       )
-      assert.isTrue(result)
+      assertTrue(result)
     }))
 
   it.effect("head", () =>
@@ -25,7 +26,7 @@ describe("Sink", () => {
         Stream.fromChunks(Chunk.range(1, 10), Chunk.range(1, 3), Chunk.range(2, 5)),
         Stream.run(Sink.head())
       )
-      assert.deepStrictEqual(result, Option.some(1))
+      deepStrictEqual(result, Option.some(1))
     }))
 
   it.effect("last", () =>
@@ -34,7 +35,7 @@ describe("Sink", () => {
         Stream.fromChunks(Chunk.range(1, 10), Chunk.range(1, 3), Chunk.range(2, 5)),
         Stream.run(Sink.last())
       )
-      assert.deepStrictEqual(result, Option.some(5))
+      deepStrictEqual(result, Option.some(5))
     }))
 
   it.effect("take - repeats until the source is exhausted", () =>
@@ -49,7 +50,7 @@ describe("Sink", () => {
         ),
         Stream.run(Sink.collectAllFrom(Sink.take<number>(3)))
       )
-      assert.deepStrictEqual(
+      deepStrictEqual(
         Array.from(result).map((chunk) => Array.from(chunk)),
         [[1, 2, 3], [4, 5, 6], [7, 8, 9], []]
       )
@@ -63,7 +64,7 @@ describe("Sink", () => {
         Stream.fromChunk(chunk),
         Stream.run(Sink.some(predicate))
       )
-      assert.isTrue(result)
+      assertTrue(result)
     }))
 
   it.effect("sum", () =>
@@ -81,7 +82,7 @@ describe("Sink", () => {
           Sink.map(Chunk.reduce(0, (x, y) => x + y))
         ))
       )
-      assert.strictEqual(result, 45)
+      strictEqual(result, 45)
     }))
 
   it.effect("take", () =>
@@ -105,11 +106,11 @@ describe("Sink", () => {
         ),
         Effect.scoped
       )
-      assert.deepStrictEqual(
+      deepStrictEqual(
         Array.from(chunk),
         Array.from(pipe(Chunk.flatten(chunks), Chunk.take(n)))
       )
-      assert.deepStrictEqual(
+      deepStrictEqual(
         Array.from(leftover),
         Array.from(pipe(Chunk.flatten(chunks), Chunk.drop(n)))
       )

diff --git a/packages/effect/test/Sink/environment.test.ts b/packages/effect/test/Sink/environment.test.ts
@@ -3,8 +3,9 @@ import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
 import * as Sink from "effect/Sink"
 import * as Stream from "effect/Stream"
+import { strictEqual } from "effect/test/util"
 import * as it from "effect/test/utils/extend"
-import { assert, describe } from "vitest"
+import { describe } from "vitest"
 
 describe("Sink", () => {
   it.effect("contextWithSink", () =>
@@ -15,6 +16,6 @@ describe("Sink", () => {
         Sink.provideContext(pipe(Context.empty(), Context.add(tag, "use this")))
       )
       const result = yield* $(Stream.make("ignore this"), Stream.run(sink))
-      assert.strictEqual(result, "use this")
+      strictEqual(result, "use this")
     }))
 })