Update to use deepCyclicCopy

packages/jest-runtime/src/index.js

@@ -19,7 +19,7 @@ import type {MockFunctionMetadata, ModuleMocker} from 'types/Mock';
 import path from 'path';
 import HasteMap from 'jest-haste-map';
 import Resolver from 'jest-resolve';
-import {createDirectory} from 'jest-util';
+import {createDirectory, deepCyclicCopy} from 'jest-util';
 import {escapePathForRegex} from 'jest-regex-util';
 import fs from 'graceful-fs';
 import stripBOM from 'strip-bom';
@@ -434,10 +434,7 @@ class Runtime {
   }
 
   getAllCoverageInfoCopy() {
-    const coverage = this._environment.global.__coverage__;
-    if (!coverage) return undefined;
-
-    return JSON.parse(JSON.stringify(coverage));
+    return deepCyclicCopy(this._environment.global.__coverage__);
   }
 
   getSourceMapInfo() {

packages/jest-util/src/__tests__/deep_cyclic_copy.test.js

@@ -70,9 +70,46 @@ it('uses the blacklist to avoid copying properties on the first level', () => {
     },
   };
 
-  expect(deepCyclicCopy(obj, new Set(['blacklisted']))).toEqual({
+  expect(deepCyclicCopy(obj, {blacklist: new Set(['blacklisted'])})).toEqual({
     subObj: {
       blacklisted: 42,
     },
   });
 });
+
+it('does not keep the prototype by default', () => {
+  const obj = new function() {}();
+  obj.nestedObj = new function() {}();
+
+  const copy = deepCyclicCopy(obj);
+  expect(Object.getPrototypeOf(copy)).not.toBe(Object.getPrototypeOf(obj));
+  expect(Object.getPrototypeOf(copy.nestedObj)).not.toBe(
+    Object.getPrototypeOf(obj.nestedObj),
+  );
+  expect(Object.getPrototypeOf(copy)).toBe(Object.getPrototypeOf({}));
+});
+
+it('does not keep the prototype for keepPrototype = false', () => {
+  const obj = new function() {}();
+  obj.nestedObj = new function() {}();
+
+  const copy = deepCyclicCopy(obj, {keepPrototype: false});
+
+  expect(Object.getPrototypeOf(copy)).not.toBe(Object.getPrototypeOf(obj));
+  expect(Object.getPrototypeOf(copy.nestedObj)).not.toBe(
+    Object.getPrototypeOf(obj.nestedObj),
+  );
+  expect(Object.getPrototypeOf(copy)).toBe(Object.getPrototypeOf({}));
+});
+
+it('keeps the prototype for keepPrototype = true', () => {
+  const obj = new function() {}();
+  obj.nestedObj = new function() {}();
+
+  const copy = deepCyclicCopy(obj, {keepPrototype: true});
+
+  expect(Object.getPrototypeOf(copy)).toBe(Object.getPrototypeOf(obj));
+  expect(Object.getPrototypeOf(copy.nestedObj)).toBe(
+    Object.getPrototypeOf(obj.nestedObj),
+  );
+});

packages/jest-util/src/create_process_object.js

@@ -13,7 +13,10 @@ const BLACKLIST = new Set(['mainModule', '_events']);
 
 export default function() {
   const process = require('process');
-  const newProcess = deepCyclicCopy(process, BLACKLIST);
+  const newProcess = deepCyclicCopy(process, {
+    blacklist: BLACKLIST,
+    keepPrototype: true,
+  });
 
   newProcess[Symbol.toStringTag] = 'process';
 

packages/jest-util/src/deep_cyclic_copy.js

@@ -9,6 +9,11 @@
 
 const EMPTY = new Set();
 
+export type DeepCyclicCopyOptions = {|
+  blacklist: Set<string>,
+  keepPrototype: boolean,
+|};
+
 // Node 6 does not have gOPDs, so we define a simple polyfill for it.
 if (!Object.getOwnPropertyDescriptors) {
   // $FlowFixMe: polyfill
@@ -26,41 +31,45 @@ if (!Object.getOwnPropertyDescriptors) {
 
 export default function deepCyclicCopy(
   value: any,
-  blacklist: Set<string> = EMPTY,
+  options?: DeepCyclicCopyOptions = {blacklist: EMPTY, keepPrototype: false},
   cycles: WeakMap<any, any> = new WeakMap(),
 ): any {
   if (typeof value !== 'object' || value === null) {
     return value;
   } else if (cycles.has(value)) {
     return cycles.get(value);
   } else if (Array.isArray(value)) {
-    return deepCyclicCopyArray(value, blacklist, cycles);
+    return deepCyclicCopyArray(value, options, cycles);
   } else {
-    return deepCyclicCopyObject(value, blacklist, cycles);
+    return deepCyclicCopyObject(value, options, cycles);
   }
 }
 
 function deepCyclicCopyObject(
   object: Object,
-  blacklist: Set<string>,
+  options: DeepCyclicCopyOptions,
   cycles: WeakMap<any, any>,
 ): Object {
-  const newObject = Object.create(Object.getPrototypeOf(object));
+  const newObject = options.keepPrototype
+    ? Object.create(Object.getPrototypeOf(object))
+    : {};
+
   // $FlowFixMe: Object.getOwnPropertyDescriptors is polyfilled above.
   const descriptors = Object.getOwnPropertyDescriptors(object);
 
   cycles.set(object, newObject);
 
   Object.keys(descriptors).forEach(key => {
-    if (blacklist.has(key)) {
+    if (options.blacklist && options.blacklist.has(key)) {
       delete descriptors[key];
       return;
     }
 
     const descriptor = descriptors[key];
 
     if (typeof descriptor.value !== 'undefined') {
-      descriptor.value = deepCyclicCopy(descriptor.value, EMPTY, cycles);
+      delete options.blacklist;
+      descriptor.value = deepCyclicCopy(descriptor.value, options, cycles);
     }
 
     descriptor.configurable = true;
@@ -71,7 +80,7 @@ function deepCyclicCopyObject(
 
 function deepCyclicCopyArray(
   array: Array<any>,
-  blacklist: Set<string>,
+  options: DeepCyclicCopyOptions,
   cycles: WeakMap<any, any>,
 ): Array<any> {
   const newArray = [];
@@ -80,7 +89,8 @@ function deepCyclicCopyArray(
   cycles.set(array, newArray);
 
   for (let i = 0; i < length; i++) {
-    newArray[i] = deepCyclicCopy(array[i], EMPTY, cycles);
+    delete options.blacklist;
+    newArray[i] = deepCyclicCopy(array[i], options, cycles);
   }
 
   return newArray;

packages/jest-util/src/index.js

@@ -21,6 +21,7 @@ import NullConsole from './null_console';
 import isInteractive from './is_interative';
 import setGlobal from './set_global';
 import validateCLIOptions from './validate_cli_options';
+import deepCyclicCopy from './deep_cyclic_copy';
 
 const createDirectory = (path: string) => {
   try {
@@ -39,6 +40,7 @@ module.exports = {
   NullConsole,
   clearLine,
   createDirectory,
+  deepCyclicCopy,
   formatTestResults,
   getConsoleOutput,
   getFailedSnapshotTests,