Always enforce the usage of the original Promise (#5077)

* Always enforce the usage of the original Promise

* Only whitelist Promise

Author: mjesun

integration_tests/__tests__/override-globals.test.js

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ */
+
+'use strict';
+
+import runJest from '../runJest';
+
+test('overriding native promise does not freeze Jest', () => {
+  const run = runJest('override-globals');
+  expect(run.stderr).toMatch(/PASS __tests__(\/|\\)index.js/);
+});

integration_tests/override-globals/__tests__/index.js

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+import _unusedRequireOverridingPromise from '..';
+
+describe('parent', () => {
+  beforeEach(() => {
+    console.log('Promise is: ' + Promise.toString());
+  });
+
+  describe('child', () => {
+    it('works well', () => {
+      expect(() => new Promise()).toThrow('Booo');
+    });
+  });
+});

integration_tests/override-globals/index.js

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ */
+
+global.Promise = function() {
+  throw new Error('Booo');
+};

integration_tests/override-globals/package.json

@@ -0,0 +1,5 @@
+{
+  "jest": {
+    "testEnvironment": "node"
+  }
+}

packages/jest-jasmine2/package.json

@@ -16,7 +16,6 @@
     "jest-matcher-utils": "^21.2.1",
     "jest-message-util": "^21.2.1",
     "jest-snapshot": "^21.2.1",
-    "p-cancelable": "^0.3.0",
     "source-map-support": "^0.5.0"
   },
   "devDependencies": {

packages/jest-jasmine2/src/jasmine/Env.js

@@ -31,9 +31,13 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 /* eslint-disable sort-keys */
 
 import queueRunner from '../queue_runner';
-
 import treeProcessor from '../tree_processor';
 
+// Try getting the real promise object from the context, if available. Someone
+// could have overridden it in a test. Async functions return it implicitly.
+// eslint-disable-next-line no-unused-vars
+const Promise = global[Symbol.for('jest-native-promise')] || global.Promise;
+
 export default function(j$) {
   function Env(options) {
     options = options || {};

packages/jest-jasmine2/src/p_cancelable.js

@@ -0,0 +1,81 @@
+'use strict';
+
+// Try getting the real promise object from the context, if available. Someone
+// could have overridden it in a test.
+const Promise = global[Symbol.for('jest-native-promise')] || global.Promise;
+
+class CancelError extends Error {
+  constructor() {
+    super('Promise was canceled');
+    this.name = 'CancelError';
+  }
+}
+
+class PCancelable {
+  static fn(fn) {
+    return function() {
+      const args = [].slice.apply(arguments);
+      return new PCancelable((onCancel, resolve, reject) => {
+        args.unshift(onCancel);
+        fn.apply(null, args).then(resolve, reject);
+      });
+    };
+  }
+
+  constructor(executor) {
+    this._pending = true;
+    this._canceled = false;
+
+    this._promise = new Promise((resolve, reject) => {
+      this._reject = reject;
+
+      return executor(
+        fn => {
+          this._cancel = fn;
+        },
+        val => {
+          this._pending = false;
+          resolve(val);
+        },
+        err => {
+          this._pending = false;
+          reject(err);
+        },
+      );
+    });
+  }
+
+  then() {
+    return this._promise.then.apply(this._promise, arguments);
+  }
+
+  catch() {
+    return this._promise.catch.apply(this._promise, arguments);
+  }
+
+  cancel() {
+    if (!this._pending || this._canceled) {
+      return;
+    }
+
+    if (typeof this._cancel === 'function') {
+      try {
+        this._cancel();
+      } catch (err) {
+        this._reject(err);
+      }
+    }
+
+    this._canceled = true;
+    this._reject(new CancelError());
+  }
+
+  get canceled() {
+    return this._canceled;
+  }
+}
+
+Object.setPrototypeOf(PCancelable.prototype, Promise.prototype);
+
+module.exports = PCancelable;
+module.exports.CancelError = CancelError;

packages/jest-jasmine2/src/p_timeout.js

@@ -7,6 +7,10 @@
  * @flow
  */
 
+// Try getting the real promise object from the context, if available. Someone
+// could have overridden it in a test.
+const Promise = global[Symbol.for('jest-native-promise')] || global.Promise;
+
 // A specialized version of `p-timeout` that does not touch globals.
 // It does not throw on timeout.
 export default function pTimeout(

packages/jest-jasmine2/src/queue_runner.js

@@ -7,7 +7,12 @@
  * @flow
  */
 
-import PCancelable from 'p-cancelable';
+// Try getting the real promise object from the context, if available. Someone
+// could have overridden it in a test.
+const Promise: Class<Promise> =
+  global[Symbol.for('jest-native-promise')] || global.Promise;
+
+import PCancelable from './p_cancelable';
 import pTimeout from './p_timeout';
 
 type Options = {
@@ -55,7 +60,9 @@ export default function queueRunner(options: Options) {
     if (!timeout) {
       return promise;
     }
+
     const timeoutMs: number = timeout();
+
     return pTimeout(
       promise,
       timeoutMs,

packages/jest-jasmine2/src/reporter.js

@@ -17,6 +17,10 @@ import type {
   TestResult,
 } from 'types/TestResult';
 
+// Try getting the real promise object from the context, if available. Someone
+// could have overridden it in a test.
+const Promise = global[Symbol.for('jest-native-promise')] || global.Promise;
+
 import {formatResultsErrors} from 'jest-message-util';
 
 type Suite = {