discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/internal-test-helpers/index.js

@@ -1,31 +0,0 @@
-export { default as factory } from './lib/factory';
-export { default as buildOwner } from './lib/build-owner';
-export { default as confirmExport } from './lib/confirm-export';
-export { default as equalInnerHTML } from './lib/equal-inner-html';
-export { default as equalTokens } from './lib/equal-tokens';
-export { default as moduleFor } from './lib/module-for';
-export { default as strip } from './lib/strip';
-export { default as applyMixins } from './lib/apply-mixins';
-export { default as getTextOf } from './lib/get-text-of';
-export { equalsElement, classes, styles, regex } from './lib/matchers';
-export { runAppend, runDestroy } from './lib/run';
-
-export { default as AbstractTestCase } from './lib/test-cases/abstract';
-export { default as AbstractApplicationTestCase } from './lib/test-cases/abstract-application';
-export { default as ApplicationTestCase } from './lib/test-cases/application';
-export { default as QueryParamTestCase } from './lib/test-cases/query-param';
-export { default as AbstractRenderingTestCase } from './lib/test-cases/abstract-rendering';
-export { default as RenderingTestCase } from './lib/test-cases/rendering';
-export { default as RouterTestCase } from './lib/test-cases/router';
-export { default as AutobootApplicationTestCase } from './lib/test-cases/autoboot-application';
-export {
-  default as DefaultResolverApplicationTestCase,
-} from './lib/test-cases/default-resolver-application';
-
-export {
-  default as TestResolver,
-  ModuleBasedResolver as ModuleBasedTestResolver,
-} from './lib/test-resolver';
-
-export { isIE11 } from './lib/browser-detect';
-export { verifyInjection, verifyRegistration } from './lib/registry-check';

data/dist/es/internal-test-helpers/lib/apply-mixins.js

@@ -1,37 +0,0 @@
-import { assign } from '@ember/polyfills';
-import getAllPropertyNames from './get-all-property-names';
-
-function isGenerator(mixin) {
-  return Array.isArray(mixin.cases) && typeof mixin.generate === 'function';
-}
-
-export default function applyMixins(TestClass, ...mixins) {
-  mixins.forEach(mixinOrGenerator => {
-    let mixin;
-
-    if (isGenerator(mixinOrGenerator)) {
-      let generator = mixinOrGenerator;
-      mixin = {};
-
-      generator.cases.forEach((value, idx) => {
-        assign(mixin, generator.generate(value, idx));
-      });
-
-      assign(TestClass.prototype, mixin);
-    } else if (typeof mixinOrGenerator === 'function') {
-      let properties = getAllPropertyNames(mixinOrGenerator);
-      mixin = new mixinOrGenerator();
-
-      properties.forEach(name => {
-        TestClass.prototype[name] = function() {
-          return mixin[name].apply(mixin, arguments);
-        };
-      });
-    } else {
-      mixin = mixinOrGenerator;
-      assign(TestClass.prototype, mixin);
-    }
-  });
-
-  return TestClass;
-}

data/dist/es/internal-test-helpers/lib/browser-detect.js

@@ -1,4 +0,0 @@
-// `window.ActiveXObject` is "falsey" in IE11 (but not `undefined` or `false`)
-// `"ActiveXObject" in window` returns `true` in all IE versions
-// only IE11 will pass _both_ of these conditions
-export const isIE11 = !window.ActiveXObject && 'ActiveXObject' in window;

data/dist/es/internal-test-helpers/lib/build-owner.js

