@goliapkg/smix 1.0.27 → 2.1.0

package/src/__tests__/RealAddonLoopback.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vitest'
+import http from 'node:http'
+import { App } from '../App.js'
+import { loadNodeDriver } from '../loadNodeDriver.js'
+import { MockSelectorResolver } from '../SelectorResolver.js'
+import { Selector, encodeSelectorJson } from '../Selector.js'
+import { Smix, bundleId } from '../Smix.js'
+
+// Drives through the REAL @goliapkg/smix-node addon (resolved via the bun
+// workspace) against a node:http loopback fake wire — no device, no publish.
+// This is the seam's production leg: a real SmixNodeDriver satisfies NodeDriver
+// and crosses napi to the loopback, the same shape C2 loopback-tested at the
+// crate, now reached through smix-rn's loadNodeDriver factory.
+const A11Y_ROOT =
+  '{"rawType":"application","identifier":"root","enabled":true,"selected":false,"hasFocus":false,"visible":true,"bounds":{"x":0,"y":0,"w":0,"h":0}}'
+
+interface Wire {
+  port: number
+  seen: Record<string, unknown>
+  close: () => Promise<void>
+}
+
+async function startFakeWire(): Promise<Wire> {
+  const seen: Record<string, unknown> = {}
+  const server = http.createServer((req, res) => {
+    let body = ''
+    req.on('data', (c) => (body += c))
+    req.on('end', () => {
+      const parsed = body ? JSON.parse(body) : {}
+      seen[req.url ?? ''] = parsed
+      const reply =
+        req.url === '/tree'
+          ? A11Y_ROOT
+          : req.url === '/session/open'
+            ? '{"sessionId":"s-1"}'
+            : '{"ok":true}'
+      res.writeHead(200, { 'content-type': 'application/json' })
+      res.end(reply)
+    })
+  })
+  await new Promise<void>((r) => server.listen(0, '127.0.0.1', () => r()))
+  const addr = server.address()
+  const port = typeof addr === 'object' && addr ? addr.port : 0
+  return { port, seen, close: () => new Promise((r) => server.close(() => r())) }
+}
+
+describe('smix-rn drives through the real napi addon (C4)', () => {
+  it('loadNodeDriver resolves a real SmixNodeDriver satisfying the seam', async () => {
+    const driver = await loadNodeDriver(1)
+    expect(typeof driver.snapshotTree).toBe('function')
+    expect(typeof driver.tapById).toBe('function')
+    expect(typeof driver.openSession).toBe('function')
+  })
+
+  it('snapshotTree crosses the real .node to the loopback wire', async () => {
+    const wire = await startFakeWire()
+    try {
+      const driver = await loadNodeDriver(wire.port)
+      const tree = JSON.parse(await driver.snapshotTree())
+      expect(tree.identifier).toBe('root')
+    } finally {
+      await wire.close()
+    }
+  })
+
+  it('Smix.launchApp with an explicit real driver launches and taps', async () => {
+    const wire = await startFakeWire()
+    try {
+      const driver = await loadNodeDriver(wire.port)
+      const resolver = new MockSelectorResolver()
+      resolver.registerHit(encodeSelectorJson(Selector.id('root')), 'root')
+      const app = await Smix.launchApp(bundleId('com.acme.app'), { driver, resolver: resolver.resolve })
+      expect(app).toBeInstanceOf(App)
+
+      await app.tap(Selector.id('root'))
+      expect((wire.seen['/tap-by-id'] as { id?: string })?.id).toBe('root')
+    } finally {
+      await wire.close()
+    }
+  })
+})

package/src/__tests__/SelectorFullSchema.test.ts

