discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-runtime/tests/system/core_object_test.js

@@ -1,114 +0,0 @@
-import { getOwner, setOwner } from 'ember-owner';
-import { get } from 'ember-metal';
-import CoreObject from '../../lib/system/core_object';
-import { moduleFor, AbstractTestCase, buildOwner } from 'internal-test-helpers';
-
-moduleFor(
-  'Ember.CoreObject',
-  class extends AbstractTestCase {
-    ['@test works with new (one arg)'](assert) {
-      let obj = new CoreObject({
-        firstName: 'Stef',
-        lastName: 'Penner',
-      });
-
-      assert.equal(obj.firstName, 'Stef');
-      assert.equal(obj.lastName, 'Penner');
-    }
-
-    ['@test works with new (> 1 arg)'](assert) {
-      let obj = new CoreObject(
-        {
-          firstName: 'Stef',
-          lastName: 'Penner',
-        },
-        {
-          other: 'name',
-        }
-      );
-
-      assert.equal(obj.firstName, 'Stef');
-      assert.equal(obj.lastName, 'Penner');
-
-      assert.equal(obj.other, undefined); // doesn't support multiple pojo' to the constructor
-    }
-
-    ['@test toString should be not be added as a property when calling toString()'](assert) {
-      let obj = new CoreObject({
-        firstName: 'Foo',
-        lastName: 'Bar',
-      });
-
-      obj.toString();
-
-      assert.notOk(
-        obj.hasOwnProperty('toString'),
-        'Calling toString() should not create a toString class property'
-      );
-    }
-
-    ['@test should not trigger proxy assertion when retrieving a proxy with (GH#16263)'](assert) {
-      let someProxyishThing = CoreObject.extend({
-        unknownProperty() {
-          return true;
-        },
-      }).create();
-
-      let obj = new CoreObject({
-        someProxyishThing,
-      });
-
-      let proxy = get(obj, 'someProxyishThing');
-      assert.equal(get(proxy, 'lolol'), true, 'should be able to get data from a proxy');
-    }
-
-    ['@test should not trigger proxy assertion when retrieving a re-registered proxy (GH#16610)'](
-      assert
-    ) {
-      let owner = buildOwner();
-
-      let someProxyishThing = CoreObject.extend({
-        unknownProperty() {
-          return true;
-        },
-      }).create();
-
-      // emulates ember-engines's process of registering services provided
-      // by the host app down to the engine
-      owner.register('thing:one', someProxyishThing, { instantiate: false });
-
-      assert.equal(owner.lookup('thing:one'), someProxyishThing);
-    }
-
-    ['@test should not trigger proxy assertion when probing for a "symbol"'](assert) {
-      let proxy = CoreObject.extend({
-        unknownProperty() {
-          return true;
-        },
-      }).create();
-
-      assert.equal(get(proxy, 'lolol'), true, 'should be able to get data from a proxy');
-
-      // should not trigger an assertion
-      getOwner(proxy);
-    }
-
-    ['@test can use getOwner in a proxy init GH#16484'](assert) {
-      let owner = {};
-      let options = {};
-      setOwner(options, owner);
-
-      CoreObject.extend({
-        init() {
-          this._super(...arguments);
-          let localOwner = getOwner(this);
-
-          assert.equal(localOwner, owner, 'should be able to `getOwner` in init');
-        },
-        unknownProperty() {
-          return undefined;
-        },
-      }).create(options);
-    }
-  }
-);

data/dist/es/ember-runtime/tests/system/namespace/base_test.js

