discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-glimmer/tests/integration/mount-test.js

@@ -1,424 +0,0 @@
-import { getOwner } from 'ember-owner';
-import { moduleFor, ApplicationTest, RenderingTest } from '../utils/test-case';
-import { compile, Component } from '../utils/helpers';
-import Controller from '@ember/controller';
-import { set } from 'ember-metal';
-import Engine, { getEngineParent } from '@ember/engine';
-import { EMBER_ENGINES_MOUNT_PARAMS } from '@ember/canary-features';
-
-if (EMBER_ENGINES_MOUNT_PARAMS) {
-  moduleFor(
-    '{{mount}} single param assertion',
-    class extends RenderingTest {
-      ['@test it asserts that only a single param is passed']() {
-        expectAssertion(() => {
-          this.render('{{mount "chat" "foo"}}');
-        }, /You can only pass a single positional argument to the {{mount}} helper, e.g. {{mount "chat-engine"}}./i);
-      }
-    }
-  );
-} else {
-  moduleFor(
-    '{{mount}} single param assertion',
-    class extends RenderingTest {
-      ['@test it asserts that only a single param is passed']() {
-        expectAssertion(() => {
-          this.render('{{mount "chat" "foo"}}');
-        }, /You can only pass a single argument to the {{mount}} helper, e.g. {{mount "chat-engine"}}./i);
-      }
-    }
-  );
-}
-
-moduleFor(
-  '{{mount}} assertions',
-  class extends RenderingTest {
-    ['@test it asserts when an invalid engine name is provided']() {
-      expectAssertion(() => {
-        this.render('{{mount engineName}}', { engineName: {} });
-      }, /Invalid engine name '\[object Object\]' specified, engine name must be either a string, null or undefined./i);
-    }
-
-    ['@test it asserts that the specified engine is registered']() {
-      expectAssertion(() => {
-        this.render('{{mount "chat"}}');
-      }, /You used `{{mount 'chat'}}`, but the engine 'chat' can not be found./i);
-    }
-  }
-);
-
-moduleFor(
-  '{{mount}} test',
-  class extends ApplicationTest {
-    constructor() {
-      super(...arguments);
-
-      let engineRegistrations = (this.engineRegistrations = {});
-
-      this.add(
-        'engine:chat',
-        Engine.extend({
-          router: null,
-
-          init() {
-            this._super(...arguments);
-
-            Object.keys(engineRegistrations).forEach(fullName => {
-              this.register(fullName, engineRegistrations[fullName]);
-            });
-          },
-        })
-      );
-
-      this.addTemplate('index', '{{mount "chat"}}');
-    }
-
-    ['@test it boots an engine, instantiates its application controller, and renders its application template'](
-      assert
-    ) {
-      this.engineRegistrations['template:application'] = compile(
-        '<h2>Chat here, {{username}}</h2>',
-        { moduleName: 'my-app/templates/application.hbs' }
-      );
-
-      let controller;
-
-      this.engineRegistrations['controller:application'] = Controller.extend({
-        username: 'dgeb',
-
-        init() {
-          this._super();
-          controller = this;
-        },
-      });
-
-      return this.visit('/').then(() => {
-        assert.ok(controller, "engine's application controller has been instantiated");
-
-        let engineInstance = getOwner(controller);
-        assert.strictEqual(
-          getEngineParent(engineInstance),
-          this.applicationInstance,
-          'engine instance has the application instance as its parent'
-        );
-
-        this.assertInnerHTML('<h2>Chat here, dgeb</h2>');
-
-        this.runTask(() => set(controller, 'username', 'chancancode'));
-
-        this.assertInnerHTML('<h2>Chat here, chancancode</h2>');
-
-        this.runTask(() => set(controller, 'username', 'dgeb'));
-
-        this.assertInnerHTML('<h2>Chat here, dgeb</h2>');
-      });
-    }
-
-    ['@test it emits a useful backtracking re-render assertion message']() {
-      this.router.map(function() {
-        this.route('route-with-mount');
-      });
-
-      this.addTemplate('index', '');
-      this.addTemplate('route-with-mount', '{{mount "chat"}}');
-
-      this.engineRegistrations['template:application'] = compile(
-        'hi {{person.name}} [{{component-with-backtracking-set person=person}}]',
-        { moduleName: 'my-app/templates/application.hbs' }
-      );
-      this.engineRegistrations['controller:application'] = Controller.extend({
-        person: { name: 'Alex' },
-      });
-
-      this.engineRegistrations['template:components/component-with-backtracking-set'] = compile(
-        '[component {{person.name}}]',
-        {
-          moduleName: 'my-app/templates/components/component-with-backtracking-set.hbs',
-        }
-      );
-      this.engineRegistrations['component:component-with-backtracking-set'] = Component.extend({
-        init() {
-          this._super(...arguments);
-          this.set('person.name', 'Ben');
-        },
-      });
-
-      let expectedBacktrackingMessage = /modified "person\.name" twice on \[object Object\] in a single render\. It was rendered in "template:my-app\/templates\/route-with-mount.hbs" \(in "engine:chat"\) and modified in "component:component-with-backtracking-set" \(in "engine:chat"\)/;
-
-      return this.visit('/').then(() => {
-        expectAssertion(() => {
-          this.visit('/route-with-mount');
-        }, expectedBacktrackingMessage);
-      });
-    }
-
-    ['@test it renders with a bound engine name']() {
-      this.router.map(function() {
-        this.route('bound-engine-name');
-      });
-      let controller;
-      this.add(
-        'controller:bound-engine-name',
-        Controller.extend({
-          engineName: null,
-          init() {
-            this._super();
-            controller = this;
-          },
-        })
-      );
-      this.addTemplate('bound-engine-name', '{{mount engineName}}');
-
-      this.add(
-        'engine:foo',
-        Engine.extend({
-          router: null,
-          init() {
-            this._super(...arguments);
-            this.register(
-              'template:application',
-              compile('<h2>Foo Engine</h2>', {
-                moduleName: 'my-app/templates/application.hbs',
-              })
-            );
-          },
-        })
-      );
-      this.add(
-        'engine:bar',
-        Engine.extend({
-          router: null,
-          init() {
-            this._super(...arguments);
-            this.register(
-              'template:application',
-              compile('<h2>Bar Engine</h2>', {
-                moduleName: 'my-app/templates/application.hbs',
-              })
-            );
-          },
-        })
-      );
-
-      return this.visit('/bound-engine-name').then(() => {
-        this.assertInnerHTML('<!---->');
-
-        this.runTask(() => set(controller, 'engineName', 'foo'));
-
-        this.assertInnerHTML('<h2>Foo Engine</h2>');
-
-        this.runTask(() => set(controller, 'engineName', undefined));
-
-        this.assertInnerHTML('<!---->');
-
-        this.runTask(() => set(controller, 'engineName', 'foo'));
-
-        this.assertInnerHTML('<h2>Foo Engine</h2>');
-
-        this.runTask(() => set(controller, 'engineName', 'bar'));
-
-        this.assertInnerHTML('<h2>Bar Engine</h2>');
-
-        this.runTask(() => set(controller, 'engineName', 'foo'));
-
-        this.assertInnerHTML('<h2>Foo Engine</h2>');
-
-        this.runTask(() => set(controller, 'engineName', null));
-
-        this.assertInnerHTML('<!---->');
-      });
-    }
-
-    ['@test it declares the event dispatcher as a singleton']() {
-      this.router.map(function() {
-        this.route('engine-event-dispatcher-singleton');
-      });
-
-      let controller;
-      let component;
-
-      this.add(
-        'controller:engine-event-dispatcher-singleton',
-        Controller.extend({
-          init() {
-            this._super(...arguments);
-            controller = this;
-          },
-        })
-      );
-      this.addTemplate('engine-event-dispatcher-singleton', '{{mount "foo"}}');
-
-      this.add(
-        'engine:foo',
-        Engine.extend({
-          router: null,
-          init() {
-            this._super(...arguments);
-            this.register(
-              'template:application',
-              compile('<h2>Foo Engine: {{tagless-component}}</h2>', {
-                moduleName: 'my-app/templates/application.hbs',
-              })
-            );
-            this.register(
-              'component:tagless-component',
-              Component.extend({
-                tagName: '',
-                init() {
-                  this._super(...arguments);
-                  component = this;
-                },
-              })
-            );
-            this.register(
-              'template:components/tagless-component',
-              compile('Tagless Component', {
-                moduleName: 'my-app/templates/components/tagless-component.hbs',
-              })
-            );
-          },
-        })
-      );
-
-      return this.visit('/engine-event-dispatcher-singleton').then(() => {
-        this.assertInnerHTML('<h2>Foo Engine: Tagless Component</h2>');
-
-        let controllerOwnerEventDispatcher = getOwner(controller).lookup('event_dispatcher:main');
-        let taglessComponentOwnerEventDispatcher = getOwner(component).lookup(
-          'event_dispatcher:main'
-        );
-
-        this.assert.strictEqual(
-          controllerOwnerEventDispatcher,
-          taglessComponentOwnerEventDispatcher
-        );
-      });
-    }
-  }
-);
-
-if (EMBER_ENGINES_MOUNT_PARAMS) {
-  moduleFor(
-    '{{mount}} params tests',
-    class extends ApplicationTest {
-      constructor() {
-        super(...arguments);
-
-        this.add(
-          'engine:paramEngine',
-          Engine.extend({
-            router: null,
-            init() {
-              this._super(...arguments);
-              this.register(
-                'template:application',
-                compile('<h2>Param Engine: {{model.foo}}</h2>', {
-                  moduleName: 'my-app/templates/application.hbs',
-                })
-              );
-            },
-          })
-        );
-      }
-
-      ['@test it renders with static parameters']() {
-        this.router.map(function() {
-          this.route('engine-params-static');
-        });
-        this.addTemplate('engine-params-static', '{{mount "paramEngine" model=(hash foo="bar")}}');
-
-        return this.visit('/engine-params-static').then(() => {
-          this.assertInnerHTML('<h2>Param Engine: bar</h2>');
-        });
-      }
-
-      ['@test it renders with bound parameters']() {
-        this.router.map(function() {
-          this.route('engine-params-bound');
-        });
-        let controller;
-        this.add(
-          'controller:engine-params-bound',
-          Controller.extend({
-            boundParamValue: null,
-            init() {
-              this._super();
-              controller = this;
-            },
-          })
-        );
-        this.addTemplate(
-          'engine-params-bound',
-          '{{mount "paramEngine" model=(hash foo=boundParamValue)}}'
-        );
-
-        return this.visit('/engine-params-bound').then(() => {
-          this.assertInnerHTML('<h2>Param Engine: </h2>');
-
-          this.runTask(() => set(controller, 'boundParamValue', 'bar'));
-
-          this.assertInnerHTML('<h2>Param Engine: bar</h2>');
-
-          this.runTask(() => set(controller, 'boundParamValue', undefined));
-
-          this.assertInnerHTML('<h2>Param Engine: </h2>');
-
-          this.runTask(() => set(controller, 'boundParamValue', 'bar'));
-
-          this.assertInnerHTML('<h2>Param Engine: bar</h2>');
-
-          this.runTask(() => set(controller, 'boundParamValue', 'baz'));
-
-          this.assertInnerHTML('<h2>Param Engine: baz</h2>');
-
-          this.runTask(() => set(controller, 'boundParamValue', 'bar'));
-
-          this.assertInnerHTML('<h2>Param Engine: bar</h2>');
-
-          this.runTask(() => set(controller, 'boundParamValue', null));
-
-          this.assertInnerHTML('<h2>Param Engine: </h2>');
-        });
-      }
-
-      ['@test it renders contextual components passed as parameter values']() {
-        this.router.map(function() {
-          this.route('engine-params-contextual-component');
-        });
-
-        this.addComponent('foo-component', {
-          template: `foo-component rendered! - {{app-bar-component}}`,
-        });
-        this.addComponent('app-bar-component', {
-          ComponentClass: Component.extend({ tagName: '' }),
-          template: 'rendered app-bar-component from the app',
-        });
-        this.add(
-          'engine:componentParamEngine',
-          Engine.extend({
-            router: null,
-            init() {
-              this._super(...arguments);
-              this.register(
-                'template:application',
-                compile('{{model.foo}}', {
-                  moduleName: 'my-app/templates/application.hbs',
-                })
-              );
-            },
-          })
-        );
-        this.addTemplate(
-          'engine-params-contextual-component',
-          '{{mount "componentParamEngine" model=(hash foo=(component "foo-component"))}}'
-        );
-
-        return this.visit('/engine-params-contextual-component').then(() => {
-          this.assertComponentElement(this.firstChild, {
-            content: 'foo-component rendered! - rendered app-bar-component from the app',
-          });
-        });
-      }
-    }
-  );
-}

