sproutcore 0.9.14 → 0.9.15

data/frameworks/sproutcore/tests/foundation/set.rhtml

@@ -0,0 +1,254 @@
+<% content_for('final') do %>
+<script>
+
+Test.context("creating SC.Set instances", {
+  
+  setup: function() {
+    // create objects...
+    a = { name: "a" } ;
+    b = { name: "b" } ;
+    c = { name: "c" } ;
+  },
+
+  teardown: function() {
+    delete a;
+    delete b;
+    delete c;
+  },
+  
+  "new SC.Set() should create empty set": function() {
+    var set = new SC.Set() ;
+    assertEqual(set.length, 0) ;
+  },
+  
+  "new SC.Set([1,2,3]) should create set with three items in them": function(){
+    var set = new SC.Set([a,b,c]) ;
+    set.length.shouldEqual(3) ;
+    set.contains(a).shouldEqual(YES) ;
+    set.contains(b).shouldEqual(YES) ;
+    set.contains(c).shouldEqual(YES) ;
+  },
+  
+  "SC.Set.create() is an alias for new SC.Set()": function() {
+    var set = SC.Set.create() ;
+    set.length.shouldEqual(0) ;
+    
+    var set = SC.Set.create([a,b,c]) ;
+    set.length.shouldEqual(3) ;
+    set.contains(a).shouldEqual(YES) ;
+    set.contains(b).shouldEqual(YES) ;
+    set.contains(c).shouldEqual(YES) ;
+  },
+  
+  "new SC.Set() should accept anything that implements SC.Array": function() {
+    var arrayLikeObject = SC.Object.create(SC.Array, {
+      
+      _content: [a,b,c],
+      length: 3,
+      objectAt: function(idx) { return this._content[idx]; } 
+    }) ;
+    
+    var set = SC.Set.create(arrayLikeObject) ;
+    set.length.shouldEqual(3) ;
+    set.contains(a).shouldEqual(YES) ;
+    set.contains(b).shouldEqual(YES) ;
+    set.contains(c).shouldEqual(YES) ;
+  },
+  
+  "new SC.Set() should accept anything that looks like an array, even if it does not implement SC.Array": function() {
+    var arrayLikeObject = { length: 3, '0': a, '1': b, '2': c } ;
+    
+    var set = SC.Set.create(arrayLikeObject) ;
+    set.length.shouldEqual(3) ;
+    set.contains(a).shouldEqual(YES) ;
+    set.contains(b).shouldEqual(YES) ;
+    set.contains(c).shouldEqual(YES) ;
+  }
+
+});
+
+// The tests below also end up testing the contains() method pretty 
+// exhaustively.
+Test.context("SC.Set.add + SC.Set.contains", {
+  
+  setup: function() {
+    set = SC.Set.create() ;
+  },
+
+  teardown: function() {
+    delete set ;
+  },
+  
+  "should add an SC.Object": function() {
+    var obj = SC.Object.create() ;
+
+    var oldLength = set.length ;
+    set.add(obj);
+    assertEqual(set.contains(obj), YES, "contains()") ;
+    assertEqual(oldLength+1, set.length, "new set length") ;
+  },
+  
+  "should add a regular hash": function() {
+    var obj = {} ;
+
+    var oldLength = set.length ;
+    set.add(obj);
+    assertEqual(set.contains(obj), YES, "contains()") ;
+    assertEqual(oldLength+1, set.length, "new set length") ;
+  },
+
+  "should add a string": function() {
+    var obj = "String!" ;
+
+    var oldLength = set.length ;
+    set.add(obj);
+    assertEqual(set.contains(obj), YES, "contains()") ;
+    assertEqual(oldLength+1, set.length, "new set length") ;
+  },
+
+  "should add a number": function() {
+    var obj = 23 ;
+
+    var oldLength = set.length ;
+    set.add(obj);
+    assertEqual(set.contains(obj), YES, "contains()") ;
+    assertEqual(oldLength+1, set.length, "new set length") ;
+  },
+
+  "should add a bool": function() {
+    var obj = true ;
+
+    var oldLength = set.length ;
+    set.add(obj);
+    assertEqual(set.contains(obj), YES, "contains()") ;
+    assertEqual(oldLength+1, set.length, "new set length") ;
+  },
+
+  "should add a function": function() {
+    var obj = function() { return "Test function"; } ;
+
+    var oldLength = set.length ;
+    set.add(obj);
+    assertEqual(set.contains(obj), YES, "contains()") ;
+    assertEqual(oldLength+1, set.length, "new set length") ;
+  },
+
+  "should NOT add a null": function() {
+    set.add(null) ;
+    assertEqual(set.length, 0) ;
+    assertEqual(set.contains(null), NO) ;
+  },
+
+  "should NOT add an undefined": function() {
+    set.add(undefined) ;
+    assertEqual(set.length, 0) ;
+    assertEqual(set.contains(undefined), NO) ;
+  }
+  
+});
+
+Test.context("SC.Set.remove + SC.Set.contains", {
+  
+  // generate a set with every type of object, but none of the specific
+  // ones we add in the tests below...
+  setup: function() {
+    set = SC.Set.create([
+      SC.Object.create({ dummy: YES }),
+      { isHash: YES },
+      "Not the String",
+      16, false]) ;
+  },
+
+  teardown: function() {
+    delete set ;
+  },
+  
+  "should remove an SC.Object and reduce length": function() {
+    var obj = SC.Object.create() ;
+    set.add(obj);
+    assertEqual(set.contains(obj), YES) ;
+    var oldLength = set.length ;
+    
+    set.remove(obj) ;
+    assertEqual(NO, set.contains(obj), "should be removed") ;
+    assertEqual(oldLength-1, set.length, "should be 1 shorter") ;
+  },
+  
+  "should remove a regular hash and reduce length": function() {
+    var obj = {} ;
+    set.add(obj);
+    assertEqual(set.contains(obj), YES) ;
+    var oldLength = set.length ;
+    
+    set.remove(obj) ;
+    assertEqual(NO, set.contains(obj), "should be removed") ;
+    assertEqual(oldLength-1, set.length, "should be 1 shorter") ;
+  },
+
+  "should remove a string and reduce length": function() {
+    var obj = "String!" ;
+    set.add(obj);
+    assertEqual(set.contains(obj), YES) ;
+    var oldLength = set.length ;
+    
+    set.remove(obj) ;
+    assertEqual(NO, set.contains(obj), "should be removed") ;
+    assertEqual(oldLength-1, set.length, "should be 1 shorter") ;
+  },
+  
+  "should remove a number and reduce length": function() {
+    var obj = 23 ;
+    set.add(obj);
+    assertEqual(set.contains(obj), YES) ;
+    var oldLength = set.length ;
+    
+    set.remove(obj) ;
+    assertEqual(NO, set.contains(obj), "should be removed") ;
+    assertEqual(oldLength-1, set.length, "should be 1 shorter") ;
+  },
+  
+  "should remove a bool and reduce length": function() {
+    var obj = true ;
+    set.add(obj);
+    assertEqual(set.contains(obj), YES) ;
+    var oldLength = set.length ;
+    
+    set.remove(obj) ;
+    assertEqual(NO, set.contains(obj), "should be removed") ;
+    assertEqual(oldLength-1, set.length, "should be 1 shorter") ;
+  },
+
+  "should remove a function and reduce length": function() {
+    var obj = function() { return "Test function"; } ;
+    set.add(obj);
+    assertEqual(set.contains(obj), YES) ;
+    var oldLength = set.length ;
+    
+    set.remove(obj) ;
+    assertEqual(NO, set.contains(obj), "should be removed") ;
+    assertEqual(oldLength-1, set.length, "should be 1 shorter") ;
+  },
+  
+  "should NOT remove a null": function() {
+    var oldLength = set.length ;
+    set.remove(null) ;
+    assertEqual(oldLength, set.length) ;
+  },
+  
+  "should NOT remove an undefined": function() {
+    var oldLength = set.length ;
+    set.remove(undefined) ;
+    assertEqual(oldLength, set.length) ;
+  },
+  
+  "should ignore removing an object not in the set": function() {
+    var obj = SC.Object.create() ;
+    var oldLength = set.length ;
+    set.remove(obj) ;
+    assertEqual(oldLength, set.length) ;
+  }
+  
+});
+
+</script>
+<% end %>

