[BUGFIX beta] #4443 - Implement testing suite for removeObjects method

emberjs · May 18, 2014 · 9b9819c · 9b9819c
1 parent 26d6e01
commit 9b9819c
Show file tree

Hide file tree

Showing 4 changed files with 225 additions and 11 deletions.
diff --git a/packages_es6/ember-runtime/tests/suites/enumerable.js b/packages_es6/ember-runtime/tests/suites/enumerable.js
@@ -159,17 +159,37 @@ var EnumerableTests = Suite.extend({
   newObject: required(Function),
 
   /**
-    Implement to return a set of new fixture objects that can be applied to
+    Implement to return a set of new fixture strings that can be applied to
     the enumerable.  This may be passed into the newObject method.
 
     @param {Number} count
       The number of items required.
 
-    @returns {Array} array of items
+    @returns {Array} array of strings
   */
   newFixture: function(cnt) {
     var ret = [];
-    while(--cnt>=0) ret.push(generateGuid());
+    while(--cnt >= 0) ret.push(generateGuid());
+    return ret;
+  },
+
+  /**
+    Implement to return a set of new fixture objects that can be applied to
+    the enumerable.  This may be passed into the newObject method.
+
+    @param {Number} cnt
+      The number of items required.
+
+    @returns {Array} array of objects
+  */
+  newObjectsFixture: function(cnt) {
+    var ret = [];
+    var item;
+    while(--cnt >= 0) {
+      item = {};
+      guidFor(item);
+      ret.push(item);
+    }
     return ret;
   },
 

diff --git a/packages_es6/ember-runtime/tests/suites/mutable_enumerable.js b/packages_es6/ember-runtime/tests/suites/mutable_enumerable.js
@@ -2,9 +2,11 @@ import {EnumerableTests, ObserverClass} from 'ember-runtime/tests/suites/enumera
 
 import addObjectTests from 'ember-runtime/tests/suites/mutable_enumerable/addObject';
 import removeObjectTests from 'ember-runtime/tests/suites/mutable_enumerable/removeObject';
+import removeObjectsTests from 'ember-runtime/tests/suites/mutable_enumerable/removeObjects';
 
 var MutableEnumerableTests = EnumerableTests.extend();
 MutableEnumerableTests.importModuleTests(addObjectTests);
 MutableEnumerableTests.importModuleTests(removeObjectTests);
+MutableEnumerableTests.importModuleTests(removeObjectsTests);
 
 export default MutableEnumerableTests;
diff --git a/packages_es6/ember-runtime/tests/suites/mutable_enumerable/removeObject.js b/packages_es6/ember-runtime/tests/suites/mutable_enumerable/removeObject.js
@@ -15,10 +15,11 @@ suite.test("should return receiver", function() {
 suite.test("[A,B,C].removeObject(B) => [A,C] + notify", function() {
   var obj, before, after, observer;
 
-  before = this.newFixture(3);
+  before = Ember.A(this.newFixture(3));
   after  = [before[0], before[2]];
-  obj = this.newObject(before);
-  observer = this.newObserver(obj, '[]', 'length');
+  obj = before;
+  observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
+  obj.getProperties('firstObject', 'lastObject'); // Prime the cache
 
   obj.removeObject(before[1]);
 
@@ -37,27 +38,28 @@ suite.test("[A,B,C].removeObject(B) => [A,C] + notify", function() {
 suite.test("[A,B,C].removeObject(D) => [A,B,C]", function() {
   var obj, before, after, observer, item;
 
-  before = this.newFixture(3);
+  before = Ember.A(this.newFixture(3));
   after  = before;
   item   = this.newFixture(1)[0];
-  obj = this.newObject(before);
-  observer = this.newObserver(obj, '[]', 'length');
+  obj = before;
+  observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
+  obj.getProperties('firstObject', 'lastObject'); // Prime the cache
 
-  obj.removeObject(item); // note: item not in set
+  obj.removeObject(item); // Note: item not in set
 
   deepEqual(this.toArray(obj), after, 'post item results');
   equal(get(obj, 'length'), after.length, 'length');
 
   if (observer.isEnabled) {
     equal(observer.validate('[]'), false, 'should NOT have notified []');
     equal(observer.validate('length'), false, 'should NOT have notified length');
+
     equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
     equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
   }
 });
 
 suite.test('Removing object should notify enumerable observer', function() {
-
   var fixtures = this.newFixture(3);
   var obj = this.newObject(fixtures);
   var observer = this.newObserver(obj).observeEnumerable(obj);

diff --git a/packages_es6/ember-runtime/tests/suites/mutable_enumerable/removeObjects.js b/packages_es6/ember-runtime/tests/suites/mutable_enumerable/removeObjects.js
@@ -0,0 +1,190 @@
+import {SuiteModuleBuilder} from 'ember-runtime/tests/suites/suite';
+import {get} from 'ember-metal/property_get';
+import Ember from "ember-metal/core";
+
+var suite = SuiteModuleBuilder.create();
+
+suite.module('removeObjects');
+
+suite.test("should return receiver", function() {
+  var before, obj;
+  before = Ember.A(this.newFixture(3));
+  obj = before;
+  equal(obj.removeObjects(before[1]), obj, 'should return receiver');
+});
+
+suite.test("[A,B,C].removeObjects([B]) => [A,C] + notify", function() {
+  var obj, before, after, observer;
+
+  before = Ember.A(this.newFixture(3));
+  after = [before[0], before[2]];
+  obj = before;
+  observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
+  obj.getProperties('firstObject', 'lastObject'); // Prime the cache
+
+  obj.removeObjects([before[1]]);
+
+  deepEqual(this.toArray(obj), after, 'post item results');
+  equal(get(obj, 'length'), after.length, 'length');
+
+  if (observer.isEnabled) {
+    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
+    equal(observer.timesCalled('length'), 1, 'should have notified length once');
+
+    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
+    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
+  }
+});
+
+suite.test("[{A},{B},{C}].removeObjects([{B}]) => [{A},{C}] + notify", function() {
+  var obj, before, after, observer;
+
+  before = Ember.A(this.newObjectsFixture(3));
+  after = [before[0], before[2]];
+  obj = before;
+  observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
+  obj.getProperties('firstObject', 'lastObject'); // Prime the cache
+
+  obj.removeObjects([before[1]]);
+
+  deepEqual(this.toArray(obj), after, 'post item results');
+  equal(get(obj, 'length'), after.length, 'length');
+
+  if (observer.isEnabled) {
+    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
+    equal(observer.timesCalled('length'), 1, 'should have notified length once');
+
+    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
+    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
+  }
+});
+
+suite.test("[A,B,C].removeObjects([A,B]) => [C] + notify", function() {
+  var obj, before, after, observer;
+
+  before = Ember.A(this.newFixture(3));
+  after  = [before[2]];
+  obj = before;
+  observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
+  obj.getProperties('firstObject', 'lastObject'); // Prime the cache
+
+  obj.removeObjects([before[0], before[1]]);
+
+  deepEqual(this.toArray(obj), after, 'post item results');
+  equal(get(obj, 'length'), after.length, 'length');
+
+  if (observer.isEnabled) {
+    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
+    equal(observer.timesCalled('length'), 1, 'should have notified length once');
+
+    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject');
+    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
+  }
+});
+
+suite.test("[{A},{B},{C}].removeObjects([{A},{B}]) => [{C}] + notify", function() {
+  var obj, before, after, observer;
+
+  before = Ember.A(this.newObjectsFixture(3));
+  after = [before[2]];
+  obj = before;
+  observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
+  obj.getProperties('firstObject', 'lastObject'); // Prime the cache
+
+  obj.removeObjects([before[0], before[1]]);
+
+  deepEqual(this.toArray(obj), after, 'post item results');
+  equal(get(obj, 'length'), after.length, 'length');
+
+  if (observer.isEnabled) {
+    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
+    equal(observer.timesCalled('length'), 1, 'should have notified length once');
+
+    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject');
+    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
+  }
+});
+
+suite.test("[A,B,C].removeObjects([A,B,C]) => [] + notify", function() {
+  var obj, before, after, observer;
+
+  before = Ember.A(this.newFixture(3));
+  after = [];
+  obj = before;
+  observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
+  obj.getProperties('firstObject', 'lastObject'); // Prime the cache
+
+  obj.removeObjects([before[0], before[1], before[2]]);
+
+  deepEqual(this.toArray(obj), after, 'post item results');
+  equal(get(obj, 'length'), after.length, 'length');
+
+  if (observer.isEnabled) {
+    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
+    equal(observer.timesCalled('length'), 1, 'should have notified length once');
+
+    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject');
+    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject');
+  }
+});
+
+suite.test("[{A},{B},{C}].removeObjects([{A},{B},{C}]) => [] + notify", function() {
+  var obj, before, after, observer;
+
+  before = Ember.A(this.newObjectsFixture(3));
+  after = [];
+  obj = before;
+  observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
+  obj.getProperties('firstObject', 'lastObject'); // Prime the cache
+
+  obj.removeObjects(before);
+
+  deepEqual(this.toArray(obj), after, 'post item results');
+  equal(get(obj, 'length'), after.length, 'length');
+
+  if (observer.isEnabled) {
+    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
+    equal(observer.timesCalled('length'), 1, 'should have notified length once');
+
+    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject');
+    equal(observer.validate('lastObject'), 1, 'should have notified lastObject');
+  }
+});
+
+suite.test("[A,B,C].removeObjects([D]) => [A,B,C]", function() {
+  var obj, before, after, observer, item;
+
+  before = Ember.A(this.newFixture(3));
+  after = before;
+  item = this.newFixture(1)[0];
+  obj = before;
+  observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
+  obj.getProperties('firstObject', 'lastObject'); // Prime the cache
+
+  obj.removeObjects([item]); // Note: item not in set
+
+  deepEqual(this.toArray(obj), after, 'post item results');
+  equal(get(obj, 'length'), after.length, 'length');
+
+  if (observer.isEnabled) {
+    equal(observer.validate('[]'), false, 'should NOT have notified []');
+    equal(observer.validate('length'), false, 'should NOT have notified length');
+
+    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
+    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
+  }
+});
+
+suite.test('Removing objects should notify enumerable observer', function() {
+  var fixtures = this.newFixture(3);
+  var obj = this.newObject(fixtures);
+  var observer = this.newObserver(obj).observeEnumerable(obj);
+  var item = fixtures[1];
+
+  obj.removeObjects([item]);
+
+  deepEqual(observer._before, [obj, [item], null]);
+  deepEqual(observer._after, [obj, [item], null]);
+});
+
+export default suite;