@@ -1,49 +0,0 @@
-import { Registry } from 'container';
-import { Router } from 'ember-routing';
-import ApplicationInstance from '@ember/application/instance';
-import Application from '@ember/application';
-import { RegistryProxyMixin, ContainerProxyMixin, Object as EmberObject } from 'ember-runtime';
-
-class ResolverWrapper {
-  constructor(resolver) {
-    this.resolver = resolver;
-  }
-
-  create() {
-    return this.resolver;
-  }
-}
-
-export default function buildOwner(options = {}) {
-  let ownerOptions = options.ownerOptions || {};
-  let resolver = options.resolver;
-  let bootOptions = options.bootOptions || {};
-
-  let Owner = EmberObject.extend(RegistryProxyMixin, ContainerProxyMixin);
-
-  let namespace = new EmberObject({
-    Resolver: new ResolverWrapper(resolver),
-  });
-
-  let fallbackRegistry = Application.buildRegistry(namespace);
-  fallbackRegistry.register('router:main', Router);
-
-  let registry = new Registry({
-    fallback: fallbackRegistry,
-  });
-
-  ApplicationInstance.setupRegistry(registry, bootOptions);
-
-  let owner = Owner.create(
-    {
-      __registry__: registry,
-      __container__: null,
-    },
-    ownerOptions
-  );
-
-  let container = registry.container({ owner });
-  owner.__container__ = container;
-
-  return owner;
-}

data/dist/es/internal-test-helpers/lib/confirm-export.js

@@ -1,45 +0,0 @@
-import require from 'require';
-
-function getDescriptor(obj, path) {
-  let parts = path.split('.');
-  let value = obj;
-  for (let i = 0; i < parts.length - 1; i++) {
-    let part = parts[i];
-    value = value[part];
-    if (!value) {
-      return undefined;
-    }
-  }
-  let last = parts[parts.length - 1];
-  return Object.getOwnPropertyDescriptor(value, last);
-}
-
-export default function confirmExport(Ember, assert, path, moduleId, exportName) {
-  try {
-    let desc = getDescriptor(Ember, path);
-    assert.ok(desc, `the ${path} property exists on the Ember global`);
-
-    if (typeof exportName === 'string') {
-      let mod = require(moduleId);
-      assert.equal(desc.value, mod[exportName], `Ember.${path} is exported correctly`);
-      assert.notEqual(mod[exportName], undefined, `Ember.${path} is not \`undefined\``);
-    } else if ('value' in desc) {
-      assert.equal(desc.value, exportName.value, `Ember.${path} is exported correctly`);
-    } else {
-      let mod = require(moduleId);
-      assert.equal(desc.get, mod[exportName.get], `Ember.${path} getter is exported correctly`);
-      assert.notEqual(desc.get, undefined, `Ember.${path} getter is not undefined`);
-
-      if (exportName.set) {
-        assert.equal(desc.set, mod[exportName.set], `Ember.${path} setter is exported correctly`);
-        assert.notEqual(desc.set, undefined, `Ember.${path} setter is not undefined`);
-      }
-    }
-  } catch (error) {
-    assert.pushResult({
-      result: false,
-      message: `An error occured while testing ${path} is exported from ${moduleId}.`,
-      source: error,
-    });
-  }
-}

data/dist/es/internal-test-helpers/lib/ember-dev/assertion.js