@@ -1,7 +1,5 @@
-// v7.5 c1 — Selector full 7-case + Modifiers flatten + Pattern + fluent
-// chaining roundtrip + Rust-compatible wire shape tests.
-//
-// Mirror Kotlin SelectorFullSchemaTest + Swift SelectorFullSchemaTests.
+// Selector's seven cases, Modifiers flattening, Pattern, fluent chaining
+// roundtrip, and the wire shape the Rust core expects.
 
 import { describe, expect, test } from 'vitest'
 import {

package/src/index.ts

@@ -8,6 +8,25 @@ export {
   App,
 } from './App.js'
 
+export {
+  MockNodeDriver,
+  MockNodeSession,
+  type NodeDriver,
+  type NodeSession,
+  type RecordedCall,
+} from './NodeDriver.js'
+
+export {
+  type SystemPopup,
+  type SystemPopupButton,
+} from './SystemPopup.js'
+
+export {
+  defaultRunnerPort,
+  loadNodeDriver,
+  loadNodeResolver,
+} from './loadNodeDriver.js'
+
 export {
   literal,
   patternFromJson,
@@ -46,14 +65,6 @@ export {
   type AppTarget,
 } from './Smix.js'
 
-export {
-  MockSimRuntime,
-  type KeyName,
-  type LaunchFreshCall,
-  type SmixSimRuntime,
-  type SwipeDirection,
-} from './SimRuntime.js'
-
 export {
   MockLabelsResolver,
   MockSelectorResolver,

package/src/loadNodeDriver.ts

@@ -0,0 +1,41 @@
+// The production leg of the NodeDriver seam: load the real napi addon
+// (`@goliapkg/smix-node`) and construct a driver aimed at a runner port. The
+// import is dynamic and lazy so a platform without a prebuilt `.node` does not
+// fail at install/import time — it fails clearly here, only when a caller
+// actually reaches for live driving. The addon is an optionalDependency, so
+// this is the single place its absence surfaces.
+
+import type { NodeDriver } from './NodeDriver.js'
+import type { LabelsResolver, SelectorResolver } from './SelectorResolver.js'
+
+/** The runner port to drive, from `SMIX_RUNNER_PORT` or the CLI default. */
+export function defaultRunnerPort(): number {
+  return Number(process.env.SMIX_RUNNER_PORT) || 22087
+}
+
+/**
+ * Load the real `SmixNodeDriver` and aim it at `port` (defaulting to the
+ * runner port). The returned instance satisfies `NodeDriver` structurally.
+ */
+export async function loadNodeDriver(port?: number): Promise<NodeDriver> {
+  const { SmixNodeDriver } = await import('@goliapkg/smix-node')
+  return new SmixNodeDriver(port ?? defaultRunnerPort()) as unknown as NodeDriver
+}
+
+/**
+ * Load a selector resolver backed by the napi addon's stone resolver. This
+ * resolves host-side — in this process, over napi — the same as the Swift /
+ * Kotlin SDKs resolve through UniFFI, rather than posting to a runner
+ * `/select/resolve` route the iOS runner does not serve. No port: resolution
+ * is a pure function of the tree and selector.
+ */
+export async function loadNodeResolver(): Promise<{
+  resolver: SelectorResolver
+  labelsResolver: LabelsResolver
+}> {
+  const { resolveSelector, resolveSelectorLabels } = await import('@goliapkg/smix-node')
+  return {
+    resolver: async (treeJson, selectorJson) => resolveSelector(treeJson, selectorJson),
+    labelsResolver: async (treeJson, selectorJson) => resolveSelectorLabels(treeJson, selectorJson),
+  }
+}

package/src/SimRuntime.ts

@@ -1,145 +0,0 @@
-// SmixSimRuntime interface + MockSimRuntime impl.
-//
-// Mirrors the Swift and Kotlin SimRuntime architecture. The TS SDK is
-// HTTP-runner-friendly:
-//   - HttpSimRuntime (real, lives in src/HttpRunner.ts): wraps the
-//     smix-runner HTTP server via fetch (cross-platform iOS+Android).
-//   - MockSimRuntime (here): in-memory tree + event log for unit tests.
-//
-// This module is intended for test targets only.
-
-import type { A11yNode } from './A11yNode.js'
-
-export type KeyName = 'return' | 'delete' | 'space' | 'tab' | 'escape' | 'enter'
-export type SwipeDirection = 'up' | 'down' | 'left' | 'right'
-
-/** Low-level emulator runtime — captures + injects events. */
-export interface SmixSimRuntime {
-  launch(bundleId: string): Promise<void>
-  terminate(bundleId: string): Promise<void>
-  snapshotTree(): Promise<A11yNode>
-  synthesizeTap(x: number, y: number): Promise<void>
-  sendString(text: string): Promise<void>
-  pressKey(key: KeyName): Promise<void>
-  swipe(direction: SwipeDirection): Promise<void>
-  screenshot(): Promise<Uint8Array>
-  systemPopups(): Promise<A11yNode[]>
-  openUrl(url: string): Promise<void>
-  launchFresh(opts: {
-    bundleId: string
-    clearState: boolean
-    clearKeychain: boolean
-    appPath?: string | undefined
-  }): Promise<void>
-  launchFromPath(appPath: string): Promise<void>
-  synthesizeTapAtNormalized(nx: number, ny: number): Promise<void>
-}
-
-export interface LaunchFreshCall {
-  bundleId: string
-  clearState: boolean
-  clearKeychain: boolean
-  appPath: string | undefined
-}
-
-const EMPTY_DEFAULT: A11yNode = {
-  rawType: 'other',
-  bounds: { x: 0, y: 0, w: 393, h: 852 },
-  enabled: true,
-  visible: true,
-  children: [],
-}
-
-/**
- * In-memory mock runtime — used by vitest unit tests for deterministic
- * wire verification without booting an emulator.
- */
-export class MockSimRuntime implements SmixSimRuntime {
-  snapshotResult: A11yNode = EMPTY_DEFAULT
-  readonly tapCalls: { x: number; y: number }[] = []
-  readonly launchCalls: string[] = []
-  readonly terminateCalls: string[] = []
-  readonly sendStringCalls: string[] = []
-  readonly pressKeyCalls: KeyName[] = []
-  readonly swipeCalls: SwipeDirection[] = []
-  screenshotCalls = 0
-  screenshotResult: Uint8Array = new Uint8Array(0)
-  systemPopupsResult: A11yNode[] = []
-  readonly openUrlCalls: string[] = []
-  readonly launchFreshCalls: LaunchFreshCall[] = []
-  readonly launchFromPathCalls: string[] = []
-  readonly tapAtNormalizedCalls: { nx: number; ny: number }[] = []
-
-  /** Hook invoked just before [snapshotTree] returns. Mirrors Swift/Kotlin. */
-  afterSnapshot: ((callIndex: number) => void) | null = null
-  private snapshotCallCount = 0
-
-  constructor(opts: { snapshotResult?: A11yNode } = {}) {
-    if (opts.snapshotResult !== undefined) this.snapshotResult = opts.snapshotResult
-  }
-
-  async launch(bundleId: string): Promise<void> {
-    this.launchCalls.push(bundleId)
-  }
-
-  async terminate(bundleId: string): Promise<void> {
-    this.terminateCalls.push(bundleId)
-  }
-
-  async snapshotTree(): Promise<A11yNode> {
-    const idx = this.snapshotCallCount++
-    this.afterSnapshot?.(idx)
-    return this.snapshotResult
-  }
-
-  async synthesizeTap(x: number, y: number): Promise<void> {
-    this.tapCalls.push({ x, y })
-  }
-
-  async sendString(text: string): Promise<void> {
-    this.sendStringCalls.push(text)
-  }
-
-  async pressKey(key: KeyName): Promise<void> {
-    this.pressKeyCalls.push(key)
-  }
-
-  async swipe(direction: SwipeDirection): Promise<void> {
-    this.swipeCalls.push(direction)
-  }
-
-  async screenshot(): Promise<Uint8Array> {
-    this.screenshotCalls++
-    return this.screenshotResult
-  }
-
-  async systemPopups(): Promise<A11yNode[]> {
-    return this.systemPopupsResult
-  }
-
-  async openUrl(url: string): Promise<void> {
-    this.openUrlCalls.push(url)
-  }
-
-  async launchFresh(opts: {
-    bundleId: string
-    clearState: boolean
-    clearKeychain: boolean
-    appPath?: string | undefined
-  }): Promise<void> {
-    this.launchFreshCalls.push({
-      bundleId: opts.bundleId,
-      clearState: opts.clearState,
-      clearKeychain: opts.clearKeychain,
-      appPath: opts.appPath,
-    })
-  }
-
-  async launchFromPath(appPath: string): Promise<void> {
-    this.launchFromPathCalls.push(appPath)
-  }
-
-  async synthesizeTapAtNormalized(nx: number, ny: number): Promise<void> {
-    this.tapAtNormalizedCalls.push({ nx, ny })
-  }
-}

package/src/__tests__/AppFullApi.test.ts

@@ -1,168 +0,0 @@
-// v7.5 c3 — App act/sense full API wire tests, mirror Kotlin
-// AppActSenseExtMockTest + AppFillPressKeyMockTest + Swift v7.2 c1/c2/c5.
-
-import { describe, expect, test } from 'vitest'
-import {
-  bundleId,
-  ExpectationFailure,
-  literal,
-  MockSelectorResolver,
-  MockSimRuntime,
-  Selector,
-  Smix,
-  type A11yNode,
-} from '../index.js'
-
-describe('App.fill / pressKey', () => {
-  test('fill = tap-to-focus + sendString', async () => {
-    const field: A11yNode = {
-      rawType: 'textField',
-      identifier: 'input-username',
-      label: 'Username',
-      bounds: { x: 50, y: 200, w: 200, h: 40 },
-      enabled: true,
-      visible: true,
-    }
-    const tree: A11yNode = {
-      rawType: 'other',
-      bounds: { x: 0, y: 0, w: 393, h: 852 },
-      visible: true,
-      children: [field],
-    }
-    const runtime = new MockSimRuntime({ snapshotResult: tree })
-    const resolver = new MockSelectorResolver()
-    resolver.registerHit('{"id":"input-username"}', 'input-username')
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, resolver.resolve)
-
-    await app.fill(Selector.id('input-username'), 'alice')
-
-    expect(runtime.tapCalls.length).toBe(1)
-    expect(runtime.tapCalls[0]?.x).toBeCloseTo(150, 1)
-    expect(runtime.tapCalls[0]?.y).toBeCloseTo(220, 1)
-    expect(runtime.sendStringCalls).toEqual(['alice'])
-  })
-
-  test('pressKey delegates to runtime', async () => {
-    const runtime = new MockSimRuntime()
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
-    await app.pressKey('return')
-    await app.pressKey('delete')
-    expect(runtime.pressKeyCalls).toEqual(['return', 'delete'])
-  })
-
-  test('fill failure surfaces ExpectationFailure (no sendString fired)', async () => {
-    const runtime = new MockSimRuntime()
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
-    await expect(app.fill(Selector.id('missing'), 'text')).rejects.toBeInstanceOf(ExpectationFailure)
-    expect(runtime.sendStringCalls).toEqual([])
-  })
-})
-
-describe('App.swipe / screenshot / systemPopups / openUrl', () => {
-  test('swipe delegates with 4 directions', async () => {
-    const runtime = new MockSimRuntime()
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
-    await app.swipe('down')
-    await app.swipe('up')
-    await app.swipe('left')
-    await app.swipe('right')
-    expect(runtime.swipeCalls).toEqual(['down', 'up', 'left', 'right'])
-  })
-
-  test('screenshot returns runtime bytes', async () => {
-    const expected = new Uint8Array([0x89, 0x50, 0x4e, 0x47])
-    const runtime = new MockSimRuntime()
-    runtime.screenshotResult = expected
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
-    const out = await app.screenshot()
-    expect(out).toEqual(expected)
-    expect(runtime.screenshotCalls).toBe(1)
-  })
-
-  test('systemPopups returns runtime list', async () => {
-    const alert: A11yNode = {
-      rawType: 'alert',
-      identifier: 'alert-permission',
-      bounds: { x: 0, y: 0, w: 200, h: 100 },
-    }
-    const runtime = new MockSimRuntime()
-    runtime.systemPopupsResult = [alert]
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
-    const popups = await app.systemPopups()
-    expect(popups.length).toBe(1)
-    expect(popups[0]?.identifier).toBe('alert-permission')
-  })
-
-  test('openUrl forwards to runtime', async () => {
-    const runtime = new MockSimRuntime()
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
-    await app.openUrl('smix://deep/link?id=42')
-    expect(runtime.openUrlCalls).toEqual(['smix://deep/link?id=42'])
-  })
-})
-
-describe('App.launchFresh', () => {
-  test('clearState + clearKeychain', async () => {
-    const runtime = new MockSimRuntime()
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
-    await app.launchFresh({ clearState: true, clearKeychain: true })
-    expect(runtime.launchFreshCalls.length).toBe(1)
-    const call = runtime.launchFreshCalls[0]!
-    expect(call.bundleId).toBe('dev.smix.fixture')
-    expect(call.clearState).toBe(true)
-    expect(call.clearKeychain).toBe(true)
-    expect(call.appPath).toBeUndefined()
-  })
-
-  test('with appPath override', async () => {
-    const runtime = new MockSimRuntime()
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
-    await app.launchFresh({ appPath: '/tmp/Reinstall.apk' })
-    expect(runtime.launchFreshCalls[0]?.appPath).toBe('/tmp/Reinstall.apk')
-  })
-
-  test('defaults are false', async () => {
-    const runtime = new MockSimRuntime()
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
-    await app.launchFresh()
-    const call = runtime.launchFreshCalls[0]!
-    expect(call.clearState).toBe(false)
-    expect(call.clearKeychain).toBe(false)
-  })
-})
-
-describe('App.tapAtCoord', () => {
-  test('valid range', async () => {
-    const runtime = new MockSimRuntime()
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
-    await app.tapAtCoord(0.5, 0.5)
-    expect(runtime.tapAtNormalizedCalls.length).toBe(1)
-    expect(runtime.tapAtNormalizedCalls[0]).toEqual({ nx: 0.5, ny: 0.5 })
-  })
-
-  test('edge values 0,0 and 1,1', async () => {
-    const runtime = new MockSimRuntime()
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
-    await app.tapAtCoord(0, 0)
-    await app.tapAtCoord(1, 1)
-    expect(runtime.tapAtNormalizedCalls.length).toBe(2)
-  })
-
-  test('out of range nx throws wrongState', async () => {
-    const runtime = new MockSimRuntime()
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
-    await expect(app.tapAtCoord(1.5, 0.5)).rejects.toMatchObject({
-      name: 'ExpectationFailure',
-      code: 'wrongState',
-    })
-    expect(runtime.tapAtNormalizedCalls).toEqual([])
-  })
-
-  test('negative ny throws wrongState', async () => {
-    const runtime = new MockSimRuntime()
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
-    await expect(app.tapAtCoord(0.5, -0.1)).rejects.toMatchObject({
-      code: 'wrongState',
-    })
-  })
-})

package/src/__tests__/AppTapMock.test.ts

@@ -1,122 +0,0 @@
-// v7.5 c1 — App.tap mock-based unit tests.
-//
-// Mirror Kotlin AppTapMockTest + Swift AppTapMockTests. Verifies wire
-// pipeline (snapshot → SelectorResolver → tap synthesize) end-to-end
-// against MockSimRuntime + MockSelectorResolver.
-
-import { describe, expect, test } from 'vitest'
-import {
-  bundleId,
-  ExpectationFailure,
-  literal,
-  MockSelectorResolver,
-  MockSimRuntime,
-  Selector,
-  Smix,
-  type A11yNode,
-} from '../index.js'
-
-describe('App.tap notFound path', () => {
-  test('empty resolver result yields notFound', async () => {
-    const runtime = new MockSimRuntime()
-    const resolver = new MockSelectorResolver()
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, resolver.resolve)
-    await expect(app.tap(Selector.id('btn-missing'))).rejects.toMatchObject({
-      name: 'ExpectationFailure',
-      code: 'notFound',
-    })
-  })
-})
-
-describe('App.tap hit path', () => {
-  test('id hit synthesizes at bounds center', async () => {
-    const button: A11yNode = {
-      rawType: 'button',
-      identifier: 'btn-login',
-      label: 'Sign In',
-      bounds: { x: 100, y: 200, w: 80, h: 40 },
-      enabled: true,
-      visible: true,
-    }
-    const root: A11yNode = {
-      rawType: 'other',
-      bounds: { x: 0, y: 0, w: 393, h: 852 },
-      enabled: true,
-      visible: true,
-      children: [button],
-    }
-    const runtime = new MockSimRuntime({ snapshotResult: root })
-    const resolver = new MockSelectorResolver()
-    resolver.registerHit('{"id":"btn-login"}', 'btn-login')
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, resolver.resolve)
-
-    await app.tap(Selector.id('btn-login'))
-
-    expect(runtime.tapCalls.length).toBe(1)
-    expect(runtime.tapCalls[0]?.x).toBeCloseTo(140, 1)
-    expect(runtime.tapCalls[0]?.y).toBeCloseTo(220, 1)
-  })
-
-  test('label hit synthesizes at center', async () => {
-    const button: A11yNode = {
-      rawType: 'button',
-      identifier: 'btn-foo',
-      label: 'Submit',
-      bounds: { x: 50, y: 600, w: 100, h: 50 },
-      visible: true,
-    }
-    const root: A11yNode = {
-      rawType: 'other',
-      bounds: { x: 0, y: 0, w: 393, h: 852 },
-      visible: true,
-      children: [button],
-    }
-    const runtime = new MockSimRuntime({ snapshotResult: root })
-    const resolver = new MockSelectorResolver()
-    resolver.registerHit('{"label":"Submit"}', 'btn-foo')
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, resolver.resolve)
-
-    await app.tap(Selector.label('Submit'))
-    expect(runtime.tapCalls.length).toBe(1)
-    expect(runtime.tapCalls[0]?.x).toBeCloseTo(100, 1)
-  })
-})
-
-describe('App.tap passes correct selectorJson', () => {
-  test('Rust-compatible untagged shape', async () => {
-    const root: A11yNode = {
-      rawType: 'other',
-      bounds: { x: 0, y: 0, w: 393, h: 852 },
-      visible: true,
-      children: [],
-    }
-    const runtime = new MockSimRuntime({ snapshotResult: root })
-    const resolver = new MockSelectorResolver()
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, resolver.resolve)
-
-    await expect(app.tap(Selector.id('btn-x'))).rejects.toBeInstanceOf(ExpectationFailure)
-
-    expect(resolver.calls.length).toBe(1)
-    expect(resolver.calls[0]?.selectorJson).toBe('{"id":"btn-x"}')
-  })
-})
-
-describe('App.tap resolver error surfaces as ExpectationFailure', () => {
-  test('throws unknown when resolver raises', async () => {
-    const root: A11yNode = {
-      rawType: 'other',
-      bounds: { x: 0, y: 0, w: 393, h: 852 },
-      visible: true,
-      children: [],
-    }
-    const runtime = new MockSimRuntime({ snapshotResult: root })
-    const resolver = new MockSelectorResolver()
-    resolver.throwOnNext = new Error('simulated FFI parse error')
-    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, resolver.resolve)
-
-    await expect(app.tap(Selector.id('anything'))).rejects.toMatchObject({
-      name: 'ExpectationFailure',
-      code: 'unknown',
-    })
-  })
-})