discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-metal/tests/mixin/introspection_test.js

@@ -1,75 +0,0 @@
-// NOTE: A previous iteration differentiated between public and private props
-// as well as methods vs props.  We are just keeping these for testing; the
-// current impl doesn't care about the differences as much...
-
-import { guidFor, NAME_KEY } from 'ember-utils';
-import { mixin, Mixin } from '../..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-const PrivateProperty = Mixin.create({
-  _foo: '_FOO',
-});
-const PublicProperty = Mixin.create({
-  foo: 'FOO',
-});
-const PrivateMethod = Mixin.create({
-  _fooMethod() {},
-});
-const PublicMethod = Mixin.create({
-  fooMethod() {},
-});
-const BarProperties = Mixin.create({
-  _bar: '_BAR',
-  bar: 'bar',
-});
-const BarMethods = Mixin.create({
-  _barMethod() {},
-  barMethod() {},
-});
-
-const Combined = Mixin.create(BarProperties, BarMethods);
-
-let obj;
-
-moduleFor(
-  'Basic introspection',
-  class extends AbstractTestCase {
-    beforeEach() {
-      obj = {};
-      mixin(obj, PrivateProperty, PublicProperty, PrivateMethod, PublicMethod, Combined);
-    }
-
-    ['@test Ember.mixins()'](assert) {
-      function mapGuids(ary) {
-        return ary.map(x => guidFor(x));
-      }
-
-      assert.deepEqual(
-        mapGuids(Mixin.mixins(obj)),
-        mapGuids([
-          PrivateProperty,
-          PublicProperty,
-          PrivateMethod,
-          PublicMethod,
-          Combined,
-          BarProperties,
-          BarMethods,
-        ]),
-        'should return included mixins'
-      );
-    }
-
-    ['@test setting a NAME_KEY on a mixin does not error'](assert) {
-      assert.expect(0);
-
-      let instance = Mixin.create();
-      instance[NAME_KEY] = 'My special name!';
-    }
-
-    ['@test setting a NAME_KEY on a mixin instance does not error'](assert) {
-      assert.expect(0);
-
-      Mixin.create({ [NAME_KEY]: 'My special name' });
-    }
-  }
-);

data/dist/es/ember-metal/tests/mixin/merged_properties_test.js

