More robust error testing

CHANGELOG.md

@@ -5,6 +5,7 @@ This project adheres to semantic versioning.
 ## 0.19.0 (_Unreleased_)
 
 - Add `clone` to `URLPath`.
+- Wrap the provided error cause in `unsafeExpect` in `Option` in an `Error` object.
 - Fix `URLPath` incorrectly parsing alternative origins.
 - Fix typings in presence of `isolatedModules`.
 - Bump minimum supported Node LTS to v20.

package.json

@@ -50,7 +50,7 @@
 		"fast-check": "^3.1.2",
 		"fp-ts": "^2.16.0",
 		"fp-ts-laws": "^0.3.0",
-		"jest": "^29.4.1",
+		"jest": "^29.7.0",
 		"jsdom": "^22.1.0",
 		"monocle-ts": "^2.3.0",
 		"newtype-ts": "^0.3.0",

src/Option.ts

@@ -28,7 +28,7 @@ import { decrement, increment } from "./Number"
  *
  * assert.throws(
  *   () => unsafeExpect('foo')(O.none),
- *   Error('Unwrapped `None`', { cause: 'foo' }),
+ *   Error('Unwrapped `None`', { cause: Error('foo') }),
  * )
  *
  * @category 3 Functions
@@ -37,7 +37,7 @@ import { decrement, increment } from "./Number"
 export const unsafeExpect =
 	(msg: string) =>
 	<A>(x: Option<A>): A => {
-		if (O.isNone(x)) throw Error("Unwrapped `None`", { cause: msg })
+		if (O.isNone(x)) throw Error("Unwrapped `None`", { cause: new Error(msg) })
 
 		return x.value
 	}

test/Enum.ts

@@ -25,20 +25,9 @@ import * as Str from "fp-ts/string"
 import { Enum as EnumBool } from "../src/Boolean"
 import { curry2 } from "../src/Function"
 import * as L from "../src/Lazy"
-import type { Lazy } from "../src/Lazy"
 import { EnumInt } from "../src/Number"
 import { EQ } from "../src/Ordering"
 
-const msgAndCause = (f: Lazy<unknown>): [string, unknown] => {
-	try {
-		f()
-		throw "didn't throw"
-	} catch (e) {
-		if (!(e instanceof Error)) throw "threw unexpected type"
-		return [e.message, e.cause]
-	}
-}
-
 const BoundedNull: Bounded<null> = {
 	equals: constant(true),
 	compare: constant(EQ),
@@ -375,10 +364,13 @@ describe("Enum", () => {
 
 		it("throws with expected message in fromEnum if member not present", () => {
 			const E = f(Str.Ord)(["foo"])
-			const [m, c] = msgAndCause(() => E.fromEnum("bar"))
-
-			expect(m).toBe("Unwrapped `None`")
-			expect(c).toMatch(/getUnsafeConstantEnum/)
+			expect(() => E.fromEnum("bar")).toThrow(
+				new Error("Unwrapped `None`", {
+					cause: new Error(
+						"Failed to lookup fromEnum input via getUnsafeConstantEnum",
+					),
+				}),
+			)
 		})
 	})
 })

test/IOOption.ts

@@ -1,17 +1,6 @@
 import { describe, expect, it } from "@jest/globals"
 import * as IOO from "fp-ts/IOOption"
 import { pass, unsafeExpect, unsafeUnwrap } from "../src/IOOption"
-import type { Lazy } from "../src/Lazy"
-
-const msgAndCause = (f: Lazy<unknown>): [string, unknown] => {
-	try {
-		f()
-		throw "didn't throw"
-	} catch (e) {
-		if (!(e instanceof Error)) throw "threw unexpected type"
-		return [e.message, e.cause]
-	}
-}
 
 describe("IOOption", () => {
 	describe("unsafeUnwrap", () => {
@@ -22,10 +11,7 @@ describe("IOOption", () => {
 		})
 
 		it("throws None", () => {
-			const [m, c] = msgAndCause(() => f(IOO.none))
-
-			expect(m).toBe("Unwrapped `None`")
-			expect(c).toBe(undefined)
+			expect(() => f(IOO.none)).toThrow(new Error("Unwrapped `None`"))
 		})
 	})
 
@@ -37,10 +23,9 @@ describe("IOOption", () => {
 		})
 
 		it("throws None with provided message", () => {
-			const [m, c] = msgAndCause(() => f(IOO.none))
-
-			expect(m).toBe("Unwrapped `None`")
-			expect(c).toBe("foo")
+			expect(() => f(IOO.none)).toThrow(
+				new Error("Unwrapped `None`", { cause: new Error("foo") }),
+			)
 		})
 	})
 

test/Option.ts

@@ -23,16 +23,6 @@ import {
 	unsafeUnwrap,
 } from "../src/Option"
 
-const msgAndCause = (f: Lazy<unknown>): [string, unknown] => {
-	try {
-		f()
-		throw "didn't throw"
-	} catch (e) {
-		if (!(e instanceof Error)) throw "threw unexpected type"
-		return [e.message, e.cause]
-	}
-}
-
 const arbOption = <A>(x: fc.Arbitrary<A>): fc.Arbitrary<Option<A>> =>
 	fc.oneof(x.map(O.some), fc.constant(O.none))
 
@@ -45,10 +35,7 @@ describe("Option", () => {
 		})
 
 		it("throws None", () => {
-			const [m, c] = msgAndCause(() => f(O.none))
-
-			expect(m).toBe("Unwrapped `None`")
-			expect(c).toBe(undefined)
+			expect(() => f(O.none)).toThrow(new Error("Unwrapped `None`"))
 		})
 	})
 
@@ -60,10 +47,9 @@ describe("Option", () => {
 		})
 
 		it("throws None with provided message", () => {
-			const [m, c] = msgAndCause(() => f(O.none))
-
-			expect(m).toBe("Unwrapped `None`")
-			expect(c).toBe("foo")
+			expect(() => f(O.none)).toThrow(
+				new Error("Unwrapped `None`", { cause: new Error("foo") }),
+			)
 		})
 	})
 

test/TaskOption.ts

@@ -2,16 +2,6 @@ import { describe, expect, it } from "@jest/globals"
 import * as TO from "fp-ts/TaskOption"
 import { pass, unsafeExpect, unsafeUnwrap } from "../src/TaskOption"
 
-const msgAndCause = async (f: Promise<unknown>): Promise<[string, unknown]> => {
-	try {
-		await f
-		throw "didn't throw"
-	} catch (e) {
-		if (!(e instanceof Error)) throw "threw unexpected type"
-		return [e.message, e.cause]
-	}
-}
-
 describe("TaskOption", () => {
 	describe("unsafeUnwrap", () => {
 		const f = unsafeUnwrap
@@ -21,10 +11,7 @@ describe("TaskOption", () => {
 		})
 
 		it("throws None", async () => {
-			const [m, c] = await msgAndCause(f(TO.none))
-
-			expect(m).toBe("Unwrapped `None`")
-			expect(c).toBe(undefined)
+			expect(f(TO.none)).rejects.toThrow(new Error("Unwrapped `None`"))
 		})
 	})
 
@@ -36,10 +23,9 @@ describe("TaskOption", () => {
 		})
 
 		it("throws None with provided message", async () => {
-			const [m, c] = await msgAndCause(f(TO.none))
-
-			expect(m).toBe("Unwrapped `None`")
-			expect(c).toBe("foo")
+			expect(f(TO.none)).rejects.toThrow(
+				new Error("Unwrapped `None`", { cause: new Error("foo") }),
+			)
 		})
 	})