discourse-ember-source 3.5.1.1 → 3.5.1.2

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

@@ -1,156 +0,0 @@
-import EmberObject from '../../../lib/system/object';
-import Evented from '../../../lib/mixins/evented';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Object events',
-  class extends AbstractTestCase {
-    ['@test a listener can be added to an object'](assert) {
-      let count = 0;
-      let F = function() {
-        count++;
-      };
-
-      let obj = EmberObject.extend(Evented).create();
-
-      obj.on('event!', F);
-      obj.trigger('event!');
-
-      assert.equal(count, 1, 'the event was triggered');
-
-      obj.trigger('event!');
-
-      assert.equal(count, 2, 'the event was triggered');
-    }
-
-    ['@test a listener can be added and removed automatically the first time it is triggered'](
-      assert
-    ) {
-      let count = 0;
-      let F = function() {
-        count++;
-      };
-
-      let obj = EmberObject.extend(Evented).create();
-
-      obj.one('event!', F);
-      obj.trigger('event!');
-
-      assert.equal(count, 1, 'the event was triggered');
-
-      obj.trigger('event!');
-
-      assert.equal(count, 1, 'the event was not triggered again');
-    }
-
-    ['@test triggering an event can have arguments'](assert) {
-      let self, args;
-
-      let obj = EmberObject.extend(Evented).create();
-
-      obj.on('event!', function() {
-        args = [].slice.call(arguments);
-        self = this;
-      });
-
-      obj.trigger('event!', 'foo', 'bar');
-
-      assert.deepEqual(args, ['foo', 'bar']);
-      assert.equal(self, obj);
-    }
-
-    ['@test a listener can be added and removed automatically and have arguments'](assert) {
-      let self, args;
-      let count = 0;
-
-      let obj = EmberObject.extend(Evented).create();
-
-      obj.one('event!', function() {
-        args = [].slice.call(arguments);
-        self = this;
-        count++;
-      });
-
-      obj.trigger('event!', 'foo', 'bar');
-
-      assert.deepEqual(args, ['foo', 'bar']);
-      assert.equal(self, obj);
-      assert.equal(count, 1, 'the event is triggered once');
-
-      obj.trigger('event!', 'baz', 'bat');
-
-      assert.deepEqual(args, ['foo', 'bar']);
-      assert.equal(count, 1, 'the event was not triggered again');
-      assert.equal(self, obj);
-    }
-
-    ['@test binding an event can specify a different target'](assert) {
-      let self, args;
-
-      let obj = EmberObject.extend(Evented).create();
-      let target = {};
-
-      obj.on('event!', target, function() {
-        args = [].slice.call(arguments);
-        self = this;
-      });
-
-      obj.trigger('event!', 'foo', 'bar');
-
-      assert.deepEqual(args, ['foo', 'bar']);
-      assert.equal(self, target);
-    }
-
-    ['@test a listener registered with one can take method as string and can be added with different target'](
-      assert
-    ) {
-      let count = 0;
-      let target = {};
-      target.fn = function() {
-        count++;
-      };
-
-      let obj = EmberObject.extend(Evented).create();
-
-      obj.one('event!', target, 'fn');
-      obj.trigger('event!');
-
-      assert.equal(count, 1, 'the event was triggered');
-
-      obj.trigger('event!');
-
-      assert.equal(count, 1, 'the event was not triggered again');
-    }
-
-    ['@test a listener registered with one can be removed with off'](assert) {
-      let obj = EmberObject.extend(Evented, {
-        F() {},
-      }).create();
-      let F = function() {};
-
-      obj.one('event!', F);
-      obj.one('event!', obj, 'F');
-
-      assert.equal(obj.has('event!'), true, 'has events');
-
-      obj.off('event!', F);
-      obj.off('event!', obj, 'F');
-
-      assert.equal(obj.has('event!'), false, 'has no more events');
-    }
-
-    ['@test adding and removing listeners should be chainable'](assert) {
-      let obj = EmberObject.extend(Evented).create();
-      let F = function() {};
-
-      let ret = obj.on('event!', F);
-      assert.equal(ret, obj, '#on returns self');
-
-      ret = obj.off('event!', F);
-      assert.equal(ret, obj, '#off returns self');
-
-      ret = obj.one('event!', F);
-      assert.equal(ret, obj, '#one returns self');
-    }
-  }
-);

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