@@ -1,87 +0,0 @@
-import { callWithStub, checkTest } from './utils';
-const BREAK = {};
-/*
-  This assertion class is used to test assertions made using Ember.assert.
-  It injects two helpers onto `window`:
-
-  - expectAssertion(func: Function, [expectedMessage: String | RegExp])
-
-  This function calls `func` and asserts that `Ember.assert` is invoked during
-  the execution. Moreover, it takes a String or a RegExp as a second optional
-  argument that can be used to test if a specific assertion message was
-  generated.
-
-  - ignoreAssertion(func: Function)
-
-  This function calls `func` and disables `Ember.assert` during the execution.
-  In particular, this prevents `Ember.assert` from throw errors that would
-  disrupt the control flow.
-*/
-export default class AssertionAssert {
-    constructor(env) {
-        this.env = env;
-    }
-    reset() { }
-    assert() { }
-    inject() {
-        let expectAssertion = (func, expectedMessage) => {
-            let { assert } = QUnit.config.current;
-            if (this.env.runningProdBuild) {
-                assert.ok(true, 'Assertions disabled in production builds.');
-                return;
-            }
-            let sawCall = false;
-            let actualMessage = undefined;
-            // The try-catch statement is used to "exit" `func` as soon as
-            // the first useful assertion has been produced.
-            try {
-                callWithStub(this.env, 'assert', func, (message, test) => {
-                    sawCall = true;
-                    if (checkTest(test)) {
-                        return;
-                    }
-                    actualMessage = message;
-                    throw BREAK;
-                });
-            }
-            catch (e) {
-                if (e !== BREAK) {
-                    throw e;
-                }
-            }
-            check(assert, sawCall, actualMessage, expectedMessage);
-        };
-        let ignoreAssertion = func => {
-            callWithStub(this.env, 'assert', func);
-        };
-        window.expectAssertion = expectAssertion;
-        window.ignoreAssertion = ignoreAssertion;
-    }
-    restore() {
-        window.expectAssertion = null;
-        window.ignoreAssertion = null;
-    }
-}
-function check(assert, sawCall, actualMessage, expectedMessage) {
-    // Run assertions in an order that is useful when debugging a test failure.
-    if (!sawCall) {
-        assert.ok(false, `Expected Ember.assert to be called (Not called with any value).`);
-    }
-    else if (!actualMessage) {
-        assert.ok(false, `Expected a failing Ember.assert (Ember.assert called, but without a failing test).`);
-    }
-    else {
-        if (expectedMessage) {
-            if (expectedMessage instanceof RegExp) {
-                assert.ok(expectedMessage.test(actualMessage), `Expected failing Ember.assert: '${expectedMessage}', but got '${actualMessage}'.`);
-            }
-            else {
-                assert.equal(actualMessage, expectedMessage, `Expected failing Ember.assert: '${expectedMessage}', but got '${actualMessage}'.`);
-            }
-        }
-        else {
-            // Positive assertion that assert was called
-            assert.ok(true, 'Expected a failing Ember.assert.');
-        }
-    }
-}

data/dist/es/internal-test-helpers/lib/ember-dev/containers.js

@@ -1,34 +0,0 @@
-import { Container } from 'container';
-
-function ContainersAssert(env) {
-  this.env = env;
-}
-
-const { _leakTracking: containerLeakTracking } = Container;
-
-ContainersAssert.prototype = {
-  reset: function() {},
-  inject: function() {},
-  assert: function() {
-    if (containerLeakTracking === undefined) return;
-    let { config } = QUnit;
-    let { testName, testId, module: { name: moduleName }, finish: originalFinish } = config.current;
-    config.current.finish = function() {
-      originalFinish.call(this);
-      originalFinish = undefined;
-      config.queue.unshift(function() {
-        if (containerLeakTracking.hasContainers()) {
-          containerLeakTracking.reset();
-          // eslint-disable-next-line no-console
-          console.assert(
-            false,
-            `Leaked container after test ${moduleName}: ${testName} testId=${testId}`
-          );
-        }
-      });
-    };
-  },
-  restore: function() {},
-};
-
-export default ContainersAssert;

data/dist/es/internal-test-helpers/lib/ember-dev/debug.js

@@ -1,47 +0,0 @@
-import MethodCallTracker from './method-call-tracker';
-class DebugAssert {
-    constructor(methodName, env) {
-        this.methodName = methodName;
-        this.env = env;
-        this.tracker = null;
-    }
-    inject() { }
-    restore() {
-        this.reset();
-    }
-    reset() {
-        if (this.tracker) {
-            this.tracker.restoreMethod();
-        }
-        this.tracker = null;
-    }
-    assert() {
-        if (this.tracker) {
-            this.tracker.assert();
-        }
-    }
-    // Run an expectation callback within the context of a new tracker, optionally
-    // accepting a function to run, which asserts immediately
-    runExpectation(func, callback) {
-        let originalTracker = null;
-        // When helpers are passed a callback, they get a new tracker context
-        if (func) {
-            originalTracker = this.tracker;
-            this.tracker = null;
-        }
-        if (!this.tracker) {
-            this.tracker = new MethodCallTracker(this.env, this.methodName);
-        }
-        // Yield to caller with tracker instance
-        callback(this.tracker);
-        // Once the given callback is invoked, the pending assertions should be
-        // flushed immediately
-        if (func) {
-            func();
-            this.assert();
-            this.reset();
-            this.tracker = originalTracker;
-        }
-    }
-}
-export default DebugAssert;

