discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/@ember/application/tests/logging_test.js

@@ -1,179 +0,0 @@
-/*globals EmberDev */
-
-import { moduleFor, ApplicationTestCase } from 'internal-test-helpers';
-
-import Controller from '@ember/controller';
-import { Route } from 'ember-routing';
-import { assign } from '@ember/polyfills';
-
-class LoggingApplicationTestCase extends ApplicationTestCase {
-  constructor() {
-    super();
-
-    this.logs = {};
-
-    /* eslint-disable no-console */
-    this._originalLogger = console.info;
-
-    console.info = (_, { fullName }) => {
-      if (!this.logs.hasOwnProperty(fullName)) {
-        this.logs[fullName] = 0;
-      }
-      /* eslint-ensable no-console */
-      this.logs[fullName]++;
-    };
-
-    this.router.map(function() {
-      this.route('posts', { resetNamespace: true });
-    });
-  }
-
-  teardown() {
-    /* eslint-disable no-console */
-    console.info = this._originalLogger;
-    /* eslint-enable no-console */
-    super.teardown();
-  }
-}
-
-moduleFor(
-  'Application with LOG_ACTIVE_GENERATION=true',
-  class extends LoggingApplicationTestCase {
-    get applicationOptions() {
-      return assign(super.applicationOptions, {
-        LOG_ACTIVE_GENERATION: true,
-      });
-    }
-
-    ['@test log class generation if logging enabled'](assert) {
-      if (EmberDev && EmberDev.runningProdBuild) {
-        assert.ok(true, 'Logging does not occur in production builds');
-        return;
-      }
-
-      return this.visit('/posts').then(() => {
-        assert.equal(Object.keys(this.logs).length, 4, 'expected logs');
-      });
-    }
-
-    ['@test actively generated classes get logged'](assert) {
-      if (EmberDev && EmberDev.runningProdBuild) {
-        assert.ok(true, 'Logging does not occur in production builds');
-        return;
-      }
-
-      return this.visit('/posts').then(() => {
-        assert.equal(
-          this.logs['controller:application'],
-          1,
-          'expected: ApplicationController was generated'
-        );
-        assert.equal(this.logs['controller:posts'], 1, 'expected: PostsController was generated');
-
-        assert.equal(this.logs['route:application'], 1, 'expected: ApplicationRoute was generated');
-        assert.equal(this.logs['route:posts'], 1, 'expected: PostsRoute was generated');
-      });
-    }
-
-    ['@test predefined classes do not get logged'](assert) {
-      this.add('controller:application', Controller.extend());
-      this.add('controller:posts', Controller.extend());
-      this.add('route:application', Route.extend());
-      this.add('route:posts', Route.extend());
-
-      return this.visit('/posts').then(() => {
-        assert.ok(
-          !this.logs['controller:application'],
-          'did not expect: ApplicationController was generated'
-        );
-        assert.ok(!this.logs['controller:posts'], 'did not expect: PostsController was generated');
-
-        assert.ok(
-          !this.logs['route:application'],
-          'did not expect: ApplicationRoute was generated'
-        );
-        assert.ok(!this.logs['route:posts'], 'did not expect: PostsRoute was generated');
-      });
-    }
-  }
-);
-
-moduleFor(
-  'Application when LOG_ACTIVE_GENERATION=false',
-  class extends LoggingApplicationTestCase {
-    get applicationOptions() {
-      return assign(super.applicationOptions, {
-        LOG_ACTIVE_GENERATION: false,
-      });
-    }
-
-    [`@test do NOT log class generation if logging disabled`](assert) {
-      return this.visit('/posts').then(() => {
-        assert.equal(Object.keys(this.logs).length, 0, 'expected logs');
-      });
-    }
-  }
-);
-
-moduleFor(
-  'Application with LOG_VIEW_LOOKUPS=true',
-  class extends LoggingApplicationTestCase {
-    get applicationOptions() {
-      return assign(super.applicationOptions, {
-        LOG_VIEW_LOOKUPS: true,
-      });
-    }
-
-    [`@test log when template and view are missing when flag is active`](assert) {
-      if (EmberDev && EmberDev.runningProdBuild) {
-        assert.ok(true, 'Logging does not occur in production builds');
-        return;
-      }
-
-      this.addTemplate('application', '{{outlet}}');
-
-      return this.visit('/')
-        .then(() => this.visit('/posts'))
-        .then(() => {
-          assert.equal(
-            this.logs['template:application'],
-            undefined,
-            'expected: Should not log template:application since it exists.'
-          );
-          assert.equal(
-            this.logs['template:index'],
-            1,
-            'expected: Could not find "index" template or view.'
-          );
-          assert.equal(
-            this.logs['template:posts'],
-            1,
-            'expected: Could not find "posts" template or view.'
-          );
-        });
-    }
-  }
-);
-
-moduleFor(
-  'Application with LOG_VIEW_LOOKUPS=false',
-  class extends LoggingApplicationTestCase {
-    get applicationOptions() {
-      return assign(super.applicationOptions, {
-        LOG_VIEW_LOOKUPS: false,
-      });
-    }
-
-    [`@test do not log when template and view are missing when flag is not true`](assert) {
-      return this.visit('/posts').then(() => {
-        assert.equal(Object.keys(this.logs).length, 0, 'expected no logs');
-      });
-    }
-
-    [`@test do not log which views are used with templates when flag is not true`](assert) {
-      return this.visit('/posts').then(() => {
-        assert.equal(Object.keys(this.logs).length, 0, 'expected no logs');
-      });
-    }
-  }
-);