@@ -1,175 +0,0 @@
-import { context } from 'ember-environment';
-import { run } from '@ember/runloop';
-import { get, setNamespaceSearchDisabled } from 'ember-metal';
-import { guidFor } from 'ember-utils';
-import EmberObject from '../../../lib/system/object';
-import Namespace from '../../../lib/system/namespace';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-const originalLookup = context.lookup;
-let lookup;
-
-moduleFor(
-  'Namespace',
-  class extends AbstractTestCase {
-    beforeEach() {
-      setNamespaceSearchDisabled(false);
-
-      lookup = context.lookup = {};
-    }
-
-    afterEach() {
-      setNamespaceSearchDisabled(false);
-
-      for (let prop in lookup) {
-        if (lookup[prop]) {
-          run(lookup[prop], 'destroy');
-        }
-      }
-
-      context.lookup = originalLookup;
-    }
-
-    ['@test Namespace should be a subclass of EmberObject'](assert) {
-      assert.ok(EmberObject.detect(Namespace));
-    }
-
-    ['@test Namespace should be duck typed'](assert) {
-      let namespace = Namespace.create();
-      try {
-        assert.ok(get(namespace, 'isNamespace'), 'isNamespace property is true');
-      } finally {
-        run(namespace, 'destroy');
-      }
-    }
-
-    ['@test Namespace is found and named'](assert) {
-      let nsA = (lookup.NamespaceA = Namespace.create());
-      assert.equal(
-        nsA.toString(),
-        'NamespaceA',
-        'namespaces should have a name if they are on lookup'
-      );
-
-      let nsB = (lookup.NamespaceB = Namespace.create());
-      assert.equal(
-        nsB.toString(),
-        'NamespaceB',
-        'namespaces work if created after the first namespace processing pass'
-      );
-    }
-
-    ['@test Classes under an Namespace are properly named'](assert) {
-      let nsA = (lookup.NamespaceA = Namespace.create());
-      nsA.Foo = EmberObject.extend();
-      assert.equal(nsA.Foo.toString(), 'NamespaceA.Foo', 'Classes pick up their parent namespace');
-
-      nsA.Bar = EmberObject.extend();
-      assert.equal(
-        nsA.Bar.toString(),
-        'NamespaceA.Bar',
-        'New Classes get the naming treatment too'
-      );
-
-      let nsB = (lookup.NamespaceB = Namespace.create());
-      nsB.Foo = EmberObject.extend();
-      assert.equal(
-        nsB.Foo.toString(),
-        'NamespaceB.Foo',
-        'Classes in new namespaces get the naming treatment'
-      );
-    }
-
-    //test("Classes under Ember are properly named", function() {
-    //  // ES6TODO: This test does not work reliably when running independent package build with Broccoli config.
-    //  Ember.TestObject = EmberObject.extend({});
-    //  equal(Ember.TestObject.toString(), "Ember.TestObject", "class under Ember is given a string representation");
-    //});
-
-    ['@test Lowercase namespaces are no longer supported'](assert) {
-      let nsC = (lookup.namespaceC = Namespace.create());
-      assert.equal(nsC.toString(), guidFor(nsC));
-    }
-
-    ['@test A namespace can be assigned a custom name'](assert) {
-      let nsA = Namespace.create({
-        name: 'NamespaceA',
-      });
-
-      try {
-        let nsB = (lookup.NamespaceB = Namespace.create({
-          name: 'CustomNamespaceB',
-        }));
-
-        nsA.Foo = EmberObject.extend();
-        nsB.Foo = EmberObject.extend();
-
-        assert.equal(
-          nsA.Foo.toString(),
-          'NamespaceA.Foo',
-          "The namespace's name is used when the namespace is not in the lookup object"
-        );
-        assert.equal(
-          nsB.Foo.toString(),
-          'CustomNamespaceB.Foo',
-          "The namespace's name is used when the namespace is in the lookup object"
-        );
-      } finally {
-        run(nsA, 'destroy');
-      }
-    }
-
-    ['@test Calling namespace.nameClasses() eagerly names all classes'](assert) {
-      setNamespaceSearchDisabled(true);
-
-      let namespace = (lookup.NS = Namespace.create());
-
-      namespace.ClassA = EmberObject.extend();
-      namespace.ClassB = EmberObject.extend();
-
-      Namespace.processAll();
-
-      assert.equal(namespace.ClassA.toString(), 'NS.ClassA');
-      assert.equal(namespace.ClassB.toString(), 'NS.ClassB');
-    }
-
-    ['@test A namespace can be looked up by its name'](assert) {
-      let NS = (lookup.NS = Namespace.create());
-      let UI = (lookup.UI = Namespace.create());
-      let CF = (lookup.CF = Namespace.create());
-
-      assert.equal(Namespace.byName('NS'), NS);
-      assert.equal(Namespace.byName('UI'), UI);
-      assert.equal(Namespace.byName('CF'), CF);
-    }
-
-    ['@test A nested namespace can be looked up by its name'](assert) {
-      let UI = (lookup.UI = Namespace.create());
-      UI.Nav = Namespace.create();
-
-      assert.equal(Namespace.byName('UI.Nav'), UI.Nav);
-
-      run(UI.Nav, 'destroy');
-    }
-
-    ['@test Destroying a namespace before caching lookup removes it from the list of namespaces'](
-      assert
-    ) {
-      let CF = (lookup.CF = Namespace.create());
-
-      run(CF, 'destroy');
-      assert.equal(Namespace.byName('CF'), undefined, 'namespace can not be found after destroyed');
-    }
-
-    ['@test Destroying a namespace after looking up removes it from the list of namespaces'](
-      assert
-    ) {
-      let CF = (lookup.CF = Namespace.create());
-
-      assert.equal(Namespace.byName('CF'), CF, 'precondition - namespace can be looked up by name');
-
-      run(CF, 'destroy');
-      assert.equal(Namespace.byName('CF'), undefined, 'namespace can not be found after destroyed');
-    }
-  }
-);

