discourse-ember-source 3.5.1.1 → 3.5.1.2

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

@@ -1,202 +0,0 @@
-import { set, get, observer, mixin, Mixin, isWatching } from '../..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Mixin observer',
-  class extends AbstractTestCase {
-    ['@test global observer helper'](assert) {
-      let MyMixin = Mixin.create({
-        count: 0,
-
-        foo: observer('bar', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      });
-
-      let obj = mixin({}, MyMixin);
-      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 global observer helper takes multiple params'](assert) {
-      let MyMixin = Mixin.create({
-        count: 0,
-
-        foo: observer('bar', 'baz', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      });
-
-      let obj = mixin({}, MyMixin);
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer immediately');
-
-      set(obj, 'bar', 'BAZ');
-      set(obj, 'baz', 'BAZ');
-      assert.equal(get(obj, 'count'), 2, 'should invoke observer after change');
-    }
-
-    ['@test replacing observer should remove old observer'](assert) {
-      let MyMixin = Mixin.create({
-        count: 0,
-
-        foo: observer('bar', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      });
-
-      let Mixin2 = Mixin.create({
-        foo: observer('baz', function() {
-          set(this, 'count', get(this, 'count') + 10);
-        }),
-      });
-
-      let obj = mixin({}, MyMixin, Mixin2);
-      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'), 10, 'should invoke observer after change');
-    }
-
-    ['@test observing chain with property before'](assert) {
-      let obj2 = { baz: 'baz' };
-
-      let MyMixin = Mixin.create({
-        count: 0,
-        bar: obj2,
-        foo: observer('bar.baz', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      });
-
-      let obj = mixin({}, MyMixin);
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer immediately');
-
-      set(obj2, 'baz', 'BAZ');
-      assert.equal(get(obj, 'count'), 1, 'should invoke observer after change');
-    }
-
-    ['@test observing chain with property after'](assert) {
-      let obj2 = { baz: 'baz' };
-
-      let MyMixin = Mixin.create({
-        count: 0,
-        foo: observer('bar.baz', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-        bar: obj2,
-      });
-
-      let obj = mixin({}, MyMixin);
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer immediately');
-
-      set(obj2, 'baz', 'BAZ');
-      assert.equal(get(obj, 'count'), 1, 'should invoke observer after change');
-    }
-
-    ['@test observing chain with property in mixin applied later'](assert) {
-      let obj2 = { baz: 'baz' };
-
-      let MyMixin = Mixin.create({
-        count: 0,
-        foo: observer('bar.baz', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      });
-
-      let MyMixin2 = Mixin.create({ bar: obj2 });
-
-      let obj = mixin({}, MyMixin);
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer immediately');
-
-      MyMixin2.apply(obj);
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer immediately');
-
-      set(obj2, 'baz', 'BAZ');
-      assert.equal(get(obj, 'count'), 1, 'should invoke observer after change');
-    }
-
-    ['@test observing chain with existing property'](assert) {
-      let obj2 = { baz: 'baz' };
-
-      let MyMixin = Mixin.create({
-        count: 0,
-        foo: observer('bar.baz', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      });
-
-      let obj = mixin({ bar: obj2 }, MyMixin);
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer immediately');
-
-      set(obj2, 'baz', 'BAZ');
-      assert.equal(get(obj, 'count'), 1, 'should invoke observer after change');
-    }
-
-    ['@test observing chain with property in mixin before'](assert) {
-      let obj2 = { baz: 'baz' };
-      let MyMixin2 = Mixin.create({ bar: obj2 });
-
-      let MyMixin = Mixin.create({
-        count: 0,
-        foo: observer('bar.baz', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      });
-
-      let obj = mixin({}, MyMixin2, MyMixin);
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer immediately');
-
-      set(obj2, 'baz', 'BAZ');
-      assert.equal(get(obj, 'count'), 1, 'should invoke observer after change');
-    }
-
-    ['@test observing chain with property in mixin after'](assert) {
-      let obj2 = { baz: 'baz' };
-      let MyMixin2 = Mixin.create({ bar: obj2 });
-
-      let MyMixin = Mixin.create({
-        count: 0,
-        foo: observer('bar.baz', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      });
-
-      let obj = mixin({}, MyMixin, MyMixin2);
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer immediately');
-
-      set(obj2, 'baz', 'BAZ');
-      assert.equal(get(obj, 'count'), 1, 'should invoke observer after change');
-    }
-
-    ['@test observing chain with overridden property'](assert) {
-      let obj2 = { baz: 'baz' };
-      let obj3 = { baz: 'foo' };
-
-      let MyMixin2 = Mixin.create({ bar: obj3 });
-
-      let MyMixin = Mixin.create({
-        count: 0,
-        foo: observer('bar.baz', function() {
-          set(this, 'count', get(this, 'count') + 1);
-        }),
-      });
-
-      let obj = mixin({ bar: obj2 }, MyMixin, MyMixin2);
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer immediately');
-
-      assert.equal(isWatching(obj2, 'baz'), false, 'should not be watching baz');
-      assert.equal(isWatching(obj3, 'baz'), true, 'should be watching baz');
-
-      set(obj2, 'baz', 'BAZ');
-      assert.equal(get(obj, 'count'), 0, 'should not invoke observer after change');
-
-      set(obj3, 'baz', 'BEAR');
-      assert.equal(get(obj, 'count'), 1, 'should invoke observer after change');
-    }
-  }
-);

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

@@ -1,53 +0,0 @@
-import { Object as EmberObject } from 'ember-runtime';
-import { get, Mixin } from '../..';
-import { run } from '@ember/runloop';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Mixin#reopen',
-  class extends AbstractTestCase {
-    ['@test using reopen() to add more properties to a simple'](assert) {
-      let MixinA = Mixin.create({ foo: 'FOO', baz: 'BAZ' });
-      MixinA.reopen({ bar: 'BAR', foo: 'FOO2' });
-      let obj = {};
-      MixinA.apply(obj);
-
-      assert.equal(get(obj, 'foo'), 'FOO2', 'mixin() should override');
-      assert.equal(get(obj, 'baz'), 'BAZ', 'preserve MixinA props');
-      assert.equal(get(obj, 'bar'), 'BAR', 'include MixinB props');
-    }
-
-    ['@test using reopen() and calling _super where there is not a super function does not cause infinite recursion'](
-      assert
-    ) {
-      let Taco = EmberObject.extend({
-        createBreakfast() {
-          // There is no original createBreakfast function.
-          // Calling the wrapped _super function here
-          // used to end in an infinite call loop
-          this._super(...arguments);
-          return 'Breakfast!';
-        },
-      });
-
-      Taco.reopen({
-        createBreakfast() {
-          return this._super(...arguments);
-        },
-      });
-
-      let taco = Taco.create();
-
-      let result;
-      run(() => {
-        try {
-          result = taco.createBreakfast();
-        } catch (e) {
-          result = 'Your breakfast was interrupted by an infinite stack error.';
-        }
-      });
-
-      assert.equal(result, 'Breakfast!');
-    }
-  }
-);

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

@@ -1,22 +0,0 @@
-import { Mixin } from '../..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'without',
-  class extends AbstractTestCase {
-    ['@test without should create a new mixin excluding named properties'](assert) {
-      let MixinA = Mixin.create({
-        foo: 'FOO',
-        bar: 'BAR',
-      });
-
-      let MixinB = MixinA.without('bar');
-
-      let obj = {};
-      MixinB.apply(obj);
-
-      assert.equal(obj.foo, 'FOO', 'should defined foo');
-      assert.equal(obj.bar, undefined, 'should not define bar');
-    }
-  }
-);

data/dist/es/ember-metal/tests/namespace_search_test.js

@@ -1,16 +0,0 @@
-import { Mixin } from '..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'NamespaceSearch',
-  class extends AbstractTestCase {
-    ['@test classToString: null as this inside class must not throw error'](assert) {
-      let mixin = Mixin.create();
-      assert.equal(
-        mixin.toString(),
-        '(unknown)',
-        'this = null should be handled on Mixin.toString() call'
-      );
-    }
-  }
-);

data/dist/es/ember-metal/tests/observer_test.js

@@ -1,961 +0,0 @@
-import { ENV } from 'ember-environment';
-import {
-  addObserver,
-  removeObserver,
-  notifyPropertyChange,
-  defineProperty,
-  computed,
-  getCachedValueFor,
-  Mixin,
-  mixin,
-  observer,
-  beginPropertyChanges,
-  endPropertyChanges,
-  changeProperties,
-  get,
-  set,
-} from '..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-function K() {}
-
-// ..........................................................
-// ADD OBSERVER
-//
-
-moduleFor(
-  'addObserver',
-  class extends AbstractTestCase {
-    ['@test observer should assert to invalid input']() {
-      expectAssertion(() => {
-        observer(() => {});
-      }, 'observer called without valid path');
-
-      expectAssertion(() => {
-        observer(null);
-      }, 'observer called without a function');
-    }
-
-    ['@test observer should fire when property is modified'](assert) {
-      let obj = {};
-      let count = 0;
-
-      addObserver(obj, 'foo', function() {
-        assert.equal(get(obj, 'foo'), 'bar', 'should invoke AFTER value changed');
-        count++;
-      });
-
-      set(obj, 'foo', 'bar');
-      assert.equal(count, 1, 'should have invoked observer');
-    }
-
-    ['@test observer should fire when dependent property is modified'](assert) {
-      let obj = { bar: 'bar' };
-      defineProperty(
-        obj,
-        'foo',
-        computed(function() {
-          return get(this, 'bar').toUpperCase();
-        }).property('bar')
-      );
-
-      get(obj, 'foo');
-
-      let count = 0;
-      addObserver(obj, 'foo', function() {
-        assert.equal(get(obj, 'foo'), 'BAZ', 'should have invoked after prop change');
-        count++;
-      });
-
-      set(obj, 'bar', 'baz');
-      assert.equal(count, 1, 'should have invoked observer');
-    }
-
-    ['@test observer should continue to fire after dependent properties are accessed'](assert) {
-      let observerCount = 0;
-      let obj = {};
-
-      defineProperty(
-        obj,
-        'prop',
-        computed(function() {
-          return Math.random();
-        })
-      );
-      defineProperty(
-        obj,
-        'anotherProp',
-        computed('prop', function() {
-          return get(this, 'prop') + Math.random();
-        })
-      );
-
-      addObserver(obj, 'prop', function() {
-        observerCount++;
-      });
-
-      get(obj, 'anotherProp');
-
-      for (let i = 0; i < 10; i++) {
-        notifyPropertyChange(obj, 'prop');
-      }
-
-      assert.equal(observerCount, 10, 'should continue to fire indefinitely');
-    }
-
-    ['@test observer added declaratively via brace expansion should fire when property changes'](
-      assert
-    ) {
-      if (ENV.EXTEND_PROTOTYPES.Function) {
-        let obj = {};
-        let count = 0;
-
-        mixin(obj, {
-          observeFooAndBar: function() {
-            count++;
-          }.observes('{foo,bar}'),
-        });
-
-        set(obj, 'foo', 'foo');
-        assert.equal(count, 1, 'observer specified via brace expansion invoked on property change');
-
-        set(obj, 'bar', 'bar');
-        assert.equal(count, 2, 'observer specified via brace expansion invoked on property change');
-
-        set(obj, 'baz', 'baz');
-        assert.equal(count, 2, 'observer not invoked on unspecified property');
-      } else {
-        assert.expect(0);
-      }
-    }
-
-    ['@test observer specified declaratively via brace expansion should fire when dependent property changes'](
-      assert
-    ) {
-      if (ENV.EXTEND_PROTOTYPES.Function) {
-        let obj = { baz: 'Initial' };
-        let count = 0;
-
-        defineProperty(
-          obj,
-          'foo',
-          computed(function() {
-            return get(this, 'bar').toLowerCase();
-          }).property('bar')
-        );
-
-        defineProperty(
-          obj,
-          'bar',
-          computed(function() {
-            return get(this, 'baz').toUpperCase();
-          }).property('baz')
-        );
-
-        mixin(obj, {
-          fooAndBarWatcher: function() {
-            count++;
-          }.observes('{foo,bar}'),
-        });
-
-        get(obj, 'foo');
-        set(obj, 'baz', 'Baz');
-        // fire once for foo, once for bar
-        assert.equal(
-          count,
-          2,
-          'observer specified via brace expansion invoked on dependent property change'
-        );
-
-        set(obj, 'quux', 'Quux');
-        assert.equal(count, 2, 'observer not fired on unspecified property');
-      } else {
-        assert.expect(0);
-      }
-    }
-
-    ['@test observers watching multiple properties via brace expansion should fire when the properties change'](
-      assert
-    ) {
-      let obj = {};
-      let count = 0;
-
-      mixin(obj, {
-        observeFooAndBar: observer('{foo,bar}', function() {
-          count++;
-        }),
-      });
-
-      set(obj, 'foo', 'foo');
-      assert.equal(count, 1, 'observer specified via brace expansion invoked on property change');
-
-      set(obj, 'bar', 'bar');
-      assert.equal(count, 2, 'observer specified via brace expansion invoked on property change');
-
-      set(obj, 'baz', 'baz');
-      assert.equal(count, 2, 'observer not invoked on unspecified property');
-    }
-
-    ['@test observers watching multiple properties via brace expansion should fire when dependent properties change'](
-      assert
-    ) {
-      let obj = { baz: 'Initial' };
-      let count = 0;
-
-      defineProperty(
-        obj,
-        'foo',
-        computed(function() {
-          return get(this, 'bar').toLowerCase();
-        }).property('bar')
-      );
-
-      defineProperty(
-        obj,
-        'bar',
-        computed(function() {
-          return get(this, 'baz').toUpperCase();
-        }).property('baz')
-      );
-
-      mixin(obj, {
-        fooAndBarWatcher: observer('{foo,bar}', function() {
-          count++;
-        }),
-      });
-
-      get(obj, 'foo');
-      set(obj, 'baz', 'Baz');
-      // fire once for foo, once for bar
-      assert.equal(
-        count,
-        2,
-        'observer specified via brace expansion invoked on dependent property change'
-      );
-
-      set(obj, 'quux', 'Quux');
-      assert.equal(count, 2, 'observer not fired on unspecified property');
-    }
-
-    ['@test nested observers should fire in order'](assert) {
-      let obj = { foo: 'foo', bar: 'bar' };
-      let fooCount = 0;
-      let barCount = 0;
-
-      addObserver(obj, 'foo', function() {
-        fooCount++;
-      });
-      addObserver(obj, 'bar', function() {
-        set(obj, 'foo', 'BAZ');
-        assert.equal(fooCount, 1, 'fooCount should have fired already');
-        barCount++;
-      });
-
-      set(obj, 'bar', 'BIFF');
-      assert.equal(barCount, 1, 'barCount should have fired');
-      assert.equal(fooCount, 1, 'foo should have fired');
-    }
-
-    ['@test removing an chain observer on change should not fail'](assert) {
-      let foo = { bar: 'bar' };
-      let obj1 = { foo: foo };
-      let obj2 = { foo: foo };
-      let obj3 = { foo: foo };
-      let obj4 = { foo: foo };
-      let count1 = 0;
-      let count2 = 0;
-      let count3 = 0;
-      let count4 = 0;
-
-      function observer1() {
-        count1++;
-      }
-      function observer2() {
-        count2++;
-      }
-      function observer3() {
-        count3++;
-        removeObserver(obj1, 'foo.bar', observer1);
-        removeObserver(obj2, 'foo.bar', observer2);
-        removeObserver(obj4, 'foo.bar', observer4);
-      }
-      function observer4() {
-        count4++;
-      }
-
-      addObserver(obj1, 'foo.bar', observer1);
-      addObserver(obj2, 'foo.bar', observer2);
-      addObserver(obj3, 'foo.bar', observer3);
-      addObserver(obj4, 'foo.bar', observer4);
-
-      set(foo, 'bar', 'baz');
-
-      assert.equal(count1, 1, 'observer1 fired');
-      assert.equal(count2, 1, 'observer2 fired');
-      assert.equal(count3, 1, 'observer3 fired');
-      assert.equal(count4, 0, 'observer4 did not fire');
-    }
-
-    ['@test deferring property change notifications'](assert) {
-      let obj = { foo: 'foo' };
-      let fooCount = 0;
-
-      addObserver(obj, 'foo', function() {
-        fooCount++;
-      });
-
-      beginPropertyChanges();
-      set(obj, 'foo', 'BIFF');
-      set(obj, 'foo', 'BAZ');
-      endPropertyChanges();
-
-      assert.equal(fooCount, 1, 'foo should have fired once');
-    }
-
-    ['@test deferring property change notifications safely despite exceptions'](assert) {
-      let obj = { foo: 'foo' };
-      let fooCount = 0;
-      let exc = new Error('Something unexpected happened!');
-
-      assert.expect(2);
-      addObserver(obj, 'foo', function() {
-        fooCount++;
-      });
-
-      try {
-        changeProperties(function() {
-          set(obj, 'foo', 'BIFF');
-          set(obj, 'foo', 'BAZ');
-          throw exc;
-        });
-      } catch (err) {
-        if (err !== exc) {
-          throw err;
-        }
-      }
-
-      assert.equal(fooCount, 1, 'foo should have fired once');
-
-      changeProperties(function() {
-        set(obj, 'foo', 'BIFF2');
-        set(obj, 'foo', 'BAZ2');
-      });
-
-      assert.equal(fooCount, 2, 'foo should have fired again once');
-    }
-
-    ['@test addObserver should propagate through prototype'](assert) {
-      let obj = { foo: 'foo', count: 0 };
-      let obj2;
-
-      addObserver(obj, 'foo', function() {
-        this.count++;
-      });
-      obj2 = Object.create(obj);
-
-      set(obj2, 'foo', 'bar');
-
-      assert.equal(obj2.count, 1, 'should have invoked observer on inherited');
-      assert.equal(obj.count, 0, 'should not have invoked observer on parent');
-
-      obj2.count = 0;
-      set(obj, 'foo', 'baz');
-      assert.equal(obj.count, 1, 'should have invoked observer on parent');
-      assert.equal(obj2.count, 0, 'should not have invoked observer on inherited');
-    }
-
-    ['@test addObserver should respect targets with methods'](assert) {
-      let observed = { foo: 'foo' };
-
-      let target1 = {
-        count: 0,
-
-        didChange(obj, keyName) {
-          let value = get(obj, keyName);
-          assert.equal(this, target1, 'should invoke with this');
-          assert.equal(obj, observed, 'param1 should be observed object');
-          assert.equal(keyName, 'foo', 'param2 should be keyName');
-          assert.equal(value, 'BAZ', 'param3 should new value');
-          this.count++;
-        },
-      };
-
-      let target2 = {
-        count: 0,
-
-        didChange(obj, keyName) {
-          let value = get(obj, keyName);
-          assert.equal(this, target2, 'should invoke with this');
-          assert.equal(obj, observed, 'param1 should be observed object');
-          assert.equal(keyName, 'foo', 'param2 should be keyName');
-          assert.equal(value, 'BAZ', 'param3 should new value');
-          this.count++;
-        },
-      };
-
-      addObserver(observed, 'foo', target1, 'didChange');
-      addObserver(observed, 'foo', target2, target2.didChange);
-
-      set(observed, 'foo', 'BAZ');
-      assert.equal(target1.count, 1, 'target1 observer should have fired');
-      assert.equal(target2.count, 1, 'target2 observer should have fired');
-    }
-
-    ['@test addObserver should allow multiple objects to observe a property'](assert) {
-      let observed = { foo: 'foo' };
-
-      let target1 = {
-        count: 0,
-
-        didChange() {
-          this.count++;
-        },
-      };
-
-      let target2 = {
-        count: 0,
-
-        didChange() {
-          this.count++;
-        },
-      };
-
-      addObserver(observed, 'foo', target1, 'didChange');
-      addObserver(observed, 'foo', target2, 'didChange');
-
-      set(observed, 'foo', 'BAZ');
-      assert.equal(target1.count, 1, 'target1 observer should have fired');
-      assert.equal(target2.count, 1, 'target2 observer should have fired');
-    }
-  }
-);
-
-// ..........................................................
-// REMOVE OBSERVER
-//
-
-moduleFor(
-  'removeObserver',
-  class extends AbstractTestCase {
-    ['@test removing observer should stop firing'](assert) {
-      let obj = {};
-      let count = 0;
-      function F() {
-        count++;
-      }
-      addObserver(obj, 'foo', F);
-
-      set(obj, 'foo', 'bar');
-      assert.equal(count, 1, 'should have invoked observer');
-
-      removeObserver(obj, 'foo', F);
-
-      set(obj, 'foo', 'baz');
-      assert.equal(count, 1, "removed observer shouldn't fire");
-    }
-
-    ['@test local observers can be removed'](assert) {
-      let barObserved = 0;
-
-      let MyMixin = Mixin.create({
-        foo1: observer('bar', function() {
-          barObserved++;
-        }),
-
-        foo2: observer('bar', function() {
-          barObserved++;
-        }),
-      });
-
-      let obj = {};
-      MyMixin.apply(obj);
-
-      set(obj, 'bar', 'HI!');
-      assert.equal(barObserved, 2, 'precond - observers should be fired');
-
-      removeObserver(obj, 'bar', null, 'foo1');
-
-      barObserved = 0;
-      set(obj, 'bar', 'HI AGAIN!');
-
-      assert.equal(barObserved, 1, 'removed observers should not be called');
-    }
-
-    ['@test removeObserver should respect targets with methods'](assert) {
-      let observed = { foo: 'foo' };
-
-      let target1 = {
-        count: 0,
-
-        didChange() {
-          this.count++;
-        },
-      };
-
-      let target2 = {
-        count: 0,
-
-        didChange() {
-          this.count++;
-        },
-      };
-
-      addObserver(observed, 'foo', target1, 'didChange');
-      addObserver(observed, 'foo', target2, target2.didChange);
-
-      set(observed, 'foo', 'BAZ');
-      assert.equal(target1.count, 1, 'target1 observer should have fired');
-      assert.equal(target2.count, 1, 'target2 observer should have fired');
-
-      removeObserver(observed, 'foo', target1, 'didChange');
-      removeObserver(observed, 'foo', target2, target2.didChange);
-
-      target1.count = target2.count = 0;
-      set(observed, 'foo', 'BAZ');
-      assert.equal(target1.count, 0, 'target1 observer should not fire again');
-      assert.equal(target2.count, 0, 'target2 observer should not fire again');
-    }
-  }
-);
-
-// ..........................................................
-// CHAINED OBSERVERS
-//
-
-let obj, count;
-
-moduleFor(
-  'addObserver - dependentkey with chained properties',
-  class extends AbstractTestCase {
-    beforeEach() {
-      obj = {
-        foo: {
-          bar: {
-            baz: {
-              biff: 'BIFF',
-            },
-          },
-        },
-        Capital: {
-          foo: {
-            bar: {
-              baz: {
-                biff: 'BIFF',
-              },
-            },
-          },
-        },
-      };
-
-      count = 0;
-    }
-
-    afterEach() {
-      obj = count = null;
-    }
-
-    ['@test depending on a chain with a computed property'](assert) {
-      defineProperty(
-        obj,
-        'computed',
-        computed(function() {
-          return { foo: 'bar' };
-        })
-      );
-
-      let changed = 0;
-      addObserver(obj, 'computed.foo', function() {
-        changed++;
-      });
-
-      assert.equal(
-        getCachedValueFor(obj, 'computed'),
-        undefined,
-        'addObserver should not compute CP'
-      );
-
-      set(obj, 'computed.foo', 'baz');
-
-      assert.equal(changed, 1, 'should fire observer');
-    }
-
-    ['@test depending on a simple chain'](assert) {
-      let val;
-      addObserver(obj, 'foo.bar.baz.biff', function(target, key) {
-        val = get(target, key);
-        count++;
-      });
-
-      set(get(obj, 'foo.bar.baz'), 'biff', 'BUZZ');
-      assert.equal(val, 'BUZZ');
-      assert.equal(count, 1);
-
-      set(get(obj, 'foo.bar'), 'baz', { biff: 'BLARG' });
-      assert.equal(val, 'BLARG');
-      assert.equal(count, 2);
-
-      set(get(obj, 'foo'), 'bar', { baz: { biff: 'BOOM' } });
-      assert.equal(val, 'BOOM');
-      assert.equal(count, 3);
-
-      set(obj, 'foo', { bar: { baz: { biff: 'BLARG' } } });
-      assert.equal(val, 'BLARG');
-      assert.equal(count, 4);
-
-      set(get(obj, 'foo.bar.baz'), 'biff', 'BUZZ');
-      assert.equal(val, 'BUZZ');
-      assert.equal(count, 5);
-
-      let foo = get(obj, 'foo');
-
-      set(obj, 'foo', 'BOO');
-      assert.equal(val, undefined);
-      assert.equal(count, 6);
-
-      set(foo.bar.baz, 'biff', 'BOOM');
-      assert.equal(count, 6, 'should be not have invoked observer');
-    }
-
-    ['@test depending on a chain with a capitalized first key'](assert) {
-      let val;
-
-      addObserver(obj, 'Capital.foo.bar.baz.biff', function(target, key) {
-        val = get(obj, key);
-        count++;
-      });
-
-      set(get(obj, 'Capital.foo.bar.baz'), 'biff', 'BUZZ');
-      assert.equal(val, 'BUZZ');
-      assert.equal(count, 1);
-
-      set(get(obj, 'Capital.foo.bar'), 'baz', { biff: 'BLARG' });
-      assert.equal(val, 'BLARG');
-      assert.equal(count, 2);
-
-      set(get(obj, 'Capital.foo'), 'bar', { baz: { biff: 'BOOM' } });
-      assert.equal(val, 'BOOM');
-      assert.equal(count, 3);
-
-      set(obj, 'Capital.foo', { bar: { baz: { biff: 'BLARG' } } });
-      assert.equal(val, 'BLARG');
-      assert.equal(count, 4);
-
-      set(get(obj, 'Capital.foo.bar.baz'), 'biff', 'BUZZ');
-      assert.equal(val, 'BUZZ');
-      assert.equal(count, 5);
-
-      let foo = get(obj, 'foo');
-
-      set(obj, 'Capital.foo', 'BOO');
-      assert.equal(val, undefined);
-      assert.equal(count, 6);
-
-      set(foo.bar.baz, 'biff', 'BOOM');
-      assert.equal(count, 6, 'should be not have invoked observer');
-    }
-  }
-);
-
-// ..........................................................
-// SETTING IDENTICAL VALUES
-//
-
-moduleFor(
-  'props/observer_test - setting identical values',
-  class extends AbstractTestCase {
-    ['@test setting simple prop should not trigger'](assert) {
-      let obj = { foo: 'bar' };
-      let count = 0;
-
-      addObserver(obj, 'foo', function() {
-        count++;
-      });
-
-      set(obj, 'foo', 'bar');
-      assert.equal(count, 0, 'should not trigger observer');
-
-      set(obj, 'foo', 'baz');
-      assert.equal(count, 1, 'should trigger observer');
-
-      set(obj, 'foo', 'baz');
-      assert.equal(count, 1, 'should not trigger observer again');
-    }
-
-    // The issue here is when a computed property is directly set with a value, then has a
-    // dependent key change (which triggers a cache expiration and recomputation), observers will
-    // not be fired if the CP setter is called with the last set value.
-    ['@test setting a cached computed property whose value has changed should trigger'](assert) {
-      let obj = {};
-
-      defineProperty(
-        obj,
-        'foo',
-        computed({
-          get: function() {
-            return get(this, 'baz');
-          },
-          set: function(key, value) {
-            return value;
-          },
-        }).property('baz')
-      );
-
-      let count = 0;
-
-      addObserver(obj, 'foo', function() {
-        count++;
-      });
-
-      set(obj, 'foo', 'bar');
-      assert.equal(count, 1);
-      assert.equal(get(obj, 'foo'), 'bar');
-
-      set(obj, 'baz', 'qux');
-      assert.equal(count, 2);
-      assert.equal(get(obj, 'foo'), 'qux');
-
-      get(obj, 'foo');
-      set(obj, 'foo', 'bar');
-      assert.equal(count, 3);
-      assert.equal(get(obj, 'foo'), 'bar');
-    }
-  }
-);
-
-moduleFor(
-  'changeProperties',
-  class extends AbstractTestCase {
-    ['@test observers added/removed during changeProperties should do the right thing.'](assert) {
-      let obj = {
-        foo: 0,
-      };
-      function Observer() {
-        this.didChangeCount = 0;
-      }
-      Observer.prototype = {
-        add() {
-          addObserver(obj, 'foo', this, 'didChange');
-        },
-        remove() {
-          removeObserver(obj, 'foo', this, 'didChange');
-        },
-        didChange() {
-          this.didChangeCount++;
-        },
-      };
-      let addedBeforeFirstChangeObserver = new Observer();
-      let addedAfterFirstChangeObserver = new Observer();
-      let addedAfterLastChangeObserver = new Observer();
-      let removedBeforeFirstChangeObserver = new Observer();
-      let removedBeforeLastChangeObserver = new Observer();
-      let removedAfterLastChangeObserver = new Observer();
-      removedBeforeFirstChangeObserver.add();
-      removedBeforeLastChangeObserver.add();
-      removedAfterLastChangeObserver.add();
-      changeProperties(function() {
-        removedBeforeFirstChangeObserver.remove();
-        addedBeforeFirstChangeObserver.add();
-
-        set(obj, 'foo', 1);
-
-        assert.equal(
-          addedBeforeFirstChangeObserver.didChangeCount,
-          0,
-          'addObserver called before the first change is deferred'
-        );
-
-        addedAfterFirstChangeObserver.add();
-        removedBeforeLastChangeObserver.remove();
-
-        set(obj, 'foo', 2);
-
-        assert.equal(
-          addedAfterFirstChangeObserver.didChangeCount,
-          0,
-          'addObserver called after the first change is deferred'
-        );
-
-        addedAfterLastChangeObserver.add();
-        removedAfterLastChangeObserver.remove();
-      });
-
-      assert.equal(
-        removedBeforeFirstChangeObserver.didChangeCount,
-        0,
-        'removeObserver called before the first change sees none'
-      );
-      assert.equal(
-        addedBeforeFirstChangeObserver.didChangeCount,
-        1,
-        'addObserver called before the first change sees only 1'
-      );
-      assert.equal(
-        addedAfterFirstChangeObserver.didChangeCount,
-        1,
-        'addObserver called after the first change sees 1'
-      );
-      assert.equal(
-        addedAfterLastChangeObserver.didChangeCount,
-        1,
-        'addObserver called after the last change sees 1'
-      );
-      assert.equal(
-        removedBeforeLastChangeObserver.didChangeCount,
-        0,
-        'removeObserver called before the last change sees none'
-      );
-      assert.equal(
-        removedAfterLastChangeObserver.didChangeCount,
-        0,
-        'removeObserver called after the last change sees none'
-      );
-    }
-
-    ['@test calling changeProperties while executing deferred observers works correctly'](assert) {
-      let obj = { foo: 0 };
-      let fooDidChange = 0;
-
-      addObserver(obj, 'foo', () => {
-        fooDidChange++;
-        changeProperties(() => {});
-      });
-
-      changeProperties(() => {
-        set(obj, 'foo', 1);
-      });
-
-      assert.equal(fooDidChange, 1);
-    }
-  }
-);
-
-moduleFor(
-  'Keys behavior with observers',
-  class extends AbstractTestCase {
-    ['@test should not leak properties on the prototype'](assert) {
-      function Beer() {}
-      Beer.prototype.type = 'ipa';
-
-      let beer = new Beer();
-
-      addObserver(beer, 'type', K);
-      assert.deepEqual(Object.keys(beer), []);
-      removeObserver(beer, 'type', K);
-    }
-
-    ['@test observing a non existent property'](assert) {
-      function Beer() {}
-      Beer.prototype.type = 'ipa';
-
-      let beer = new Beer();
-
-      addObserver(beer, 'brand', K);
-
-      assert.deepEqual(Object.keys(beer), []);
-
-      set(beer, 'brand', 'Corona');
-      assert.deepEqual(Object.keys(beer), ['brand']);
-
-      removeObserver(beer, 'brand', K);
-    }
-
-    ['@test with observers switched on and off'](assert) {
-      function Beer() {}
-      Beer.prototype.type = 'ipa';
-
-      let beer = new Beer();
-
-      addObserver(beer, 'type', K);
-      removeObserver(beer, 'type', K);
-
-      assert.deepEqual(Object.keys(beer), []);
-    }
-
-    ['@test observers switched on and off with setter in between'](assert) {
-      function Beer() {}
-      Beer.prototype.type = 'ipa';
-
-      let beer = new Beer();
-
-      addObserver(beer, 'type', K);
-      set(beer, 'type', 'ale');
-      removeObserver(beer, 'type', K);
-
-      assert.deepEqual(Object.keys(beer), ['type']);
-    }
-
-    ['@test observer switched on and off and then setter'](assert) {
-      function Beer() {}
-      Beer.prototype.type = 'ipa';
-
-      let beer = new Beer();
-
-      addObserver(beer, 'type', K);
-      removeObserver(beer, 'type', K);
-      set(beer, 'type', 'ale');
-
-      assert.deepEqual(Object.keys(beer), ['type']);
-    }
-
-    ['@test observers switched on and off with setter in between (observed property is not shadowing)'](
-      assert
-    ) {
-      function Beer() {}
-
-      let beer = new Beer();
-      set(beer, 'type', 'ale');
-      assert.deepEqual(Object.keys(beer), ['type'], 'only set');
-
-      let otherBeer = new Beer();
-      addObserver(otherBeer, 'type', K);
-      set(otherBeer, 'type', 'ale');
-      assert.deepEqual(Object.keys(otherBeer), ['type'], 'addObserver -> set');
-
-      let yetAnotherBeer = new Beer();
-      addObserver(yetAnotherBeer, 'type', K);
-      set(yetAnotherBeer, 'type', 'ale');
-      removeObserver(beer, 'type', K);
-      assert.deepEqual(
-        Object.keys(yetAnotherBeer),
-        ['type'],
-        'addObserver -> set -> removeObserver'
-      );
-
-      let itsMyLastBeer = new Beer();
-      set(itsMyLastBeer, 'type', 'ale');
-      removeObserver(beer, 'type', K);
-      assert.deepEqual(Object.keys(itsMyLastBeer), ['type'], 'set -> removeObserver');
-    }
-
-    ['@test observers switched on and off with setter in between (observed property is shadowing one on the prototype)'](
-      assert
-    ) {
-      function Beer() {}
-      Beer.prototype.type = 'ipa';
-
-      let beer = new Beer();
-      set(beer, 'type', 'ale');
-      assert.deepEqual(Object.keys(beer), ['type'], 'after set');
-
-      let otherBeer = new Beer();
-      addObserver(otherBeer, 'type', K);
-      set(otherBeer, 'type', 'ale');
-      assert.deepEqual(Object.keys(otherBeer), ['type'], 'addObserver -> set');
-
-      let yetAnotherBeer = new Beer();
-      addObserver(yetAnotherBeer, 'type', K);
-      set(yetAnotherBeer, 'type', 'ale');
-      removeObserver(beer, 'type', K);
-      assert.deepEqual(
-        Object.keys(yetAnotherBeer),
-        ['type'],
-        'addObserver -> set -> removeObserver'
-      );
-
-      let itsMyLastBeer = new Beer();
-      set(itsMyLastBeer, 'type', 'ale');
-      removeObserver(beer, 'type', K);
-      assert.deepEqual(Object.keys(itsMyLastBeer), ['type'], 'set -> removeObserver');
-    }
-  }
-);