data/dist/es/ember-glimmer/tests/integration/outlet-test.js

@@ -1,318 +0,0 @@
-import { RenderingTest, moduleFor } from '../utils/test-case';
-import { runAppend } from 'internal-test-helpers';
-import { set } from 'ember-metal';
-
-moduleFor(
-  'outlet view',
-  class extends RenderingTest {
-    constructor() {
-      super(...arguments);
-
-      let CoreOutlet = this.owner.factoryFor('view:-outlet');
-
-      this.component = CoreOutlet.create();
-    }
-
-    ['@test should not error when initial rendered template is undefined']() {
-      let outletState = {
-        render: {
-          owner: this.owner,
-          into: undefined,
-          outlet: 'main',
-          name: 'application',
-          controller: undefined,
-          template: undefined,
-        },
-
-        outlets: Object.create(null),
-      };
-
-      this.runTask(() => this.component.setOutletState(outletState));
-
-      runAppend(this.component);
-
-      this.assertText('');
-    }
-
-    ['@test should render the outlet when set after DOM insertion']() {
-      let outletState = {
-        render: {
-          owner: this.owner,
-          into: undefined,
-          outlet: 'main',
-          name: 'application',
-          controller: undefined,
-          template: undefined,
-        },
-
-        outlets: Object.create(null),
-      };
-
-      this.runTask(() => this.component.setOutletState(outletState));
-
-      runAppend(this.component);
-
-      this.assertText('');
-
-      this.registerTemplate('application', 'HI{{outlet}}');
-      outletState = {
-        render: {
-          owner: this.owner,
-          into: undefined,
-          outlet: 'main',
-          name: 'application',
-          controller: {},
-          template: this.owner.lookup('template:application'),
-        },
-        outlets: Object.create(null),
-      };
-
-      this.runTask(() => this.component.setOutletState(outletState));
-
-      this.assertText('HI');
-
-      this.assertStableRerender();
-
-      this.registerTemplate('index', '<p>BYE</p>');
-      outletState.outlets.main = {
-        render: {
-          owner: this.owner,
-          into: undefined,
-          outlet: 'main',
-          name: 'index',
-          controller: {},
-          template: this.owner.lookup('template:index'),
-        },
-        outlets: Object.create(null),
-      };
-
-      this.runTask(() => this.component.setOutletState(outletState));
-
-      this.assertText('HIBYE');
-    }
-
-    ['@test should render the outlet when set before DOM insertion']() {
-      this.registerTemplate('application', 'HI{{outlet}}');
-      let outletState = {
-        render: {
-          owner: this.owner,
-          into: undefined,
-          outlet: 'main',
-          name: 'application',
-          controller: {},
-          template: this.owner.lookup('template:application'),
-        },
-        outlets: Object.create(null),
-      };
-
-      this.runTask(() => this.component.setOutletState(outletState));
-
-      runAppend(this.component);
-
-      this.assertText('HI');
-
-      this.assertStableRerender();
-
-      this.registerTemplate('index', '<p>BYE</p>');
-      outletState.outlets.main = {
-        render: {
-          owner: this.owner,
-          into: undefined,
-          outlet: 'main',
-          name: 'index',
-          controller: {},
-          template: this.owner.lookup('template:index'),
-        },
-        outlets: Object.create(null),
-      };
-
-      this.runTask(() => this.component.setOutletState(outletState));
-
-      this.assertText('HIBYE');
-    }
-
-    ['@test should support an optional name']() {
-      this.registerTemplate('application', '<h1>HI</h1>{{outlet "special"}}');
-      let outletState = {
-        render: {
-          owner: this.owner,
-          into: undefined,
-          outlet: 'main',
-          name: 'application',
-          controller: {},
-          template: this.owner.lookup('template:application'),
-        },
-        outlets: Object.create(null),
-      };
-
-      this.runTask(() => this.component.setOutletState(outletState));
-
-      runAppend(this.component);
-
-      this.assertText('HI');
-
-      this.assertStableRerender();
-
-      this.registerTemplate('special', '<p>BYE</p>');
-      outletState.outlets.special = {
-        render: {
-          owner: this.owner,
-          into: undefined,
-          outlet: 'main',
-          name: 'special',
-          controller: {},
-          template: this.owner.lookup('template:special'),
-        },
-        outlets: Object.create(null),
-      };
-
-      this.runTask(() => this.component.setOutletState(outletState));
-
-      this.assertText('HIBYE');
-    }
-
-    ['@test does not default outlet name when positional argument is present']() {
-      this.registerTemplate('application', '<h1>HI</h1>{{outlet someUndefinedThing}}');
-      let outletState = {
-        render: {
-          owner: this.owner,
-          into: undefined,
-          outlet: 'main',
-          name: 'application',
-          controller: {},
-          template: this.owner.lookup('template:application'),
-        },
-        outlets: Object.create(null),
-      };
-
-      this.runTask(() => this.component.setOutletState(outletState));
-
-      runAppend(this.component);
-
-      this.assertText('HI');
-
-      this.assertStableRerender();
-
-      this.registerTemplate('special', '<p>BYE</p>');
-      outletState.outlets.main = {
-        render: {
-          owner: this.owner,
-          into: undefined,
-          outlet: 'main',
-          name: 'special',
-          controller: {},
-          template: this.owner.lookup('template:special'),
-        },
-        outlets: Object.create(null),
-      };
-
-      this.runTask(() => this.component.setOutletState(outletState));
-
-      this.assertText('HI');
-    }
-
-    ['@test should support bound outlet name']() {
-      let controller = { outletName: 'foo' };
-      this.registerTemplate('application', '<h1>HI</h1>{{outlet outletName}}');
-      let outletState = {
-        render: {
-          owner: this.owner,
-          into: undefined,
-          outlet: 'main',
-          name: 'application',
-          controller,
-          template: this.owner.lookup('template:application'),
-        },
-        outlets: Object.create(null),
-      };
-
-      this.runTask(() => this.component.setOutletState(outletState));
-
-      runAppend(this.component);
-
-      this.assertText('HI');
-
-      this.assertStableRerender();
-
-      this.registerTemplate('foo', '<p>FOO</p>');
-      outletState.outlets.foo = {
-        render: {
-          owner: this.owner,
-          into: undefined,
-          outlet: 'main',
-          name: 'foo',
-          controller: {},
-          template: this.owner.lookup('template:foo'),
-        },
-        outlets: Object.create(null),
-      };
-
-      this.registerTemplate('bar', '<p>BAR</p>');
-      outletState.outlets.bar = {
-        render: {
-          owner: this.owner,
-          into: undefined,
-          outlet: 'main',
-          name: 'bar',
-          controller: {},
-          template: this.owner.lookup('template:bar'),
-        },
-        outlets: Object.create(null),
-      };
-
-      this.runTask(() => this.component.setOutletState(outletState));
-
-      this.assertText('HIFOO');
-
-      this.runTask(() => set(controller, 'outletName', 'bar'));
-
-      this.assertText('HIBAR');
-    }
-
-    ['@test outletState can pass through user code (liquid-fire initimate API) ']() {
-      this.registerTemplate(
-        'outer',
-        'A{{#-with-dynamic-vars outletState=(identity (-get-dynamic-var "outletState"))}}B{{outlet}}D{{/-with-dynamic-vars}}E'
-      );
-      this.registerTemplate('inner', 'C');
-
-      // This looks like it doesn't do anything, but its presence
-      // guarantees that the outletState gets converted from a reference
-      // to a value and then back to a reference. That is what we're
-      // testing here.
-      this.registerHelper('identity', ([a]) => a);
-
-      let outletState = {
-        render: {
-          owner: this.owner,
-          into: undefined,
-          outlet: 'main',
-          name: 'outer',
-          controller: {},
-          template: this.owner.lookup('template:outer'),
-        },
-        outlets: {
-          main: {
-            render: {
-              owner: this.owner,
-              into: undefined,
-              outlet: 'main',
-              name: 'inner',
-              controller: {},
-              template: this.owner.lookup('template:inner'),
-            },
-            outlets: Object.create(null),
-          },
-        },
-      };
-
-      this.runTask(() => this.component.setOutletState(outletState));
-
-      runAppend(this.component);
-
-      this.assertText('ABCDE');
-
-      this.assertStableRerender();
-    }
-  }
-);