data/frameworks/sproutcore/tests/mixins/enumerable.rhtml

@@ -0,0 +1,421 @@
+<% content_for('final') do %>
+<script>
+
+// Define some standard tests.  We need to test both on a custom enumerable
+// and on a real Array.
+var EnumerableTests = {
+  
+  "should get enumerator that iterates through objects": function() {
+    var e = src.enumerator() ;
+    assertNotEqual(e, null, 'enumerator must not be null');
+    
+    var idx = 0;
+    var cur ;
+    while(cur = e.nextObject()) {
+      assertEqual(src.objectAt(idx), cur, "object at index %@".fmt(idx)) ;
+      idx++;
+    }
+    
+    assertEqual(src.get('length'), idx) ;
+  },
+  
+  "should run forEach() to go through objects": function() {
+    var idx = 0;
+    
+    // save for testing later
+    var items = [] ;
+    var indexes = [] ;
+    var arrays = [] ;
+    var targets = [] ;
+    
+    src.forEach(function(item, index, array) {
+      items.push(item);
+      indexes.push(index);
+      arrays.push(array);
+      targets.push(this);
+    }, this);
+    
+    var len = src.get('length') ;
+    for(var idx=0;idx<len;idx++) {
+      assertEqual(items[idx], src.objectAt(idx)) ;
+      assertEqual(indexes[idx], idx) ;
+      assertEqual(arrays[idx], src) ;
+      assertEqual(targets[idx], this) ;
+    }
+  },
+  
+  "should map to values while passing proper params": function() {
+    var idx = 0;
+    
+    // save for testing later
+    var items = [] ;
+    var indexes = [] ;
+    var arrays = [] ;
+    var targets = [] ;
+    
+    var mapped = src.map(function(item, index, array) {
+      items.push(item);
+      indexes.push(index);
+      arrays.push(array);
+      targets.push(this);
+      
+      return index ;
+    }, this);
+    
+    var len = src.get('length') ;
+    for(var idx=0;idx<len;idx++) {
+      assertEqual(src.objectAt(idx), items[idx], "items") ;
+      assertEqual(idx, indexes[idx], "indexes") ;
+      assertEqual(src, arrays[idx], 'arrays') ;
+      assertEqual(SC.guidFor(this), SC.guidFor(targets[idx]), "this") ;
+      
+      assertEqual(idx, mapped[idx], "mapped") ;
+    }
+  },
+  
+  "should filter to items that return for callback": function() {
+    var idx = 0;
+    
+    // save for testing later
+    var items = [] ;
+    var indexes = [] ;
+    var arrays = [] ;
+    var targets = [] ;
+    
+    var filtered = src.filter(function(item, index, array) {
+      items.push(item);
+      indexes.push(index);
+      arrays.push(array);
+      targets.push(this);
+  
+      return item.gender === "female" ;
+    }, this);
+    
+    var len = src.get('length') ;
+    for(var idx=0;idx<len;idx++) {
+      assertEqual(src.objectAt(idx), items[idx], "items") ;
+      assertEqual(idx, indexes[idx], "indexes") ;
+      assertEqual(src, arrays[idx], 'arrays') ;
+      assertEqual(SC.guidFor(this), SC.guidFor(targets[idx]), "this") ;
+    }
+    
+    filtered.length.shouldEqual(1) ;
+    filtered[0].first.shouldEqual("Jenna") ;
+  },
+  
+  "should return true if function for every() returns true": function() {
+    var idx = 0;
+    
+    // save for testing later
+    var items = [] ;
+    var indexes = [] ;
+    var arrays = [] ;
+    var targets = [] ;
+    
+    var result = src.every(function(item, index, array) {
+      items.push(item);
+      indexes.push(index);
+      arrays.push(array);
+      targets.push(this);
+  
+      return true ;
+    }, this);
+    
+    var len = src.get('length') ;
+    for(var idx=0;idx<len;idx++) {
+      assertEqual(src.objectAt(idx), items[idx], "items") ;
+      assertEqual(idx, indexes[idx], "indexes") ;
+      assertEqual(src, arrays[idx], 'arrays') ;
+      assertEqual(SC.guidFor(this), SC.guidFor(targets[idx]), "this") ;
+    }
+  
+    assertEqual(result, YES) ;
+  },
+  
+  "should return false if one function for every() returns false": function() {
+    var result = src.every(function(item, index, array) {
+      return item.gender === "male" ;
+    }, this);
+    assertEqual(result, NO) ;
+  },
+
+  "should return false if all functions for some() returns false": function() {
+    var idx = 0;
+    
+    // save for testing later
+    var items = [] ;
+    var indexes = [] ;
+    var arrays = [] ;
+    var targets = [] ;
+    
+    var result = src.some(function(item, index, array) {
+      items.push(item);
+      indexes.push(index);
+      arrays.push(array);
+      targets.push(this);
+  
+      return false ;
+    }, this);
+    
+    var len = src.get('length') ;
+    for(var idx=0;idx<len;idx++) {
+      assertEqual(src.objectAt(idx), items[idx], "items") ;
+      assertEqual(idx, indexes[idx], "indexes") ;
+      assertEqual(src, arrays[idx], 'arrays') ;
+      assertEqual(SC.guidFor(this), SC.guidFor(targets[idx]), "this") ;
+    }
+  
+    assertEqual(result, NO) ;
+  },
+  
+  "should return true if one function for some() returns true": function() {
+    var result = src.some(function(item, index, array) {
+      return item.gender !== "male" ;
+    }, this);
+    assertEqual(result, YES) ;
+  },
+
+    
+  "should mapProperty for all items": function() {
+    var mapped = src.mapProperty("first") ;
+    var idx ;
+    var len = src.get('length') ;
+    for(idx=0;idx<len;idx++) {
+      mapped[idx].shouldEqual(src.objectAt(idx).first) ;
+    }
+  },
+  
+  "should filterProperty with match": function() {
+    var filtered = src.filterProperty("gender", "female") ;
+    filtered.length.shouldEqual(1) ;
+    filtered[0].first.shouldEqual("Jenna") ;
+  },
+
+  "should filterProperty with default bool": function() {
+    var filtered = src.filterProperty("californian") ;
+    filtered.length.shouldEqual(1) ;
+    filtered[0].first.shouldEqual("Jenna") ;
+  },
+
+
+  
+  "everyProperty should return true if all properties macth": function() {
+    var ret = src.everyProperty('visited', 'Prague') ;
+    assertEqual(YES, ret, "visited") ;
+  },
+
+  "everyProperty should return true if all properties true": function() {
+    var ret = src.everyProperty('ready') ;
+    assertEqual(YES, ret, "ready") ;
+  },
+
+  "everyProperty should return false if any properties false": function() {
+    var ret = src.everyProperty('gender', 'male') ;
+    assertEqual(NO, ret, "ready") ;
+  },
+  
+
+  "someProperty should return false if all properties not match": function() {
+    var ret = src.someProperty('visited', 'Timbuktu') ;
+    assertEqual(NO, ret, "visited") ;
+  },
+
+  "someProperty should return false if all properties false": function() {
+    var ret = src.someProperty('doneTravelling') ;
+    assertEqual(NO, ret, "doneTravelling") ;
+  },
+
+  "someProperty should return true if any properties true": function() {
+    var ret = src.someProperty('first', 'Charles') ;
+    assertEqual(YES, ret, "first") ;
+  },
+  
+  "invokeWhile should call method on member objects until return does not match": function() {
+    var ret = src.invokeWhile("OK", "invokeWhileTest", "item2") ;
+    assertEqual("FAIL", ret, "return value");
+  },
+  
+  "get @min(balance) should return the minimum balance": function() {
+    assertEqual(1, src.get('@min(balance)')) ;
+  },
+  
+  "get @max(balance) should return the maximum balance": function() {
+    assertEqual(4, src.get('@max(balance)')) ;
+  },
+  
+  "get @minObject(balance) should return the record with min balance": function() {
+    assertEqual(src.objectAt(0), src.get('@minObject(balance)')) ;
+  },
+  
+  "get @maxObject(balance) should return the record with the max balance": function() {
+    assertEqual(src.objectAt(0), src.get('@maxObject(balance)')) ;
+  },
+  
+  "get @sum(balance) should return the sum of the balances.": function() {
+    assertEqual(1+2+3+4, src.get("@sum(balance)")) ;
+  },
+  
+  "get @average(balance) should return the average of balances": function() {
+    assertEqual((1+2+3+4)/4, src.get("@average(balance)")) ;
+  },
+  
+  "should invoke custom reducer": function() {
+    // install reducer method
+    src.reduceTest = reduceTestFunc ;
+    assertEqual("TEST", src.get("@test")) ;
+    assertEqual("prop", src.get("@test(prop)")) ;
+  },
+  "should trigger observer of reduced prop when array changes once property retrieved once": function() {
+
+    // get the property...this will install the reducer property...
+    src.get("@max(balance)") ;
+    
+    // install observer
+    var observedValue = null ;
+    src.addObserver("@max(balance)", function() { 
+      observedValue = src.get("@max(balance)");
+    }) ;
+    
+    src.addProbe('[]') ;
+    src.addProbe('@max(balance)');
+    
+    // add record to array
+    src.pushObject({ 
+      first: "John", 
+      gender: "male", 
+      californian: NO, 
+      ready: YES, 
+      visited: "Paris", 
+      balance: 5
+    }) ;
+    
+    //SC.NotificationQueue.flush() ; // force observers to trigger
+    
+    // observed value should now be set because the reduced property observer
+    // was triggered when we changed the array contents.
+    assertEqual(5, observedValue) ;
+  },
+  
+  "should trigger observer of reduced prop when array changes - even if you never retrieved the property before": function() {
+    // install observer
+    var observedValue = null ;
+    src.addObserver("@max(balance)", function() { 
+      observedValue = src.get("@max(balance)");
+    }) ;
+    
+    // add record to array
+    src.pushObject({ 
+      first: "John", 
+      gender: "male", 
+      californian: NO, 
+      ready: YES, 
+      visited: "Paris", 
+      balance: 5
+    }) ;
+    
+    //SC.NotificationQueue.flush() ; // force observers to trigger
+    
+    // observed value should now be set because the reduced property observer
+    // was triggered when we changed the array contents.
+    assertEqual(5, observedValue) ;
+  }
+  
+}; 
+
+var DummyEnumerable = SC.Object.extend(SC.Enumerable, {
+  
+  content: [],
+  
+  length: function() { return this.content.length; }.property(),
+  
+  objectAt: function(idx) { return this.content[idx]; },
+  
+  nextObject: function(idx) { return this.content[idx]; },
+  
+  // add support for reduced properties.
+  unknownProperty: function(key, value) {
+    var ret = this.reducedProperty(key, value) ;
+    if (ret === undefined) {
+      if (value !== undefined) this[key] = value ;
+      ret = value ;
+    }
+    return ret ;
+  },
+  
+  pushObject: function(object) {
+    this.content.push(object) ;
+    this.enumerableContentDidChange() ;
+  }
+  
+}) ;
+
+var runFunc = function(a,b) { return ['DONE', a, b]; } ;
+var invokeWhileOK = function() { return "OK"; } ;
+var invokeWhileNotOK = function() { return "FAIL"; };
+var reduceTestFunc = function(prev, item, idx, e, pname) { return pname||'TEST'; } ;
+
+var CommonArray = [
+  { first: "Charles", 
+    gender: "male", 
+    californian: NO, 
+    ready: YES, 
+    visited: "Prague", 
+    doneTravelling: NO, 
+    run: runFunc,
+    invokeWhileTest: invokeWhileOK,
+    balance: 1
+  },
+
+  { first: "Jenna", 
+    gender: "female", 
+    californian: YES, 
+    ready: YES, 
+    visited: "Prague", 
+    doneTravelling: NO, 
+    run: runFunc,
+    invokeWhileTest: invokeWhileOK,
+    balance: 2 
+  },
+  
+  { first: "Peter", 
+    gender: "male", 
+    californian: NO, 
+    ready: YES, 
+    visited: "Prague", 
+    doneTravelling: NO, 
+    run: runFunc,
+    invokeWhileTest: invokeWhileNotOK,
+    balance: 3 
+  },
+  
+  { first: "Chris", 
+    gender: "male", 
+    californian: NO, 
+    ready: YES, 
+    visited: "Prague", 
+    doneTravelling: NO, 
+    run: runFunc,
+    invokeWhileTest: invokeWhileOK,
+    balance: 4
+  } ] ;
+
+Test.context("Real Array", SC.mixin(EnumerableTests, {
+  
+  setup: function() { src = CommonArray.clone(); },
+  
+  teardown: function() { src = null ; }
+
+}));
+
+Test.context("DummyEnumerable", SC.mixin(EnumerableTests, {
+  
+  setup: function() { 
+    src = DummyEnumerable.create({ content: CommonArray }) ;
+  },
+  
+  teardown: function() { src = null ; }
+
+}));
+
+</script>
+<% end %>