sproutit-sproutcore 1.0.0.20090416161445 → 1.0.0.20090720093355

data/frameworks/sproutcore/frameworks/runtime/tests/core/compare.js

@@ -0,0 +1,44 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Apple, Inc. and contributors.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+/*globals module ok equals same test MyApp */
+
+// test parsing of query string
+var v = [];
+module("SC.compare()", {
+  setup: function() {
+    // setup dummy data
+    v[0]  = null;
+    v[1]  = false;
+    v[2]  = true;
+    v[3]  = -12;
+    v[4]  = 3.5;
+    v[5]  = 'a string';
+    v[6]  = 'another string';
+    v[7]  = 'last string';
+    v[8]  = [1,2];
+    v[9]  = [1,2,3];
+    v[10] = [1,3];
+    v[11] = {a: 'hash'};
+    v[12] = SC.Object.create();
+    v[13] = function (a) {return a};
+  }
+});
+
+
+// ..........................................................
+// TESTS
+// 
+
+test("ordering should work", function() {
+  for (var j=0; j < v.length; j++) {
+    equals(SC.compare(v[j],v[j]), 0, j +' should equal itself');
+    for (var i=j+1; i < v.length; i++) {
+      equals(SC.compare(v[j],v[i]), -1, 'v[' + j + '] (' + SC.typeOf(v[j]) + ') should be smaller than v[' + i + '] (' + SC.typeOf(v[i]) + ')' );
+    };
+    
+  };
+}); 
+  

data/frameworks/sproutcore/frameworks/runtime/tests/core/console.js

@@ -0,0 +1,16 @@
+// ========================================================================
+// SC.guidFor Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+
+module("Console object");
+
+test("The console object should be defined for all browsers and work if supported", function() {
+  ok((console!==undefined), "console should not be undefined");
+  console.info("Console.info is working");
+  console.log("Console.log is working");
+  console.warn("Console.warn is working");
+  console.error("Console.error is working");
+});
+

data/frameworks/sproutcore/frameworks/runtime/tests/core/keys.js

@@ -14,7 +14,7 @@ test("should get a key array for a specified object ",function(){
 
 	var object2 = [];
 	object2 = SC.keys(object1);
-	equals(object2,'names,age,place');
+	same(object2,['names','age','place']);
 });
 
 

data/frameworks/sproutcore/frameworks/runtime/tests/core/makeArray.js

