discourse-ember-source 3.5.1.1 → 3.5.1.2

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

@@ -1,135 +0,0 @@
-import { getOwner, setOwner } from 'ember-owner';
-import { computed, Mixin, observer } from 'ember-metal';
-import { DEBUG } from '@glimmer/env';
-import EmberObject from '../../../lib/system/object';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'EmberObject.create',
-  class extends AbstractTestCase {
-    ['@test simple properties are set'](assert) {
-      let o = EmberObject.create({ ohai: 'there' });
-      assert.equal(o.get('ohai'), 'there');
-    }
-
-    ['@test calls computed property setters'](assert) {
-      let MyClass = EmberObject.extend({
-        foo: computed({
-          get() {
-            return "this is not the value you're looking for";
-          },
-          set(key, value) {
-            return value;
-          },
-        }),
-      });
-
-      let o = MyClass.create({ foo: 'bar' });
-      assert.equal(o.get('foo'), 'bar');
-    }
-
-    ['@test sets up mandatory setters for watched simple properties'](assert) {
-      if (DEBUG) {
-        let MyClass = EmberObject.extend({
-          foo: null,
-          bar: null,
-          fooDidChange: observer('foo', function() {}),
-        });
-
-        let o = MyClass.create({ foo: 'bar', bar: 'baz' });
-        assert.equal(o.get('foo'), 'bar');
-
-        let descriptor = Object.getOwnPropertyDescriptor(o, 'foo');
-        assert.ok(descriptor.set, 'Mandatory setter was setup');
-
-        descriptor = Object.getOwnPropertyDescriptor(o, 'bar');
-        assert.ok(!descriptor.set, 'Mandatory setter was not setup');
-      } else {
-        assert.expect(0);
-      }
-    }
-
-    ['@test calls setUnknownProperty if defined'](assert) {
-      let setUnknownPropertyCalled = false;
-
-      let MyClass = EmberObject.extend({
-        setUnknownProperty(/* key, value */) {
-          setUnknownPropertyCalled = true;
-        },
-      });
-
-      MyClass.create({ foo: 'bar' });
-      assert.ok(setUnknownPropertyCalled, 'setUnknownProperty was called');
-    }
-
-    ['@test throws if you try to define a computed property']() {
-      expectAssertion(function() {
-        EmberObject.create({
-          foo: computed(function() {}),
-        });
-      }, 'EmberObject.create no longer supports defining computed properties. Define computed properties using extend() or reopen() before calling create().');
-    }
-
-    ['@test throws if you try to call _super in a method']() {
-      expectAssertion(function() {
-        EmberObject.create({
-          foo() {
-            this._super(...arguments);
-          },
-        });
-      }, 'EmberObject.create no longer supports defining methods that call _super.');
-    }
-
-    ["@test throws if you try to 'mixin' a definition"]() {
-      let myMixin = Mixin.create({
-        adder(arg1, arg2) {
-          return arg1 + arg2;
-        },
-      });
-
-      expectAssertion(function() {
-        EmberObject.create(myMixin);
-      }, 'EmberObject.create no longer supports mixing in other definitions, use .extend & .create separately instead.');
-    }
-
-    ['@test inherits properties from passed in EmberObject'](assert) {
-      let baseObj = EmberObject.create({ foo: 'bar' });
-      let secondaryObj = EmberObject.create(baseObj);
-
-      assert.equal(
-        secondaryObj.foo,
-        baseObj.foo,
-        'Em.O.create inherits properties from EmberObject parameter'
-      );
-    }
-
-    ['@test throws if you try to pass anything a string as a parameter']() {
-      let expected = 'EmberObject.create only accepts objects.';
-
-      expectAssertion(() => EmberObject.create('some-string'), expected);
-    }
-
-    ['@test EmberObject.create can take undefined as a parameter'](assert) {
-      let o = EmberObject.create(undefined);
-      assert.deepEqual(EmberObject.create(), o);
-    }
-
-    ['@test can use getOwner in a proxy init GH#16484'](assert) {
-      let owner = {};
-      let options = {};
-      setOwner(options, owner);
-
-      EmberObject.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/object/destroy_test.js

@@ -1,146 +0,0 @@
-import { run } from '@ember/runloop';
-import { observer, get, set, beginPropertyChanges, endPropertyChanges } from 'ember-metal';
-import { peekMeta } from 'ember-meta';
-import EmberObject from '../../../lib/system/object';
-import { DEBUG } from '@glimmer/env';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'ember-runtime/system/object/destroy_test',
-  class extends AbstractTestCase {
-    ['@test should schedule objects to be destroyed at the end of the run loop'](assert) {
-      let obj = EmberObject.create();
-      let meta;
-
-      run(() => {
-        obj.destroy();
-        meta = peekMeta(obj);
-        assert.ok(meta, 'meta is not destroyed immediately');
-        assert.ok(get(obj, 'isDestroying'), 'object is marked as destroying immediately');
-        assert.ok(!get(obj, 'isDestroyed'), 'object is not destroyed immediately');
-      });
-
-      meta = peekMeta(obj);
-      assert.ok(get(obj, 'isDestroyed'), 'object is destroyed after run loop finishes');
-    }
-
-    // MANDATORY_SETTER moves value to meta.values
-    // a destroyed object removes meta but leaves the accessor
-    // that looks it up
-    ['@test should raise an exception when modifying watched properties on a destroyed object'](
-      assert
-    ) {
-      if (DEBUG) {
-        let obj = EmberObject.extend({
-          fooDidChange: observer('foo', function() {}),
-        }).create({
-          foo: 'bar',
-        });
-
-        run(() => obj.destroy());
-
-        assert.throws(() => set(obj, 'foo', 'baz'), Error, 'raises an exception');
-      } else {
-        assert.expect(0);
-      }
-    }
-
-    ['@test observers should not fire after an object has been destroyed'](assert) {
-      let count = 0;
-      let obj = EmberObject.extend({
-        fooDidChange: observer('foo', function() {
-          count++;
-        }),
-      }).create();
-
-      obj.set('foo', 'bar');
-
-      assert.equal(count, 1, 'observer was fired once');
-
-      run(() => {
-        beginPropertyChanges();
-        obj.set('foo', 'quux');
-        obj.destroy();
-        endPropertyChanges();
-      });
-
-      assert.equal(count, 1, 'observer was not called after object was destroyed');
-    }
-
-    ['@test destroyed objects should not see each others changes during teardown but a long lived object should'](
-      assert
-    ) {
-      let shouldChange = 0;
-      let shouldNotChange = 0;
-
-      let objs = {};
-
-      let A = EmberObject.extend({
-        objs: objs,
-        isAlive: true,
-        willDestroy() {
-          this.set('isAlive', false);
-        },
-        bDidChange: observer('objs.b.isAlive', function() {
-          shouldNotChange++;
-        }),
-        cDidChange: observer('objs.c.isAlive', function() {
-          shouldNotChange++;
-        }),
-      });
-
-      let B = EmberObject.extend({
-        objs: objs,
-        isAlive: true,
-        willDestroy() {
-          this.set('isAlive', false);
-        },
-        aDidChange: observer('objs.a.isAlive', function() {
-          shouldNotChange++;
-        }),
-        cDidChange: observer('objs.c.isAlive', function() {
-          shouldNotChange++;
-        }),
-      });
-
-      let C = EmberObject.extend({
-        objs: objs,
-        isAlive: true,
-        willDestroy() {
-          this.set('isAlive', false);
-        },
-        aDidChange: observer('objs.a.isAlive', function() {
-          shouldNotChange++;
-        }),
-        bDidChange: observer('objs.b.isAlive', function() {
-          shouldNotChange++;
-        }),
-      });
-
-      let LongLivedObject = EmberObject.extend({
-        objs: objs,
-        isAliveDidChange: observer('objs.a.isAlive', function() {
-          shouldChange++;
-        }),
-      });
-
-      objs.a = new A();
-
-      objs.b = new B();
-
-      objs.c = new C();
-
-      new LongLivedObject();
-
-      run(() => {
-        let keys = Object.keys(objs);
-        for (let i = 0; i < keys.length; i++) {
-          objs[keys[i]].destroy();
-        }
-      });
-
-      assert.equal(shouldNotChange, 0, 'destroyed graph objs should not see change in willDestroy');
-      assert.equal(shouldChange, 1, 'long lived should see change in willDestroy');
-    }
-  }
-);

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

@@ -1,38 +0,0 @@
-import EmberObject from '../../../lib/system/object';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'system/object/detectInstance',
-  class extends AbstractTestCase {
-    ['@test detectInstance detects instances correctly'](assert) {
-      let A = EmberObject.extend();
-      let B = A.extend();
-      let C = A.extend();
-
-      let o = EmberObject.create();
-      let a = A.create();
-      let b = B.create();
-      let c = C.create();
-
-      assert.ok(EmberObject.detectInstance(o), 'o is an instance of EmberObject');
-      assert.ok(EmberObject.detectInstance(a), 'a is an instance of EmberObject');
-      assert.ok(EmberObject.detectInstance(b), 'b is an instance of EmberObject');
-      assert.ok(EmberObject.detectInstance(c), 'c is an instance of EmberObject');
-
-      assert.ok(!A.detectInstance(o), 'o is not an instance of A');
-      assert.ok(A.detectInstance(a), 'a is an instance of A');
-      assert.ok(A.detectInstance(b), 'b is an instance of A');
-      assert.ok(A.detectInstance(c), 'c is an instance of A');
-
-      assert.ok(!B.detectInstance(o), 'o is not an instance of B');
-      assert.ok(!B.detectInstance(a), 'a is not an instance of B');
-      assert.ok(B.detectInstance(b), 'b is an instance of B');
-      assert.ok(!B.detectInstance(c), 'c is not an instance of B');
-
-      assert.ok(!C.detectInstance(o), 'o is not an instance of C');
-      assert.ok(!C.detectInstance(a), 'a is not an instance of C');
-      assert.ok(!C.detectInstance(b), 'b is not an instance of C');
-      assert.ok(C.detectInstance(c), 'c is an instance of C');
-    }
-  }
-);

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

