discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-testing/tests/ext/rsvp_test.js

@@ -1,124 +0,0 @@
-import RSVP from '../../lib/ext/rsvp';
-import { getAdapter, setAdapter } from '../../lib/test/adapter';
-import TestPromise, { getLastPromise } from '../../lib/test/promise';
-import { getCurrentRunLoop } from '@ember/runloop';
-import { isTesting, setTesting } from '@ember/debug';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-const originalTestAdapter = getAdapter();
-const originalTestingFlag = isTesting();
-
-let asyncStarted = 0;
-let asyncEnded = 0;
-
-moduleFor(
-  'ember-testing RSVP',
-  class extends AbstractTestCase {
-    constructor() {
-      super();
-      setTesting(true);
-      setAdapter({
-        asyncStart() {
-          asyncStarted++;
-        },
-        asyncEnd() {
-          asyncEnded++;
-        },
-      });
-    }
-
-    teardown() {
-      asyncStarted = 0;
-      asyncEnded = 0;
-      setAdapter(originalTestAdapter);
-      setTesting(originalTestingFlag);
-    }
-
-    ['@test given `Ember.testing = true`, correctly informs the test suite about async steps'](
-      assert
-    ) {
-      let done = assert.async();
-      assert.expect(19);
-
-      assert.ok(!getCurrentRunLoop(), 'expect no run-loop');
-
-      setTesting(true);
-
-      assert.equal(asyncStarted, 0);
-      assert.equal(asyncEnded, 0);
-
-      let user = RSVP.Promise.resolve({ name: 'tomster' });
-
-      assert.equal(asyncStarted, 0);
-      assert.equal(asyncEnded, 0);
-
-      user
-        .then(function(user) {
-          assert.equal(asyncStarted, 1);
-          assert.equal(asyncEnded, 1);
-
-          assert.equal(user.name, 'tomster');
-
-          return RSVP.Promise.resolve(1).then(function() {
-            assert.equal(asyncStarted, 1);
-            assert.equal(asyncEnded, 1);
-          });
-        })
-        .then(function() {
-          assert.equal(asyncStarted, 1);
-          assert.equal(asyncEnded, 1);
-
-          return new RSVP.Promise(function(resolve) {
-            setTimeout(function() {
-              assert.equal(asyncStarted, 1);
-              assert.equal(asyncEnded, 1);
-
-              resolve({ name: 'async tomster' });
-
-              assert.equal(asyncStarted, 2);
-              assert.equal(asyncEnded, 1);
-            }, 0);
-          });
-        })
-        .then(function(user) {
-          assert.equal(user.name, 'async tomster');
-          assert.equal(asyncStarted, 2);
-          assert.equal(asyncEnded, 2);
-          done();
-        });
-    }
-  }
-);
-
-moduleFor(
-  'TestPromise',
-  class extends AbstractTestCase {
-    ['does not throw error when falsy value passed to then'](assert) {
-      assert.expect(1);
-      return new TestPromise(function(resolve) {
-        resolve();
-      })
-        .then(null)
-        .then(function() {
-          assert.ok(true);
-        });
-    }
-
-    ['able to get last Promise'](assert) {
-      assert.expect(2);
-
-      var p1 = new TestPromise(function(resolve) {
-        resolve();
-      }).then(function() {
-        assert.ok(true);
-      });
-
-      var p2 = new TestPromise(function(resolve) {
-        resolve();
-      });
-
-      assert.deepEqual(getLastPromise(), p2);
-      return p1;
-    }
-  }
-);

data/dist/es/ember-testing/tests/helper_registration_test.js

@@ -1,98 +0,0 @@
-import { run } from '@ember/runloop';
-import Test from '../lib/test';
-import EmberApplication from '@ember/application';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-var App, appBooted, helperContainer;
-
-function registerHelper() {
-  Test.registerHelper('boot', function(app) {
-    run(app, app.advanceReadiness);
-    appBooted = true;
-    return app.testHelpers.wait();
-  });
-}
-
-function unregisterHelper() {
-  Test.unregisterHelper('boot');
-}
-
-var originalAdapter = Test.adapter;
-
-function setupApp() {
-  appBooted = false;
-  helperContainer = {};
-
-  run(function() {
-    App = EmberApplication.create();
-    App.setupForTesting();
-    App.injectTestHelpers(helperContainer);
-  });
-}
-
-function destroyApp() {
-  if (App) {
-    run(App, 'destroy');
-    App = null;
-    helperContainer = null;
-  }
-}
-
-moduleFor(
-  'Test - registerHelper/unregisterHelper',
-  class extends AbstractTestCase {
-    teardown() {
-      Test.adapter = originalAdapter;
-      destroyApp();
-    }
-
-    ['@test Helper gets registered'](assert) {
-      assert.expect(2);
-
-      registerHelper();
-      setupApp();
-
-      assert.ok(App.testHelpers.boot);
-      assert.ok(helperContainer.boot);
-    }
-
-    ['@test Helper is ran when called'](assert) {
-      let done = assert.async();
-      assert.expect(1);
-
-      registerHelper();
-      setupApp();
-
-      App.testHelpers
-        .boot()
-        .then(function() {
-          assert.ok(appBooted);
-        })
-        .finally(done);
-    }
-
-    ['@test Helper can be unregistered'](assert) {
-      assert.expect(4);
-
-      registerHelper();
-      setupApp();
-
-      assert.ok(App.testHelpers.boot);
-      assert.ok(helperContainer.boot);
-
-      unregisterHelper();
-
-      run(App, 'destroy');
-      setupApp();
-
-      assert.ok(
-        !App.testHelpers.boot,
-        'once unregistered the helper is not added to App.testHelpers'
-      );
-      assert.ok(
-        !helperContainer.boot,
-        'once unregistered the helper is not added to the helperContainer'
-      );
-    }
-  }
-);