data/dist/es/internal-test-helpers/lib/ember-dev/deprecation.js

@@ -1,71 +0,0 @@
-import DebugAssert from './debug';
-import { callWithStub } from './utils';
-class DeprecationAssert extends DebugAssert {
-    constructor(env) {
-        super('deprecate', env);
-    }
-    inject() {
-        // Expects no deprecation to happen within a function, or if no function is
-        // passed, from the time of calling until the end of the test.
-        //
-        // expectNoDeprecation(function() {
-        //   fancyNewThing();
-        // });
-        //
-        // expectNoDeprecation();
-        // Ember.deprecate("Old And Busted");
-        //
-        let expectNoDeprecation = func => {
-            if (typeof func !== 'function') {
-                func = undefined;
-            }
-            this.runExpectation(func, tracker => {
-                if (tracker.isExpectingCalls()) {
-                    throw new Error('expectNoDeprecation was called after expectDeprecation was called!');
-                }
-                tracker.expectNoCalls();
-            });
-        };
-        // Expect a deprecation to happen within a function, or if no function
-        // is pass, from the time of calling until the end of the test. Can be called
-        // multiple times to assert deprecations with different specific messages
-        // were fired.
-        //
-        // expectDeprecation(function() {
-        //   Ember.deprecate("Old And Busted");
-        // }, /* optionalStringOrRegex */);
-        //
-        // expectDeprecation(/* optionalStringOrRegex */);
-        // Ember.deprecate("Old And Busted");
-        //
-        let expectDeprecation = (func, message) => {
-            let actualFunc;
-            if (typeof func !== 'function') {
-                message = func;
-                actualFunc = undefined;
-            }
-            else {
-                actualFunc = func;
-            }
-            this.runExpectation(actualFunc, tracker => {
-                if (tracker.isExpectingNoCalls()) {
-                    throw new Error('expectDeprecation was called after expectNoDeprecation was called!');
-                }
-                tracker.expectCall(message, ['id', 'until']);
-            });
-        };
-        let ignoreDeprecation = func => {
-            callWithStub(this.env, 'deprecate', func);
-        };
-        window.expectNoDeprecation = expectNoDeprecation;
-        window.expectDeprecation = expectDeprecation;
-        window.ignoreDeprecation = ignoreDeprecation;
-    }
-    restore() {
-        super.restore();
-        window.expectDeprecation = null;
-        window.expectNoDeprecation = null;
-        window.ignoreDeprecation = null;
-    }
-}
-export default DeprecationAssert;

data/dist/es/internal-test-helpers/lib/ember-dev/index.js

@@ -1,19 +0,0 @@
-import DeprecationAssert from './deprecation';
-import WarningAssert from './warning';
-import AssertionAssert from './assertion';
-import RunLoopAssert from './run-loop';
-import NamespacesAssert from './namespaces';
-import ContainersAssert from './containers';
-
-import { buildCompositeAssert } from './utils';
-
-var EmberDevTestHelperAssert = buildCompositeAssert([
-  DeprecationAssert,
-  WarningAssert,
-  AssertionAssert,
-  RunLoopAssert,
-  NamespacesAssert,
-  ContainersAssert,
-]);
-
-export default EmberDevTestHelperAssert;

data/dist/es/internal-test-helpers/lib/ember-dev/method-call-tracker.js