@@ -1,200 +0,0 @@
-import { Object as EmberObject } from 'ember-runtime';
-import { get, mixin, Mixin } from '../..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Mixin mergedProperties',
-  class extends AbstractTestCase {
-    ['@test defining mergedProperties should merge future version'](assert) {
-      let MixinA = Mixin.create({
-        mergedProperties: ['foo'],
-        foo: { a: true, b: true, c: true },
-      });
-
-      let MixinB = Mixin.create({
-        foo: { d: true, e: true, f: true },
-      });
-
-      let obj = mixin({}, MixinA, MixinB);
-      assert.deepEqual(get(obj, 'foo'), {
-        a: true,
-        b: true,
-        c: true,
-        d: true,
-        e: true,
-        f: true,
-      });
-    }
-
-    ['@test defining mergedProperties on future mixin should merged into past'](assert) {
-      let MixinA = Mixin.create({
-        foo: { a: true, b: true, c: true },
-      });
-
-      let MixinB = Mixin.create({
-        mergedProperties: ['foo'],
-        foo: { d: true, e: true, f: true },
-      });
-
-      let obj = mixin({}, MixinA, MixinB);
-      assert.deepEqual(get(obj, 'foo'), {
-        a: true,
-        b: true,
-        c: true,
-        d: true,
-        e: true,
-        f: true,
-      });
-    }
-
-    ['@test defining mergedProperties with null properties should keep properties null'](assert) {
-      let MixinA = Mixin.create({
-        mergedProperties: ['foo'],
-        foo: null,
-      });
-
-      let MixinB = Mixin.create({
-        foo: null,
-      });
-
-      let obj = mixin({}, MixinA, MixinB);
-      assert.equal(get(obj, 'foo'), null);
-    }
-
-    ["@test mergedProperties' properties can get overwritten"](assert) {
-      let MixinA = Mixin.create({
-        mergedProperties: ['foo'],
-        foo: { a: 1 },
-      });
-
-      let MixinB = Mixin.create({
-        foo: { a: 2 },
-      });
-
-      let obj = mixin({}, MixinA, MixinB);
-      assert.deepEqual(get(obj, 'foo'), { a: 2 });
-    }
-
-    ['@test mergedProperties should be concatenated'](assert) {
-      let MixinA = Mixin.create({
-        mergedProperties: ['foo'],
-        foo: { a: true, b: true, c: true },
-      });
-
-      let MixinB = Mixin.create({
-        mergedProperties: 'bar',
-        foo: { d: true, e: true, f: true },
-        bar: { a: true, l: true },
-      });
-
-      let MixinC = Mixin.create({
-        bar: { e: true, x: true },
-      });
-
-      let obj = mixin({}, MixinA, MixinB, MixinC);
-      assert.deepEqual(get(obj, 'mergedProperties'), ['foo', 'bar'], 'get mergedProperties');
-      assert.deepEqual(
-        get(obj, 'foo'),
-        { a: true, b: true, c: true, d: true, e: true, f: true },
-        'get foo'
-      );
-      assert.deepEqual(get(obj, 'bar'), { a: true, l: true, e: true, x: true }, 'get bar');
-    }
-
-    ['@test mergedProperties should exist even if not explicitly set on create'](assert) {
-      let AnObj = EmberObject.extend({
-        mergedProperties: ['options'],
-        options: {
-          a: 'a',
-          b: {
-            c: 'ccc',
-          },
-        },
-      });
-
-      let obj = AnObj.create({
-        options: {
-          a: 'A',
-        },
-      });
-
-      assert.equal(get(obj, 'options').a, 'A');
-      assert.equal(get(obj, 'options').b.c, 'ccc');
-    }
-
-    ['@test defining mergedProperties at create time should not modify the prototype'](assert) {
-      let AnObj = EmberObject.extend({
-        mergedProperties: ['options'],
-        options: {
-          a: 1,
-        },
-      });
-
-      let objA = AnObj.create({
-        options: {
-          a: 2,
-        },
-      });
-      let objB = AnObj.create({
-        options: {
-          a: 3,
-        },
-      });
-
-      assert.equal(get(objA, 'options').a, 2);
-      assert.equal(get(objB, 'options').a, 3);
-    }
-
-    ["@test mergedProperties' overwriting methods can call _super"](assert) {
-      assert.expect(4);
-
-      let MixinA = Mixin.create({
-        mergedProperties: ['foo'],
-        foo: {
-          meth(a) {
-            assert.equal(a, 'WOOT', "_super successfully called MixinA's `foo.meth` method");
-            return 'WAT';
-          },
-        },
-      });
-
-      let MixinB = Mixin.create({
-        foo: {
-          meth() {
-            assert.ok(true, "MixinB's `foo.meth` method called");
-            return this._super(...arguments);
-          },
-        },
-      });
-
-      let MixinC = Mixin.create({
-        foo: {
-          meth(a) {
-            assert.ok(true, "MixinC's `foo.meth` method called");
-            return this._super(a);
-          },
-        },
-      });
-
-      let obj = mixin({}, MixinA, MixinB, MixinC);
-      assert.equal(obj.foo.meth('WOOT'), 'WAT');
-    }
-
-    ['@test Merging an Array should raise an error'](assert) {
-      assert.expect(1);
-
-      let MixinA = Mixin.create({
-        mergedProperties: ['foo'],
-        foo: { a: true, b: true, c: true },
-      });
-
-      let MixinB = Mixin.create({
-        foo: ['a'],
-      });
-
-      expectAssertion(() => {
-        mixin({}, MixinA, MixinB);
-      }, 'You passed in `["a"]` as the value for `foo` but `foo` cannot be an Array');
-    }
-  }
-);

data/dist/es/ember-metal/tests/mixin/method_test.js

