discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/internal-test-helpers/lib/test-cases/abstract.js

@@ -1,222 +0,0 @@
-/* global Element */
-
-import { assign } from '@ember/polyfills';
-import { getCurrentRunLoop, hasScheduledTimers, next, run } from '@ember/runloop';
-
-import NodeQuery from './node-query';
-import equalInnerHTML from '../equal-inner-html';
-import equalTokens from '../equal-tokens';
-import { equalsElement, regex, classes } from '../matchers';
-import { Promise } from 'rsvp';
-
-const TextNode = window.Text;
-const HTMLElement = window.HTMLElement;
-const Comment = window.Comment;
-
-function isMarker(node) {
-  if (node instanceof Comment && node.textContent === '') {
-    return true;
-  }
-
-  if (node instanceof TextNode && node.textContent === '') {
-    return true;
-  }
-
-  return false;
-}
-
-export default class AbstractTestCase {
-  constructor(assert) {
-    this.element = null;
-    this.snapshot = null;
-    this.assert = assert;
-
-    let { fixture } = this;
-    if (fixture) {
-      this.setupFixture(fixture);
-    }
-  }
-
-  teardown() {}
-  afterEach() {}
-
-  runTask(callback) {
-    return run(callback);
-  }
-
-  runTaskNext() {
-    return new Promise(resolve => {
-      return next(resolve);
-    });
-  }
-
-  setupFixture(innerHTML) {
-    let fixture = document.getElementById('qunit-fixture');
-    fixture.innerHTML = innerHTML;
-  }
-
-  // The following methods require `this.element` to work
-
-  get firstChild() {
-    return this.nthChild(0);
-  }
-
-  nthChild(n) {
-    let i = 0;
-    let node = this.element.firstChild;
-
-    while (node) {
-      if (!isMarker(node)) {
-        i++;
-      }
-
-      if (i > n) {
-        break;
-      } else {
-        node = node.nextSibling;
-      }
-    }
-
-    return node;
-  }
-
-  get nodesCount() {
-    let count = 0;
-    let node = this.element.firstChild;
-
-    while (node) {
-      if (!isMarker(node)) {
-        count++;
-      }
-
-      node = node.nextSibling;
-    }
-
-    return count;
-  }
-
-  $(sel) {
-    if (sel instanceof Element) {
-      return NodeQuery.element(sel);
-    } else if (typeof sel === 'string') {
-      return NodeQuery.query(sel, this.element);
-    } else if (sel !== undefined) {
-      throw new Error(`Invalid this.$(${sel})`);
-    } else {
-      return NodeQuery.element(this.element);
-    }
-  }
-
-  wrap(element) {
-    return NodeQuery.element(element);
-  }
-
-  click(selector) {
-    let element;
-    if (typeof selector === 'string') {
-      element = this.element.querySelector(selector);
-    } else {
-      element = selector;
-    }
-
-    let event = element.click();
-
-    return this.runLoopSettled(event);
-  }
-
-  // TODO: Find a better name 😎
-  runLoopSettled(value) {
-    return new Promise(function(resolve) {
-      // Every 5ms, poll for the async thing to have finished
-      let watcher = setInterval(() => {
-        // If there are scheduled timers or we are inside of a run loop, keep polling
-        if (hasScheduledTimers() || getCurrentRunLoop()) {
-          return;
-        }
-
-        // Stop polling
-        clearInterval(watcher);
-
-        // Synchronously resolve the promise
-        resolve(value);
-      }, 5);
-    });
-  }
-
-  textValue() {
-    return this.element.textContent;
-  }
-
-  takeSnapshot() {
-    let snapshot = (this.snapshot = []);
-
-    let node = this.element.firstChild;
-
-    while (node) {
-      if (!isMarker(node)) {
-        snapshot.push(node);
-      }
-
-      node = node.nextSibling;
-    }
-
-    return snapshot;
-  }
-
-  assertText(text) {
-    this.assert.strictEqual(
-      this.textValue(),
-      text,
-      `#qunit-fixture content should be: \`${text}\``
-    );
-  }
-
-  assertInnerHTML(html) {
-    equalInnerHTML(this.assert, this.element, html);
-  }
-
-  assertHTML(html) {
-    equalTokens(this.element, html, `#qunit-fixture content should be: \`${html}\``);
-  }
-
-  assertElement(node, { ElementType = HTMLElement, tagName, attrs = null, content = null }) {
-    if (!(node instanceof ElementType)) {
-      throw new Error(`Expecting a ${ElementType.name}, but got ${node}`);
-    }
-
-    equalsElement(this.assert, node, tagName, attrs, content);
-  }
-
-  assertComponentElement(
-    node,
-    { ElementType = HTMLElement, tagName = 'div', attrs = null, content = null }
-  ) {
-    attrs = assign({}, { id: regex(/^ember\d*$/), class: classes('ember-view') }, attrs || {});
-    this.assertElement(node, { ElementType, tagName, attrs, content });
-  }
-
-  assertSameNode(actual, expected) {
-    this.assert.strictEqual(actual, expected, 'DOM node stability');
-  }
-
-  assertInvariants(oldSnapshot, newSnapshot) {
-    oldSnapshot = oldSnapshot || this.snapshot;
-    newSnapshot = newSnapshot || this.takeSnapshot();
-
-    this.assert.strictEqual(newSnapshot.length, oldSnapshot.length, 'Same number of nodes');
-
-    for (let i = 0; i < oldSnapshot.length; i++) {
-      this.assertSameNode(newSnapshot[i], oldSnapshot[i]);
-    }
-  }
-
-  assertPartialInvariants(start, end) {
-    this.assertInvariants(this.snapshot, this.takeSnapshot().slice(start, end));
-  }
-
-  assertStableRerender() {
-    this.takeSnapshot();
-    this.runTask(() => this.rerender());
-    this.assertInvariants();
-  }
-}