@@ -22,7 +22,7 @@ test("should return an array for the object passed ",function(){
 	var ret = SC.makeArray(obj);
 	equals(SC.isArray(ret),true);	
 	ret = SC.makeArray(stringA);
-	equals(SC.isArray(ret), false) ;  	
+	equals(SC.isArray(ret), true) ;  	
 	ret = SC.makeArray(numberA);
 	equals(SC.isArray(ret),true) ;  	
 	ret = SC.makeArray(arrayA);

data/frameworks/sproutcore/frameworks/runtime/tests/core/objectForPropertyPath.js

@@ -1,19 +1,19 @@
 // ========================================================================
 // SC.objectForPropertyPath Tests
 // ========================================================================
-/*globals module test ok isObj equals expects */
+/*globals module test ok same equals expects */
 
 // An ObjectController will make a content object or an array of content objects 
 module("SC.objectForPropertyPath") ;
 
 test("should be able to resolve an object on the window", function() {
-  var myLocal = window['myGlobal'] = { test: 'this '} ;
+  var myLocal = (window.myGlobal = { test: 'this '}) ;
   
-  isObj(myLocal, { test: 'this '}) ;
-  isObj(window['myGlobal'], { test: 'this '}) ;
+  same(myLocal, { test: 'this '}) ;
+  same(window.myGlobal, { test: 'this '}) ;
   
   // verify we can resolve our binding path
   same(SC.objectForPropertyPath('myGlobal'), { test: 'this '}) ;
   
-  delete g ;
+  window.myGlobal =null ;
 });

data/frameworks/sproutcore/frameworks/runtime/tests/mixins/array.js

@@ -0,0 +1,57 @@
+// ==========================================================================
+// Project:   SproutCore Costello - Property Observing Library
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+// Unit test some standard SC.Array implementations.
+
+// ..........................................................
+// BUILT-IN ARRAY
+// 
+
+SC.ArraySuite.generate("built-in Array");
+
+// ..........................................................
+// DUMMY ARRAY (BASIC FAKE IMPLEMENTATION)
+// 
+
+// Test the SproutCore Array interface on a custom object.
+var DummyArray = SC.Object.extend(SC.Array, {
+  
+  length: 0,
+  
+  content: null,
+  
+  replace: function(idx, amt, objects) {
+    if (!this.content) this.content = [] ;
+
+    this.beginPropertyChanges() ;
+    this.content.replace(idx,amt,objects) ;
+
+    this.set('length', this.content.length) ;
+
+    // figure out the range that changed.  If amt + objects are the same, use
+    // amt.  Otherwise use total length.
+    var len = objects ? objects.get('length') : 0;
+    this.enumerableContentDidChange(idx, amt, len - amt) ;
+    this.endPropertyChanges() ;
+  },
+  
+  objectAt: function(idx) {
+    if (!this.content) this.content = [] ;
+    return this.content[idx] ;
+  }
+  
+});
+
+SC.ArraySuite.generate("DummyArray", {
+  newObject: function(expected) {
+    if (!expected || typeof expected === SC.T_NUMBER) {
+      expected = this.expected(expected); 
+    }
+    return DummyArray.create({ content: expected, length: expected.length }) ;
+  }
+});
+

data/frameworks/sproutcore/frameworks/runtime/tests/mixins/enumerable.js

@@ -123,6 +123,16 @@ test("should get enumerator that iterates through objects", function() {
   }
 });
 
+test("should return firstObject for item with content", function() {
+  var src, ary2 = enumerables ;
+  for (var idx2=0, len2=ary2.length; idx2<len2; idx2++) {
+    src = ary2[idx2] ;
+    equals(src.firstObject(), CommonArray[0], 'firstObject should return first object');
+  }
+  
+  equals([].firstObject(), undefined, 'firstObject() on empty enumerable should return undefined');
+});
+
 test("should run forEach() to go through objects", function() {
   var src, ary2 = enumerables ;
   for (var idx2=0, len2=ary2.length; idx2<len2; idx2++) {
@@ -147,7 +157,10 @@ test("should run forEach() to go through objects", function() {
       equals(items[idx], src.objectAt(idx)) ;
       equals(indexes[idx], idx) ;
       equals(arrays[idx], src) ;
-      equals(targets[idx], this) ;
+
+      // use this method because equals() is taking too much time to log out
+      // results.  probably an issue with jsDump
+      ok(targets[idx] === this, 'target should always be this') ;
     }
   }
 });
@@ -431,7 +444,7 @@ test("get @maxObject(balance) should return the record with the max balance", fu
   var src, ary2 = enumerables ;
   for (var idx2=0, len2=ary2.length; idx2<len2; idx2++) {
     src = ary2[idx2] ;
-    equals(src.objectAt(0), src.get('@maxObject(balance)')) ;
+    equals(src.objectAt(3), src.get('@maxObject(balance)')) ;
   }
 });
 
@@ -524,6 +537,12 @@ test("should trigger observer of reduced prop when array changes - even if you n
   }
 });
 
+test("should find the first element matching the criteria", function() {
+  var people = enumerables[1] ;
+  var jenna = people.find(function(person) { return person.gender == 'female'; });
+  equals(jenna.first, 'Jenna');
+});
+
 var source ; // global variables
 
 module("Real Array", {

data/frameworks/sproutcore/frameworks/runtime/tests/mixins/observable/observable.js

@@ -176,14 +176,31 @@ module("Computed properties", {
         return 'dependentCached';
       }.property('changer').cacheable(),
       
-      
       // everytime it is recomputed, increments call
       incCallCount: 0,
       inc: function() {
         return this.incCallCount++;
-      }.property('changer').cacheable()
+      }.property('changer').cacheable(),
+
+      // depends on cached property which depends on another property...
+      nestedIncCallCount: 0,
+      nestedInc: function(key, value) {
+        return this.nestedIncCallCount++;
+      }.property('inc').cacheable(),
+      
+      // two computed properties that depend on a third property
+      state: 'on',
+      isOn: function(key, value) {
+        if (value !== undefined) this.set('state', 'on');
+        return this.get('state') === 'on';
+      }.property('state'),
       
-    })    ;
+      isOff: function(key, value) {
+        if (value !== undefined) this.set('state', 'off');
+        return this.get('state') === 'off';
+      }.property('state')
+      
+    }) ;
   }
 });
 
@@ -259,6 +276,60 @@ test("change dependent should clear cache", function() {
   equals(object.get('inc'), ret1+1, 'should increment after dependent key changes'); // should run again
 });
 
