discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-testing/lib/test/on_inject_helpers.js

@@ -1,38 +0,0 @@
-export const callbacks = [];
-
-/**
-  Used to register callbacks to be fired whenever `App.injectTestHelpers`
-  is called.
-
-  The callback will receive the current application as an argument.
-
-  Example:
-
-  ```javascript
-  import $ from 'jquery';
-
-  Ember.Test.onInjectHelpers(function() {
-    $(document).ajaxSend(function() {
-      Test.pendingRequests++;
-    });
-
-    $(document).ajaxComplete(function() {
-      Test.pendingRequests--;
-    });
-  });
-  ```
-
-  @public
-  @for Ember.Test
-  @method onInjectHelpers
-  @param {Function} callback The function to be called.
-*/
-export function onInjectHelpers(callback) {
-  callbacks.push(callback);
-}
-
-export function invokeInjectHelpersCallbacks(app) {
-  for (let i = 0; i < callbacks.length; i++) {
-    callbacks[i](app);
-  }
-}

data/dist/es/ember-testing/lib/test/pending_requests.js

@@ -1,24 +0,0 @@
-let requests = [];
-
-export function pendingRequests() {
-  return requests.length;
-}
-
-export function clearPendingRequests() {
-  requests.length = 0;
-}
-
-export function incrementPendingRequests(_, xhr) {
-  requests.push(xhr);
-}
-
-export function decrementPendingRequests(_, xhr) {
-  setTimeout(function() {
-    for (let i = 0; i < requests.length; i++) {
-      if (xhr === requests[i]) {
-        requests.splice(i, 1);
-        break;
-      }
-    }
-  }, 0);
-}

data/dist/es/ember-testing/lib/test/promise.js

@@ -1,79 +0,0 @@
-import { RSVP } from 'ember-runtime';
-import run from './run';
-
-let lastPromise;
-
-export default class TestPromise extends RSVP.Promise {
-  constructor() {
-    super(...arguments);
-    lastPromise = this;
-  }
-
-  then(_onFulfillment, ...args) {
-    let onFulfillment =
-      typeof _onFulfillment === 'function' ? result => isolate(_onFulfillment, result) : undefined;
-    return super.then(onFulfillment, ...args);
-  }
-}
-
-/**
-  This returns a thenable tailored for testing.  It catches failed
-  `onSuccess` callbacks and invokes the `Ember.Test.adapter.exception`
-  callback in the last chained then.
-
-  This method should be returned by async helpers such as `wait`.
-
-  @public
-  @for Ember.Test
-  @method promise
-  @param {Function} resolver The function used to resolve the promise.
-  @param {String} label An optional string for identifying the promise.
-*/
-export function promise(resolver, label) {
-  let fullLabel = `Ember.Test.promise: ${label || '<Unknown Promise>'}`;
-  return new TestPromise(resolver, fullLabel);
-}
-
-/**
-  Replacement for `Ember.RSVP.resolve`
-  The only difference is this uses
-  an instance of `Ember.Test.Promise`
-
-  @public
-  @for Ember.Test
-  @method resolve
-  @param {Mixed} The value to resolve
-  @since 1.2.0
-*/
-export function resolve(result, label) {
-  return TestPromise.resolve(result, label);
-}
-
-export function getLastPromise() {
-  return lastPromise;
-}
-
-// This method isolates nested async methods
-// so that they don't conflict with other last promises.
-//
-// 1. Set `Ember.Test.lastPromise` to null
-// 2. Invoke method
-// 3. Return the last promise created during method
-function isolate(onFulfillment, result) {
-  // Reset lastPromise for nested helpers
-  lastPromise = null;
-
-  let value = onFulfillment(result);
-
-  let promise = lastPromise;
-  lastPromise = null;
-
-  // If the method returned a promise
-  // return that promise. If not,
-  // return the last async helper's promise
-  if ((value && value instanceof TestPromise) || !promise) {
-    return value;
-  } else {
-    return run(() => resolve(promise).then(() => value));
-  }
-}