@@ -1,33 +0,0 @@
-import EmberObject from '../../../lib/system/object';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'system/object/detect',
-  class extends AbstractTestCase {
-    ['@test detect detects classes correctly'](assert) {
-      let A = EmberObject.extend();
-      let B = A.extend();
-      let C = A.extend();
-
-      assert.ok(EmberObject.detect(EmberObject), 'EmberObject is an EmberObject class');
-      assert.ok(EmberObject.detect(A), 'A is an EmberObject class');
-      assert.ok(EmberObject.detect(B), 'B is an EmberObject class');
-      assert.ok(EmberObject.detect(C), 'C is an EmberObject class');
-
-      assert.ok(!A.detect(EmberObject), 'EmberObject is not an A class');
-      assert.ok(A.detect(A), 'A is an A class');
-      assert.ok(A.detect(B), 'B is an A class');
-      assert.ok(A.detect(C), 'C is an A class');
-
-      assert.ok(!B.detect(EmberObject), 'EmberObject is not a B class');
-      assert.ok(!B.detect(A), 'A is not a B class');
-      assert.ok(B.detect(B), 'B is a B class');
-      assert.ok(!B.detect(C), 'C is not a B class');
-
-      assert.ok(!C.detect(EmberObject), 'EmberObject is not a C class');
-      assert.ok(!C.detect(A), 'A is not a C class');
-      assert.ok(!C.detect(B), 'B is not a C class');
-      assert.ok(C.detect(C), 'C is a C class');
-    }
-  }
-);

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