data/dist/es/@ember/application/tests/readiness_test.js

@@ -1,138 +0,0 @@
-import { moduleFor, ApplicationTestCase } from 'internal-test-helpers';
-import { run } from '@ember/runloop';
-import EmberApplication from '..';
-
-let jQuery, application, Application;
-let readyWasCalled, domReady, readyCallbacks;
-
-// We are using a small mock of jQuery because jQuery is third-party code with
-// very well-defined semantics, and we want to confirm that a jQuery stub run
-// in a more minimal server environment that implements this behavior will be
-// sufficient for Ember's requirements.
-moduleFor(
-  'Application readiness',
-  class extends ApplicationTestCase {
-    constructor() {
-      super();
-
-      readyWasCalled = 0;
-      readyCallbacks = [];
-
-      let jQueryInstance = {
-        ready(callback) {
-          readyCallbacks.push(callback);
-          if (jQuery.isReady) {
-            domReady();
-          }
-        },
-      };
-
-      jQuery = function() {
-        return jQueryInstance;
-      };
-      jQuery.isReady = false;
-
-      let domReadyCalled = 0;
-      domReady = function() {
-        if (domReadyCalled !== 0) {
-          return;
-        }
-        domReadyCalled++;
-        for (let i = 0; i < readyCallbacks.length; i++) {
-          readyCallbacks[i]();
-        }
-      };
-
-      Application = EmberApplication.extend({
-        $: jQuery,
-
-        ready() {
-          readyWasCalled++;
-        },
-      });
-    }
-
-    teardown() {
-      if (application) {
-        run(() => application.destroy());
-        jQuery = readyCallbacks = domReady = Application = application = undefined;
-      }
-    }
-
-    // These tests are confirming that if the callbacks passed into jQuery's ready hook is called
-    // synchronously during the application's initialization, we get the same behavior as if
-    // it was triggered after initialization.
-
-    ["@test Application's ready event is called right away if jQuery is already ready"](assert) {
-      jQuery.isReady = true;
-
-      run(() => {
-        application = Application.create({ router: false });
-
-        assert.equal(readyWasCalled, 0, 'ready is not called until later');
-      });
-
-      assert.equal(readyWasCalled, 1, 'ready was called');
-
-      domReady();
-
-      assert.equal(readyWasCalled, 1, "application's ready was not called again");
-    }
-
-    ["@test Application's ready event is called after the document becomes ready"](assert) {
-      run(() => {
-        application = Application.create({ router: false });
-      });
-
-      assert.equal(readyWasCalled, 0, "ready wasn't called yet");
-
-      domReady();
-
-      assert.equal(readyWasCalled, 1, 'ready was called now that DOM is ready');
-    }
-
-    ["@test Application's ready event can be deferred by other components"](assert) {
-      run(() => {
-        application = Application.create({ router: false });
-        application.deferReadiness();
-      });
-
-      assert.equal(readyWasCalled, 0, "ready wasn't called yet");
-
-      domReady();
-
-      assert.equal(readyWasCalled, 0, "ready wasn't called yet");
-
-      run(() => {
-        application.advanceReadiness();
-        assert.equal(readyWasCalled, 0);
-      });
-
-      assert.equal(readyWasCalled, 1, 'ready was called now all readiness deferrals are advanced');
-    }
-
-    ["@test Application's ready event can be deferred by other components"](assert) {
-      jQuery.isReady = false;
-
-      run(() => {
-        application = Application.create({ router: false });
-        application.deferReadiness();
-        assert.equal(readyWasCalled, 0, "ready wasn't called yet");
-      });
-
-      domReady();
-
-      assert.equal(readyWasCalled, 0, "ready wasn't called yet");
-
-      run(() => {
-        application.advanceReadiness();
-      });
-
-      assert.equal(readyWasCalled, 1, 'ready was called now all readiness deferrals are advanced');
-
-      expectAssertion(() => {
-        application.deferReadiness();
-      });
-    }
-  }
-);

data/dist/es/@ember/application/tests/reset_test.js

