sproutit-sproutcore 1.0.0.20090407205609 → 1.0.0.20090408130025

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

@@ -0,0 +1,467 @@
+// ========================================================================
+// SC.Observable Tests
+// ========================================================================
+/*globals module test ok isObj equals expects Namespace */
+
+var object, ObjectC, ObjectD, objectA, objectB ;
+
+// ..........................................................
+// GET()
+// 
+
+module("object.get()", {
+  
+  setup: function() {
+    object = SC.Object.create({
+      
+      normal: 'value',
+      numberVal: 24,
+      toggleVal: true,
+
+      computed: function() { return 'value'; }.property(),
+      
+      method: function() { return "value"; },
+      
+      nullProperty: null,
+      
+      unknownProperty: function(key, value) {
+        this.lastUnknownProperty = key ;
+        return "unknown" ;
+      }
+      
+    });
+  }
+  
+});
+
+test("should get normal properties", function() {
+  equals(object.get('normal'), 'value') ;
+});
+
+test("should call computed properties and return their result", function() {
+  equals(object.get("computed"), "value") ;
+});
+
+test("should return the function for a non-computed property", function() {
+  var value = object.get("method") ;
+  equals(SC.typeOf(value), SC.T_FUNCTION) ;
+});
+
+test("should return null when property value is null", function() {
+  equals(object.get("nullProperty"), null) ;
+});
+
+test("should call unknownProperty when value is undefined", function() {
+  equals(object.get("unknown"), "unknown") ;
+  equals(object.lastUnknownProperty, "unknown") ;
+});
+
+
+// ..........................................................
+// SET()
+// 
+
+module("object.set()", {
+  
+  setup: function() {
+    object = SC.Object.create({
+      
+      // normal property
+      normal: 'value',
+      
+      // computed property
+      _computed: "computed",
+      computed: function(key, value) {
+        if (value !== undefined) {
+          this._computed = value ;
+        }
+        return this._computed ;
+      }.property(),
+      
+      // method, but not a property
+      _method: "method",
+      method: function(key, value) {
+        if (value !== undefined) {
+          this._method = value ;
+        }
+        return this._method ;
+      },
+      
+      // null property
+      nullProperty: null,
+      
+      // unknown property
+      _unknown: 'unknown',
+      unknownProperty: function(key, value) {
+        if (value !== undefined) {
+          this._unknown = value ;
+        }
+        return this._unknown ;
+      }
+      
+    });
+  }
+
+});
+
+test("should change normal properties and return this", function() {
+  var ret = object.set("normal", "changed") ;
+  equals(object.normal, "changed") ;
+  equals(ret, object) ;
+});
+
+test("should call computed properties passing value and return this", function() {
+  var ret = object.set("computed", "changed") ;
+  equals(object._computed, "changed") ;
+  equals(SC.typeOf(object.computed), SC.T_FUNCTION) ;
+  equals(ret, object) ;
+});
+
+test("should replace the function for a non-computed property and return this", function() {
+  var ret = object.set("method", "changed") ;
+  equals(object._method, "method") ; // make sure this was NOT run
+  ok(SC.typeOf(object.method) !== SC.T_FUNCTION) ;
+  equals(ret, object) ;
+});
+
+test("should replace prover when property value is null", function() {
+  var ret = object.set("nullProperty", "changed") ;
+  equals(object.nullProperty, "changed") ;
+  equals(object._unknown, "unknown"); // verify unknownProperty not called.
+  equals(ret, object) ;
+});
+
+test("should call unknownProperty with value when property is undefined", function() {
+  var ret = object.set("unknown", "changed") ;
+  equals(object._unknown, "changed") ;
+  equals(ret, object) ;
+});
+
+// ..........................................................
+// COMPUTED PROPERTIES
+// 
+
+module("Computed properties", {
+  setup: function() {
+    object = SC.Object.create({
+      
+      // REGULAR
+      
+      computedCalls: [],
+      computed: function(key, value) {
+        this.computedCalls.push(value);
+        return 'computed';
+      }.property(),
+      
+      computedCachedCalls: [],
+      computedCached: function(key, value) {
+        this.computedCachedCalls.push(value);
+        return 'computedCached';
+      }.property().cacheable(),
+      
+      
+      // DEPENDENT KEYS
+      
+      changer: 'foo',
+      
+      dependentCalls: [],
+      dependent: function(key, value) {
+        this.dependentCalls.push(value);
+        return 'dependent';
+      }.property('changer'),
+      
+      dependentCachedCalls: [],
+      dependentCached: function(key, value) {
+        this.dependentCachedCalls.push(value);
+        return 'dependentCached';
+      }.property('changer').cacheable(),
+      
+      
+      // everytime it is recomputed, increments call
+      incCallCount: 0,
+      inc: function() {
+        return this.incCallCount++;
+      }.property('changer').cacheable()
+      
+    })    ;
+  }
+});
+
+test("getting values should call function return value", function() {
+  
+  // get each property twice. Verify return.
+  var keys = 'computed computedCached dependent dependentCached'.w();
+  
+  keys.forEach(function(key) {
+    equals(object.get(key), key, 'Try #1: object.get(%@) should run function'.fmt(key));
+    equals(object.get(key), key, 'Try #2: object.get(%@) should run function'.fmt(key));
+  });
+  
+  // verify each call count.  cached should only be called once
+  'computedCalls dependentCalls'.w().forEach(function(key) {
+    equals(object[key].length, 2, 'non-cached property %@ should be called 2x'.fmt(key));
+  });
+
+  'computedCachedCalls dependentCachedCalls'.w().forEach(function(key) {
+    equals(object[key].length, 1, 'non-cached property %@ should be called 1x'.fmt(key));
+  });
+  
+});
+
+test("setting values should call function return value", function() {
+  
+  // get each property twice. Verify return.
+  var keys = 'computed dependent computedCached dependentCached'.w();
+  var values = 'value1 value2'.w();
+  
+  keys.forEach(function(key) {
+    
+    equals(object.set(key, values[0]), object, 'Try #1: object.set(%@, %@) should run function'.fmt(key, values[0]));
+
+    equals(object.set(key, values[1]), object, 'Try #2: object.set(%@, %@) should run function'.fmt(key, values[1]));
+    equals(object.set(key, values[1]), object, 'Try #3: object.set(%@, %@) should not run function since it is setting same value as before'.fmt(key, values[1]));
+    
+  });
+  
+  
+  // verify each call count.  cached should only be called once
+  keys.forEach(function(key) {
+    var calls = object[key + 'Calls'], idx;
+    equals(calls.length, 2, 'set(%@) should be called 2x'.fmt(key));
+    for(idx=0;idx<2;idx++) {
+      equals(calls[idx], values[idx], 'call #%@ to set(%@) should have passed value %@'.fmt(idx+1, key, values[idx]));
+    }
+  });
+  
+});
+
+test("notify change should clear cache", function() {
+
+  // call get several times to collect call count
+  object.get('computedCached'); // should run func
+  object.get('computedCached'); // should not run func
+
+  object.propertyWillChange('computedCached')
+    .propertyDidChange('computedCached');
+    
+  object.get('computedCached'); // should run again
+  equals(object.computedCachedCalls.length, 2, 'should have invoked method 2x');
+});
+
+test("change 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.set('changer', 'bar');
+    
+  equals(object.get('inc'), ret1+1, 'should increment after dependent key changes'); // should run again
+});
+
+test("allPropertiesDidChange should clear cache", function() {
+  // note: test this with a computed method that returns a different value
+  // each time to ensure clean function.
+  var ret1 = object.get('inc');
+  equals(object.get('inc'), ret1, 'should not change after first call');
+  
+  // flush all props
+  object.allPropertiesDidChange();
+  equals(object.get('inc'), ret1+1, 'should increment after change');
+});
+
+
+// ..........................................................
+// OBSERVABLE OBJECTS
+// 
+
+module("Observable objects & object properties ", {
+  
+  setup: function() {
+    object = SC.Object.create({
+      
+      normal: 'value',
+	  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')
+	
+    });	
+	}	 
+  
+});
+
+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');
+});
+
+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'));
+});
+
+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' ;
+			}
+		});
+   	}
+});
+
+test("should register an observer for a property", function() {
+	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' ;
+			}
+		});
+   	}
+});
+
+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');	
+});
+
+
+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);	
+});
+
+
+
+module("Bind function ", {
+  
+  setup: function() {
+    objectA = SC.Object.create({
+      name: "Sproutcore",
+      location: "Timbaktu"
+    });
+
+   	objectB = SC.Object.create({
+      normal: "value",
+ 	  computed:function(){
+		this.normal = 'newValue';
+	  }
+    }) ;
+         
+    Namespace = {
+      objectA: objectA,
+	  objectB: objectB	
+    } ;
+  }
+});
+
+test("should bind property with method parameter as undefined", function() {
+  // creating binding
+  objectA.bind("name", "Namespace.objectB.normal",undefined) ;
+  SC.Binding.flushPendingChanges() ; // actually sets up up the binding
+  
+  // now make a change to see if the binding triggers.
+  objectB.set("normal", "changedValue") ;
+  
+  // support new-style bindings if available
+  SC.Binding.flushPendingChanges();
+  equals("changedValue", objectA.get("name"), "objectA.name is binded");
+});

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

