ember-source 4.5.0-beta.1 → 4.6.0-alpha.3

package/dist/packages/ember-testing/lib/adapters/qunit.js

@@ -1,27 +1,18 @@
 /* globals QUnit */
 import { inspect } from '@ember/-internals/utils';
 import Adapter from './adapter';
-/**
-   @module ember
-*/
 
-/**
-  This class implements the methods defined by TestAdapter for the
-  QUnit testing framework.
+function isVeryOldQunit(obj) {
+  return obj != null && typeof obj.stop === 'function';
+}
 
-  @class QUnitAdapter
-  @namespace Ember.Test
-  @extends TestAdapter
-  @public
-*/
-
-export default Adapter.extend({
+const QUnitAdapter = Adapter.extend({
   init() {
     this.doneCallbacks = [];
   },
 
   asyncStart() {
-    if (typeof QUnit.stop === 'function') {
+    if (isVeryOldQunit(QUnit)) {
       // very old QUnit version
       // eslint-disable-next-line qunit/no-qunit-stop
       QUnit.stop();
@@ -34,7 +25,7 @@ export default Adapter.extend({
     // checking for QUnit.stop here (even though we _need_ QUnit.start) because
     // QUnit.start() still exists in QUnit 2.x (it just throws an error when calling
     // inside a test context)
-    if (typeof QUnit.stop === 'function') {
+    if (isVeryOldQunit(QUnit)) {
       QUnit.start();
     } else {
       let done = this.doneCallbacks.pop(); // This can be null if asyncStart() was called outside of a test
@@ -49,4 +40,5 @@ export default Adapter.extend({
     QUnit.config.current.assert.ok(false, inspect(error));
   }
 
-});
+});
+export default QUnitAdapter;

package/dist/packages/ember-testing/lib/ext/application.js

@@ -5,13 +5,14 @@ import TestPromise, { resolve, getLastPromise } from '../test/promise';
 import run from '../test/run';
 import { invokeInjectHelpersCallbacks } from '../test/on_inject_helpers';
 import { asyncStart, asyncEnd } from '../test/adapter';
+import { assert } from '@ember/debug';
 EmberApplication.reopen({
   /**
    This property contains the testing helpers for the current application. These
    are created once you call `injectTestHelpers` on your `Application`
    instance. The included helpers are also available on the `window` object by
    default, but can be used from this object on the individual application also.
-     @property testHelpers
+       @property testHelpers
     @type {Object}
     @default {}
     @public
@@ -21,9 +22,9 @@ EmberApplication.reopen({
   /**
    This property will contain the original methods that were registered
    on the `helperContainer` before `injectTestHelpers` is called.
-    When `removeTestHelpers` is called, these methods are restored to the
+      When `removeTestHelpers` is called, these methods are restored to the
    `helperContainer`.
-     @property originalMethods
+       @property originalMethods
     @type {Object}
     @default {}
     @private
@@ -35,7 +36,7 @@ EmberApplication.reopen({
   This property indicates whether or not this application is currently in
   testing mode. This is set when `setupForTesting` is called on the current
   application.
-   @property testing
+     @property testing
   @type {Boolean}
   @default false
   @since 1.3.0
@@ -50,11 +51,11 @@ EmberApplication.reopen({
     (preventing both accidental leaking of state between tests and interference
     with your testing framework). `setupForTesting` should only be called after
     setting a custom `router` class (for example `App.Router = Router.extend(`).
-     Example:
-     ```
+       Example:
+       ```
     App.setupForTesting();
     ```
-     @method setupForTesting
+       @method setupForTesting
     @public
   */
   setupForTesting() {
@@ -68,7 +69,7 @@ EmberApplication.reopen({
   /**
     This will be used as the container to inject the test helpers into. By
     default the helpers are injected into `window`.
-     @property helperContainer
+       @property helperContainer
     @type {Object} The object to be used for test helpers.
     @default window
     @since 1.2.0
@@ -82,13 +83,13 @@ EmberApplication.reopen({
     to `window`. If a function of the same name has already been defined it will be cached
     (so that it can be reset if the helper is removed with `unregisterHelper` or
     `removeTestHelpers`).
-     Any callbacks registered with `onInjectHelpers` will be called once the
+       Any callbacks registered with `onInjectHelpers` will be called once the
     helpers have been injected.
-     Example:
+       Example:
     ```
     App.injectTestHelpers();
     ```
-     @method injectTestHelpers
+       @method injectTestHelpers
     @public
   */
   injectTestHelpers(helperContainer) {
@@ -109,8 +110,11 @@ EmberApplication.reopen({
     this.testHelpers = {};
 
     for (let name in helpers) {
-      this.originalMethods[name] = this.helperContainer[name];
-      this.testHelpers[name] = this.helperContainer[name] = helper(this, name);
+      // SAFETY: It is safe to access a property on an object
+      this.originalMethods[name] = this.helperContainer[name]; // SAFETY: It is not quite as safe to do this, but it _seems_ to be ok.
+
+      this.testHelpers[name] = this.helperContainer[name] = helper(this, name); // SAFETY: We checked that it exists
+
       protoWrap(TestPromise.prototype, name, helper(this, name), helpers[name].meta.wait);
     }
 
@@ -120,11 +124,11 @@ EmberApplication.reopen({
   /**
     This removes all helpers that have been registered, and resets and functions
     that were overridden by the helpers.
-     Example:
-     ```javascript
+       Example:
+       ```javascript
     App.removeTestHelpers();
     ```
-     @public
+       @public
     @method removeTestHelpers
   */
   removeTestHelpers() {
@@ -133,7 +137,8 @@ EmberApplication.reopen({
     }
 
     for (let name in helpers) {
-      this.helperContainer[name] = this.originalMethods[name];
+      this.helperContainer[name] = this.originalMethods[name]; // SAFETY: This is a weird thing, but it's not technically unsafe here.
+
       delete TestPromise.prototype[name];
       delete this.testHelpers[name];
       delete this.originalMethods[name];
@@ -145,10 +150,12 @@ EmberApplication.reopen({
 // of helper chaining
 
 function protoWrap(proto, name, callback, isAsync) {
+  // SAFETY: This isn't entirely safe, but it _seems_ to be ok.
   proto[name] = function (...args) {
     if (isAsync) {
       return callback.apply(this, args);
     } else {
+      // SAFETY: This is not actually safe.
       return this.then(function () {
         return callback.apply(this, args);
       });
@@ -157,8 +164,10 @@ function protoWrap(proto, name, callback, isAsync) {
 }
 
 function helper(app, name) {
-  let fn = helpers[name].method;
-  let meta = helpers[name].meta;
+  let helper = helpers[name];
+  assert(`[BUG] Missing helper: ${name}`, helper);
+  let fn = helper.method;
+  let meta = helper.meta;
 
   if (!meta.wait) {
     return (...args) => fn.apply(app, [app, ...args]);

package/dist/packages/ember-testing/lib/helpers/and_then.js

@@ -1,3 +1,6 @@
+import { assert } from '@ember/debug';
 export default function andThen(app, callback) {
-  return app.testHelpers.wait(callback(app));
+  let wait = app.testHelpers['wait'];
+  assert('[BUG] Missing wait helper', wait);
+  return wait(callback(app));
 }

package/dist/packages/ember-testing/lib/helpers/current_path.js

@@ -2,6 +2,8 @@
 @module ember
 */
 import { get } from '@ember/-internals/metal';
+import { RoutingService } from '@ember/-internals/routing';
+import { assert } from '@ember/debug';
 /**
   Returns the current path.
 
@@ -22,7 +24,10 @@ click('#some-link-id').then(validateURL);
 */
 
 export default function currentPath(app) {
+  assert('[BUG] app.__container__ is not set', app.__container__);
+
   let routingService = app.__container__.lookup('service:-routing');
 
+  assert('[BUG] service:-routing is not a RoutingService', routingService instanceof RoutingService);
   return get(routingService, 'currentPath');
 }

package/dist/packages/ember-testing/lib/helpers/current_route_name.js

@@ -2,6 +2,8 @@
 @module ember
 */
 import { get } from '@ember/-internals/metal';
+import { RoutingService } from '@ember/-internals/routing';
+import { assert } from '@ember/debug';
 /**
   Returns the currently active route name.
 
@@ -21,7 +23,10 @@ visit('/some/path').then(validateRouteName)
 */
 
 export default function currentRouteName(app) {
+  assert('[BUG] app.__container__ is not set', app.__container__);
+
   let routingService = app.__container__.lookup('service:-routing');
 
+  assert('[BUG] service:-routing is not a RoutingService', routingService instanceof RoutingService);
   return get(routingService, 'currentRouteName');
 }

package/dist/packages/ember-testing/lib/helpers/current_url.js

@@ -2,6 +2,8 @@
 @module ember
 */
 import { get } from '@ember/-internals/metal';
+import { assert } from '@ember/debug';
+import Router from '@ember/routing/router';
 /**
   Returns the current URL.
 
@@ -22,7 +24,12 @@ click('#some-link-id').then(validateURL);
 */
 
 export default function currentURL(app) {
+  assert('[BUG] app.__container__ is not set', app.__container__);
+
   let router = app.__container__.lookup('router:main');
 
-  return get(router, 'location').getURL();
+  assert('[BUG] router:main is not a Router', router instanceof Router);
+  let location = get(router, 'location');
+  assert('[BUG] location is still a string', typeof location !== 'string');
+  return location.getURL();
 }

package/dist/packages/ember-testing/lib/helpers/visit.js

@@ -1,3 +1,5 @@
+import { assert } from '@ember/debug';
+import Router from '@ember/routing/router';
 import { run } from '@ember/runloop';
 /**
   Loads a route, sets up any controllers, and renders any templates associated
@@ -19,18 +21,24 @@ import { run } from '@ember/runloop';
 */
 
 export default function visit(app, url) {
-  let router = app.__container__.lookup('router:main');
+  assert('[BUG] Missing container', app.__container__);
 
+  const router = app.__container__.lookup('router:main');
+
+  assert('[BUG] router:main is not a Router', router instanceof Router);
   let shouldHandleURL = false;
   app.boot().then(() => {
+    assert('[BUG] router.location is still a string', typeof router.location !== 'string');
     router.location.setURL(url);
 
     if (shouldHandleURL) {
+      assert("[BUG] __deprecatedInstance__ isn't set", app.__deprecatedInstance__);
       run(app.__deprecatedInstance__, 'handleURL', url);
     }
   });
 
   if (app._readinessDeferrals > 0) {
+    // SAFETY: This should be safe, though it is odd.
     router.initialURL = url;
     run(app, 'advanceReadiness');
     delete router.initialURL;
@@ -38,5 +46,7 @@ export default function visit(app, url) {
     shouldHandleURL = true;
   }
 
-  return app.testHelpers.wait();
+  let wait = app.testHelpers['wait'];
+  assert('[BUG] missing wait helper', wait);
+  return wait();
 }

package/dist/packages/ember-testing/lib/helpers/wait.js

@@ -5,6 +5,8 @@ import { checkWaiters } from '../test/waiters';
 import { RSVP } from '@ember/-internals/runtime';
 import { _getCurrentRunLoop, _hasScheduledTimers, run } from '@ember/runloop';
 import { pendingRequests } from '../test/pending_requests';
+import { assert } from '@ember/debug';
+import Router from '@ember/routing/router';
 /**
   Causes the run loop to process any pending events. This is used to ensure that
   any async operations from other helpers (or your assertions) have been processed.
@@ -38,8 +40,11 @@ import { pendingRequests } from '../test/pending_requests';
 
 export default function wait(app, value) {
   return new RSVP.Promise(function (resolve) {
-    let router = app.__container__.lookup('router:main'); // Every 10ms, poll for the async thing to have finished
+    assert('[BUG] Missing container', app.__container__);
 
+    const router = app.__container__.lookup('router:main');
+
+    assert('[BUG] Expected router:main to be a subclass of Ember Router', router instanceof Router); // Every 10ms, poll for the async thing to have finished
 
     let watcher = setInterval(() => {
       // 1. If the router is loading, keep polling

package/dist/packages/ember-testing/lib/initializers.js

@@ -1,8 +1,8 @@
 import { onLoad } from '@ember/application';
 let name = 'deferReadiness in `testing` mode';
-onLoad('Ember.Application', function (Application) {
-  if (!Application.initializers[name]) {
-    Application.initializer({
+onLoad('Ember.Application', function (ApplicationClass) {
+  if (!ApplicationClass.initializers[name]) {
+    ApplicationClass.initializer({
       name: name,
 
       initialize(application) {

package/dist/packages/ember-testing/lib/test/adapter.js

@@ -24,6 +24,7 @@ export function asyncEnd() {
 }
 
 function adapterDispatch(error) {
-  adapter.exception(error);
+  adapter.exception(error); // @ts-expect-error Normally unreachable
+
   console.error(error.stack); // eslint-disable-line no-console
 }

package/dist/packages/ember-testing/lib/test/helpers.js

@@ -124,6 +124,8 @@ export function registerAsyncHelper(name, helperMethod) {
 */
 
 export function unregisterHelper(name) {
-  delete helpers[name];
+  delete helpers[name]; // SAFETY: This isn't necessarily a safe thing to do, but in terms of the immediate types here
+  // it won't error.
+
   delete TestPromise.prototype[name];
 }

package/dist/packages/ember-testing/lib/test/on_inject_helpers.js

@@ -31,7 +31,7 @@ export function onInjectHelpers(callback) {
   callbacks.push(callback);
 }
 export function invokeInjectHelpersCallbacks(app) {
-  for (let i = 0; i < callbacks.length; i++) {
-    callbacks[i](app);
+  for (let callback of callbacks) {
+    callback(app);
   }
 }

package/dist/packages/ember-testing/lib/test/promise.js

@@ -1,15 +1,15 @@
 import { RSVP } from '@ember/-internals/runtime';
 import run from './run';
-let lastPromise;
+let lastPromise = null;
 export default class TestPromise extends RSVP.Promise {
-  constructor() {
-    super(...arguments);
+  constructor(executor, label) {
+    super(executor, label);
     lastPromise = this;
   }
 
-  then(_onFulfillment, ...args) {
-    let onFulfillment = typeof _onFulfillment === 'function' ? result => isolate(_onFulfillment, result) : undefined;
-    return super.then(onFulfillment, ...args);
+  then(onFulfilled, onRejected, label) {
+    let normalizedOnFulfilled = typeof onFulfilled === 'function' ? result => isolate(onFulfilled, result) : undefined;
+    return super.then(normalizedOnFulfilled, onRejected, label);
   }
 
 }
@@ -55,10 +55,10 @@ export function getLastPromise() {
 // 2. Invoke method
 // 3. Return the last promise created during method
 
-function isolate(onFulfillment, result) {
+function isolate(onFulfilled, result) {
   // Reset lastPromise for nested helpers
   lastPromise = null;
-  let value = onFulfillment(result);
+  let value = onFulfilled(result);
   let promise = lastPromise;
   lastPromise = null; // If the method returned a promise
   // return that promise. If not,

package/dist/packages/ember-testing/lib/test/waiters.js

@@ -3,55 +3,24 @@
 */
 const contexts = [];
 const callbacks = [];
-/**
-   This allows ember-testing to play nicely with other asynchronous
-   events, such as an application that is waiting for a CSS3
-   transition or an IndexDB transaction. The waiter runs periodically
-   after each async helper (i.e. `click`, `andThen`, `visit`, etc) has executed,
-   until the returning result is truthy. After the waiters finish, the next async helper
-   is executed and the process repeats.
-
-   For example:
-
-   ```javascript
-   import { registerWaiter } from '@ember/test';
-
-   registerWaiter(function() {
-     return myPendingTransactions() === 0;
-   });
-   ```
-   The `context` argument allows you to optionally specify the `this`
-   with which your callback will be invoked.
-
-   For example:
-
-   ```javascript
-   import { registerWaiter } from '@ember/test';
-
-   registerWaiter(MyDB, MyDB.hasPendingTransactions);
-   ```
-
-   @public
-   @for @ember/test
-   @static
-   @method registerWaiter
-   @param {Object} context (optional)
-   @param {Function} callback
-   @since 1.2.0
-*/
-
-export function registerWaiter(context, callback) {
-  if (arguments.length === 1) {
-    callback = context;
-    context = null;
+export function registerWaiter(...args) {
+  let checkedCallback;
+  let checkedContext;
+
+  if (args.length === 1) {
+    checkedContext = null;
+    checkedCallback = args[0];
+  } else {
+    checkedContext = args[0];
+    checkedCallback = args[1];
   }
 
-  if (indexOf(context, callback) > -1) {
+  if (indexOf(checkedContext, checkedCallback) > -1) {
     return;
   }
 
-  contexts.push(context);
-  callbacks.push(callback);
+  contexts.push(checkedContext);
+  callbacks.push(checkedCallback);
 }
 /**
    `unregisterWaiter` is used to unregister a callback that was
@@ -106,7 +75,7 @@ export function checkWaiters() {
 
   for (let i = 0; i < callbacks.length; i++) {
     let context = contexts[i];
-    let callback = callbacks[i];
+    let callback = callbacks[i]; // SAFETY: The loop ensures that this exists
 
     if (!callback.call(context)) {
       return true;

package/dist/packages/ember-testing/lib/test.js

@@ -22,7 +22,7 @@ import { getAdapter, setAdapter } from './test/adapter';
 const Test = {
   /**
     Hash containing all known test helpers.
-     @property _helpers
+       @property _helpers
     @private
     @since 1.7.0
   */