@@ -1,153 +0,0 @@
-import { computed, get, observer } from 'ember-metal';
-import EmberObject from '../../../lib/system/object';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'EmberObject.extend',
-  class extends AbstractTestCase {
-    ['@test Basic extend'](assert) {
-      let SomeClass = EmberObject.extend({ foo: 'BAR' });
-      assert.ok(SomeClass.isClass, 'A class has isClass of true');
-      let obj = new SomeClass();
-      assert.equal(obj.foo, 'BAR');
-    }
-
-    ['@test Sub-subclass'](assert) {
-      let SomeClass = EmberObject.extend({ foo: 'BAR' });
-      let AnotherClass = SomeClass.extend({ bar: 'FOO' });
-      let obj = new AnotherClass();
-      assert.equal(obj.foo, 'BAR');
-      assert.equal(obj.bar, 'FOO');
-    }
-
-    ['@test Overriding a method several layers deep'](assert) {
-      let SomeClass = EmberObject.extend({
-        fooCnt: 0,
-        foo() {
-          this.fooCnt++;
-        },
-
-        barCnt: 0,
-        bar() {
-          this.barCnt++;
-        },
-      });
-
-      let AnotherClass = SomeClass.extend({
-        barCnt: 0,
-        bar() {
-          this.barCnt++;
-          this._super(...arguments);
-        },
-      });
-
-      let FinalClass = AnotherClass.extend({
-        fooCnt: 0,
-        foo() {
-          this.fooCnt++;
-          this._super(...arguments);
-        },
-      });
-
-      let obj = new FinalClass();
-      obj.foo();
-      obj.bar();
-      assert.equal(obj.fooCnt, 2, 'should invoke both');
-      assert.equal(obj.barCnt, 2, 'should invoke both');
-
-      // Try overriding on create also
-      obj = FinalClass.extend({
-        foo() {
-          this.fooCnt++;
-          this._super(...arguments);
-        },
-      }).create();
-
-      obj.foo();
-      obj.bar();
-      assert.equal(obj.fooCnt, 3, 'should invoke final as well');
-      assert.equal(obj.barCnt, 2, 'should invoke both');
-    }
-
-    ['@test With concatenatedProperties'](assert) {
-      let SomeClass = EmberObject.extend({
-        things: 'foo',
-        concatenatedProperties: ['things'],
-      });
-      let AnotherClass = SomeClass.extend({ things: 'bar' });
-      let YetAnotherClass = SomeClass.extend({ things: 'baz' });
-      let some = new SomeClass();
-      let another = new AnotherClass();
-      let yetAnother = new YetAnotherClass();
-      assert.deepEqual(some.get('things'), ['foo'], 'base class should have just its value');
-      assert.deepEqual(
-        another.get('things'),
-        ['foo', 'bar'],
-        "subclass should have base class' and its own"
-      );
-      assert.deepEqual(
-        yetAnother.get('things'),
-        ['foo', 'baz'],
-        "subclass should have base class' and its own"
-      );
-    }
-
-    ['@test With concatenatedProperties class properties'](assert) {
-      let SomeClass = EmberObject.extend();
-      SomeClass.reopenClass({
-        concatenatedProperties: ['things'],
-        things: 'foo',
-      });
-      let AnotherClass = SomeClass.extend();
-      AnotherClass.reopenClass({ things: 'bar' });
-      let YetAnotherClass = SomeClass.extend();
-      YetAnotherClass.reopenClass({ things: 'baz' });
-      let some = new SomeClass();
-      let another = new AnotherClass();
-      let yetAnother = new YetAnotherClass();
-      assert.deepEqual(
-        get(some.constructor, 'things'),
-        ['foo'],
-        'base class should have just its value'
-      );
-      assert.deepEqual(
-        get(another.constructor, 'things'),
-        ['foo', 'bar'],
-        "subclass should have base class' and its own"
-      );
-      assert.deepEqual(
-        get(yetAnother.constructor, 'things'),
-        ['foo', 'baz'],
-        "subclass should have base class' and its own"
-      );
-    }
-
-    ['@test Overriding a computed property with an observer'](assert) {
-      let Parent = EmberObject.extend({
-        foo: computed(function() {
-          return 'FOO';
-        }),
-      });
-
-      let seen = [];
-
-      let Child = Parent.extend({
-        foo: observer('bar', function() {
-          seen.push(this.get('bar'));
-        }),
-      });
-
-      let child = Child.create({ bar: 0 });
-
-      assert.deepEqual(seen, []);
-
-      child.set('bar', 1);
-
-      assert.deepEqual(seen, [1]);
-
-      child.set('bar', 2);
-
-      assert.deepEqual(seen, [1, 2]);
-    }
-  }
-);

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