data/dist/es/ember-runtime/tests/system/native_array/a_test.js

@@ -1,16 +0,0 @@
-import EmberArray from '../../../lib/mixins/array';
-import { A } from '../../../lib/mixins/array';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Ember.A',
-  class extends AbstractTestCase {
-    ['@test Ember.A'](assert) {
-      assert.deepEqual(A([1, 2]), [1, 2], 'array values were not be modified');
-      assert.deepEqual(A(), [], 'returned an array with no arguments');
-      assert.deepEqual(A(null), [], 'returned an array with a null argument');
-      assert.ok(EmberArray.detect(A()), 'returned an ember array');
-      assert.ok(EmberArray.detect(A([1, 2])), 'returned an ember array');
-    }
-  }
-);

data/dist/es/ember-runtime/tests/system/native_array/copyable_suite_test.js

@@ -1,19 +0,0 @@
-import { A as emberA } from '../../../lib/mixins/array';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'NativeArray Copyable',
-  class extends AbstractTestCase {
-    ['@test deep copy is respected'](assert) {
-      let array = emberA([{ id: 1 }, { id: 2 }, { id: 3 }]);
-      let copiedArray;
-
-      expectDeprecation(() => {
-        copiedArray = array.copy(true);
-      }, `Using \`NativeArray#copy\` is deprecated`);
-
-      assert.deepEqual(copiedArray, array, 'copied array is equivalent');
-      assert.ok(copiedArray[0] !== array[0], 'objects inside should be unique');
-    }
-  }
-);

data/dist/es/ember-runtime/tests/system/native_array/replace_test.js

@@ -1,17 +0,0 @@
-import { A } from '../../../lib/mixins/array';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'NativeArray.replace',
-  class extends AbstractTestCase {
-    ['@test raises assertion if third argument is not an array']() {
-      expectAssertion(function() {
-        A([1, 2, 3]).replace(1, 1, '');
-      }, 'The third argument to replace needs to be an array.');
-    }
-
-    ['@test it does not raise an assertion if third parameter is not passed'](assert) {
-      assert.deepEqual(A([1, 2, 3]).replace(1, 2), A([1]), 'no assertion raised');
-    }
-  }
-);

data/dist/es/ember-runtime/tests/system/object/computed_test.js