data/dist/es/ember-testing/lib/test/run.js

@@ -1,9 +0,0 @@
-import { getCurrentRunLoop, run as emberRun } from '@ember/runloop';
-
-export default function run(fn) {
-  if (!getCurrentRunLoop()) {
-    return emberRun(fn);
-  } else {
-    return fn();
-  }
-}

data/dist/es/ember-testing/lib/test/waiters.js

@@ -1,117 +0,0 @@
-/**
- @module @ember/test
-*/
-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;
-  }
-  if (indexOf(context, callback) > -1) {
-    return;
-  }
-  contexts.push(context);
-  callbacks.push(callback);
-}
-
-/**
-   `unregisterWaiter` is used to unregister a callback that was
-   registered with `registerWaiter`.
-
-   @public
-   @for @ember/test
-   @static
-   @method unregisterWaiter
-   @param {Object} context (optional)
-   @param {Function} callback
-   @since 1.2.0
-*/
-export function unregisterWaiter(context, callback) {
-  if (!callbacks.length) {
-    return;
-  }
-  if (arguments.length === 1) {
-    callback = context;
-    context = null;
-  }
-  let i = indexOf(context, callback);
-  if (i === -1) {
-    return;
-  }
-  contexts.splice(i, 1);
-  callbacks.splice(i, 1);
-}
-
-/**
-  Iterates through each registered test waiter, and invokes
-  its callback. If any waiter returns false, this method will return
-  true indicating that the waiters have not settled yet.
-
-  This is generally used internally from the acceptance/integration test
-  infrastructure.
-
-  @public
-  @for @ember/test
-  @static
-  @method checkWaiters
-*/
-export function checkWaiters() {
-  if (!callbacks.length) {
-    return false;
-  }
-  for (let i = 0; i < callbacks.length; i++) {
-    let context = contexts[i];
-    let callback = callbacks[i];
-    if (!callback.call(context)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-function indexOf(context, callback) {
-  for (let i = 0; i < callbacks.length; i++) {
-    if (callbacks[i] === callback && contexts[i] === context) {
-      return i;
-    }
-  }
-  return -1;
-}

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

@@ -1,478 +0,0 @@
-import { moduleFor, AutobootApplicationTestCase } from 'internal-test-helpers';
-
-import { later } from '@ember/runloop';
-import Test from '../lib/test';
-import QUnitAdapter from '../lib/adapters/qunit';
-import { Route } from 'ember-routing';
-import { RSVP } from 'ember-runtime';
-import { jQueryDisabled } from 'ember-views';
-import { getDebugFunction, setDebugFunction } from '@ember/debug';
-
-const originalDebug = getDebugFunction('debug');
-
-var originalConsoleError = console.error; // eslint-disable-line no-console
-let testContext;
-
-if (!jQueryDisabled) {
-  moduleFor(
-    'ember-testing Acceptance',
-    class extends AutobootApplicationTestCase {
-      constructor() {
-        setDebugFunction('debug', function() {});
-        super();
-        this._originalAdapter = Test.adapter;
-
-        testContext = this;
-
-        this.runTask(() => {
-          this.createApplication();
-          this.router.map(function() {
-            this.route('posts');
-            this.route('comments');
-
-            this.route('abort_transition');
-
-            this.route('redirect');
-          });
-
-          this.indexHitCount = 0;
-          this.currentRoute = 'index';
-
-          this.add(
-            'route:index',
-            Route.extend({
-              model() {
-                testContext.indexHitCount += 1;
-              },
-            })
-          );
-
-          this.add(
-            'route:posts',
-            Route.extend({
-              renderTemplate() {
-                testContext.currentRoute = 'posts';
-                this._super(...arguments);
-              },
-            })
-          );
-
-          this.addTemplate(
-            'posts',
-            `
-          <div class="posts-view">
-            <a class="dummy-link"></a>
-            <div id="comments-link">
-              {{#link-to \'comments\'}}Comments{{/link-to}}
-            </div>
-          </div>
-        `
-          );
-
-          this.add(
-            'route:comments',
-            Route.extend({
-              renderTemplate() {
-                testContext.currentRoute = 'comments';
-                this._super(...arguments);
-              },
-            })
-          );
-
-          this.addTemplate('comments', `<div>{{input type="text"}}</div>`);
-
-          this.add(
-            'route:abort_transition',
-            Route.extend({
-              beforeModel(transition) {
-                transition.abort();
-              },
-            })
-          );
-
-          this.add(
-            'route:redirect',
-            Route.extend({
-              beforeModel() {
-                this.transitionTo('comments');
-              },
-            })
-          );
-
-          this.application.setupForTesting();
-
-          Test.registerAsyncHelper('slowHelper', () => {
-            return new RSVP.Promise(resolve => later(resolve, 10));
-          });
-
-          this.application.injectTestHelpers();
-        });
-      }
-      afterEach() {
-        console.error = originalConsoleError; // eslint-disable-line no-console
-        super.afterEach();
-      }
-
-      teardown() {
-        setDebugFunction('debug', originalDebug);
-        Test.adapter = this._originalAdapter;
-        Test.unregisterHelper('slowHelper');
-        window.slowHelper = undefined;
-        testContext = undefined;
-        super.teardown();
-      }
-
-      [`@test helpers can be chained with then`](assert) {
-        assert.expect(6);
-
-        window
-          .visit('/posts')
-          .then(() => {
-            assert.equal(this.currentRoute, 'posts', 'Successfully visited posts route');
-            assert.equal(window.currentURL(), '/posts', 'posts URL is correct');
-            return window.click('a:contains("Comments")');
-          })
-          .then(() => {
-            assert.equal(this.currentRoute, 'comments', 'visit chained with click');
-            return window.fillIn('.ember-text-field', 'yeah');
-          })
-          .then(() => {
-            assert.equal(
-              document.querySelector('.ember-text-field').value,
-              'yeah',
-              'chained with fillIn'
-            );
-            return window.fillIn('.ember-text-field', '#qunit-fixture', 'context working');
-          })
-          .then(() => {
-            assert.equal(
-              document.querySelector('.ember-text-field').value,
-              'context working',
-              'chained with fillIn'
-            );
-            return window.click('.does-not-exist');
-          })
-          .catch(e => {
-            assert.equal(
-              e.message,
-              'Element .does-not-exist not found.',
-              'Non-existent click exception caught'
-            );
-          });
-      }
-
-      [`@test helpers can be chained to each other (legacy)`](assert) {
-        assert.expect(7);
-
-        window
-          .visit('/posts')
-          .click('a:first', '#comments-link')
-          .fillIn('.ember-text-field', 'hello')
-          .then(() => {
-            assert.equal(this.currentRoute, 'comments', 'Successfully visited comments route');
-            assert.equal(window.currentURL(), '/comments', 'Comments URL is correct');
-            assert.equal(
-              document.querySelector('.ember-text-field').value,
-              'hello',
-              'Fillin successfully works'
-            );
-            window.find('.ember-text-field').one('keypress', e => {
-              assert.equal(e.keyCode, 13, 'keyevent chained with correct keyCode.');
-              assert.equal(e.which, 13, 'keyevent chained with correct which.');
-            });
-          })
-          .keyEvent('.ember-text-field', 'keypress', 13)
-          .visit('/posts')
-          .then(() => {
-            assert.equal(this.currentRoute, 'posts', 'Thens can also be chained to helpers');
-            assert.equal(window.currentURL(), '/posts', 'URL is set correct on chained helpers');
-          });
-      }
-
-      [`@test helpers don't need to be chained`](assert) {
-        assert.expect(5);
-
-        window.visit('/posts');
-
-        window.click('a:first', '#comments-link');
-
-        window.fillIn('.ember-text-field', 'hello');
-
-        window.andThen(() => {
-          assert.equal(this.currentRoute, 'comments', 'Successfully visited comments route');
-          assert.equal(window.currentURL(), '/comments', 'Comments URL is correct');
-          assert.equal(
-            window.find('.ember-text-field').val(),
-            'hello',
-            'Fillin successfully works'
-          );
-        });
-
-        window.visit('/posts');
-
-        window.andThen(() => {
-          assert.equal(this.currentRoute, 'posts');
-          assert.equal(window.currentURL(), '/posts');
-        });
-      }
-
-      [`@test Nested async helpers`](assert) {
-        assert.expect(5);
-
-        window.visit('/posts');
-
-        window.andThen(() => {
-          window.click('a:first', '#comments-link');
-          window.fillIn('.ember-text-field', 'hello');
-        });
-
-        window.andThen(() => {
-          assert.equal(this.currentRoute, 'comments', 'Successfully visited comments route');
-          assert.equal(window.currentURL(), '/comments', 'Comments URL is correct');
-          assert.equal(
-            window.find('.ember-text-field').val(),
-            'hello',
-            'Fillin successfully works'
-          );
-        });
-
-        window.visit('/posts');
-
-        window.andThen(() => {
-          assert.equal(this.currentRoute, 'posts');
-          assert.equal(window.currentURL(), '/posts');
-        });
-      }
-
-      [`@test Multiple nested async helpers`](assert) {
-        assert.expect(3);
-
-        window.visit('/posts');
-
-        window.andThen(() => {
-          window.click('a:first', '#comments-link');
-
-          window.fillIn('.ember-text-field', 'hello');
-          window.fillIn('.ember-text-field', 'goodbye');
-        });
-
-        window.andThen(() => {
-          assert.equal(
-            window.find('.ember-text-field').val(),
-            'goodbye',
-            'Fillin successfully works'
-          );
-          assert.equal(this.currentRoute, 'comments', 'Successfully visited comments route');
-          assert.equal(window.currentURL(), '/comments', 'Comments URL is correct');
-        });
-      }
-
-      [`@test Helpers nested in thens`](assert) {
-        assert.expect(5);
-
-        window.visit('/posts').then(() => {
-          window.click('a:first', '#comments-link');
-        });
-
-        window.andThen(() => {
-          window.fillIn('.ember-text-field', 'hello');
-        });
-
-        window.andThen(() => {
-          assert.equal(this.currentRoute, 'comments', 'Successfully visited comments route');
-          assert.equal(window.currentURL(), '/comments', 'Comments URL is correct');
-          assert.equal(
-            window.find('.ember-text-field').val(),
-            'hello',
-            'Fillin successfully works'
-          );
-        });
-
-        window.visit('/posts');
-
-        window.andThen(() => {
-          assert.equal(this.currentRoute, 'posts');
-          assert.equal(window.currentURL(), '/posts', 'Posts URL is correct');
-        });
-      }
-
-      [`@test Aborted transitions are not logged via Ember.Test.adapter#exception`](assert) {
-        assert.expect(0);
-
-        Test.adapter = QUnitAdapter.create({
-          exception() {
-            assert.ok(false, 'aborted transitions are not logged');
-          },
-        });
-
-        window.visit('/abort_transition');
-      }
-
-      [`@test Unhandled exceptions are logged via Ember.Test.adapter#exception`](assert) {
-        assert.expect(2);
-
-        console.error = () => {}; // eslint-disable-line no-console
-        let asyncHandled;
-        Test.adapter = QUnitAdapter.create({
-          exception(error) {
-            assert.equal(
-              error.message,
-              'Element .does-not-exist not found.',
-              'Exception successfully caught and passed to Ember.Test.adapter.exception'
-            );
-            // handle the rejection so it doesn't leak later.
-            asyncHandled.catch(() => {});
-          },
-        });
-
-        window.visit('/posts');
-
-        window.click('.invalid-element').catch(error => {
-          assert.equal(
-            error.message,
-            'Element .invalid-element not found.',
-            'Exception successfully handled in the rejection handler'
-          );
-        });
-
-        asyncHandled = window.click('.does-not-exist');
-      }
-
-      [`@test Unhandled exceptions in 'andThen' are logged via Ember.Test.adapter#exception`](
-        assert
-      ) {
-        assert.expect(1);
-
-        console.error = () => {}; // eslint-disable-line no-console
-        Test.adapter = QUnitAdapter.create({
-          exception(error) {
-            assert.equal(
-              error.message,
-              'Catch me',
-              'Exception successfully caught and passed to Ember.Test.adapter.exception'
-            );
-          },
-        });
-
-        window.visit('/posts');
-
-        window.andThen(() => {
-          throw new Error('Catch me');
-        });
-      }
-
-      [`@test should not start routing on the root URL when visiting another`](assert) {
-        assert.expect(4);
-
-        window.visit('/posts');
-
-        window.andThen(() => {
-          assert.ok(window.find('#comments-link'), 'found comments-link');
-          assert.equal(this.currentRoute, 'posts', 'Successfully visited posts route');
-          assert.equal(window.currentURL(), '/posts', 'Posts URL is correct');
-          assert.equal(
-            this.indexHitCount,
-            0,
-            'should not hit index route when visiting another route'
-          );
-        });
-      }
-
-      [`@test only enters the index route once when visiting `](assert) {
-        assert.expect(1);
-
-        window.visit('/');
-
-        window.andThen(() => {
-          assert.equal(this.indexHitCount, 1, 'should hit index once when visiting /');
-        });
-      }
-
-      [`@test test must not finish while asyncHelpers are pending`](assert) {
-        assert.expect(2);
-
-        let async = 0;
-        let innerRan = false;
-
-        Test.adapter = QUnitAdapter.extend({
-          asyncStart() {
-            async++;
-            this._super();
-          },
-          asyncEnd() {
-            async--;
-            this._super();
-          },
-        }).create();
-
-        this.application.testHelpers.slowHelper();
-
-        window.andThen(() => {
-          innerRan = true;
-        });
-
-        assert.equal(innerRan, false, 'should not have run yet');
-        assert.ok(async > 0, 'should have told the adapter to pause');
-
-        if (async === 0) {
-          // If we failed the test, prevent zalgo from escaping and breaking
-          // our other tests.
-          Test.adapter.asyncStart();
-          Test.resolve().then(() => {
-            Test.adapter.asyncEnd();
-          });
-        }
-      }
-
-      [`@test visiting a URL that causes another transition should yield the correct URL`](assert) {
-        assert.expect(1);
-
-        window.visit('/redirect');
-
-        window.andThen(() => {
-          assert.equal(window.currentURL(), '/comments', 'Redirected to Comments URL');
-        });
-      }
-
-      [`@test visiting a URL and then visiting a second URL with a transition should yield the correct URL`](
-        assert
-      ) {
-        assert.expect(2);
-
-        window.visit('/posts');
-
-        window.andThen(function() {
-          assert.equal(window.currentURL(), '/posts', 'First visited URL is correct');
-        });
-
-        window.visit('/redirect');
-
-        window.andThen(() => {
-          assert.equal(window.currentURL(), '/comments', 'Redirected to Comments URL');
-        });
-      }
-    }
-  );
-
-  moduleFor(
-    'ember-testing Acceptance - teardown',
-    class extends AutobootApplicationTestCase {
-      [`@test that the setup/teardown happens correctly`](assert) {
-        assert.expect(2);
-
-        this.runTask(() => {
-          this.createApplication();
-        });
-        this.application.injectTestHelpers();
-
-        assert.ok(typeof Test.Promise.prototype.click === 'function');
-
-        this.runTask(() => {
-          this.application.destroy();
-        });
-
-        assert.equal(Test.Promise.prototype.click, undefined);
-      }
-    }
-  );
-}