@@ -0,0 +1,123 @@
+// ========================================================================
+// SC.Observable Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+module("object.propertyChanges", {  
+  setup: function() {
+    ObjectA = SC.Object.create({
+      foo  : 'fooValue',
+      prop : 'propValue',
+            
+      action: function() {
+        this.prop= 'changedPropValue';
+      }.observes('foo'),
+      
+      newFoo : 'newFooValue',
+      newProp: 'newPropValue',
+      
+      notifyAction: function() {
+        this.newProp = 'changedNewPropValue';
+      }.observes('newFoo'),
+      
+      notifyAllAction: function() {
+        this.newFoo = 'changedNewFooValue';
+      }.observes('prop'),
+
+      starProp: null,
+      starObserver: function(target, key) {
+        this.starProp = key;
+      }
+      
+    });
+    }
+});
+
+
+test("should observe the changes within the nested begin / end property changes", function() {
+    
+  //start the outer nest
+  ObjectA.beginPropertyChanges();
+    // Inner nest
+    ObjectA.beginPropertyChanges();
+        ObjectA.set('foo', 'changeFooValue');
+      equals(ObjectA.prop, "propValue") ;
+      ObjectA.endPropertyChanges();
+    
+    //end inner nest
+    ObjectA.set('prop', 'changePropValue');
+    equals(ObjectA.newFoo, "newFooValue") ;
+  //close the outer nest
+  ObjectA.endPropertyChanges();
+  
+  equals(ObjectA.prop, "changedPropValue") ;
+  equals(ObjectA.newFoo, "changedNewFooValue") ;
+  
+});
+
+test("should increment the indicator before begining the changes to the object", function() {
+    equals(ObjectA.beginPropertyChanges()._kvo_changeLevel, 1) ;
+});
+
+test("should increment the indicator before begining the changes to the object", function() {
+    equals(ObjectA.endPropertyChanges()._kvo_changeLevel, 0) ;
+});
+
+test("should observe the changes within the begin and end property changes", function() {
+    
+  ObjectA.beginPropertyChanges();
+    ObjectA.set('foo', 'changeFooValue');
+    
+  equals(ObjectA.prop, "propValue") ;
+    ObjectA.endPropertyChanges();
+    
+  equals(ObjectA.prop, "changedPropValue") ;
+});
+
+test("should indicate that the property of an object has just changed", function() {
+  // inidicate that proprty of foo will change to its subscribers
+  ObjectA.propertyWillChange('foo') ;
+  
+  //Value of the prop is unchanged yet as this will be changed when foo changes
+  equals(ObjectA.prop, 'propValue' ) ;
+  
+  //change the value of foo.
+  ObjectA.foo = 'changeFooValue';
+  
+  // Indicate the subscribers of foo that the value has just changed
+  ObjectA.propertyDidChange('foo', null) ;
+  
+  // Values of prop has just changed
+  equals(ObjectA.prop,'changedPropValue') ;
+});
+
+test("should notify that the property of an object has changed", function() {
+  // 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.
+  equals(ObjectA.newProp,'changedNewPropValue') ;
+});
+
+test("should notify all observers that their property might have changed", function() {
+  //When this function is called, all the subscribers are notified that something has
+  //Changed. So when allPropertiesDidChange() is called, all the subscribers get invoked. 
+  ObjectA.allPropertiesDidChange();
+  
+  //All the values changed.
+  equals(ObjectA.prop,'changedPropValue') ;
+  equals(ObjectA.newProp,'changedNewPropValue') ;
+  equals(ObjectA.newFoo,'changedNewFooValue') ;
+});
+
+test("star observers", function() {
+  // setup observer
+  ObjectA.addObserver('*', ObjectA, ObjectA.starObserver);
+  ObjectA.set('foo', 'bar');
+  equals(ObjectA.starProp, 'foo', 'should have fired star observer for foo');
+  
+  ObjectA.set('bar', 'foo');
+  equals(ObjectA.starProp, 'bar', 'should have fired star observer for bar');
+});

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