@@ -1,352 +0,0 @@
-import { alias, computed, set, get, getWithDefault, observer, defineProperty } from 'ember-metal';
-import { oneWay as reads } from '@ember/object/computed';
-import EmberObject from '../../../lib/system/object';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-function K() {
-  return this;
-}
-
-function testWithDefault(assert, expect, x, y, z) {
-  assert.equal(get(x, y), expect);
-  assert.equal(getWithDefault(x, y, z), expect);
-  assert.equal(x.getWithDefault(y, z), expect);
-}
-
-moduleFor(
-  'EmberObject computed property',
-  class extends AbstractTestCase {
-    ['@test computed property on instance'](assert) {
-      let MyClass = EmberObject.extend({
-        foo: computed(function() {
-          return 'FOO';
-        }),
-      });
-
-      testWithDefault(assert, 'FOO', new MyClass(), 'foo');
-    }
-
-    ['@test computed property on subclass'](assert) {
-      let MyClass = EmberObject.extend({
-        foo: computed(function() {
-          return 'FOO';
-        }),
-      });
-
-      let Subclass = MyClass.extend({
-        foo: computed(function() {
-          return 'BAR';
-        }),
-      });
-
-      testWithDefault(assert, 'BAR', new Subclass(), 'foo');
-    }
-
-    ['@test replacing computed property with regular val'](assert) {
-      let MyClass = EmberObject.extend({
-        foo: computed(function() {
-          return 'FOO';
-        }),
-      });
-
-      let Subclass = MyClass.extend({
-        foo: 'BAR',
-      });
-
-      testWithDefault(assert, 'BAR', new Subclass(), 'foo');
-    }
-
-    ['@test complex depndent keys'](assert) {
-      let MyClass = EmberObject.extend({
-        init() {
-          this._super(...arguments);
-          set(this, 'bar', { baz: 'BIFF' });
-        },
-
-        count: 0,
-
-        foo: computed(function() {
-          set(this, 'count', get(this, 'count') + 1);
-          return get(get(this, 'bar'), 'baz') + ' ' + get(this, 'count');
-        }).property('bar.baz'),
-      });
-
-      let Subclass = MyClass.extend({
-        count: 20,
-      });
-
-      let obj1 = new MyClass();
-      let obj2 = new Subclass();
-
-      testWithDefault(assert, 'BIFF 1', obj1, 'foo');
-      testWithDefault(assert, 'BIFF 21', obj2, 'foo');
-
-      set(get(obj1, 'bar'), 'baz', 'BLARG');
-
-      testWithDefault(assert, 'BLARG 2', obj1, 'foo');
-      testWithDefault(assert, 'BIFF 21', obj2, 'foo');
-
-      set(get(obj2, 'bar'), 'baz', 'BOOM');
-
-      testWithDefault(assert, 'BLARG 2', obj1, 'foo');
-      testWithDefault(assert, 'BOOM 22', obj2, 'foo');
-    }
-
-    ['@test complex dependent keys changing complex dependent keys'](assert) {
-      let MyClass = EmberObject.extend({
-        init() {
-          this._super(...arguments);
-          set(this, 'bar', { baz: 'BIFF' });
-        },
-
-        count: 0,
-
-        foo: computed(function() {
-          set(this, 'count', get(this, 'count') + 1);
-          return get(get(this, 'bar'), 'baz') + ' ' + get(this, 'count');
-        }).property('bar.baz'),
-      });
-
-      let Subclass = MyClass.extend({
-        init() {
-          this._super(...arguments);
-          set(this, 'bar2', { baz: 'BIFF2' });
-        },
-
-        count: 0,
-
-        foo: computed(function() {
-          set(this, 'count', get(this, 'count') + 1);
-          return get(get(this, 'bar2'), 'baz') + ' ' + get(this, 'count');
-        }).property('bar2.baz'),
-      });
-
-      let obj2 = new Subclass();
-
-      testWithDefault(assert, 'BIFF2 1', obj2, 'foo');
-
-      set(get(obj2, 'bar'), 'baz', 'BLARG');
-      testWithDefault(assert, 'BIFF2 1', obj2, 'foo'); // should not invalidate property
-
-      set(get(obj2, 'bar2'), 'baz', 'BLARG');
-      testWithDefault(assert, 'BLARG 2', obj2, 'foo'); // should not invalidate property
-    }
-
-    ['@test can retrieve metadata for a computed property'](assert) {
-      let MyClass = EmberObject.extend({
-        computedProperty: computed(function() {}).meta({ key: 'keyValue' }),
-      });
-
-      assert.equal(
-        get(MyClass.metaForProperty('computedProperty'), 'key'),
-        'keyValue',
-        'metadata saved on the computed property can be retrieved'
-      );
-
-      let ClassWithNoMetadata = EmberObject.extend({
-        computedProperty: computed(function() {}).volatile(),
-
-        staticProperty: 12,
-      });
-
-      assert.equal(
-        typeof ClassWithNoMetadata.metaForProperty('computedProperty'),
-        'object',
-        'returns empty hash if no metadata has been saved'
-      );
-
-      expectAssertion(function() {
-        ClassWithNoMetadata.metaForProperty('nonexistentProperty');
-      }, "metaForProperty() could not find a computed property with key 'nonexistentProperty'.");
-
-      expectAssertion(function() {
-        ClassWithNoMetadata.metaForProperty('staticProperty');
-      }, "metaForProperty() could not find a computed property with key 'staticProperty'.");
-    }
-
-    ['@test overriding a computed property with null removes it from eachComputedProperty iteration'](
-      assert
-    ) {
-      let MyClass = EmberObject.extend({
-        foo: computed(function() {}),
-
-        fooDidChange: observer('foo', function() {}),
-
-        bar: computed(function() {}),
-      });
-
-      let SubClass = MyClass.extend({
-        foo: null,
-      });
-
-      let list = [];
-
-      SubClass.eachComputedProperty(name => list.push(name));
-
-      assert.deepEqual(
-        list.sort(),
-        ['bar'],
-        'overridding with null removes from eachComputedProperty listing'
-      );
-    }
-
-    ['@test can iterate over a list of computed properties for a class'](assert) {
-      let MyClass = EmberObject.extend({
-        foo: computed(function() {}),
-
-        fooDidChange: observer('foo', function() {}),
-
-        bar: computed(function() {}),
-
-        qux: alias('foo'),
-      });
-
-      let SubClass = MyClass.extend({
-        baz: computed(function() {}),
-      });
-
-      SubClass.reopen({
-        bat: computed(function() {}).meta({ iAmBat: true }),
-      });
-
-      let list = [];
-
-      MyClass.eachComputedProperty(function(name) {
-        list.push(name);
-      });
-
-      assert.deepEqual(
-        list.sort(),
-        ['bar', 'foo', 'qux'],
-        'watched and unwatched computed properties are iterated'
-      );
-
-      list = [];
-
-      SubClass.eachComputedProperty(function(name, meta) {
-        list.push(name);
-
-        if (name === 'bat') {
-          assert.deepEqual(meta, { iAmBat: true });
-        } else {
-          assert.deepEqual(meta, {});
-        }
-      });
-
-      assert.deepEqual(
-        list.sort(),
-        ['bar', 'bat', 'baz', 'foo', 'qux'],
-        'all inherited properties are included'
-      );
-    }
-
-    ['@test list of properties updates when an additional property is added (such cache busting)'](
-      assert
-    ) {
-      let MyClass = EmberObject.extend({
-        foo: computed(K),
-
-        fooDidChange: observer('foo', function() {}),
-
-        bar: computed(K),
-      });
-
-      let list = [];
-
-      MyClass.eachComputedProperty(function(name) {
-        list.push(name);
-      });
-
-      assert.deepEqual(list.sort(), ['bar', 'foo'].sort(), 'expected two computed properties');
-
-      MyClass.reopen({
-        baz: computed(K),
-      });
-
-      MyClass.create(); // force apply mixins
-
-      list = [];
-
-      MyClass.eachComputedProperty(function(name) {
-        list.push(name);
-      });
-
-      assert.deepEqual(
-        list.sort(),
-        ['bar', 'foo', 'baz'].sort(),
-        'expected three computed properties'
-      );
-
-      defineProperty(MyClass.prototype, 'qux', computed(K));
-
-      list = [];
-
-      MyClass.eachComputedProperty(function(name) {
-        list.push(name);
-      });
-
-      assert.deepEqual(
-        list.sort(),
-        ['bar', 'foo', 'baz', 'qux'].sort(),
-        'expected four computed properties'
-      );
-    }
-
-    ['@test Calling _super in call outside the immediate function of a CP getter works'](assert) {
-      function macro(callback) {
-        return computed(function() {
-          return callback.call(this);
-        });
-      }
-
-      let MyClass = EmberObject.extend({
-        foo: computed(function() {
-          return 'FOO';
-        }),
-      });
-
-      let SubClass = MyClass.extend({
-        foo: macro(function() {
-          return this._super();
-        }),
-      });
-
-      assert.ok(get(SubClass.create(), 'foo'), 'FOO', 'super value is fetched');
-    }
-
-    ['@test Calling _super in apply outside the immediate function of a CP getter works'](assert) {
-      function macro(callback) {
-        return computed(function() {
-          return callback.apply(this);
-        });
-      }
-
-      let MyClass = EmberObject.extend({
-        foo: computed(function() {
-          return 'FOO';
-        }),
-      });
-
-      let SubClass = MyClass.extend({
-        foo: macro(function() {
-          return this._super();
-        }),
-      });
-
-      assert.ok(get(SubClass.create(), 'foo'), 'FOO', 'super value is fetched');
-    }
-
-    ['@test observing computed.reads prop and overriding it in create() works'](assert) {
-      let Obj = EmberObject.extend({
-        name: reads('model.name'),
-        nameDidChange: observer('name', function() {}),
-      });
-
-      let obj1 = Obj.create({ name: '1' });
-      let obj2 = Obj.create({ name: '2' });
-
-      assert.equal(obj1.get('name'), '1');
-      assert.equal(obj2.get('name'), '2');
-    }
-  }
-);