data/dist/es/internal-test-helpers/lib/test-cases/application.js

@@ -1,39 +0,0 @@
-import TestResolverApplicationTestCase from './test-resolver-application';
-import Application from '@ember/application';
-import { Router } from 'ember-routing';
-import { assign } from '@ember/polyfills';
-
-export default class ApplicationTestCase extends TestResolverApplicationTestCase {
-  constructor() {
-    super(...arguments);
-
-    let { applicationOptions } = this;
-    this.application = this.runTask(this.createApplication.bind(this, applicationOptions));
-
-    this.resolver = this.application.__registry__.resolver;
-
-    if (this.resolver) {
-      this.resolver.add('router:main', Router.extend(this.routerOptions));
-    }
-  }
-
-  createApplication(myOptions = {}, MyApplication = Application) {
-    return MyApplication.create(myOptions);
-  }
-
-  get applicationOptions() {
-    return assign(super.applicationOptions, {
-      autoboot: false,
-    });
-  }
-
-  get appRouter() {
-    return this.applicationInstance.lookup('router:main');
-  }
-
-  transitionTo() {
-    return this.runTask(() => {
-      return this.appRouter.transitionTo(...arguments);
-    });
-  }
-}

data/dist/es/internal-test-helpers/lib/test-cases/autoboot-application.js

@@ -1,34 +0,0 @@
-import TestResolverApplicationTestCase from './test-resolver-application';
-import Application from '@ember/application';
-import { assign } from '@ember/polyfills';
-import { Router } from 'ember-routing';
-
-export default class AutobootApplicationTestCase extends TestResolverApplicationTestCase {
-  createApplication(options, MyApplication = Application) {
-    let myOptions = assign(this.applicationOptions, options);
-    let application = (this.application = MyApplication.create(myOptions));
-    this.resolver = application.__registry__.resolver;
-
-    if (this.resolver) {
-      this.resolver.add('router:main', Router.extend(this.routerOptions));
-    }
-
-    return application;
-  }
-
-  visit(url) {
-    return this.application.boot().then(() => {
-      return this.applicationInstance.visit(url);
-    });
-  }
-
-  get applicationInstance() {
-    let { application } = this;
-
-    if (!application) {
-      return undefined;
-    }
-
-    return application.__deprecatedInstance__;
-  }
-}

data/dist/es/internal-test-helpers/lib/test-cases/default-resolver-application.js