@@ -0,0 +1,79 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            portions copyright @2009 Apple, Inc.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+/*globals module test ok equals same */
+
+var object ;
+
+module("object.registerDependentKeys()", {  
+  setup: function() {
+    object = SC.Object.create({
+
+        // normal properties
+        firstName:  'John',
+        lastName:   'Doe',
+        observedValue: '',
+
+        // computed property
+        fullName: function() {
+          return this.getEach('firstName','lastName').compact().join(' ');
+        }.property(),
+
+        // init to setup registerDependentKey...
+        init: function() {
+          sc_super();
+          this.registerDependentKey('fullName', 'firstName', 'lastName');
+        },
+
+        //observer that should fire whenever the 'fullName' property changes
+        fullNameDidChange:  function() {
+          this.set('observedValue', this.get('fullName')) ;
+        }.observes('fullName')
+    });
+  }
+});
+
+
+test("should indicate the registered property changes if the dependent key value changes", function() {
+  // now, change the firstName...
+  object.set('firstName', 'Jane');
+
+  // since fullName is 'dependent' on firstName, then the observer for  
+  // 'fullName' should fire here because you changed a dependent key.
+  equals(object.get('observedValue'), 'Jane Doe');
+
+  // now change the lastName
+  object.set('lastName', 'Johnson');
+
+  // again, fullName is 'dependent' on lastName, so observer for  
+  // fullName should fire.
+  equals(object.get('observedValue'), 'Jane Johnson');
+});
+
+
+test("should indicate the registered property changes if the dependent key value changes and change is within begin property loop ", function() {
+  // Wrap the changes with begin property changes call
+  object.beginPropertyChanges();
+  
+  // now, change the firstName & lastname...
+  object.set('firstName', 'Jane');
+  object.set('lastName', 'Johnson');
+  
+  // The observer for fullName should not have fired yet at this  
+  // point because we are inside a propertyChange loop.
+  equals(object.get('observedValue'), '');
+  
+  //End the property changes loop.
+  object.endPropertyChanges();
+  
+  // now change the lastName
+  object.set('lastName', 'Johnson');
+
+  // again, fullName is 'dependent' on lastName, so observer for  
+  // fullName should fire.
+  equals(object.get('observedValue'), 'Jane Johnson');
+});