v8 deserialize() does not use same Object prototype

[robross0606]

Version

14.19.1

Platform

Microsoft Windows NT 10.0.19044.0 x64

Subsystem

v8

What steps will reproduce the bug?

const v8 = require('v8')

const obj = new Object()
console.log(object instanceof Object) // true
console.log(Object.prototype.isPrototypeOf(obj)) // true
console.log(obj.constructor === Object) // true
console.log(obj.constructor.name == 'Object') // true

// Old-style JSON deep clone
const clone1 = JSON.parse(JSON.stringify(obj))
console.log(clone1 instanceof Object) // true
console.log(Object.prototype.isPrototypeOf(clone1)) // true
console.log(clone1.constructor === Object) // true
console.log(clone1.constructor.name == 'Object') // true

// Newer v8 structured deep clone
const clone2 = v8.deserialize(v8.serialize(obj))
console.log(clone2 instanceof Object) // false
console.log(Object.prototype.isPrototypeOf(clone2)) // false
console.log(clone2.constructor === Object) // false
console.log(clone2.constructor.name == 'Object') // true

How often does it reproduce? Is there a required condition?

100% reproducible

What is the expected behavior?

When using the v8.deserialize(), one would think it the DefaultDeserializer would maintain the same Object prototype as the original item as well as the older style JSON.parse().

What do you see instead?

Instead, the deserialized object has an Object prototype but it appears to be a different prototype with exactly the same contents. Even Jest gets confused and claims the prototypes "serialize to the same string" and yet test as not being the same via all calls.

Additional information

No response

[targos]

I'm unable to reproduce. If I fix the example (by replacing object with obj on line 4), all logs print true.

[robross0606]

So this isn't quite as reproducible as I thought. Maybe it is Node.js version specific? I can 100% reproduce this in a Jest unit test with 14.19.1 on Microsoft Windows NT 10.0.19044.0 x64.

[robross0606]

I was also able to reproduce this on a Jest test in CodeSandboxIo:

https://codesandbox.io/s/relaxed-mestorf-e7yjy3?file=/src/test.js

[robross0606]

Could jest be causing this? Perhaps monkey-patching Object or something wonky like that?

[robross0606]

What I'm seeing is really confusing, but maybe I just don't fully understand the prototype chain here. In the same Jest test file, I created another test:

  it.only('Comparing versions of Object', () => {
    const clone = deserialize(serialize(obj))

    const prototype1 = Object.getPrototypeOf(obj)
    const prototype2 = Object.getPrototypeOf(clone)

    expect(prototype1.name).toEqual(prototype2.name)
    expect(prototype1).toEqual(Object.prototype)
    expect(prototype2).toEqual(Object.prototype)
    expect(Object.prototype.isPrototypeOf(obj)).toBe(true)
    expect(Object.prototype.isPrototypeOf(clone)).toBe(true)
  })

Which yields:

  ● Object clones › Comparing versions of Object

    expect(received).toBe(expected) // Object.is equality

    Expected: true
    Received: false

      40 |     expect(prototype2).toEqual(Object.prototype)
      41 |     expect(Object.prototype.isPrototypeOf(obj)).toBe(true)
    > 42 |     expect(Object.prototype.isPrototypeOf(clone)).toBe(true)
         |                                                   ^
      43 |   })
      44 | })
      45 |

      at Object.toBe (__tests__/wat.test.js:42:51)

So both the prototype of obj and clone equal Object.prototype yet only Object.prototype.isPrototypeOf(clone) is false?

[BridgeAR]

Jest has own globals. This is a common pitfall.

[robross0606]

So how on Earth can we create proper coverage of something that uses structured cloning?

[BridgeAR]

Please reach out to jest. The only solution I know is to use a different test runner.

[robross0606]

Ah, I see cracks in the curtain now. I changed toEqual to toStrictEqual and at least it fails on the expected line:

  ● Object clones › Comparing versions of Object

    expect(received).toStrictEqual(expected) // deep equality

    Expected: {}
    Received: serializes to the same string

      38 |     expect(prototype1.name).toStrictEqual(prototype2.name)
      39 |     expect(prototype1).toStrictEqual(Object.prototype)
    > 40 |     expect(prototype2).toStrictEqual(Object.prototype)
         |                        ^
      41 |     expect(Object.prototype.isPrototypeOf(obj)).toBe(true)
      42 |     expect(Object.prototype.isPrototypeOf(clone)).toBe(true)
      43 |   })

      at Object.toStrictEqual (__tests__/wat.test.js:40:24)

[robross0606]

Note that this still only fails on v8.deserialize() and not JSON.parse() which is curious.

[bnoordhuis]

Converted to a discussion since this is not a node bug. Refs jestjs/jest#2549.