discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-runtime/tests/legacy_1x/mixins/observable/propertyChanges_test.js

@@ -1,142 +0,0 @@
-/*
-  NOTE: This test is adapted from the 1.x series of unit tests.  The tests
-  are the same except for places where we intend to break the API we instead
-  validate that we warn the developer appropriately.
-
-  CHANGES FROM 1.6:
-
-  * Create ObservableObject which includes Ember.Observable
-  * Remove test that tests internal _kvo_changeLevel property.  This is an
-    implementation detail.
-  * Remove test for allPropertiesDidChange
-  * Removed star observer test.  no longer supported
-  * Removed property revision test.  no longer supported
-*/
-
-// ========================================================================
-// Ember.Observable Tests
-// ========================================================================
-
-import EmberObject from '../../../../lib/system/object';
-import Observable from '../../../../lib/mixins/observable';
-import { computed, observer } from 'ember-metal';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-const ObservableObject = EmberObject.extend(Observable);
-
-let ObjectA;
-
-moduleFor(
-  'object.propertyChanges',
-  class extends AbstractTestCase {
-    beforeEach() {
-      ObjectA = ObservableObject.extend({
-        action: observer('foo', function() {
-          this.set('prop', 'changedPropValue');
-        }),
-        notifyAction: observer('newFoo', function() {
-          this.set('newProp', 'changedNewPropValue');
-        }),
-
-        notifyAllAction: observer('prop', function() {
-          this.set('newFoo', 'changedNewFooValue');
-        }),
-
-        starObserver(target, key) {
-          this.starProp = key;
-        },
-      }).create({
-        starProp: null,
-
-        foo: 'fooValue',
-        prop: 'propValue',
-
-        newFoo: 'newFooValue',
-        newProp: 'newPropValue',
-      });
-    }
-
-    ['@test should observe the changes within the nested begin / end property changes'](assert) {
-      //start the outer nest
-      ObjectA.beginPropertyChanges();
-
-      // Inner nest
-      ObjectA.beginPropertyChanges();
-      ObjectA.set('foo', 'changeFooValue');
-
-      assert.equal(ObjectA.prop, 'propValue');
-      ObjectA.endPropertyChanges();
-
-      //end inner nest
-      ObjectA.set('prop', 'changePropValue');
-      assert.equal(ObjectA.newFoo, 'newFooValue');
-
-      //close the outer nest
-      ObjectA.endPropertyChanges();
-
-      assert.equal(ObjectA.prop, 'changedPropValue');
-      assert.equal(ObjectA.newFoo, 'changedNewFooValue');
-    }
-
-    ['@test should observe the changes within the begin and end property changes'](assert) {
-      ObjectA.beginPropertyChanges();
-      ObjectA.set('foo', 'changeFooValue');
-
-      assert.equal(ObjectA.prop, 'propValue');
-      ObjectA.endPropertyChanges();
-
-      assert.equal(ObjectA.prop, 'changedPropValue');
-    }
-
-    ['@test should indicate that the property of an object has just changed'](assert) {
-      //change the value of foo.
-      ObjectA.set('foo', 'changeFooValue');
-
-      // Indicate the subscribers of foo that the value has just changed
-      ObjectA.notifyPropertyChange('foo', null);
-
-      // Values of prop has just changed
-      assert.equal(ObjectA.prop, 'changedPropValue');
-    }
-
-    ['@test should notify that the property of an object has changed'](assert) {
-      // Notify to its subscriber that the values of 'newFoo' will be changed. In this
-      // case the observer is "newProp". Therefore this will call the notifyAction function
-      // and value of "newProp" will be changed.
-      ObjectA.notifyPropertyChange('newFoo', 'fooValue');
-
-      //value of newProp changed.
-      assert.equal(ObjectA.newProp, 'changedNewPropValue');
-    }
-
-    ['@test should invalidate function property cache when notifyPropertyChange is called'](
-      assert
-    ) {
-      let a = ObservableObject.extend({
-        b: computed({
-          get() {
-            return this._b;
-          },
-          set(key, value) {
-            this._b = value;
-            return this;
-          },
-        }).volatile(),
-      }).create({
-        _b: null,
-      });
-
-      a.set('b', 'foo');
-      assert.equal(a.get('b'), 'foo', 'should have set the correct value for property b');
-
-      a._b = 'bar';
-      a.notifyPropertyChange('b');
-      a.set('b', 'foo');
-      assert.equal(
-        a.get('b'),
-        'foo',
-        'should have invalidated the cache so that the newly set value is actually set'
-      );
-    }
-  }
-);

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