@@ -1,469 +0,0 @@
-import EmberObject from '../../../lib/system/object';
-import { Mixin, defineProperty, computed, addObserver, addListener, sendEvent } from 'ember-metal';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'EmberObject ES Compatibility',
-  class extends AbstractTestCase {
-    ['@test extending an Ember.Object'](assert) {
-      let calls = [];
-
-      class MyObject extends EmberObject {
-        constructor() {
-          calls.push('constructor');
-          super(...arguments);
-          this.postInitProperty = 'post-init-property';
-        }
-
-        init() {
-          calls.push('init');
-          super.init(...arguments);
-          this.initProperty = 'init-property';
-        }
-      }
-
-      let myObject = MyObject.create({ passedProperty: 'passed-property' });
-
-      assert.deepEqual(calls, ['constructor', 'init'], 'constructor then init called (create)');
-      assert.equal(
-        myObject.postInitProperty,
-        'post-init-property',
-        'constructor property available on instance (create)'
-      );
-      assert.equal(
-        myObject.initProperty,
-        'init-property',
-        'init property available on instance (create)'
-      );
-      assert.equal(
-        myObject.passedProperty,
-        'passed-property',
-        'passed property available on instance (create)'
-      );
-      calls = [];
-      myObject = new MyObject({ passedProperty: 'passed-property' });
-
-      assert.deepEqual(calls, ['constructor', 'init'], 'constructor then init called (new)');
-      assert.equal(
-        myObject.postInitProperty,
-        'post-init-property',
-        'constructor property available on instance (new)'
-      );
-      assert.equal(
-        myObject.initProperty,
-        'init-property',
-        'init property available on instance (new)'
-      );
-      assert.equal(
-        myObject.passedProperty,
-        'passed-property',
-        'passed property available on instance (new)'
-      );
-    }
-
-    ['@test normal method super'](assert) {
-      let calls = [];
-
-      let Foo = EmberObject.extend({
-        method() {
-          calls.push('foo');
-        },
-      });
-
-      let Bar = Foo.extend({
-        method() {
-          this._super();
-          calls.push('bar');
-        },
-      });
-
-      class Baz extends Bar {
-        method() {
-          super.method();
-          calls.push('baz');
-        }
-      }
-
-      let Qux = Baz.extend({
-        method() {
-          this._super();
-          calls.push('qux');
-        },
-      });
-
-      let Quux = Qux.extend({
-        method() {
-          this._super();
-          calls.push('quux');
-        },
-      });
-
-      class Corge extends Quux {
-        method() {
-          super.method();
-          calls.push('corge');
-        }
-      }
-
-      let callValues = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge'];
-
-      [Foo, Bar, Baz, Qux, Quux, Corge].forEach((Class, index) => {
-        calls = [];
-        new Class().method();
-
-        assert.deepEqual(
-          calls,
-          callValues.slice(0, index + 1),
-          'chain of static methods called with super'
-        );
-      });
-    }
-
-    ['@test static method super'](assert) {
-      let calls;
-
-      let Foo = EmberObject.extend();
-      Foo.reopenClass({
-        method() {
-          calls.push('foo');
-        },
-      });
-
-      let Bar = Foo.extend();
-      Bar.reopenClass({
-        method() {
-          this._super();
-          calls.push('bar');
-        },
-      });
-
-      class Baz extends Bar {
-        static method() {
-          super.method();
-          calls.push('baz');
-        }
-      }
-
-      let Qux = Baz.extend();
-      Qux.reopenClass({
-        method() {
-          this._super();
-          calls.push('qux');
-        },
-      });
-
-      let Quux = Qux.extend();
-      Quux.reopenClass({
-        method() {
-          this._super();
-          calls.push('quux');
-        },
-      });
-
-      class Corge extends Quux {
-        static method() {
-          super.method();
-          calls.push('corge');
-        }
-      }
-
-      let callValues = ['foo', 'bar', 'baz', 'qux', 'quux', 'corge'];
-
-      [Foo, Bar, Baz, Qux, Quux, Corge].forEach((Class, index) => {
-        calls = [];
-        Class.method();
-
-        assert.deepEqual(
-          calls,
-          callValues.slice(0, index + 1),
-          'chain of static methods called with super'
-        );
-      });
-    }
-
-    ['@test using mixins'](assert) {
-      let Mixin1 = Mixin.create({
-        property1: 'data-1',
-      });
-
-      let Mixin2 = Mixin.create({
-        property2: 'data-2',
-      });
-
-      class MyObject extends EmberObject.extend(Mixin1, Mixin2) {}
-
-      let myObject = new MyObject();
-      assert.equal(myObject.property1, 'data-1', 'includes the first mixin');
-      assert.equal(myObject.property2, 'data-2', 'includes the second mixin');
-    }
-
-    ['@test using instanceof'](assert) {
-      class MyObject extends EmberObject {}
-
-      let myObject1 = MyObject.create();
-      let myObject2 = new MyObject();
-
-      assert.ok(myObject1 instanceof MyObject);
-      assert.ok(myObject1 instanceof EmberObject);
-
-      assert.ok(myObject2 instanceof MyObject);
-      assert.ok(myObject2 instanceof EmberObject);
-    }
-
-    ['@test extending an ES subclass of EmberObject'](assert) {
-      let calls = [];
-
-      class SubEmberObject extends EmberObject {
-        constructor() {
-          calls.push('constructor');
-          super(...arguments);
-        }
-
-        init() {
-          calls.push('init');
-          super.init(...arguments);
-        }
-      }
-
-      class MyObject extends SubEmberObject {}
-
-      MyObject.create();
-      assert.deepEqual(calls, ['constructor', 'init'], 'constructor then init called (create)');
-
-      calls = [];
-      new MyObject();
-      assert.deepEqual(calls, ['constructor', 'init'], 'constructor then init called (new)');
-    }
-
-    ['@test calling extend on an ES subclass of EmberObject'](assert) {
-      let calls = [];
-
-      class SubEmberObject extends EmberObject {
-        constructor() {
-          calls.push('before constructor');
-          super(...arguments);
-          calls.push('after constructor');
-          this.foo = 123;
-        }
-
-        init() {
-          calls.push('init');
-          super.init(...arguments);
-        }
-      }
-
-      let MyObject = SubEmberObject.extend({});
-
-      MyObject.create();
-      assert.deepEqual(
-        calls,
-        ['before constructor', 'init', 'after constructor'],
-        'constructor then init called (create)'
-      );
-
-      calls = [];
-      new MyObject();
-      assert.deepEqual(
-        calls,
-        ['before constructor', 'init', 'after constructor'],
-        'constructor then init called (new)'
-      );
-
-      let obj = MyObject.create({
-        foo: 456,
-        bar: 789,
-      });
-
-      assert.equal(obj.foo, 123, 'sets class fields on instance correctly');
-      assert.equal(obj.bar, 789, 'sets passed in properties on instance correctly');
-    }
-
-    ['@test calling metaForProperty on a native class works'](assert) {
-      assert.expect(0);
-
-      class SubEmberObject extends EmberObject {}
-
-      defineProperty(
-        SubEmberObject.prototype,
-        'foo',
-        computed('foo', {
-          get() {
-            return 'bar';
-          },
-        })
-      );
-
-      // able to get meta without throwing an error
-      SubEmberObject.metaForProperty('foo');
-    }
-
-    '@test super and _super interop between old and new methods'(assert) {
-      let calls = [];
-      let changes = [];
-      let events = [];
-      let lastProps;
-
-      class A extends EmberObject {
-        init(props) {
-          calls.push('A init');
-          lastProps = props;
-        }
-      }
-
-      let Mixin1 = Mixin.create({
-        init() {
-          calls.push('Mixin1 init before _super');
-          this._super(...arguments);
-          calls.push('Mixin1 init after _super');
-        },
-      });
-
-      let Mixin2 = Mixin.create({
-        init() {
-          calls.push('Mixin2 init before _super');
-          this._super(...arguments);
-          calls.push('Mixin2 init after _super');
-        },
-      });
-
-      class B extends A.extend(Mixin1, Mixin2) {
-        init() {
-          calls.push('B init before super.init');
-          super.init(...arguments);
-          calls.push('B init after super.init');
-        }
-
-        onSomeEvent(evt) {
-          events.push(`B onSomeEvent ${evt}`);
-        }
-
-        fullNameDidChange() {
-          changes.push('B fullNameDidChange');
-        }
-      }
-
-      // // define a CP
-      defineProperty(
-        B.prototype,
-        'full',
-        computed('first', 'last', {
-          get() {
-            return this.first + ' ' + this.last;
-          },
-        })
-      );
-
-      // Only string observers are allowed for prototypes
-      addObserver(B.prototype, 'full', null, 'fullNameDidChange');
-
-      // Only string listeners are allowed for prototypes
-      addListener(B.prototype, 'someEvent', null, 'onSomeEvent');
-
-      B.reopen({
-        init() {
-          calls.push('reopen init before _super');
-          this._super(...arguments);
-          calls.push('reopen init after _super');
-        },
-      });
-
-      let C = B.extend({
-        init() {
-          calls.push('C init before _super');
-          this._super(...arguments);
-          calls.push('C init after _super');
-        },
-
-        onSomeEvent(evt) {
-          calls.push('C onSomeEvent before _super');
-          this._super(evt);
-          calls.push('C onSomeEvent after _super');
-        },
-
-        fullNameDidChange() {
-          calls.push('C fullNameDidChange before _super');
-          this._super();
-          calls.push('C fullNameDidChange after _super');
-        },
-      });
-
-      class D extends C {
-        constructor(props) {
-          if (props.last === undefined) {
-            props.last = 'Jackson';
-          }
-          super(props);
-        }
-
-        init() {
-          calls.push('D init before super.init');
-          super.init(...arguments);
-          calls.push('D init after super.init');
-        }
-
-        onSomeEvent(evt) {
-          events.push('D onSomeEvent before super.onSomeEvent');
-          super.onSomeEvent(evt);
-          events.push('D onSomeEvent after super.onSomeEvent');
-        }
-
-        fullNameDidChange() {
-          changes.push('D fullNameDidChange before super.fullNameDidChange');
-          super.fullNameDidChange();
-          changes.push('D fullNameDidChange after super.fullNameDidChange');
-        }
-
-        triggerSomeEvent(...args) {
-          sendEvent(this, 'someEvent', args);
-        }
-      }
-
-      assert.deepEqual(calls, [], 'nothing has been called');
-      assert.deepEqual(changes, [], 'full has not changed');
-      assert.deepEqual(events, [], 'onSomeEvent has not been triggered');
-
-      let d = D.create({ first: 'Robert' });
-
-      assert.deepEqual(calls, [
-        'D init before super.init',
-        'C init before _super',
-        'reopen init before _super',
-        'B init before super.init',
-        'Mixin2 init before _super',
-        'Mixin1 init before _super',
-        'A init',
-        'Mixin1 init after _super',
-        'Mixin2 init after _super',
-        'B init after super.init',
-        'reopen init after _super',
-        'C init after _super',
-        'D init after super.init',
-      ]);
-      assert.deepEqual(changes, [], 'full has not changed');
-      assert.deepEqual(events, [], 'onSomeEvent has not been triggered');
-
-      assert.deepEqual(lastProps, {
-        first: 'Robert',
-        last: 'Jackson',
-      });
-
-      assert.equal(d.full, 'Robert Jackson');
-
-      d.setProperties({ first: 'Kris', last: 'Selden' });
-      assert.deepEqual(changes, [
-        'D fullNameDidChange before super.fullNameDidChange',
-        'B fullNameDidChange',
-        'D fullNameDidChange after super.fullNameDidChange',
-      ]);
-
-      assert.equal(d.full, 'Kris Selden');
-
-      d.triggerSomeEvent('event arg');
-      assert.deepEqual(events, [
-        'D onSomeEvent before super.onSomeEvent',
-        'B onSomeEvent event arg',
-        'D onSomeEvent after super.onSomeEvent',
-      ]);
-    }
-  }
-);