@@ -1,216 +0,0 @@
-import { run } from '@ember/runloop';
-import { observer, get, set } from 'ember-metal';
-import EmberObject from '../../../lib/system/object';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'EmberObject observer',
-  class extends AbstractTestCase {
-    ['@test observer on class'](assert) {
-      let MyClass = EmberObject.extend({
-        count: 0,
-
-        foo: observer('bar', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      });
-
-      let obj = new MyClass();
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer immediately');
-
-      set(obj, 'bar', 'BAZ');
-      assert.equal(get(obj, 'count'), 1, 'should invoke observer after change');
-    }
-
-    ['@test observer on subclass'](assert) {
-      let MyClass = EmberObject.extend({
-        count: 0,
-
-        foo: observer('bar', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      });
-
-      let Subclass = MyClass.extend({
-        foo: observer('baz', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      });
-
-      let obj = new Subclass();
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer immediately');
-
-      set(obj, 'bar', 'BAZ');
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer after change');
-
-      set(obj, 'baz', 'BAZ');
-      assert.equal(get(obj, 'count'), 1, 'should invoke observer after change');
-    }
-
-    ['@test observer on instance'](assert) {
-      let obj = EmberObject.extend({
-        foo: observer('bar', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      }).create({
-        count: 0,
-      });
-
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer immediately');
-
-      set(obj, 'bar', 'BAZ');
-      assert.equal(get(obj, 'count'), 1, 'should invoke observer after change');
-    }
-
-    ['@test observer on instance overriding class'](assert) {
-      let MyClass = EmberObject.extend({
-        count: 0,
-
-        foo: observer('bar', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      });
-
-      let obj = MyClass.extend({
-        foo: observer('baz', function() {
-          // <-- change property we observe
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      }).create();
-
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer immediately');
-
-      set(obj, 'bar', 'BAZ');
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer after change');
-
-      set(obj, 'baz', 'BAZ');
-      assert.equal(get(obj, 'count'), 1, 'should invoke observer after change');
-    }
-
-    ['@test observer should not fire after being destroyed'](assert) {
-      let obj = EmberObject.extend({
-        count: 0,
-        foo: observer('bar', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      }).create();
-
-      assert.equal(get(obj, 'count'), 0, 'precond - should not invoke observer immediately');
-
-      run(() => obj.destroy());
-
-      expectAssertion(function() {
-        set(obj, 'bar', 'BAZ');
-      }, `calling set on destroyed object: ${obj}.bar = BAZ`);
-
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer after change');
-    }
-
-    // ..........................................................
-    // COMPLEX PROPERTIES
-    //
-
-    ['@test chain observer on class'](assert) {
-      let MyClass = EmberObject.extend({
-        count: 0,
-
-        foo: observer('bar.baz', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      });
-
-      let obj1 = MyClass.create({
-        bar: { baz: 'biff' },
-      });
-
-      let obj2 = MyClass.create({
-        bar: { baz: 'biff2' },
-      });
-
-      assert.equal(get(obj1, 'count'), 0, 'should not invoke yet');
-      assert.equal(get(obj2, 'count'), 0, 'should not invoke yet');
-
-      set(get(obj1, 'bar'), 'baz', 'BIFF1');
-      assert.equal(get(obj1, 'count'), 1, 'should invoke observer on obj1');
-      assert.equal(get(obj2, 'count'), 0, 'should not invoke yet');
-
-      set(get(obj2, 'bar'), 'baz', 'BIFF2');
-      assert.equal(get(obj1, 'count'), 1, 'should not invoke again');
-      assert.equal(get(obj2, 'count'), 1, 'should invoke observer on obj2');
-    }
-
-    ['@test chain observer on class'](assert) {
-      let MyClass = EmberObject.extend({
-        count: 0,
-
-        foo: observer('bar.baz', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      });
-
-      let obj1 = MyClass.extend().create({
-        bar: { baz: 'biff' },
-      });
-
-      let obj2 = MyClass.extend({
-        foo: observer('bar2.baz', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      }).create({
-        bar: { baz: 'biff2' },
-        bar2: { baz: 'biff3' },
-      });
-
-      assert.equal(get(obj1, 'count'), 0, 'should not invoke yet');
-      assert.equal(get(obj2, 'count'), 0, 'should not invoke yet');
-
-      set(get(obj1, 'bar'), 'baz', 'BIFF1');
-      assert.equal(get(obj1, 'count'), 1, 'should invoke observer on obj1');
-      assert.equal(get(obj2, 'count'), 0, 'should not invoke yet');
-
-      set(get(obj2, 'bar'), 'baz', 'BIFF2');
-      assert.equal(get(obj1, 'count'), 1, 'should not invoke again');
-      assert.equal(get(obj2, 'count'), 0, 'should not invoke yet');
-
-      set(get(obj2, 'bar2'), 'baz', 'BIFF3');
-      assert.equal(get(obj1, 'count'), 1, 'should not invoke again');
-      assert.equal(get(obj2, 'count'), 1, 'should invoke observer on obj2');
-    }
-
-    ['@test chain observer on class that has a reference to an uninitialized object will finish chains that reference it'](
-      assert
-    ) {
-      let changed = false;
-
-      let ChildClass = EmberObject.extend({
-        parent: null,
-        parentOneTwoDidChange: observer('parent.one.two', function() {
-          changed = true;
-        }),
-      });
-
-      let ParentClass = EmberObject.extend({
-        one: {
-          two: 'old',
-        },
-        init() {
-          this.child = ChildClass.create({
-            parent: this,
-          });
-        },
-      });
-
-      let parent = new ParentClass();
-
-      assert.equal(changed, false, 'precond');
-
-      set(parent, 'one.two', 'new');
-
-      assert.equal(changed, true, 'child should have been notified of change to path');
-
-      set(parent, 'one', { two: 'newer' });
-
-      assert.equal(changed, true, 'child should have been notified of change to path');
-    }
-  }
-);