@@ -1,185 +0,0 @@
-import { run } from '@ember/runloop';
-import { get } from 'ember-metal';
-import Controller from '@ember/controller';
-import { Router } from 'ember-routing';
-import { moduleFor, AutobootApplicationTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Application - resetting',
-  class extends AutobootApplicationTestCase {
-    ['@test Brings its own run-loop if not provided'](assert) {
-      assert.expect(0);
-      run(() => this.createApplication());
-      this.application.reset();
-    }
-
-    ['@test Does not bring its own run loop if one is already provided'](assert) {
-      assert.expect(3);
-
-      let didBecomeReady = false;
-
-      run(() => this.createApplication());
-
-      run(() => {
-        this.application.ready = () => {
-          didBecomeReady = true;
-        };
-
-        this.application.reset();
-
-        this.application.deferReadiness();
-        assert.ok(!didBecomeReady, 'app is not ready');
-      });
-
-      assert.ok(!didBecomeReady, 'app is not ready');
-      run(this.application, 'advanceReadiness');
-      assert.ok(didBecomeReady, 'app is ready');
-    }
-
-    ['@test When an application is reset, new instances of controllers are generated'](assert) {
-      run(() => {
-        this.createApplication();
-        this.add('controller:academic', Controller.extend());
-      });
-
-      let firstController = this.applicationInstance.lookup('controller:academic');
-      let secondController = this.applicationInstance.lookup('controller:academic');
-
-      this.application.reset();
-
-      let thirdController = this.applicationInstance.lookup('controller:academic');
-
-      assert.strictEqual(
-        firstController,
-        secondController,
-        'controllers looked up in succession should be the same instance'
-      );
-
-      assert.ok(
-        firstController.isDestroying,
-        'controllers are destroyed when their application is reset'
-      );
-
-      assert.notStrictEqual(
-        firstController,
-        thirdController,
-        'controllers looked up after the application is reset should not be the same instance'
-      );
-    }
-
-    ['@test When an application is reset, the eventDispatcher is destroyed and recreated'](assert) {
-      let eventDispatcherWasSetup = 0;
-      let eventDispatcherWasDestroyed = 0;
-
-      let mockEventDispatcher = {
-        setup() {
-          eventDispatcherWasSetup++;
-        },
-        destroy() {
-          eventDispatcherWasDestroyed++;
-        },
-      };
-
-      run(() => {
-        this.createApplication();
-        this.add('event_dispatcher:main', {
-          create: () => mockEventDispatcher,
-        });
-
-        assert.equal(eventDispatcherWasSetup, 0);
-        assert.equal(eventDispatcherWasDestroyed, 0);
-      });
-
-      assert.equal(eventDispatcherWasSetup, 1);
-      assert.equal(eventDispatcherWasDestroyed, 0);
-
-      this.application.reset();
-
-      assert.equal(eventDispatcherWasDestroyed, 1);
-      assert.equal(eventDispatcherWasSetup, 2, 'setup called after reset');
-    }
-
-    ['@test When an application is reset, the router URL is reset to `/`'](assert) {
-      run(() => {
-        this.createApplication();
-
-        this.add(
-          'router:main',
-          Router.extend({
-            location: 'none',
-          })
-        );
-
-        this.router.map(function() {
-          this.route('one');
-          this.route('two');
-        });
-      });
-
-      let initialRouter, initialApplicationController;
-      return this.visit('/one')
-        .then(() => {
-          initialApplicationController = this.applicationInstance.lookup('controller:application');
-          initialRouter = this.applicationInstance.lookup('router:main');
-          let location = initialRouter.get('location');
-
-          assert.equal(location.getURL(), '/one');
-          assert.equal(get(initialApplicationController, 'currentPath'), 'one');
-
-          this.application.reset();
-
-          return this.application._bootPromise;
-        })
-        .then(() => {
-          let applicationController = this.applicationInstance.lookup('controller:application');
-          assert.strictEqual(
-            applicationController,
-            undefined,
-            'application controller no longer exists'
-          );
-
-          return this.visit('/one');
-        })
-        .then(() => {
-          let applicationController = this.applicationInstance.lookup('controller:application');
-          let router = this.applicationInstance.lookup('router:main');
-          let location = router.get('location');
-
-          assert.notEqual(initialRouter, router, 'a different router instance was created');
-          assert.notEqual(
-            initialApplicationController,
-            applicationController,
-            'a different application controller is created'
-          );
-
-          assert.equal(location.getURL(), '/one');
-          assert.equal(get(applicationController, 'currentPath'), 'one');
-        });
-    }
-
-    ['@test When an application with advance/deferReadiness is reset, the app does correctly become ready after reset'](
-      assert
-    ) {
-      let readyCallCount = 0;
-
-      run(() => {
-        this.createApplication({
-          ready() {
-            readyCallCount++;
-          },
-        });
-
-        this.application.deferReadiness();
-        assert.equal(readyCallCount, 0, 'ready has not yet been called');
-      });
-
-      run(this.application, 'advanceReadiness');
-
-      assert.equal(readyCallCount, 1, 'ready was called once');
-
-      this.application.reset();
-
-      assert.equal(readyCallCount, 2, 'ready was called twice');
-    }
-  }
-);