@@ -1,98 +0,0 @@
-import { get, set } from 'ember-metal';
-import EmberObject from '../../../../lib/system/object';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-/*
-  NOTE: This test is adapted from the 1.x series of unit tests.  The tests
-  are the same except for places where we intend to break the API we instead
-  validate that we warn the developer appropriately.
-
-  CHANGES FROM 1.6:
-
-  * Changed get(obj, ) and set(obj, ) to Ember.get() and Ember.set()
-  * Removed obj.instanceOf() and obj.kindOf() tests.  use obj instanceof Foo
-    instead
-  * Removed respondsTo() and tryToPerform() tests.  Can be brought back in a
-    utils package.
-  * Removed destroy() test.  You can impl yourself but not built in
-  * Changed Class.subclassOf() test to Class.detect()
-  * Remove broken test for 'superclass' property.
-  * Removed obj.didChangeFor()
-*/
-
-// ========================================================================
-// EmberObject Base Tests
-// ========================================================================
-
-let obj, obj1; // global variables
-
-moduleFor(
-  'A new EmberObject instance',
-  class extends AbstractTestCase {
-    beforeEach() {
-      obj = EmberObject.create({
-        foo: 'bar',
-        total: 12345,
-        aMethodThatExists() {},
-        aMethodThatReturnsTrue() {
-          return true;
-        },
-        aMethodThatReturnsFoobar() {
-          return 'Foobar';
-        },
-        aMethodThatReturnsFalse() {
-          return false;
-        },
-      });
-    }
-
-    afterEach() {
-      obj = undefined;
-    }
-
-    ['@test Should return its properties when requested using EmberObject#get'](assert) {
-      assert.equal(get(obj, 'foo'), 'bar');
-      assert.equal(get(obj, 'total'), 12345);
-    }
-
-    ['@test Should allow changing of those properties by calling EmberObject#set'](assert) {
-      assert.equal(get(obj, 'foo'), 'bar');
-      assert.equal(get(obj, 'total'), 12345);
-
-      set(obj, 'foo', 'Chunky Bacon');
-      set(obj, 'total', 12);
-
-      assert.equal(get(obj, 'foo'), 'Chunky Bacon');
-      assert.equal(get(obj, 'total'), 12);
-    }
-  }
-);
-
-moduleFor(
-  'EmberObject superclass and subclasses',
-  class extends AbstractTestCase {
-    beforeEach() {
-      obj = EmberObject.extend({
-        method1() {
-          return 'hello';
-        },
-      });
-      obj1 = obj.extend();
-    }
-
-    afterEach() {
-      obj = undefined;
-      obj1 = undefined;
-    }
-
-    ['@test Checking the detect() function on an object and its subclass'](assert) {
-      assert.equal(obj.detect(obj1), true);
-      assert.equal(obj1.detect(obj), false);
-    }
-
-    ['@test Checking the detectInstance() function on an object and its subclass'](assert) {
-      assert.ok(EmberObject.detectInstance(obj.create()));
-      assert.ok(obj.detectInstance(obj.create()));
-    }
-  }
-);

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