+test("just notifying change of dependent should clear cache", function() {
+
+  // call get several times to collect call count
+  var ret1 = object.get('inc'); // should run func
+  equals(object.get('inc'), ret1, 'multiple calls should not run cached prop');
+
+  object.notifyPropertyChange('changer');
+    
+  equals(object.get('inc'), ret1+1, 'should increment after dependent key changes'); // should run again
+});
+
+test("changing dependent should clear nested cache", function() {
+
+  // call get several times to collect call count
+  var ret1 = object.get('nestedInc'); // should run func
+  equals(object.get('nestedInc'), ret1, 'multiple calls should not run cached prop');
+
+  object.set('changer', 'bar');
+    
+  equals(object.get('nestedInc'), ret1+1, 'should increment after dependent key changes'); // should run again
+  
+});
+
+test("just notifying change of dependent should clear nested cache", function() {
+
+  // call get several times to collect call count
+  var ret1 = object.get('nestedInc'); // should run func
+  equals(object.get('nestedInc'), ret1, 'multiple calls should not run cached prop');
+
+  object.notifyPropertyChange('changer');
+    
+  equals(object.get('nestedInc'), ret1+1, 'should increment after dependent key changes'); // should run again
+  
+});
+
+
+// This verifies a specific bug encountered where observers for computed 
+// properties would fire before their prop caches were cleared.
+test("change dependent should clear cache when observers of dependent are called", function() {
+
+  // call get several times to collect call count
+  var ret1 = object.get('inc'); // should run func
+  equals(object.get('inc'), ret1, 'multiple calls should not run cached prop');
+
+  // add observer to verify change...
+  object.addObserver('inc', this, function() {
+    equals(object.get('inc'), ret1+1, 'should increment after dependent key changes'); // should run again
+  });
+
+  // now run
+  object.set('changer', 'bar');
+    
+});
+
 test("allPropertiesDidChange should clear cache", function() {
   // note: test this with a computed method that returns a different value
   // each time to ensure clean function.
@@ -270,6 +341,16 @@ test("allPropertiesDidChange should clear cache", function() {
   equals(object.get('inc'), ret1+1, 'should increment after change');
 });
 
+test('setting one of two computed properties that depend on a third property should clear the kvo cache', function() {
+  // we have to call set twice to fill up the cache
+  object.set('isOff', YES);
+  object.set('isOn', YES);
+  
+  // setting isOff to YES should clear the kvo cache
+  object.set('isOff', YES);
+  equals(object.get('isOff'), YES, 'object.isOff should be YES');
+  equals(object.get('isOn'), NO, 'object.isOn should be NO');
+});
 
 // ..........................................................
 // OBSERVABLE OBJECTS
@@ -281,152 +362,163 @@ module("Observable objects & object properties ", {
     object = SC.Object.create({
       
       normal: 'value',
-	  abnormal: 'zeroValue',
+      abnormal: 'zeroValue',
       numberVal: 24,
       toggleVal: true,
-      observedProperty:'beingWatched',
-	  testRemove:'observerToBeRemoved',	
-		
-	  automaticallyNotifiesObserversFor : function(key) { 
-	          	    return NO;		
-  	  },	
-	  
-	  getEach: function() {
-	    	var keys = ['normal','abnormal'];
-	    	var ret = [];
-	    	for(var idx=0; idx<keys.length;idx++) {
-	      		ret[ret.length] = this.getPath(keys[idx]);
-	    	}
-	    	return ret ;
-	  },
-	  
-	  newObserver:function(){
-			this.abnormal = 'changedValueObserved';
-	  },
-	
-	  testObserver:function(){
-			this.abnormal = 'removedObserver';
-	  }.observes('normal')
-	
-    });	
-	}	 
+      observedProperty: 'beingWatched',
+      testRemove: 'observerToBeRemoved',  
+      normalArray: [1,2,3,4,5],
+    
+      automaticallyNotifiesObserversFor : function(key) { 
+        return NO;    
+      },  
+    
+      getEach: function() {
+        var keys = ['normal','abnormal'];
+        var ret = [];
+        for(var idx=0; idx<keys.length;idx++) {
+          ret[ret.length] = this.getPath(keys[idx]);
+        }
+        return ret ;
+      },
+    
+      newObserver:function(){
+        this.abnormal = 'changedValueObserved';
+      },
+    
+      testObserver:function(){
+        this.abnormal = 'removedObserver';
+      }.observes('normal'),
+    
+      testArrayObserver:function(){
+        this.abnormal = 'notifiedObserver';
+      }.observes('*normalArray.[]')
+    
+    });
+  }   
   
 });
 
 test('incrementProperty and decrementProperty',function(){
-  	var newValue = object.incrementProperty('numberVal');
-    equals(25,newValue,'numerical value incremented');
-	object.numberVal = 24;
-	newValue = object.decrementProperty('numberVal');
-    equals(23,newValue,'numerical value decremented');
+  var newValue = object.incrementProperty('numberVal');
+  equals(25,newValue,'numerical value incremented');
+  object.numberVal = 24;
+  newValue = object.decrementProperty('numberVal');
+  equals(23,newValue,'numerical value decremented');
 });
 
 test('toggle function, should be boolean',function(){
-  	equals(object.toggleProperty('toggleVal',true,false),object.get('toggleVal')); 
-    equals(object.toggleProperty('toggleVal',true,false),object.get('toggleVal'));
-    equals(object.toggleProperty('toggleVal',undefined,undefined),object.get('toggleVal'));
+  equals(object.toggleProperty('toggleVal',true,false),object.get('toggleVal')); 
+  equals(object.toggleProperty('toggleVal',true,false),object.get('toggleVal'));
+  equals(object.toggleProperty('toggleVal',undefined,undefined),object.get('toggleVal'));
 });
 
 test('should not notify the observers of a property automatically',function(){
-	object.set('normal', 'doNotNotifyObserver'); 
-	equals(object.abnormal,'zeroValue')	;
-});
-
-
-module("object.addObserver()", {	
-	setup: function() {
-				
-		ObjectC = SC.Object.create({
-			
-			ObjectE:SC.Object.create({
-				propertyVal:"chainedProperty"
-			}),
-			
-			normal: 'value',
-			normal1: 'zeroValue',
-			normal2: 'dependentValue',
-			incrementor: 10,
-			
-			action: function() {
-				this.normal1= 'newZeroValue';
-			},
-						
-			observeOnceAction: function() {
-				this.incrementor= this.incrementor+1;
-			},
-							
-			chainedObserver:function(){
-				this.normal2 = 'chainedPropertyObserved' ;
-			}
-		});
-   	}
+  object.set('normal', 'doNotNotifyObserver'); 
+  equals(object.abnormal,'zeroValue')  ;
+});
+
+test('should notify array observer when array changes',function(){
+  object.normalArray.replace(0,0,6);
+  equals(object.abnormal, 'notifiedObserver', 'observer should be notified');
+});
+
+
+module("object.addObserver()", {  
+  setup: function() {
+        
+    ObjectC = SC.Object.create({
+      
+      ObjectE:SC.Object.create({
+        propertyVal:"chainedProperty"
+      }),
+      
+      normal: 'value',
+      normal1: 'zeroValue',
+      normal2: 'dependentValue',
+      incrementor: 10,
+      
+      action: function() {
+        this.normal1= 'newZeroValue';
+      },
+            
+      observeOnceAction: function() {
+        this.incrementor= this.incrementor+1;
+      },
+              
+      chainedObserver:function(){
+        this.normal2 = 'chainedPropertyObserved' ;
+      }
+      
+    });
+  }
 });
 
 test("should register an observer for a property", function() {
-	ObjectC.addObserver('normal', ObjectC, 'action');
-	ObjectC.set('normal','newValue');
-	equals(ObjectC.normal1, 'newZeroValue');
+  ObjectC.addObserver('normal', ObjectC, 'action');
+  ObjectC.set('normal','newValue');
+  equals(ObjectC.normal1, 'newZeroValue');
 });
 
 test("should register an observer for a property - Special case of chained property", function() {
-	 ObjectC.addObserver('ObjectE.propertyVal',ObjectC,'chainedObserver');
-	 ObjectC.ObjectE.set('propertyVal',"chainedPropertyValue");
-	 equals('chainedPropertyObserved',ObjectC.normal2);
-	 ObjectC.normal2 = 'dependentValue';
-	 ObjectC.set('ObjectE','');
-	 equals('chainedPropertyObserved',ObjectC.normal2);	
-});
-
-
-module("object.removeObserver()", {	
-	setup: function() {
-		ObjectD = SC.Object.create({
-			
-			ObjectF:SC.Object.create({
-					propertyVal:"chainedProperty"
-			}),
-			
-			normal: 'value',
-			normal1: 'zeroValue',
-			normal2: 'dependentValue',
-			ArrayKeys: ['normal','normal1'],
-							
-			addAction: function() {
-				this.normal1= 'newZeroValue';
-			},
-			
-			removeAction: function() {
-				this.normal2= 'newDependentValue';
-			},
-			removeChainedObserver:function(){
-				this.normal2 = 'chainedPropertyObserved' ;
-			}
-		});
-   	}
+  ObjectC.addObserver('ObjectE.propertyVal',ObjectC,'chainedObserver');
+  ObjectC.ObjectE.set('propertyVal',"chainedPropertyValue");
+  equals('chainedPropertyObserved',ObjectC.normal2);
+  ObjectC.normal2 = 'dependentValue';
+  ObjectC.set('ObjectE','');
+  equals('chainedPropertyObserved',ObjectC.normal2);  
+});
+
+
+module("object.removeObserver()", {  
+  setup: function() {
+    ObjectD = SC.Object.create({
+      
+      ObjectF:SC.Object.create({
+        propertyVal:"chainedProperty"
+      }),
+      
+      normal: 'value',
+      normal1: 'zeroValue',
+      normal2: 'dependentValue',
+      ArrayKeys: ['normal','normal1'],
+      
+      addAction: function() {
+        this.normal1 = 'newZeroValue';
+      },
+      removeAction: function() {
+        this.normal2 = 'newDependentValue';
+      },
+      removeChainedObserver:function(){
+        this.normal2 = 'chainedPropertyObserved' ;
+      }
+    });
+    
+  }
 });
 
 test("should unregister an observer for a property", function() {
-	ObjectD.addObserver('normal', ObjectD, 'addAction');
-	ObjectD.set('normal','newValue');
-	equals(ObjectD.normal1, 'newZeroValue');
-	
-	ObjectD.set('normal1','zeroValue');
-	
-	ObjectD.removeObserver('normal', ObjectD, 'addAction');
-	ObjectD.set('normal','newValue');
-	equals(ObjectD.normal1, 'zeroValue');	
+  ObjectD.addObserver('normal', ObjectD, 'addAction');
+  ObjectD.set('normal','newValue');
+  equals(ObjectD.normal1, 'newZeroValue');
+  
+  ObjectD.set('normal1','zeroValue');
+  
+  ObjectD.removeObserver('normal', ObjectD, 'addAction');
+  ObjectD.set('normal','newValue');
+  equals(ObjectD.normal1, 'zeroValue');  
 });
 
 
 test("should unregister an observer for a property - special case when key has a '.' in it.", function() {
-   	ObjectD.addObserver('ObjectF.propertyVal',ObjectD,'removeChainedObserver');
-	ObjectD.ObjectF.set('propertyVal',"chainedPropertyValue");
-	ObjectD.removeObserver('ObjectF.propertyVal',ObjectD,'removeChainedObserver');
-	ObjectD.normal2 = 'dependentValue';
-	ObjectD.ObjectF.set('propertyVal',"removedPropertyValue");
-	equals('dependentValue',ObjectD.normal2);
-	ObjectD.set('ObjectF','');
-	equals('dependentValue',ObjectD.normal2);	
+  ObjectD.addObserver('ObjectF.propertyVal',ObjectD,'removeChainedObserver');
+  ObjectD.ObjectF.set('propertyVal',"chainedPropertyValue");
+  ObjectD.removeObserver('ObjectF.propertyVal',ObjectD,'removeChainedObserver');
+  ObjectD.normal2 = 'dependentValue';
+  ObjectD.ObjectF.set('propertyVal',"removedPropertyValue");
+  equals('dependentValue',ObjectD.normal2);
+  ObjectD.set('ObjectF','');
+  equals('dependentValue',ObjectD.normal2);  
 });
 
 
