[Bug]: expect.any fails for `Array` and for other object instances when they come from different realms (Asymmetric matcher cross-realm issue)

[sgleisner]

Version

29.7.0

Steps to reproduce

1. Clone https://github.com/sgleisner/jest-cross-realm-expect-any-example
2. yarn install
3. yarn test

Alternatively, fork this sandbox and it should run tests on startup: https://codesandbox.io/p/github/sgleisner/jest-cross-realm-expect-any-example/main

Expected behavior

expect.any(Array) should succeed for the ["apple", "banana", "cherry"] value in both tests.

Actual behavior

expect.any(Array) succeds for ["apple", "banana", "cherry"] when the array comes from the same realm, but when it comes from another realm, fails with the following error:

expect(received).toMatchObject(expected)

- Expected  - 1
+ Received  + 5

  Object {
-   "details": Any<Array>,
+   "details": Array [
+     "apple",
+     "banana",
+     "cherry",
+   ],  

Additional context

To reproduce the issue, I created a function that returns a fetch Response, which operates in a different realm than the test function.

The problem lies in the asymmetricMatch method:

// v29.7.0
asymmetricMatch(other: unknown) {
  if (this.sample == String) {
    return typeof other == 'string' || other instanceof String;
  }

  if (this.sample == Number) {
    return typeof other == 'number' || other instanceof Number;
  }

  if (this.sample == Function) {
    return typeof other == 'function' || other instanceof Function;
  }

  if (this.sample == Boolean) {
    return typeof other == 'boolean' || other instanceof Boolean;
  }

  if (this.sample == BigInt) {
    return typeof other == 'bigint' || other instanceof BigInt;
  }

  if (this.sample == Symbol) {
    return typeof other == 'symbol' || other instanceof Symbol;
  }

  if (this.sample == Object) {
    return typeof other == 'object';
  }

  return other instanceof this.sample;
}

For Array, it defaults to other instanceof this.sample, which is false when sample is Array and other is an instance of Array from another realm.

Note that this was fixed in #15101 and released in v30.0.0-alpha.6 by correctly using Array.isArray:

// v30.0.0-alpha.6
asymmetricMatch(other: unknown) {
  if (this.sample === String) {
    return typeof other === 'string' || other instanceof String;
  }

  if (this.sample === Number) {
    return typeof other === 'number' || other instanceof Number;
  }

  if (this.sample === Function) {
    return typeof other === 'function' || other instanceof Function;
  }

  if (this.sample === Boolean) {
    return typeof other === 'boolean' || other instanceof Boolean;
  }

  if (this.sample === BigInt) {
    return typeof other === 'bigint' || other instanceof BigInt;
  }

  if (this.sample === Symbol) {
    return typeof other === 'symbol' || other instanceof Symbol;
  }

  if (this.sample === Object) {
    return typeof other === 'object';
  }

  if (this.sample === Array) {
    return Array.isArray(other);
  }

  return other instanceof this.sample;
}

Should this fix be backported to v29?

Environment

System:
    OS: Linux 6.1 Debian GNU/Linux 12 (bookworm) 12 (bookworm)
    CPU: (2) x64 AMD EPYC
  Binaries:
    Node: 20.12.0 - /usr/local/bin/node
    Yarn: 1.22.19 - /usr/local/bin/yarn
    npm: 10.5.0 - /usr/local/bin/npm
    pnpm: 8.15.6 - /usr/local/share/npm-global/bin/pnpm
  npmPackages:
    jest: ^29.7.0 => 29.7.0

[icholy]

Is this limited to just Array or all of the instanceof expressions here?

[sgleisner]

@icholy Good catch! This does affect all the cases where instanceof is used, since it returns false when this.sample and other come from different realms. I've updated the issue and example accordingly.

I missed that initially, but considering it now, the bug seems more fundamental, and likely still present in v30.

Some quick thoughts:

1. Primitive wrapper types: Instead of relying on instanceof, we could check behavior:

if (this.sample === String) {
  return typeof other === 'string' || (
    typeof other === 'object' &&
    typeof other.valueOf === 'function' &&
    typeof other.valueOf() === 'string'
  );
}

Optionally, we could also traverse the prototype chain to find '[object String]'.

2. Function, BigInt, Symbol: I'm not sure instanceof is meaningful here, since it would never be true, as these are not primitive wrappers. Just typeof should be enough:

if (this.sample === BigInt) {
  return typeof other === 'bigint';
}

3. Built-in reference types: This is trickier. Hardcoding type checks for each built-in type (as done here) could work, but it’s neither elegant nor future-proof.

4. Custom types: Probably fine to use instanceof across realms and get false, as it avoids false positives.

[icholy]

You're probably better of writing a custom asymetric matcher similar to expect.any but that takes a vm parameter and uses the types exported there.

[sgleisner]

@icholy Unfortunately, I don't know of any way to get the realm of an object at runtime. (Is there even a way to assign an object's realm to a vm variable?)

My actual use case is similar to the examples I mentioned: I'm testing some server-side functions that return objects. When a function returns a fetch Response object, the test fails; otherwise, everything works as expected. This feels like unintended behavior.

Arrays seem to be fixed in v30, but it still misbehaves with reference types (Map, Set, Promise, etc.) and primitive wrapper types (String, Number, Boolean).

Ideally, avoiding instanceof checks for built-in types would ensure cross-realm safety.

[icholy]

You'll need to get access to the context where those values are created:

const vm = require('vm');
const context = vm.createContext();
const StringFromVM = vm.runInContext('String', context);

expect(value).toBeInstanceOf(StringFromVM);

[github-actions]

This issue is stale because it has been open 30 days with no activity. Remove stale label or comment or this will be closed in 30 days.