@@ -1,131 +0,0 @@
-import { get } from 'ember-metal';
-import EmberObject from '../../../../lib/system/object';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-/*
-  NOTE: This test is adapted from the 1.x series of unit tests.  The tests
-  are the same except for places where we intend to break the API we instead
-  validate that we warn the developer appropriately.
-
-  CHANGES FROM 1.6:
-
-  * changed get(obj, ) and set(obj, ) to Ember.get() and Ember.set()
-  * converted uses of obj.isEqual() to use deepEqual() test since isEqual is not
-    always defined
-*/
-
-function K() {
-  return this;
-}
-
-let klass;
-
-moduleFor(
-  'EmberObject Concatenated Properties',
-  class extends AbstractTestCase {
-    beforeEach() {
-      klass = EmberObject.extend({
-        concatenatedProperties: ['values', 'functions'],
-        values: ['a', 'b', 'c'],
-        functions: [K],
-      });
-    }
-
-    ['@test concatenates instances'](assert) {
-      let obj = klass.create({
-        values: ['d', 'e', 'f'],
-      });
-
-      let values = get(obj, 'values');
-      let expected = ['a', 'b', 'c', 'd', 'e', 'f'];
-
-      assert.deepEqual(
-        values,
-        expected,
-        `should concatenate values property (expected: ${expected}, got: ${values})`
-      );
-    }
-
-    ['@test concatenates subclasses'](assert) {
-      let subKlass = klass.extend({
-        values: ['d', 'e', 'f'],
-      });
-      let obj = subKlass.create();
-
-      let values = get(obj, 'values');
-      let expected = ['a', 'b', 'c', 'd', 'e', 'f'];
-
-      assert.deepEqual(
-        values,
-        expected,
-        `should concatenate values property (expected: ${expected}, got: ${values})`
-      );
-    }
-
-    ['@test concatenates reopen'](assert) {
-      klass.reopen({
-        values: ['d', 'e', 'f'],
-      });
-      let obj = klass.create();
-
-      let values = get(obj, 'values');
-      let expected = ['a', 'b', 'c', 'd', 'e', 'f'];
-
-      assert.deepEqual(
-        values,
-        expected,
-        `should concatenate values property (expected: ${expected}, got: ${values})`
-      );
-    }
-
-    ['@test concatenates mixin'](assert) {
-      let mixin = {
-        values: ['d', 'e'],
-      };
-      let subKlass = klass.extend(mixin, {
-        values: ['f'],
-      });
-      let obj = subKlass.create();
-
-      let values = get(obj, 'values');
-      let expected = ['a', 'b', 'c', 'd', 'e', 'f'];
-
-      assert.deepEqual(
-        values,
-        expected,
-        `should concatenate values property (expected: ${expected}, got: ${values})`
-      );
-    }
-
-    ['@test concatenates reopen, subclass, and instance'](assert) {
-      klass.reopen({ values: ['d'] });
-      let subKlass = klass.extend({ values: ['e'] });
-      let obj = subKlass.create({ values: ['f'] });
-
-      let values = get(obj, 'values');
-      let expected = ['a', 'b', 'c', 'd', 'e', 'f'];
-
-      assert.deepEqual(
-        values,
-        expected,
-        `should concatenate values property (expected: ${expected}, got: ${values})`
-      );
-    }
-
-    ['@test concatenates subclasses when the values are functions'](assert) {
-      let subKlass = klass.extend({
-        functions: K,
-      });
-      let obj = subKlass.create();
-
-      let values = get(obj, 'functions');
-      let expected = [K, K];
-
-      assert.deepEqual(
-        values,
-        expected,
-        `should concatenate functions property (expected: ${expected}, got: ${values})`
-      );
-    }
-  }
-);

data/dist/es/ember-runtime/tests/mixins/array_test.js