@@ -1,252 +0,0 @@
-import { mixin, Mixin } from '../..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Mixin Methods',
-  class extends AbstractTestCase {
-    ['@test defining simple methods'](assert) {
-      let MixinA, obj, props;
-
-      props = {
-        publicMethod() {
-          return 'publicMethod';
-        },
-        _privateMethod() {
-          return 'privateMethod';
-        },
-      };
-
-      MixinA = Mixin.create(props);
-      obj = {};
-      MixinA.apply(obj);
-
-      // but should be defined
-      assert.equal(props.publicMethod(), 'publicMethod', 'publicMethod is func');
-      assert.equal(props._privateMethod(), 'privateMethod', 'privateMethod is func');
-    }
-
-    ['@test overriding public methods'](assert) {
-      let MixinA, MixinB, MixinD, MixinF, obj;
-
-      MixinA = Mixin.create({
-        publicMethod() {
-          return 'A';
-        },
-      });
-
-      MixinB = Mixin.create(MixinA, {
-        publicMethod() {
-          return this._super(...arguments) + 'B';
-        },
-      });
-
-      MixinD = Mixin.create(MixinA, {
-        publicMethod() {
-          return this._super(...arguments) + 'D';
-        },
-      });
-
-      MixinF = Mixin.create({
-        publicMethod() {
-          return this._super(...arguments) + 'F';
-        },
-      });
-
-      obj = {};
-      MixinB.apply(obj);
-      assert.equal(obj.publicMethod(), 'AB', 'should define super for A and B');
-
-      obj = {};
-      MixinD.apply(obj);
-      assert.equal(obj.publicMethod(), 'AD', 'should define super for A and B');
-
-      obj = {};
-      MixinA.apply(obj);
-      MixinF.apply(obj);
-      assert.equal(obj.publicMethod(), 'AF', 'should define super for A and F');
-
-      obj = {
-        publicMethod() {
-          return 'obj';
-        },
-      };
-      MixinF.apply(obj);
-      assert.equal(obj.publicMethod(), 'objF', 'should define super for F');
-    }
-
-    ['@test overriding inherited objects'](assert) {
-      let cnt = 0;
-      let MixinA = Mixin.create({
-        foo() {
-          cnt++;
-        },
-      });
-
-      let MixinB = Mixin.create({
-        foo() {
-          this._super(...arguments);
-          cnt++;
-        },
-      });
-
-      let objA = {};
-      MixinA.apply(objA);
-
-      let objB = Object.create(objA);
-      MixinB.apply(objB);
-
-      cnt = 0;
-      objB.foo();
-      assert.equal(cnt, 2, 'should invoke both methods');
-
-      cnt = 0;
-      objA.foo();
-      assert.equal(cnt, 1, 'should not screw w/ parent obj');
-    }
-
-    ['@test Including the same mixin more than once will only run once'](assert) {
-      let cnt = 0;
-      let MixinA = Mixin.create({
-        foo() {
-          cnt++;
-        },
-      });
-
-      let MixinB = Mixin.create(MixinA, {
-        foo() {
-          this._super(...arguments);
-        },
-      });
-
-      let MixinC = Mixin.create(MixinA, {
-        foo() {
-          this._super(...arguments);
-        },
-      });
-
-      let MixinD = Mixin.create(MixinB, MixinC, MixinA, {
-        foo() {
-          this._super(...arguments);
-        },
-      });
-
-      let obj = {};
-      MixinD.apply(obj);
-      MixinA.apply(obj); // try to apply again..
-
-      cnt = 0;
-      obj.foo();
-
-      assert.equal(cnt, 1, 'should invoke MixinA.foo one time');
-    }
-
-    ['@test _super from a single mixin with no superclass does not error'](assert) {
-      let MixinA = Mixin.create({
-        foo() {
-          this._super(...arguments);
-        },
-      });
-
-      let obj = {};
-      MixinA.apply(obj);
-
-      obj.foo();
-      assert.ok(true);
-    }
-
-    ['@test _super from a first-of-two mixins with no superclass function does not error'](assert) {
-      // _super was previously calling itself in the second assertion.
-      // Use remaining count of calls to ensure it doesn't loop indefinitely.
-      let remaining = 3;
-      let MixinA = Mixin.create({
-        foo() {
-          if (remaining-- > 0) {
-            this._super(...arguments);
-          }
-        },
-      });
-
-      let MixinB = Mixin.create({
-        foo() {
-          this._super(...arguments);
-        },
-      });
-
-      let obj = {};
-      MixinA.apply(obj);
-      MixinB.apply(obj);
-
-      obj.foo();
-      assert.ok(true);
-    }
-  }
-);
-
-// ..........................................................
-// CONFLICTS
-//
-moduleFor(
-  'Method Conflicts',
-  class extends AbstractTestCase {
-    ['@test overriding toString'](assert) {
-      let MixinA = Mixin.create({
-        toString() {
-          return 'FOO';
-        },
-      });
-
-      let obj = {};
-      MixinA.apply(obj);
-      assert.equal(obj.toString(), 'FOO', 'should override toString w/o error');
-
-      obj = {};
-      mixin(obj, {
-        toString() {
-          return 'FOO';
-        },
-      });
-      assert.equal(obj.toString(), 'FOO', 'should override toString w/o error');
-    }
-  }
-);
-
-// ..........................................................
-// BUGS
-//
-moduleFor(
-  'system/mixin/method_test BUGS',
-  class extends AbstractTestCase {
-    ['@test applying several mixins at once with sup already defined causes infinite loop'](
-      assert
-    ) {
-      let cnt = 0;
-      let MixinA = Mixin.create({
-        foo() {
-          cnt++;
-        },
-      });
-
-      let MixinB = Mixin.create({
-        foo() {
-          this._super(...arguments);
-          cnt++;
-        },
-      });
-
-      let MixinC = Mixin.create({
-        foo() {
-          this._super(...arguments);
-          cnt++;
-        },
-      });
-
-      let obj = {};
-      mixin(obj, MixinA); // sup already exists
-      mixin(obj, MixinB, MixinC); // must be more than one mixin
-
-      cnt = 0;
-      obj.foo();
-      assert.equal(cnt, 3, 'should invoke all 3 methods');
-    }
-  }
-);