@@ -439,16 +531,16 @@ module("Bind function ", {
       location: "Timbaktu"
     });
 
-   	objectB = SC.Object.create({
+    objectB = SC.Object.create({
       normal: "value",
- 	  computed:function(){
-		this.normal = 'newValue';
-	  }
+      computed:function() {
+        this.normal = 'newValue';
+      }
     }) ;
          
     Namespace = {
       objectA: objectA,
-	  objectB: objectB	
+      objectB: objectB  
     } ;
   }
 });
@@ -465,3 +557,31 @@ test("should bind property with method parameter as undefined", function() {
   SC.Binding.flushPendingChanges();
   equals("changedValue", objectA.get("name"), "objectA.name is binded");
 });
+
+// ..........................................................
+// SPECIAL CASES
+// 
+
+test("changing chained observer object to null should not raise exception", function() {
+
+  var obj = SC.Object.create({
+    foo: SC.Object.create({
+      bar: SC.Object.create({ bat: "BAT" })
+    })
+  });
+  
+  var callCount = 0;
+  obj.foo.addObserver('bar.bat', obj, function(target, key, value) { 
+    equals(target, null, 'new target value should be null');
+    equals(key, 'bat', 'key should be bat');
+    callCount++; 
+  });
+  
+  SC.run(function() {
+    obj.foo.set('bar', null);
+  });
+
+  //debugger ;
+  equals(callCount, 1, 'changing bar should trigger observer');
+  expect(3);
+});