@playfast/reform-proof 1.2.0 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playfast/reform-proof",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Headless testing toolkit for reform — drive a scene's compositions and assert on the props they compute, with no DOM, timers, or text matching.",
   "keywords": [
     "effect",

package/src/assert.ts

@@ -0,0 +1,65 @@
+import { Array as Arr, Effect, Option, Record as Rec } from 'effect'
+import { AssertionFailed } from './errors'
+import { formatFingerprint } from './fingerprint'
+
+interface ComparePair {
+  readonly left: unknown
+  readonly right: unknown
+}
+
+const show = (subject: unknown): string => formatFingerprint(subject)
+
+const deepEqual = ({ left, right }: ComparePair): boolean =>
+  Object.is(left, right) || show(left) === show(right)
+
+const fail = (message: string): Effect.Effect<never> =>
+  Effect.dieMessage(new AssertionFailed({ detail: message }).message)
+
+export const expect = <A>(actual: A) => ({
+  toBe: (expected: A): Effect.Effect<void> =>
+    Object.is(actual, expected)
+      ? Effect.void
+      : fail(`expected ${show(actual)} to be ${show(expected)}`),
+  toEqual: (expected: A): Effect.Effect<void> =>
+    deepEqual({ left: actual, right: expected })
+      ? Effect.void
+      : fail(`expected ${show(actual)} to equal ${show(expected)}`),
+  toContain: (expected: A extends ReadonlyArray<infer E> ? E : unknown): Effect.Effect<void> =>
+    Array.isArray(actual) && actual.some((element) => deepEqual({ left: element, right: expected }))
+      ? Effect.void
+      : fail(`expected ${show(actual)} to contain ${show(expected)}`),
+  toMatchObject: (expected: Partial<A>): Effect.Effect<void> => {
+    const mismatch = matchPartial({ actual, expected })
+    return mismatch === undefined ? Effect.void : fail(mismatch)
+  },
+})
+
+export const isRecord = (candidate: unknown): candidate is Record<string, unknown> =>
+  typeof candidate === 'object' && candidate !== null
+
+interface MatchInput {
+  readonly actual: unknown
+  readonly expected: unknown
+}
+
+const matchPartial = ({ actual, expected }: MatchInput): string | undefined => {
+  if (!isRecord(expected)) {
+    return deepEqual({ left: actual, right: expected })
+      ? undefined
+      : `expected ${show(actual)} to match ${show(expected)}`
+  }
+  if (!isRecord(actual)) {
+    return `expected ${show(actual)} to be an object matching ${show(expected)}`
+  }
+  const mismatch = Arr.findFirst(
+    Rec.keys(expected),
+    (key) => !deepEqual({ left: actual[key], right: expected[key] }),
+  )
+  return Option.match(mismatch, {
+    onNone: () => undefined,
+    onSome: (key) =>
+      `expected key ${show(key)} to match ${show(expected[key])}, got ${show(actual[key])}`,
+  })
+}
+
+export const matchProps: (input: MatchInput) => string | undefined = matchPartial