improve and test overriding loaded object modules

__test__/jest/jest.mock.types.override.test.cjs

@@ -0,0 +1,41 @@
+const number = require('./fixtures/number.cjs')
+const object = require('./fixtures/object.cjs')
+const classobject = require('./fixtures/classobject.cjs')
+const subclassobject = require('./fixtures/subclassobject.cjs')
+
+test('number', () => {
+  jest.mock('./fixtures/number.cjs')
+  expect(number).toBe(42)
+})
+
+test('object', () => {
+  jest.mock('./fixtures/object.cjs')
+  expect(object.value).toBe(20)
+  expect(object.hello).toBe('world')
+  expect(object.call()).toBe(undefined)
+  expect(() => object.none()).toThrow()
+  expect(object.stringobj).toBeInstanceOf(String)
+  expect(`${object.stringobj}`).toBe('hello')
+  expect(object.arr).toBeInstanceOf(Array)
+  // jest is weird for the below, but let's follow that
+  expect(object.arr.length).toBe(0)
+})
+
+test('classobject', () => {
+  jest.mock('./fixtures/classobject.cjs')
+  expect(classobject.something).toBe('fun')
+  expect(classobject.bar()).toBe(undefined)
+  expect(() => classobject.not()).toThrow()
+})
+
+test('subclassobject', () => {
+  jest.mock('./fixtures/subclassobject.cjs')
+  expect(subclassobject.hi()).toBe(undefined)
+  expect(subclassobject.why()).toBe(undefined)
+  expect(subclassobject.overridden()).toBe(undefined)
+  expect(() => subclassobject.foo()).toThrow()
+  expect(subclassobject.two).toBe(2)
+  expect(subclassobject.one).toBe(1)
+  expect(subclassobject.common).toBe('high')
+  expect(Object.getPrototypeOf(subclassobject)).toBe(Object.prototype) // flattened!
+})

src/jest.mock.js

@@ -44,9 +44,11 @@ const isObject = (obj) => [Object.prototype, null].includes(Object.getPrototypeO
 function override(resolved, lax = false) {
   const value = mapMocks.get(resolved)
   const current = mapActual.get(resolved)
-  assert(isObject(current), 'Modules that export a default non-object can not be mocked')
+  if (current === value) return
   assert(isObject(value), 'Overriding loaded or internal modules is possible with objects only')
-  mapActual.set(resolved, { ...current })
+  const clone = { ...current }
+  Object.setPrototypeOf(clone, Object.getPrototypeOf(current))
+  mapActual.set(resolved, clone)
   for (const key of Object.keys(current)) {
     try {
       delete current[key]
@@ -58,6 +60,8 @@ function override(resolved, lax = false) {
   const access = { configurable: true, enumerable: true, writable: true }
   const definitions = Object.fromEntries(filtered.map(([k, value]) => [k, { value, ...access }]))
   Object.defineProperties(current, definitions)
+  const proto = Object.getPrototypeOf(value)
+  if (Object.getPrototypeOf(current) !== proto) Object.setPrototypeOf(current, proto)
   if (!lax) assert.deepEqual({ ...current }, value)
 }
 
@@ -94,13 +98,16 @@ function mockCloneItem(obj, cache) {
     let modified = stack.length > 1
     for (const level of stack) {
       for (const [name, desc] of Object.entries(Object.getOwnPropertyDescriptors(level))) {
+        if (name === 'constructor') continue
+
         for (const key of ['get', 'set', 'value']) {
           if (!desc[key]) continue
           const orig = desc[key]
           desc[key] = mockClone(desc[key], cache)
           if (orig !== desc[key]) modified = true
         }
 
+        desc.enumerable = desc.configurable = true
         if (desc.value !== undefined || desc.get || desc.set) definitions.push([name, desc])
       }
     }