data/dist/es/ember-testing/tests/helpers_test.js

@@ -1,1228 +0,0 @@
-import { moduleFor, AutobootApplicationTestCase, isIE11 } from 'internal-test-helpers';
-
-import { Route } from 'ember-routing';
-import Controller from '@ember/controller';
-import { RSVP } from 'ember-runtime';
-import { later } from '@ember/runloop';
-import { Component } from 'ember-glimmer';
-import { jQueryDisabled, jQuery } from 'ember-views';
-
-import Test from '../lib/test';
-import setupForTesting from '../lib/setup_for_testing';
-
-import {
-  pendingRequests,
-  incrementPendingRequests,
-  decrementPendingRequests,
-  clearPendingRequests,
-} from '../lib/test/pending_requests';
-import { setAdapter, getAdapter } from '../lib/test/adapter';
-import { registerWaiter, unregisterWaiter } from '../lib/test/waiters';
-import { getDebugFunction, setDebugFunction } from '@ember/debug';
-
-var originalInfo = getDebugFunction('info');
-var noop = function() {};
-
-function registerHelper() {
-  Test.registerHelper('LeakyMcLeakLeak', () => {});
-}
-
-function assertHelpers(assert, application, helperContainer, expected) {
-  if (!helperContainer) {
-    helperContainer = window;
-  }
-  if (expected === undefined) {
-    expected = true;
-  }
-
-  function checkHelperPresent(helper, expected) {
-    var presentInHelperContainer = !!helperContainer[helper];
-    var presentInTestHelpers = !!application.testHelpers[helper];
-
-    assert.ok(
-      presentInHelperContainer === expected,
-      "Expected '" + helper + "' to be present in the helper container (defaults to window)."
-    );
-    assert.ok(
-      presentInTestHelpers === expected,
-      "Expected '" + helper + "' to be present in App.testHelpers."
-    );
-  }
-
-  checkHelperPresent('visit', expected);
-  checkHelperPresent('click', expected);
-  checkHelperPresent('keyEvent', expected);
-  checkHelperPresent('fillIn', expected);
-  checkHelperPresent('wait', expected);
-  checkHelperPresent('triggerEvent', expected);
-}
-
-function assertNoHelpers(assert, application, helperContainer) {
-  assertHelpers(assert, application, helperContainer, false);
-}
-
-class HelpersTestCase extends AutobootApplicationTestCase {
-  constructor() {
-    super();
-    this._originalAdapter = getAdapter();
-  }
-
-  teardown() {
-    setAdapter(this._originalAdapter);
-    document.removeEventListener('ajaxSend', incrementPendingRequests);
-    document.removeEventListener('ajaxComplete', decrementPendingRequests);
-    clearPendingRequests();
-    if (this.application) {
-      this.application.removeTestHelpers();
-    }
-    super.teardown();
-  }
-}
-
-class HelpersApplicationTestCase extends HelpersTestCase {
-  constructor() {
-    super();
-    this.runTask(() => {
-      this.createApplication();
-      this.application.setupForTesting();
-      this.application.injectTestHelpers();
-    });
-  }
-}
-
-if (!jQueryDisabled) {
-  moduleFor(
-    'ember-testing: Helper setup',
-    class extends HelpersTestCase {
-      [`@test Ember.Application#injectTestHelpers/#removeTestHelper`](assert) {
-        this.runTask(() => {
-          this.createApplication();
-        });
-
-        assertNoHelpers(assert, this.application);
-
-        registerHelper();
-
-        this.application.injectTestHelpers();
-
-        assertHelpers(assert, this.application);
-
-        assert.ok(Test.Promise.prototype.LeakyMcLeakLeak, 'helper in question SHOULD be present');
-
-        this.application.removeTestHelpers();
-
-        assertNoHelpers(assert, this.application);
-
-        assert.equal(
-          Test.Promise.prototype.LeakyMcLeakLeak,
-          undefined,
-          'should NOT leak test promise extensions'
-        );
-      }
-
-      [`@test Ember.Application#setupForTesting`](assert) {
-        this.runTask(() => {
-          this.createApplication();
-          this.application.setupForTesting();
-        });
-
-        let routerInstance = this.applicationInstance.lookup('router:main');
-        assert.equal(routerInstance.location, 'none');
-      }
-
-      [`@test Ember.Application.setupForTesting sets the application to 'testing'`](assert) {
-        this.runTask(() => {
-          this.createApplication();
-          this.application.setupForTesting();
-        });
-
-        assert.equal(this.application.testing, true, 'Application instance is set to testing.');
-      }
-
-      [`@test Ember.Application.setupForTesting leaves the system in a deferred state.`](assert) {
-        this.runTask(() => {
-          this.createApplication();
-          this.application.setupForTesting();
-        });
-
-        assert.equal(
-          this.application._readinessDeferrals,
-          1,
-          'App is in deferred state after setupForTesting.'
-        );
-      }
-
-      [`@test App.reset() after Application.setupForTesting leaves the system in a deferred state.`](
-        assert
-      ) {
-        this.runTask(() => {
-          this.createApplication();
-          this.application.setupForTesting();
-        });
-
-        assert.equal(
-          this.application._readinessDeferrals,
-          1,
-          'App is in deferred state after setupForTesting.'
-        );
-
-        this.application.reset();
-
-        assert.equal(
-          this.application._readinessDeferrals,
-          1,
-          'App is in deferred state after setupForTesting.'
-        );
-      }
-
-      [`@test Ember.Application#injectTestHelpers calls callbacks registered with onInjectHelpers`](
-        assert
-      ) {
-        let injected = 0;
-
-        Test.onInjectHelpers(() => {
-          injected++;
-        });
-
-        // bind(this) so Babel doesn't leak _this
-        // into the context onInjectHelpers.
-        this.runTask(
-          function() {
-            this.createApplication();
-            this.application.setupForTesting();
-          }.bind(this)
-        );
-
-        assert.equal(injected, 0, 'onInjectHelpers are not called before injectTestHelpers');
-
-        this.application.injectTestHelpers();
-
-        assert.equal(injected, 1, 'onInjectHelpers are called after injectTestHelpers');
-      }
-
-      [`@test Ember.Application#injectTestHelpers adds helpers to provided object.`](assert) {
-        let helpers = {};
-
-        this.runTask(() => {
-          this.createApplication();
-          this.application.setupForTesting();
-        });
-
-        this.application.injectTestHelpers(helpers);
-
-        assertHelpers(assert, this.application, helpers);
-
-        this.application.removeTestHelpers();
-
-        assertNoHelpers(assert, this.application, helpers);
-      }
-
-      [`@test Ember.Application#removeTestHelpers resets the helperContainer\'s original values`](
-        assert
-      ) {
-        let helpers = { visit: 'snazzleflabber' };
-
-        this.runTask(() => {
-          this.createApplication();
-          this.application.setupForTesting();
-        });
-
-        this.application.injectTestHelpers(helpers);
-
-        assert.notEqual(helpers.visit, 'snazzleflabber', 'helper added to container');
-        this.application.removeTestHelpers();
-
-        assert.equal(helpers.visit, 'snazzleflabber', 'original value added back to container');
-      }
-    }
-  );
-
-  moduleFor(
-    'ember-testing: Helper methods',
-    class extends HelpersApplicationTestCase {
-      [`@test 'wait' respects registerWaiters`](assert) {
-        assert.expect(3);
-
-        let counter = 0;
-        function waiter() {
-          return ++counter > 2;
-        }
-
-        let other = 0;
-        function otherWaiter() {
-          return ++other > 2;
-        }
-
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-
-        registerWaiter(waiter);
-        registerWaiter(otherWaiter);
-
-        let { application: { testHelpers } } = this;
-        return testHelpers
-          .wait()
-          .then(() => {
-            assert.equal(waiter(), true, 'should not resolve until our waiter is ready');
-            unregisterWaiter(waiter);
-            counter = 0;
-            return testHelpers.wait();
-          })
-          .then(() => {
-            assert.equal(counter, 0, 'unregistered waiter was not checked');
-            assert.equal(otherWaiter(), true, 'other waiter is still registered');
-          })
-          .finally(() => {
-            unregisterWaiter(otherWaiter);
-          });
-      }
-
-      [`@test 'visit' advances readiness.`](assert) {
-        assert.expect(2);
-
-        assert.equal(
-          this.application._readinessDeferrals,
-          1,
-          'App is in deferred state after setupForTesting.'
-        );
-
-        return this.application.testHelpers.visit('/').then(() => {
-          assert.equal(
-            this.application._readinessDeferrals,
-            0,
-            `App's readiness was advanced by visit.`
-          );
-        });
-      }
-
-      [`@test 'wait' helper can be passed a resolution value`](assert) {
-        assert.expect(4);
-
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-
-        let promiseObjectValue = {};
-        let objectValue = {};
-        let { application: { testHelpers } } = this;
-        return testHelpers
-          .wait('text')
-          .then(val => {
-            assert.equal(val, 'text', 'can resolve to a string');
-            return testHelpers.wait(1);
-          })
-          .then(val => {
-            assert.equal(val, 1, 'can resolve to an integer');
-            return testHelpers.wait(objectValue);
-          })
-          .then(val => {
-            assert.equal(val, objectValue, 'can resolve to an object');
-            return testHelpers.wait(RSVP.resolve(promiseObjectValue));
-          })
-          .then(val => {
-            assert.equal(val, promiseObjectValue, 'can resolve to a promise resolution value');
-          });
-      }
-
-      [`@test 'click' triggers appropriate events in order`](assert) {
-        assert.expect(5);
-
-        this.add(
-          'component:index-wrapper',
-          Component.extend({
-            classNames: 'index-wrapper',
-
-            didInsertElement() {
-              let wrapper = document.querySelector('.index-wrapper');
-              wrapper.addEventListener('mousedown', e => events.push(e.type));
-              wrapper.addEventListener('mouseup', e => events.push(e.type));
-              wrapper.addEventListener('click', e => events.push(e.type));
-              wrapper.addEventListener('focusin', e => {
-                // IE11 _sometimes_ triggers focusin **twice** in a row
-                // (we believe this is when it is under higher load)
-                //
-                // the goal here is to only push a single focusin when running on
-                // IE11
-                if (isIE11) {
-                  if (events[events.length - 1] !== 'focusin') {
-                    events.push(e.type);
-                  }
-                } else {
-                  events.push(e.type);
-                }
-              });
-            },
-          })
-        );
-
-        this.add(
-          'component:x-checkbox',
-          Component.extend({
-            tagName: 'input',
-            attributeBindings: ['type'],
-            type: 'checkbox',
-            click() {
-              events.push('click:' + this.get('checked'));
-            },
-            change() {
-              events.push('change:' + this.get('checked'));
-            },
-          })
-        );
-
-        this.addTemplate(
-          'index',
-          `
-        {{#index-wrapper}}
-          {{input type="text"}}
-          {{x-checkbox type="checkbox"}}
-          {{textarea}}
-          <div contenteditable="true"> </div>
-        {{/index-wrapper}}'));
-      `
-        );
-
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-
-        let events;
-        let { application: { testHelpers } } = this;
-        return testHelpers
-          .wait()
-          .then(() => {
-            events = [];
-            return testHelpers.click('.index-wrapper');
-          })
-          .then(() => {
-            assert.deepEqual(events, ['mousedown', 'mouseup', 'click'], 'fires events in order');
-          })
-          .then(() => {
-            events = [];
-            return testHelpers.click('.index-wrapper input[type=text]');
-          })
-          .then(() => {
-            assert.deepEqual(
-              events,
-              ['mousedown', 'focusin', 'mouseup', 'click'],
-              'fires focus events on inputs'
-            );
-          })
-          .then(() => {
-            events = [];
-            return testHelpers.click('.index-wrapper textarea');
-          })
-          .then(() => {
-            assert.deepEqual(
-              events,
-              ['mousedown', 'focusin', 'mouseup', 'click'],
-              'fires focus events on textareas'
-            );
-          })
-          .then(() => {
-            events = [];
-            return testHelpers.click('.index-wrapper div');
-          })
-          .then(() => {
-            assert.deepEqual(
-              events,
-              ['mousedown', 'focusin', 'mouseup', 'click'],
-              'fires focus events on contenteditable'
-            );
-          })
-          .then(() => {
-            events = [];
-            return testHelpers.click('.index-wrapper input[type=checkbox]');
-          })
-          .then(() => {
-            // i.e. mousedown, mouseup, change:true, click, click:true
-            // Firefox differs so we can't assert the exact ordering here.
-            // See https://bugzilla.mozilla.org/show_bug.cgi?id=843554.
-            assert.equal(events.length, 5, 'fires click and change on checkboxes');
-          });
-      }
-
-      [`@test 'click' triggers native events with simulated X/Y coordinates`](assert) {
-        assert.expect(15);
-
-        this.add(
-          'component:index-wrapper',
-          Component.extend({
-            classNames: 'index-wrapper',
-
-            didInsertElement() {
-              let pushEvent = e => events.push(e);
-              this.element.addEventListener('mousedown', pushEvent);
-              this.element.addEventListener('mouseup', pushEvent);
-              this.element.addEventListener('click', pushEvent);
-            },
-          })
-        );
-
-        this.addTemplate(
-          'index',
-          `
-        {{#index-wrapper}}some text{{/index-wrapper}}
-      `
-        );
-
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-
-        let events;
-        let { application: { testHelpers: { wait, click } } } = this;
-        return wait()
-          .then(() => {
-            events = [];
-            return click('.index-wrapper');
-          })
-          .then(() => {
-            events.forEach(e => {
-              assert.ok(e instanceof window.Event, 'The event is an instance of MouseEvent');
-              assert.ok(typeof e.screenX === 'number', 'screenX is correct');
-              assert.ok(typeof e.screenY === 'number', 'screenY is correct');
-              assert.ok(typeof e.clientX === 'number', 'clientX is correct');
-              assert.ok(typeof e.clientY === 'number', 'clientY is correct');
-            });
-          });
-      }
-
-      [`@test 'triggerEvent' with mouseenter triggers native events with simulated X/Y coordinates`](
-        assert
-      ) {
-        assert.expect(5);
-
-        let evt;
-        this.add(
-          'component:index-wrapper',
-          Component.extend({
-            classNames: 'index-wrapper',
-            didInsertElement() {
-              this.element.addEventListener('mouseenter', e => (evt = e));
-            },
-          })
-        );
-
-        this.addTemplate('index', `{{#index-wrapper}}some text{{/index-wrapper}}`);
-
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-
-        let { application: { testHelpers: { wait, triggerEvent } } } = this;
-        return wait()
-          .then(() => {
-            return triggerEvent('.index-wrapper', 'mouseenter');
-          })
-          .then(() => {
-            assert.ok(evt instanceof window.Event, 'The event is an instance of MouseEvent');
-            assert.ok(typeof evt.screenX === 'number', 'screenX is correct');
-            assert.ok(typeof evt.screenY === 'number', 'screenY is correct');
-            assert.ok(typeof evt.clientX === 'number', 'clientX is correct');
-            assert.ok(typeof evt.clientY === 'number', 'clientY is correct');
-          });
-      }
-
-      [`@test 'wait' waits for outstanding timers`](assert) {
-        assert.expect(1);
-
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-
-        let waitDone = false;
-        later(() => {
-          waitDone = true;
-        }, 20);
-
-        return this.application.testHelpers.wait().then(() => {
-          assert.equal(waitDone, true, 'should wait for the timer to be fired.');
-        });
-      }
-
-      [`@test 'wait' respects registerWaiters with optional context`](assert) {
-        assert.expect(3);
-
-        let obj = {
-          counter: 0,
-          ready() {
-            return ++this.counter > 2;
-          },
-        };
-
-        let other = 0;
-        function otherWaiter() {
-          return ++other > 2;
-        }
-
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-
-        registerWaiter(obj, obj.ready);
-        registerWaiter(otherWaiter);
-
-        let { application: { testHelpers: { wait } } } = this;
-        return wait()
-          .then(() => {
-            assert.equal(obj.ready(), true, 'should not resolve until our waiter is ready');
-            unregisterWaiter(obj, obj.ready);
-            obj.counter = 0;
-            return wait();
-          })
-          .then(() => {
-            assert.equal(obj.counter, 0, 'the unregistered waiter should still be at 0');
-            assert.equal(otherWaiter(), true, 'other waiter should still be registered');
-          })
-          .finally(() => {
-            unregisterWaiter(otherWaiter);
-          });
-      }
-
-      [`@test 'wait' does not error if routing has not begun`](assert) {
-        assert.expect(1);
-
-        return this.application.testHelpers.wait().then(() => {
-          assert.ok(true, 'should not error without `visit`');
-        });
-      }
-
-      [`@test 'triggerEvent' accepts an optional options hash without context`](assert) {
-        assert.expect(3);
-
-        let event;
-        this.add(
-          'component:index-wrapper',
-          Component.extend({
-            didInsertElement() {
-              let domElem = document.querySelector('.input');
-              domElem.addEventListener('change', e => (event = e));
-              domElem.addEventListener('keydown', e => (event = e));
-            },
-          })
-        );
-
-        this.addTemplate('index', `{{index-wrapper}}`);
-        this.addTemplate(
-          'components/index-wrapper',
-          `
-        {{input type="text" id="scope" class="input"}}
-      `
-        );
-
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-
-        let { application: { testHelpers: { wait, triggerEvent } } } = this;
-        return wait()
-          .then(() => {
-            return triggerEvent('.input', 'keydown', { keyCode: 13 });
-          })
-          .then(() => {
-            assert.equal(event.keyCode, 13, 'options were passed');
-            assert.equal(event.type, 'keydown', 'correct event was triggered');
-            assert.equal(
-              event.target.getAttribute('id'),
-              'scope',
-              'triggered on the correct element'
-            );
-          });
-      }
-
-      [`@test 'triggerEvent' can limit searching for a selector to a scope`](assert) {
-        assert.expect(2);
-
-        let event;
-        this.add(
-          'component:index-wrapper',
-          Component.extend({
-            didInsertElement() {
-              let firstInput = document.querySelector('.input');
-              firstInput.addEventListener('blur', e => (event = e));
-              firstInput.addEventListener('change', e => (event = e));
-              let secondInput = document.querySelector('#limited .input');
-              secondInput.addEventListener('blur', e => (event = e));
-              secondInput.addEventListener('change', e => (event = e));
-            },
-          })
-        );
-
-        this.addTemplate(
-          'components/index-wrapper',
-          `
-        {{input type="text" id="outside-scope" class="input"}}
-        <div id="limited">
-          {{input type="text" id="inside-scope" class="input"}}
-        </div>
-      `
-        );
-        this.addTemplate('index', `{{index-wrapper}}`);
-
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-
-        let { application: { testHelpers: { wait, triggerEvent } } } = this;
-        return wait()
-          .then(() => {
-            return triggerEvent('.input', '#limited', 'blur');
-          })
-          .then(() => {
-            assert.equal(event.type, 'blur', 'correct event was triggered');
-            assert.equal(
-              event.target.getAttribute('id'),
-              'inside-scope',
-              'triggered on the correct element'
-            );
-          });
-      }
-
-      [`@test 'triggerEvent' can be used to trigger arbitrary events`](assert) {
-        assert.expect(2);
-
-        let event;
-        this.add(
-          'component:index-wrapper',
-          Component.extend({
-            didInsertElement() {
-              let foo = document.getElementById('foo');
-              foo.addEventListener('blur', e => (event = e));
-              foo.addEventListener('change', e => (event = e));
-            },
-          })
-        );
-
-        this.addTemplate(
-          'components/index-wrapper',
-          `
-        {{input type="text" id="foo"}}
-      `
-        );
-        this.addTemplate('index', `{{index-wrapper}}`);
-
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-
-        let { application: { testHelpers: { wait, triggerEvent } } } = this;
-        return wait()
-          .then(() => {
-            return triggerEvent('#foo', 'blur');
-          })
-          .then(() => {
-            assert.equal(event.type, 'blur', 'correct event was triggered');
-            assert.equal(
-              event.target.getAttribute('id'),
-              'foo',
-              'triggered on the correct element'
-            );
-          });
-      }
-
-      [`@test 'fillIn' takes context into consideration`](assert) {
-        assert.expect(2);
-
-        this.addTemplate(
-          'index',
-          `
-        <div id="parent">
-          {{input type="text" id="first" class="current"}}
-        </div>
-        {{input type="text" id="second" class="current"}}
-      `
-        );
-
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-
-        let { application: { testHelpers: { visit, fillIn, andThen, find } } } = this;
-        visit('/');
-        fillIn('.current', '#parent', 'current value');
-
-        return andThen(() => {
-          assert.equal(find('#first')[0].value, 'current value');
-          assert.equal(find('#second')[0].value, '');
-        });
-      }
-
-      [`@test 'fillIn' focuses on the element`](assert) {
-        let wasFocused = false;
-
-        this.add(
-          'controller:index',
-          Controller.extend({
-            actions: {
-              wasFocused() {
-                wasFocused = true;
-              },
-            },
-          })
-        );
-
-        this.addTemplate(
-          'index',
-          `
-        <div id="parent">
-          {{input type="text" id="first" focus-in=(action "wasFocused")}}
-        </div>'
-      `
-        );
-
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-
-        let { application: { testHelpers: { visit, fillIn, andThen, find, wait } } } = this;
-        visit('/');
-        fillIn('#first', 'current value');
-        andThen(() => {
-          assert.ok(wasFocused, 'focusIn event was triggered');
-
-          assert.equal(find('#first')[0].value, 'current value');
-        });
-
-        return wait();
-      }
-
-      [`@test 'fillIn' fires 'input' and 'change' events in the proper order`](assert) {
-        assert.expect(1);
-
-        let events = [];
-        this.add(
-          'controller:index',
-          Controller.extend({
-            actions: {
-              oninputHandler(e) {
-                events.push(e.type);
-              },
-              onchangeHandler(e) {
-                events.push(e.type);
-              },
-            },
-          })
-        );
-
-        this.addTemplate(
-          'index',
-          `
-        <input type="text" id="first"
-            oninput={{action "oninputHandler"}}
-            onchange={{action "onchangeHandler"}}>
-      `
-        );
-
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-
-        let { application: { testHelpers: { visit, fillIn, andThen, wait } } } = this;
-
-        visit('/');
-        fillIn('#first', 'current value');
-        andThen(() => {
-          assert.deepEqual(
-            events,
-            ['input', 'change'],
-            '`input` and `change` events are fired in the proper order'
-          );
-        });
-
-        return wait();
-      }
-
-      [`@test 'fillIn' only sets the value in the first matched element`](assert) {
-        this.addTemplate(
-          'index',
-          `
-        <input type="text" id="first" class="in-test">
-        <input type="text" id="second" class="in-test">
-      `
-        );
-
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-
-        let { application: { testHelpers: { visit, fillIn, find, andThen, wait } } } = this;
-
-        visit('/');
-        fillIn('input.in-test', 'new value');
-        andThen(() => {
-          assert.equal(find('#first')[0].value, 'new value');
-          assert.equal(find('#second')[0].value, '');
-        });
-
-        return wait();
-      }
-
-      [`@test 'triggerEvent' accepts an optional options hash and context`](assert) {
-        assert.expect(3);
-
-        let event;
-        this.add(
-          'component:index-wrapper',
-          Component.extend({
-            didInsertElement() {
-              let firstInput = document.querySelector('.input');
-              firstInput.addEventListener('keydown', e => (event = e), false);
-              firstInput.addEventListener('change', e => (event = e), false);
-              let secondInput = document.querySelector('#limited .input');
-              secondInput.addEventListener('keydown', e => (event = e), false);
-              secondInput.addEventListener('change', e => (event = e), false);
-            },
-          })
-        );
-
-        this.addTemplate(
-          'components/index-wrapper',
-          `
-        {{input type="text" id="outside-scope" class="input"}}
-        <div id="limited">
-          {{input type="text" id="inside-scope" class="input"}}
-        </div>
-      `
-        );
-        this.addTemplate('index', `{{index-wrapper}}`);
-
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-
-        let { application: { testHelpers: { wait, triggerEvent } } } = this;
-        return wait()
-          .then(() => {
-            return triggerEvent('.input', '#limited', 'keydown', {
-              keyCode: 13,
-            });
-          })
-          .then(() => {
-            assert.equal(event.keyCode, 13, 'options were passed');
-            assert.equal(event.type, 'keydown', 'correct event was triggered');
-            assert.equal(
-              event.target.getAttribute('id'),
-              'inside-scope',
-              'triggered on the correct element'
-            );
-          });
-      }
-    }
-  );
-
-  moduleFor(
-    'ember-testing: debugging helpers',
-    class extends HelpersApplicationTestCase {
-      afterEach() {
-        super.afterEach();
-        setDebugFunction('info', originalInfo);
-      }
-
-      constructor() {
-        super();
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-      }
-
-      [`@test pauseTest pauses`](assert) {
-        assert.expect(1);
-        // overwrite info to supress the console output (see https://github.com/emberjs/ember.js/issues/16391)
-        setDebugFunction('info', noop);
-
-        let { andThen, pauseTest } = this.application.testHelpers;
-
-        andThen(() => {
-          Test.adapter.asyncStart = () => {
-            assert.ok(true, 'Async start should be called after waiting for other helpers');
-          };
-        });
-
-        pauseTest();
-      }
-
-      [`@test resumeTest resumes paused tests`](assert) {
-        assert.expect(1);
-        // overwrite info to supress the console output (see https://github.com/emberjs/ember.js/issues/16391)
-        setDebugFunction('info', noop);
-
-        let { application: { testHelpers: { pauseTest, resumeTest } } } = this;
-
-        later(() => resumeTest(), 20);
-        return pauseTest().then(() => {
-          assert.ok(true, 'pauseTest promise was resolved');
-        });
-      }
-
-      [`@test resumeTest throws if nothing to resume`](assert) {
-        assert.expect(1);
-
-        assert.throws(() => {
-          this.application.testHelpers.resumeTest();
-        }, /Testing has not been paused. There is nothing to resume./);
-      }
-    }
-  );
-
-  moduleFor(
-    'ember-testing: routing helpers',
-    class extends HelpersTestCase {
-      constructor() {
-        super();
-        this.runTask(() => {
-          this.createApplication();
-          this.application.setupForTesting();
-          this.application.injectTestHelpers();
-          this.router.map(function() {
-            this.route('posts', { resetNamespace: true }, function() {
-              this.route('new');
-              this.route('edit', { resetNamespace: true });
-            });
-          });
-        });
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-      }
-
-      [`@test currentRouteName for '/'`](assert) {
-        assert.expect(3);
-
-        let { application: { testHelpers } } = this;
-        return testHelpers.visit('/').then(() => {
-          assert.equal(testHelpers.currentRouteName(), 'index', `should equal 'index'.`);
-          assert.equal(testHelpers.currentPath(), 'index', `should equal 'index'.`);
-          assert.equal(testHelpers.currentURL(), '/', `should equal '/'.`);
-        });
-      }
-
-      [`@test currentRouteName for '/posts'`](assert) {
-        assert.expect(3);
-
-        let { application: { testHelpers } } = this;
-        return testHelpers.visit('/posts').then(() => {
-          assert.equal(
-            testHelpers.currentRouteName(),
-            'posts.index',
-            `should equal 'posts.index'.`
-          );
-          assert.equal(testHelpers.currentPath(), 'posts.index', `should equal 'posts.index'.`);
-          assert.equal(testHelpers.currentURL(), '/posts', `should equal '/posts'.`);
-        });
-      }
-
-      [`@test currentRouteName for '/posts/new'`](assert) {
-        assert.expect(3);
-
-        let { application: { testHelpers } } = this;
-        return testHelpers.visit('/posts/new').then(() => {
-          assert.equal(testHelpers.currentRouteName(), 'posts.new', `should equal 'posts.new'.`);
-          assert.equal(testHelpers.currentPath(), 'posts.new', `should equal 'posts.new'.`);
-          assert.equal(testHelpers.currentURL(), '/posts/new', `should equal '/posts/new'.`);
-        });
-      }
-
-      [`@test currentRouteName for '/posts/edit'`](assert) {
-        assert.expect(3);
-
-        let { application: { testHelpers } } = this;
-        return testHelpers.visit('/posts/edit').then(() => {
-          assert.equal(testHelpers.currentRouteName(), 'edit', `should equal 'edit'.`);
-          assert.equal(testHelpers.currentPath(), 'posts.edit', `should equal 'posts.edit'.`);
-          assert.equal(testHelpers.currentURL(), '/posts/edit', `should equal '/posts/edit'.`);
-        });
-      }
-    }
-  );
-
-  moduleFor(
-    'ember-testing: pendingRequests',
-    class extends HelpersApplicationTestCase {
-      trigger(type, xhr) {
-        jQuery(document).trigger(type, xhr);
-      }
-
-      [`@test pendingRequests is maintained for ajaxSend and ajaxComplete events`](assert) {
-        let done = assert.async();
-        assert.equal(pendingRequests(), 0);
-
-        let xhr = { some: 'xhr' };
-
-        this.trigger('ajaxSend', xhr);
-        assert.equal(pendingRequests(), 1, 'Ember.Test.pendingRequests was incremented');
-
-        this.trigger('ajaxComplete', xhr);
-        setTimeout(function() {
-          assert.equal(pendingRequests(), 0, 'Ember.Test.pendingRequests was decremented');
-          done();
-        }, 0);
-      }
-
-      [`@test pendingRequests is ignores ajaxComplete events from past setupForTesting calls`](
-        assert
-      ) {
-        assert.equal(pendingRequests(), 0);
-
-        let xhr = { some: 'xhr' };
-
-        this.trigger('ajaxSend', xhr);
-        assert.equal(pendingRequests(), 1, 'Ember.Test.pendingRequests was incremented');
-
-        setupForTesting();
-
-        assert.equal(pendingRequests(), 0, 'Ember.Test.pendingRequests was reset');
-
-        let altXhr = { some: 'more xhr' };
-
-        this.trigger('ajaxSend', altXhr);
-        assert.equal(pendingRequests(), 1, 'Ember.Test.pendingRequests was incremented');
-
-        this.trigger('ajaxComplete', xhr);
-        assert.equal(
-          pendingRequests(),
-          1,
-          'Ember.Test.pendingRequests is not impressed with your unexpected complete'
-        );
-      }
-
-      [`@test pendingRequests is reset by setupForTesting`](assert) {
-        incrementPendingRequests();
-
-        setupForTesting();
-
-        assert.equal(pendingRequests(), 0, 'pendingRequests is reset');
-      }
-    }
-  );
-
-  moduleFor(
-    'ember-testing: async router',
-    class extends HelpersTestCase {
-      constructor() {
-        super();
-
-        this.runTask(() => {
-          this.createApplication();
-
-          this.router.map(function() {
-            this.route('user', { resetNamespace: true }, function() {
-              this.route('profile');
-              this.route('edit');
-            });
-          });
-
-          // Emulate a long-running unscheduled async operation.
-          let resolveLater = () =>
-            new RSVP.Promise(resolve => {
-              /*
-          * The wait() helper has a 10ms tick. We should resolve() after
-          * at least one tick to test whether wait() held off while the
-          * async router was still loading. 20ms should be enough.
-          */
-              later(resolve, { firstName: 'Tom' }, 20);
-            });
-
-          this.add(
-            'route:user',
-            Route.extend({
-              model() {
-                return resolveLater();
-              },
-            })
-          );
-
-          this.add(
-            'route:user.profile',
-            Route.extend({
-              beforeModel() {
-                return resolveLater().then(() => this.transitionTo('user.edit'));
-              },
-            })
-          );
-
-          this.application.setupForTesting();
-        });
-
-        this.application.injectTestHelpers();
-        this.runTask(() => {
-          this.application.advanceReadiness();
-        });
-      }
-
-      [`@test currentRouteName for '/user'`](assert) {
-        assert.expect(4);
-
-        let { application: { testHelpers } } = this;
-        return testHelpers.visit('/user').then(() => {
-          assert.equal(testHelpers.currentRouteName(), 'user.index', `should equal 'user.index'.`);
-          assert.equal(testHelpers.currentPath(), 'user.index', `should equal 'user.index'.`);
-          assert.equal(testHelpers.currentURL(), '/user', `should equal '/user'.`);
-          let userRoute = this.applicationInstance.lookup('route:user');
-          assert.equal(userRoute.get('controller.model.firstName'), 'Tom', `should equal 'Tom'.`);
-        });
-      }
-
-      [`@test currentRouteName for '/user/profile'`](assert) {
-        assert.expect(4);
-
-        let { application: { testHelpers } } = this;
-        return testHelpers.visit('/user/profile').then(() => {
-          assert.equal(testHelpers.currentRouteName(), 'user.edit', `should equal 'user.edit'.`);
-          assert.equal(testHelpers.currentPath(), 'user.edit', `should equal 'user.edit'.`);
-          assert.equal(testHelpers.currentURL(), '/user/edit', `should equal '/user/edit'.`);
-          let userRoute = this.applicationInstance.lookup('route:user');
-          assert.equal(userRoute.get('controller.model.firstName'), 'Tom', `should equal 'Tom'.`);
-        });
-      }
-    }
-  );
-
-  moduleFor(
-    'ember-testing: can override built-in helpers',
-    class extends HelpersTestCase {
-      constructor() {
-        super();
-        this.runTask(() => {
-          this.createApplication();
-          this.application.setupForTesting();
-        });
-        this._originalVisitHelper = Test._helpers.visit;
-        this._originalFindHelper = Test._helpers.find;
-      }
-
-      teardown() {
-        Test._helpers.visit = this._originalVisitHelper;
-        Test._helpers.find = this._originalFindHelper;
-        super.teardown();
-      }
-
-      [`@test can override visit helper`](assert) {
-        assert.expect(1);
-
-        Test.registerHelper('visit', () => {
-          assert.ok(true, 'custom visit helper was called');
-        });
-
-        this.application.injectTestHelpers();
-
-        return this.application.testHelpers.visit();
-      }
-
-      [`@test can override find helper`](assert) {
-        assert.expect(1);
-
-        Test.registerHelper('find', () => {
-          assert.ok(true, 'custom find helper was called');
-
-          return ['not empty array'];
-        });
-
-        this.application.injectTestHelpers();
-
-        return this.application.testHelpers.findWithAssert('.who-cares');
-      }
-    }
-  );
-}