@@ -1,127 +0,0 @@
-import { checkTest } from './utils';
-export default class MethodCallTracker {
-    constructor(env, methodName) {
-        this._env = env;
-        this._methodName = methodName;
-        this._isExpectingNoCalls = false;
-        this._expectedMessages = [];
-        this._expectedOptionLists = [];
-        this._actuals = [];
-        this._originalMethod = undefined;
-    }
-    stubMethod() {
-        if (this._originalMethod) {
-            // Method is already stubbed
-            return;
-        }
-        let env = this._env;
-        let methodName = this._methodName;
-        this._originalMethod = env.getDebugFunction(methodName);
-        env.setDebugFunction(methodName, (message, test, options) => {
-            let resultOfTest = checkTest(test);
-            this._actuals.push([message, resultOfTest, options]);
-        });
-    }
-    restoreMethod() {
-        if (this._originalMethod) {
-            this._env.setDebugFunction(this._methodName, this._originalMethod);
-        }
-    }
-    expectCall(message, options) {
-        this.stubMethod();
-        this._expectedMessages.push(message || /.*/);
-        this._expectedOptionLists.push(options);
-    }
-    expectNoCalls() {
-        this.stubMethod();
-        this._isExpectingNoCalls = true;
-    }
-    isExpectingNoCalls() {
-        return this._isExpectingNoCalls;
-    }
-    isExpectingCalls() {
-        return !this._isExpectingNoCalls && this._expectedMessages.length;
-    }
-    assert() {
-        let { assert } = QUnit.config.current;
-        let env = this._env;
-        let methodName = this._methodName;
-        let isExpectingNoCalls = this._isExpectingNoCalls;
-        let expectedMessages = this._expectedMessages;
-        let expectedOptionLists = this._expectedOptionLists;
-        let actuals = this._actuals;
-        let o, i, j;
-        if (!isExpectingNoCalls && expectedMessages.length === 0 && actuals.length === 0) {
-            return;
-        }
-        if (env.runningProdBuild) {
-            assert.ok(true, `calls to Ember.${methodName} disabled in production builds.`);
-            return;
-        }
-        if (isExpectingNoCalls) {
-            let actualMessages = [];
-            for (i = 0; i < actuals.length; i++) {
-                if (!actuals[i][1]) {
-                    actualMessages.push(actuals[i][0]);
-                }
-            }
-            assert.ok(actualMessages.length === 0, `Expected no Ember.${methodName} calls, got ${actuals.length}: ${actualMessages.join(', ')}`);
-            return;
-        }
-        let actual;
-        let match = undefined;
-        for (o = 0; o < expectedMessages.length; o++) {
-            const expectedMessage = expectedMessages[o];
-            const expectedOptionList = expectedOptionLists[o];
-            for (i = 0; i < actuals.length; i++) {
-                let matchesMessage = false;
-                let matchesOptionList = false;
-                actual = actuals[i];
-                if (actual[1] === true) {
-                    continue;
-                }
-                if (expectedMessage instanceof RegExp && expectedMessage.test(actual[0])) {
-                    matchesMessage = true;
-                }
-                else if (expectedMessage === actual[0]) {
-                    matchesMessage = true;
-                }
-                if (expectedOptionList === undefined) {
-                    matchesOptionList = true;
-                }
-                else if (actual[2]) {
-                    matchesOptionList = true;
-                    for (j = 0; j < expectedOptionList.length; j++) {
-                        matchesOptionList =
-                            matchesOptionList && actual[2].hasOwnProperty(expectedOptionList[j]);
-                    }
-                }
-                if (matchesMessage && matchesOptionList) {
-                    match = actual;
-                    break;
-                }
-            }
-            const expectedOptionsMessage = expectedOptionList
-                ? `and options: { ${expectedOptionList.join(', ')} }`
-                : 'and no options';
-            const actualOptionsMessage = actual && actual[2]
-                ? `and options: { ${Object.keys(actual[2]).join(', ')} }`
-                : 'and no options';
-            if (!actual) {
-                assert.ok(false, `Received no Ember.${methodName} calls at all, expecting: ${expectedMessage}`);
-            }
-            else if (match && !match[1]) {
-                assert.ok(true, `Received failing Ember.${methodName} call with message: ${match[0]}`);
-            }
-            else if (match && match[1]) {
-                assert.ok(false, `Expected failing Ember.${methodName} call, got succeeding with message: ${match[0]}`);
-            }
-            else if (actual[1]) {
-                assert.ok(false, `Did not receive failing Ember.${methodName} call matching '${expectedMessage}' ${expectedOptionsMessage}, last was success with '${actual[0]}' ${actualOptionsMessage}`);
-            }
-            else if (!actual[1]) {
-                assert.ok(false, `Did not receive failing Ember.${methodName} call matching '${expectedMessage}' ${expectedOptionsMessage}, last was failure with '${actual[0]}' ${actualOptionsMessage}`);
-            }
-        }
-    }
-}