@@ -1,43 +0,0 @@
-import AbstractApplicationTestCase from './abstract-application';
-import DefaultResolver from '@ember/application/globals-resolver';
-import Application from '@ember/application';
-import { setTemplates, setTemplate } from 'ember-glimmer';
-import { assign } from '@ember/polyfills';
-import { Router } from 'ember-routing';
-
-export default class ApplicationTestCase extends AbstractApplicationTestCase {
-  createApplication() {
-    let application = (this.application = Application.create(this.applicationOptions));
-    application.Router = Router.extend(this.routerOptions);
-    return application;
-  }
-
-  get applicationOptions() {
-    return assign(super.applicationOptions, {
-      name: 'TestApp',
-      autoboot: false,
-      Resolver: DefaultResolver,
-    });
-  }
-
-  afterEach() {
-    setTemplates({});
-    return super.afterEach();
-  }
-
-  get appRouter() {
-    return this.applicationInstance.lookup('router:main');
-  }
-
-  transitionTo() {
-    return this.runTask(() => {
-      return this.appRouter.transitionTo(...arguments);
-    });
-  }
-
-  addTemplate(name, templateString) {
-    let compiled = this.compile(templateString);
-    setTemplate(name, compiled);
-    return compiled;
-  }
-}

data/dist/es/internal-test-helpers/lib/test-cases/node-query.js

@@ -1,120 +0,0 @@
-/* global Node */
-
-import { assert } from '@ember/debug';
-import { fireEvent, focus, matches } from '../system/synthetic-events';
-
-export default class NodeQuery {
-  static query(selector, context = document) {
-    assert(`Invalid second parameter to NodeQuery.query`, context && context instanceof Node);
-    return new NodeQuery(toArray(context.querySelectorAll(selector)));
-  }
-
-  static element(element) {
-    return new NodeQuery([element]);
-  }
-
-  constructor(nodes) {
-    assert('NodeQuery must be initialized with a literal array', Array.isArray(nodes));
-    this.nodes = nodes;
-
-    for (let i = 0; i < nodes.length; i++) {
-      this[i] = nodes[i];
-    }
-
-    this.length = nodes.length;
-
-    Object.freeze(this);
-  }
-
-  find(selector) {
-    assertSingle(this);
-
-    return this[0].querySelector(selector);
-  }
-
-  findAll(selector) {
-    let nodes = [];
-
-    this.nodes.forEach(node => {
-      nodes.push(...node.querySelectorAll(selector));
-    });
-
-    return new NodeQuery(nodes);
-  }
-
-  trigger(eventName, options) {
-    return this.nodes.map(node => fireEvent(node, eventName, options));
-  }
-
-  click() {
-    return this.trigger('click');
-  }
-
-  focus() {
-    this.nodes.forEach(focus);
-  }
-
-  text() {
-    return this.nodes.map(node => node.textContent).join('');
-  }
-
-  attr(name) {
-    if (arguments.length !== 1) {
-      throw new Error('not implemented');
-    }
-
-    assertSingle(this);
-
-    return this.nodes[0].getAttribute(name);
-  }
-
-  prop(name, value) {
-    if (arguments.length > 1) {
-      return this.setProp(name, value);
-    }
-
-    assertSingle(this);
-
-    return this.nodes[0][name];
-  }
-
-  setProp(name, value) {
-    this.nodes.forEach(node => (node[name] = value));
-
-    return this;
-  }
-
-  val(value) {
-    if (arguments.length === 1) {
-      return this.setProp('value', value);
-    }
-
-    return this.prop('value');
-  }
-
-  is(selector) {
-    return this.nodes.every(node => matches(node, selector));
-  }
-
-  hasClass(className) {
-    return this.is(`.${className}`);
-  }
-}
-
-function assertSingle(nodeQuery) {
-  if (nodeQuery.length !== 1) {
-    throw new Error(
-      `attr(name) called on a NodeQuery with ${this.nodes.length} elements. Expected one element.`
-    );
-  }
-}
-
-function toArray(nodes) {
-  let out = [];
-
-  for (let i = 0; i < nodes.length; i++) {
-    out.push(nodes[i]);
-  }
-
-  return out;
-}