@@ -1,400 +0,0 @@
-import {
-  get,
-  set,
-  objectAt,
-  addObserver,
-  observer as emberObserver,
-  computed,
-  addArrayObserver,
-  removeArrayObserver,
-  arrayContentDidChange,
-  arrayContentWillChange,
-} from 'ember-metal';
-import EmberObject from '../../lib/system/object';
-import EmberArray from '../../lib/mixins/array';
-import { A as emberA } from '../../lib/mixins/array';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-/*
-  Implement a basic fake mutable array.  This validates that any non-native
-  enumerable can impl this API.
-*/
-const TestArray = EmberObject.extend(EmberArray, {
-  _content: null,
-
-  init() {
-    this._content = this._content || [];
-  },
-
-  // some methods to modify the array so we can test changes.  Note that
-  // arrays can be modified even if they don't implement MutableArray.  The
-  // MutableArray is just a standard API for mutation but not required.
-  addObject(obj) {
-    let idx = this._content.length;
-    arrayContentWillChange(this, idx, 0, 1);
-    this._content.push(obj);
-    arrayContentDidChange(this, idx, 0, 1);
-  },
-
-  removeFirst() {
-    arrayContentWillChange(this, 0, 1, 0);
-    this._content.shift();
-    arrayContentDidChange(this, 0, 1, 0);
-  },
-
-  objectAt(idx) {
-    return this._content[idx];
-  },
-
-  length: computed(function() {
-    return this._content.length;
-  }),
-});
-
-moduleFor(
-  'Ember.Array',
-  class extends AbstractTestCase {
-    ['@test the return value of slice has Ember.Array applied'](assert) {
-      let x = EmberObject.extend(EmberArray).create({
-        length: 0,
-      });
-      let y = x.slice(1);
-      assert.equal(EmberArray.detect(y), true, 'mixin should be applied');
-    }
-
-    ['@test slice supports negative index arguments'](assert) {
-      let testArray = new TestArray({ _content: [1, 2, 3, 4] });
-
-      assert.deepEqual(testArray.slice(-2), [3, 4], 'slice(-2)');
-      assert.deepEqual(testArray.slice(-2, -1), [3], 'slice(-2, -1');
-      assert.deepEqual(testArray.slice(-2, -2), [], 'slice(-2, -2)');
-      assert.deepEqual(testArray.slice(-1, -2), [], 'slice(-1, -2)');
-
-      assert.deepEqual(testArray.slice(-4, 1), [1], 'slice(-4, 1)');
-      assert.deepEqual(testArray.slice(-4, 5), [1, 2, 3, 4], 'slice(-4, 5)');
-      assert.deepEqual(testArray.slice(-4), [1, 2, 3, 4], 'slice(-4)');
-
-      assert.deepEqual(testArray.slice(0, -1), [1, 2, 3], 'slice(0, -1)');
-      assert.deepEqual(testArray.slice(0, -4), [], 'slice(0, -4)');
-      assert.deepEqual(testArray.slice(0, -3), [1], 'slice(0, -3)');
-    }
-  }
-);
-
-// ..........................................................
-// CONTENT DID CHANGE
-//
-
-const DummyArray = EmberObject.extend(EmberArray, {
-  length: 0,
-  objectAt(idx) {
-    return 'ITEM-' + idx;
-  },
-});
-
-let obj, observer;
-
-// ..........................................................
-// NOTIFY ARRAY OBSERVERS
-//
-
-moduleFor(
-  'mixins/array/arrayContent[Will|Did]Change',
-  class extends AbstractTestCase {
-    ['@test should notify observers of []'](assert) {
-      obj = DummyArray.extend({
-        enumerablePropertyDidChange: emberObserver('[]', function() {
-          this._count++;
-        }),
-      }).create({
-        _count: 0,
-      });
-
-      assert.equal(obj._count, 0, 'should not have invoked yet');
-
-      arrayContentWillChange(obj, 0, 1, 1);
-      arrayContentDidChange(obj, 0, 1, 1);
-
-      assert.equal(obj._count, 1, 'should have invoked');
-    }
-  }
-);
-
-// ..........................................................
-// NOTIFY CHANGES TO LENGTH
-//
-
-moduleFor(
-  'notify observers of length',
-  class extends AbstractTestCase {
-    beforeEach(assert) {
-      obj = DummyArray.extend({
-        lengthDidChange: emberObserver('length', function() {
-          this._after++;
-        }),
-      }).create({
-        _after: 0,
-      });
-
-      assert.equal(obj._after, 0, 'should not have fired yet');
-    }
-
-    afterEach() {
-      obj = null;
-    }
-
-    ['@test should notify observers when call with no params'](assert) {
-      arrayContentWillChange(obj);
-      assert.equal(obj._after, 0);
-
-      arrayContentDidChange(obj);
-      assert.equal(obj._after, 1);
-    }
-
-    // API variation that included items only
-    ['@test should not notify when passed lengths are same'](assert) {
-      arrayContentWillChange(obj, 0, 1, 1);
-      assert.equal(obj._after, 0);
-
-      arrayContentDidChange(obj, 0, 1, 1);
-      assert.equal(obj._after, 0);
-    }
-
-    ['@test should notify when passed lengths are different'](assert) {
-      arrayContentWillChange(obj, 0, 1, 2);
-      assert.equal(obj._after, 0);
-
-      arrayContentDidChange(obj, 0, 1, 2);
-      assert.equal(obj._after, 1);
-    }
-  }
-);
-
-// ..........................................................
-// NOTIFY ARRAY OBSERVER
-//
-
-moduleFor(
-  'notify array observers',
-  class extends AbstractTestCase {
-    beforeEach(assert) {
-      obj = DummyArray.create();
-
-      observer = EmberObject.extend({
-        arrayWillChange() {
-          assert.equal(this._before, null); // should only call once
-          this._before = Array.prototype.slice.call(arguments);
-        },
-
-        arrayDidChange() {
-          assert.equal(this._after, null); // should only call once
-          this._after = Array.prototype.slice.call(arguments);
-        },
-      }).create({
-        _before: null,
-        _after: null,
-      });
-
-      addArrayObserver(obj, observer);
-    }
-
-    afterEach() {
-      obj = observer = null;
-    }
-
-    ['@test should notify array observers when called with no params'](assert) {
-      arrayContentWillChange(obj);
-      assert.deepEqual(observer._before, [obj, 0, -1, -1]);
-
-      arrayContentDidChange(obj);
-      assert.deepEqual(observer._after, [obj, 0, -1, -1]);
-    }
-
-    // API variation that included items only
-    ['@test should notify when called with same length items'](assert) {
-      arrayContentWillChange(obj, 0, 1, 1);
-      assert.deepEqual(observer._before, [obj, 0, 1, 1]);
-
-      arrayContentDidChange(obj, 0, 1, 1);
-      assert.deepEqual(observer._after, [obj, 0, 1, 1]);
-    }
-
-    ['@test should notify when called with diff length items'](assert) {
-      arrayContentWillChange(obj, 0, 2, 1);
-      assert.deepEqual(observer._before, [obj, 0, 2, 1]);
-
-      arrayContentDidChange(obj, 0, 2, 1);
-      assert.deepEqual(observer._after, [obj, 0, 2, 1]);
-    }
-
-    ['@test removing array observer should disable'](assert) {
-      removeArrayObserver(obj, observer);
-      arrayContentWillChange(obj);
-      assert.deepEqual(observer._before, null);
-
-      arrayContentDidChange(obj);
-      assert.deepEqual(observer._after, null);
-    }
-  }
-);
-
-// ..........................................................
-// @each
-//
-
-let ary;
-
-moduleFor(
-  'EmberArray.@each support',
-  class extends AbstractTestCase {
-    beforeEach() {
-      ary = new TestArray({
-        _content: [
-          { isDone: true, desc: 'Todo 1' },
-          { isDone: false, desc: 'Todo 2' },
-          { isDone: true, desc: 'Todo 3' },
-          { isDone: false, desc: 'Todo 4' },
-        ],
-      });
-    }
-
-    afterEach() {
-      ary = null;
-    }
-
-    ['@test adding an object should notify (@each.isDone)'](assert) {
-      let called = 0;
-
-      let observerObject = EmberObject.create({
-        wasCalled() {
-          called++;
-        },
-      });
-
-      addObserver(ary, '@each.isDone', observerObject, 'wasCalled');
-
-      ary.addObject(
-        EmberObject.create({
-          desc: 'foo',
-          isDone: false,
-        })
-      );
-
-      assert.equal(called, 1, 'calls observer when object is pushed');
-    }
-
-    ['@test getting @each is deprecated'](assert) {
-      assert.expect(1);
-
-      expectDeprecation(() => {
-        get(ary, '@each');
-      }, /Getting the '@each' property on object .* is deprecated/);
-    }
-
-    ['@test @each is readOnly'](assert) {
-      assert.expect(1);
-
-      assert.throws(function() {
-        set(ary, '@each', 'foo');
-      }, /Cannot set read-only property "@each"/);
-    }
-
-    ['@test using @each to observe arrays that does not return objects raise error'](assert) {
-      let called = 0;
-
-      let observerObject = EmberObject.create({
-        wasCalled() {
-          called++;
-        },
-      });
-
-      ary = TestArray.create({
-        objectAt(idx) {
-          return get(this._content[idx], 'desc');
-        },
-      });
-
-      addObserver(ary, '@each.isDone', observerObject, 'wasCalled');
-
-      expectAssertion(() => {
-        ary.addObject(
-          EmberObject.create({
-            desc: 'foo',
-            isDone: false,
-          })
-        );
-      }, /When using @each to observe the array/);
-
-      assert.equal(called, 0, 'not calls observer when object is pushed');
-    }
-
-    ['@test modifying the array should also indicate the isDone prop itself has changed'](assert) {
-      // NOTE: we never actually get the '@each.isDone' property here.  This is
-      // important because it tests the case where we don't have an isDone
-      // EachArray materialized but just want to know when the property has
-      // changed.
-      let each;
-      expectDeprecation(() => {
-        each = get(ary, '@each');
-      });
-      let count = 0;
-
-      addObserver(each, 'isDone', () => count++);
-
-      count = 0;
-      let item = objectAt(ary, 2);
-      set(item, 'isDone', !get(item, 'isDone'));
-      assert.equal(count, 1, '@each.isDone should have notified');
-    }
-
-    ['@test `objectAt` returns correct object'](assert) {
-      let arr = ['first', 'second', 'third', 'fourth'];
-      assert.equal(objectAt(arr, 2), 'third');
-      assert.equal(objectAt(arr, 4), undefined);
-    }
-
-    ['@test should be clear caches for computed properties that have dependent keys on arrays that are changed after object initialization'](
-      assert
-    ) {
-      let obj = EmberObject.extend({
-        init() {
-          this._super(...arguments);
-          set(this, 'resources', emberA());
-        },
-
-        common: computed('resources.@each.common', function() {
-          return get(objectAt(get(this, 'resources'), 0), 'common');
-        }),
-      }).create();
-
-      get(obj, 'resources').pushObject(EmberObject.create({ common: 'HI!' }));
-      assert.equal('HI!', get(obj, 'common'));
-
-      set(objectAt(get(obj, 'resources'), 0), 'common', 'BYE!');
-      assert.equal('BYE!', get(obj, 'common'));
-    }
-
-    ['@test observers that contain @each in the path should fire only once the first time they are accessed'](
-      assert
-    ) {
-      let count = 0;
-
-      let obj = EmberObject.extend({
-        init() {
-          this._super(...arguments);
-          // Observer does not fire on init
-          set(this, 'resources', emberA());
-        },
-
-        commonDidChange: emberObserver('resources.@each.common', () => count++),
-      }).create();
-
-      // Observer fires second time when new object is added
-      get(obj, 'resources').pushObject(EmberObject.create({ common: 'HI!' }));
-      // Observer fires third time when property on an object is changed
-      set(objectAt(get(obj, 'resources'), 0), 'common', 'BYE!');
-
-      assert.equal(count, 2, 'observers should only be called once');
-    }
-  }
-);