+82

tests/effect-basic.test.ts

reviewed

··· 1 1 + import { describe, it, expect } from "bun:test" 2 2 + import { 3 3 + succeed, fail, sync, attempt, fromPromise, 4 4 + mapEff, flatMap, foldEff, catchAll, access, provide, 5 5 + pipe, runPromise, runPromiseExit, Exit 6 6 + } from "../src/index" 7 7 + 8 8 + describe("Effect - Basic Operations", () => { 9 9 + describe("constructors", () => { 10 10 + it("succeed creates successful effect", async () => { 11 11 + const result = await runPromise(succeed(42)) 12 12 + expect(result).toBe(42) 13 13 + }) 14 14 + 15 15 + it("fail creates failed effect", async () => { 16 16 + const exit = await runPromiseExit(fail("error")) 17 17 + expect(Exit.isFailure(exit)).toBe(true) 18 18 + if (Exit.isFailure(exit)) { 19 19 + expect(exit.error).toBe("error") 20 20 + } 21 21 + }) 22 22 + 23 23 + it("sync lifts synchronous computation", async () => { 24 24 + const result = await runPromise(sync(() => 1 + 1)) 25 25 + expect(result).toBe(2) 26 26 + }) 27 27 + 28 28 + it("attempt catches thrown errors", async () => { 29 29 + const effect = attempt(() => { throw new Error("boom") }) 30 30 + const exit = await runPromiseExit(effect) 31 31 + expect(Exit.isFailure(exit)).toBe(true) 32 32 + }) 33 33 + 34 34 + it("fromPromise wraps promises", async () => { 35 35 + const result = await runPromise(fromPromise(() => Promise.resolve(42))) 36 36 + expect(result).toBe(42) 37 37 + }) 38 38 + }) 39 39 + 40 40 + describe("transformations", () => { 41 41 + it("mapEff transforms success value", async () => { 42 42 + const result = await runPromise(pipe(succeed(5), mapEff(x => x * 2))) 43 43 + expect(result).toBe(10) 44 44 + }) 45 45 + 46 46 + it("flatMap chains effects", async () => { 47 47 + const result = await runPromise( 48 48 + pipe(succeed(5), flatMap(x => succeed(x * 2)), flatMap(x => succeed(x + 1))) 49 49 + ) 50 50 + expect(result).toBe(11) 51 51 + }) 52 52 + 53 53 + it("foldEff handles both success and failure", async () => { 54 54 + const handle = foldEff( 55 55 + (e: string) => succeed(`error: ${e}`), 56 56 + (a: number) => succeed(`success: ${a}`) 57 57 + ) 58 58 + 59 59 + expect(await runPromise(pipe(succeed(42), handle))).toBe("success: 42") 60 60 + expect(await runPromise(pipe(fail("oops"), handle))).toBe("error: oops") 61 61 + }) 62 62 + 63 63 + it("catchAll recovers from errors", async () => { 64 64 + const result = await runPromise( 65 65 + pipe(fail("error"), catchAll(() => succeed("recovered"))) 66 66 + ) 67 67 + expect(result).toBe("recovered") 68 68 + }) 69 69 + }) 70 70 + 71 71 + describe("dependency injection", () => { 72 72 + type Config = { baseUrl: string } 73 73 + 74 74 + it("access reads from environment", async () => { 75 75 + const getBaseUrl = access<Config, string>(env => env.baseUrl) 76 76 + const result = await runPromise( 77 77 + pipe(getBaseUrl, provide<Config>({ baseUrl: "https://api.example.com" })) 78 78 + ) 79 79 + expect(result).toBe("https://api.example.com") 80 80 + }) 81 81 + }) 82 82 + })

+90

tests/effect-concurrency.test.ts

reviewed

··· 1 1 + import { describe, it, expect } from "bun:test" 2 2 + import { 3 3 + succeed, fail, sleep, fork, join, race, all, timeout, retry, 4 4 + mapEff, flatMap, pipe, runPromise, runPromiseExit, runFiber, Exit 5 5 + } from "../src/index" 6 6 + 7 7 + describe("Effect - Concurrency", () => { 8 8 + describe("fork and join", () => { 9 9 + it("fork spawns a fiber", async () => { 10 10 + const fiber = await runPromise(fork(succeed(42))) 11 11 + expect(fiber._tag).toBe("Fiber") 12 12 + }) 13 13 + 14 14 + it("join awaits fiber result", async () => { 15 15 + const program = pipe(fork(succeed(42)), flatMap(fiber => join(fiber))) 16 16 + const result = await runPromise(program) 17 17 + expect(result).toBe(42) 18 18 + }) 19 19 + }) 20 20 + 21 21 + describe("race", () => { 22 22 + it("returns first to complete", async () => { 23 23 + const slow = pipe(sleep(100), mapEff(() => "slow")) 24 24 + const fast = pipe(sleep(10), mapEff(() => "fast")) 25 25 + const result = await runPromise(race(slow, fast)) 26 26 + expect(result).toBe("fast") 27 27 + }) 28 28 + }) 29 29 + 30 30 + describe("all", () => { 31 31 + it("runs effects in parallel", async () => { 32 32 + const start = Date.now() 33 33 + const results = await runPromise(all([ 34 34 + pipe(sleep(50), mapEff(() => "a")), 35 35 + pipe(sleep(50), mapEff(() => "b")), 36 36 + pipe(sleep(50), mapEff(() => "c")), 37 37 + ])) 38 38 + const elapsed = Date.now() - start 39 39 + 40 40 + expect(results).toEqual(["a", "b", "c"]) 41 41 + expect(elapsed).toBeLessThan(150) 42 42 + }) 43 43 + 44 44 + it("fails fast on first error", async () => { 45 45 + const exit = await runPromiseExit(all([ 46 46 + pipe(sleep(10), flatMap(() => fail("first error"))), 47 47 + pipe(sleep(100), mapEff(() => "never")), 48 48 + ])) 49 49 + expect(Exit.isFailure(exit)).toBe(true) 50 50 + }) 51 51 + }) 52 52 + 53 53 + describe("timeout", () => { 54 54 + it("returns value if completes in time", async () => { 55 55 + const result = await runPromise(timeout(100)(succeed(42))) 56 56 + expect(result).toBe(42) 57 57 + }) 58 58 + 59 59 + it("returns null if times out", async () => { 60 60 + const slow = pipe(sleep(200), mapEff(() => "done")) 61 61 + const result = await runPromise(timeout(50)(slow)) 62 62 + expect(result).toBeNull() 63 63 + }) 64 64 + }) 65 65 + 66 66 + describe("retry", () => { 67 67 + it("retries failing effect", async () => { 68 68 + let attempts = 0 69 69 + const flaky = pipe( 70 70 + succeed(null), 71 71 + flatMap(() => { 72 72 + attempts++ 73 73 + return attempts < 3 ? fail("not yet") : succeed("success") 74 74 + }) 75 75 + ) 76 76 + const result = await runPromise(retry(5)(flaky)) 77 77 + expect(result).toBe("success") 78 78 + expect(attempts).toBe(3) 79 79 + }) 80 80 + }) 81 81 + 82 82 + describe("interruption", () => { 83 83 + it("fiber can be interrupted", async () => { 84 84 + const fiber = runFiber(pipe(sleep(1000), mapEff(() => "done")), {}) 85 85 + setTimeout(() => fiber.interrupt(), 20) 86 86 + const exit = await fiber.await() 87 87 + expect(Exit.isInterrupted(exit)).toBe(true) 88 88 + }) 89 89 + }) 90 90 + })