sproutit-sproutcore 1.0.0.20090407205609 → 1.0.0.20090408130025

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

@@ -0,0 +1,80 @@
+module("object.propertyChanges()", {	
+	setup: function() {
+		ObjectA = SC.Object.create({
+			normal: 'value',
+			normal1: 'zeroValue',
+						
+			action: function() {
+				this.normal1= 'newValue';
+			}.observes('normal'),
+			
+			normal2: 'dependentValue',
+			normal3: 'notifiedValue',
+			
+			notifyAction: function() {
+				this.normal3= 'newDependentValue';
+			}.observes('normal2'),
+			
+			notifyAllAction: function() {
+				this.normal2= 'newZeroValue';
+			}.observes('normal1')			
+		});
+  }
+});
+
+// CAJ: These tests are OK but the purpose of begin/end property changes is
+// to suspend notifications.  you should do something like:
+/*
+  obj.beginPropertyChanges()
+  obj.set('foo', 'bar');
+  -- verify that observer for 'foo' did not fire
+  obj.endPropertyChanges()
+  -- verify that observer for 'foo' did fire
+*/
+// also, we need some tests verifying that begin/end property changes can
+// be nested.  When they are nested, observers should not fire until you 
+// unnest them.  i.e.  
+/*
+  obj.beginPropertyChanges()
+    obj.beginPropertyChanges() // nested!
+      obj.set('foo', 'bar')
+    obj.endPropertyChanges(); // nested - do not fire.
+  obj.endProeprtyChanges()
+  -- observers fire here!
+*/
+//
+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) ;
+});
+
+// CAJ: This test works but its confusing.  the relationship between 'normal' 
+// and 'normal1' is really unclear.  Rename these properties
+// to something more descriptive and add comments to this test explaining 
+// what you expect to have happen.  You should always comment in the test 
+// anytime you expect something to happen in the background (such as expecting
+// an observer to fire.) 
+test("should indicate that the property of an object has just changed", function() {
+	equals(ObjectA.propertyWillChange('normal'),ObjectA) ;
+	ObjectA.normal = 'newValue';
+	equals(ObjectA.propertyDidChange('normal', null),ObjectA) ;
+	equals(ObjectA.normal1,'newValue') ;
+});
+
+// CAJ:  See my comment from above.  It's not clear how this test works.  
+// Consider using different property names and add a comment inline to 
+// explain that you expect an observer to fire.
+test("should notify that the property of an object has changed", function() {
+	ObjectA.notifyPropertyChange('normal2','value');
+	equals(ObjectA.normal3,'newDependentValue') ;
+});
+
+// CAJ:  Same comment here as the previous two tests.
+test("should notify all observers that their property might have changed", function() {
+	ObjectA.allPropertiesDidChange();
+	equals(ObjectA.normal2,'newZeroValue') ;
+});
+

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

@@ -0,0 +1,263 @@
+// ========================================================================
+// SC.Array Unit Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+var arrays, observer ; // global variables
+
+// 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) ;
+    this.enumerableContentDidChange() ;
+    this.endPropertyChanges() ;
+  },
+  
+  objectAt: function(idx) {
+    if (!this.content) this.content = [] ;
+    return this.content[idx] ;
+  }
+  
+});
+
+module("Array, DummyArray and SC.SparseArray", {
+
+  setup: function() {
+    arrays = [[], DummyArray.create(), SC.SparseArray.array()] ;
+    
+    // this will record observed changes.
+    observer = SC.Object.create({
+      
+      init: function() {
+        arguments.callee.base.apply(this, arguments) ; // sc_super() ;
+        
+        var that = this ;
+        this.observer = function(target, key, value) {
+          that.notified[key] = true ;
+          that.notifiedValue[key] = value ;
+        } ;
+      
+        this.resetObservers = function() {
+          this.notified = {} ;
+          this.notifiedValue = {} ;
+        } ;
+      
+        this.observe = function() {
+          var keys = SC.$A(arguments) ;
+          var loc = keys.length ;
+          while(--loc >= 0) {
+            this.a.addObserver(keys[loc], this, this.observer) ;
+          }
+        };
+      
+        this.didNotify = function(key) {
+          return !!this.notified[key] ;
+        } ;
+        
+        this.resetObservers() ;
+      }
+    });
+  }
+  
+});
+
+test("[].replace(0,0,'X') => ['X'] + notify", function() {
+  var ary2 = arrays ;
+  for (var idx2=0, len2=ary2.length; idx2<len2; idx2++) {
+    observer.a = ary2[idx2] ;
+    observer.observe('[]') ;
+    observer.a.replace(0,0,['X']) ;
+    
+    equals(observer.a.get('length'), 1, 'observer.a.length') ;
+    equals(observer.a.objectAt(0), 'X', 'observer.a.objectAt') ;
+    equals(observer.didNotify('[]'), YES, 'didNotify([])') ;
+  }
+});
+
+test("[A,B,C,D].replace(1,2,X) => [A,X,D] + notify", function() {
+  var ary2 = arrays ;
+  for (var idx2=0, len2=ary2.length; idx2<len2; idx2++) {
+    observer.a = ary2[idx2] ;
+    observer.a.replace(0,0, 'A B C D'.w()) ;
+    observer.observe('[]') ;
+    
+    observer.a.replace(1,2,['X']) ;
+    
+    equals(observer.a.get('length'), 3, 'a.length - %@'.fmt(SC.A(observer.a))) ;
+    equals(observer.a.objectAt(0), 'A', 'a.objectAt(0)') ;
+    equals(observer.a.objectAt(1), 'X', 'a.objectAt(1)') ;
+    equals(observer.a.objectAt(2), 'D', 'a.objectAt(2)') ;
+    equals(observer.didNotify("[]"), YES) ;
+  }
+});
+
+test("[A,B,C,D].replace(1,2,[X,Y]) => [A,X,Y,D] + notify", function() {
+  var ary2 = arrays ;
+  for (var idx2=0, len2=ary2.length; idx2<len2; idx2++) {
+    observer.a = ary2[idx2] ;
+    observer.a.replace(0,0, 'A B C D'.w()) ;
+    observer.observe('[]') ;
+    
+    observer.a.replace(1,2, 'X Y'.w()) ;
+    
+    equals(observer.a.get('length'), 4) ;
+    equals(observer.a.objectAt(0), 'A') ;
+    equals(observer.a.objectAt(1), 'X') ;
+    equals(observer.a.objectAt(2), 'Y') ;
+    equals(observer.a.objectAt(3), 'D') ;
+    equals(observer.didNotify("[]"), YES) ;
+  }
+});
+
+test("[A,B].replace(1,0,[X,Y]) => [A,X,Y,B] + notify", function() {
+  var ary2 = arrays ;
+  for (var idx2=0, len2=ary2.length; idx2<len2; idx2++) {
+    observer.a = ary2[idx2] ;
+    observer.a.replace(0,0, 'A B'.w()) ;
+    observer.observe('[]') ;
+    
+    observer.a.replace(1,0, 'X Y'.w()) ;
+    
+    equals(observer.a.get('length'), 4) ;
+    equals(observer.a.objectAt(0), 'A') ;
+    equals(observer.a.objectAt(1), 'X') ;
+    equals(observer.a.objectAt(2), 'Y') ;
+    equals(observer.a.objectAt(3), 'B') ;
+    equals(observer.didNotify("[]"), YES) ;
+  }
+});
+
+test("[A,B,C,D].replace(2,2) => [A,B] + notify", function() {
+  var ary2 = arrays ;
+  for (var idx2=0, len2=ary2.length; idx2<len2; idx2++) {
+    observer.a = ary2[idx2] ;
+    observer.a.replace(0,0, 'A B C D'.w()) ;
+    observer.observe('[]') ;
+    
+    observer.a.replace(2,2) ;
+    
+    equals(observer.a.get('length'), 2, 'a.length') ;
+    equals(observer.a.objectAt(0), 'A', 'a.objectAt(0)') ;
+    equals(observer.a.objectAt(1), 'B', 'a.objectAt(1)') ;
+    equals(observer.didNotify("[]"), YES) ;
+  }
+});
+
+test("[].insertAt(0,X) => [X] + notify", function() {
+  var ary2 = arrays ;
+  for (var idx2=0, len2=ary2.length; idx2<len2; idx2++) {
+    observer.a = ary2[idx2] ;
+    observer.observe('[]') ;
+    
+    observer.a.insertAt(0,['X']) ;
+    
+    equals(observer.a.get('length'), 1) ;
+    equals(observer.a.objectAt(0), 'X') ;
+    equals(observer.didNotify("[]"), YES) ;
+  }
+});
+
+test("[].removeObject(obj) should remove regardless of index position", function() {
+  var ary2 = arrays ;
+  for (var idx2=0, len2=ary2.length; idx2<len2; idx2++) {
+    observer.a = ary2[idx2] ;
+    // spec for bug in Rev:402 where removeObject was skipping index 0 when scanning the array
+    observer.a.set('[]', 'A B C'.w()) ;
+    equals(observer.a.get('length'), 3) ;
+    
+    observer.a.removeObject('C') ;
+    equals(observer.a.get('length'), 2) ;
+    observer.a.removeObject('B') ;
+    equals(observer.a.get('length'), 1) ;
+    observer.a.removeObject('A') ;
+    equals(observer.a.get('length'), 0) ;
+  }
+});
+
+test("[].objectAt(0) => undefined", function() {
+  var ary2 = arrays ;
+  for (var idx2=0, len2=ary2.length; idx2<len2; idx2++) {
+    observer.a = ary2[idx2] ;
+    equals(observer.a.get('length'), 0) ;
+    equals((observer.a.objectAt(0) === undefined), YES) ;
+  }
+});
+
+test("[A,B,C].objectAt(5) => undefined", function() {
+  var ary2 = arrays ;
+  for (var idx2=0, len2=ary2.length; idx2<len2; idx2++) {
+    observer.a = ary2[idx2] ;
+    equals(observer.a.get('length'), 0) ;
+    observer.a.set('[]', 'A B C'.w()) ;
+    equals(observer.a.get('length'), 3) ;
+    equals(observer.a.objectAt(0), 'A') ;
+    equals((observer.a.objectAt(5) === undefined), YES) ;
+  }
+});
+
+test("[A,B,C].set('[]',[X,Y]) => [X,Y] + notify", function() {
+  var ary2 = arrays ;
+  for (var idx2=0, len2=ary2.length; idx2<len2; idx2++) {
+    observer.a = ary2[idx2] ;
+    observer.a.replace(0,0, 'A B C'.w()) ;
+    observer.observe('[]') ;
+    
+    observer.a.set('[]', 'X Y'.w()) ;
+    
+    equals(observer.a.get('length'), 2) ;
+    equals(observer.a.objectAt(0), 'X') ;
+    equals(observer.a.objectAt(1), 'Y') ;
+    equals(observer.didNotify('[]'), YES) ;
+  }
+});
+
+test("[A,B,C] should be Enumerable", function() {
+  var ary2 = arrays, cnt, items;
+  
+  var iterator = function( item, idx ) {
+    items.push(item) ;
+    cnt++ ;
+  };
+  
+  for (var idx2=0, len2=ary2.length; idx2<len2; idx2++) {
+    observer.a = ary2[idx2] ;
+    observer.a.replace(0, 0, 'A B C'.w()) ;
+    
+    cnt = 0 ;
+    items = [] ;
+    observer.a.forEach(iterator) ;
+    equals(cnt, observer.a.get('length')) ;
+    equals('A', items[0]) ;
+    equals('B', items[1]) ;
+    equals('C',items[2]) ;
+  }
+});
+
+test("ary.isEqual() should return true when array contents match", function() {
+  var ary2 = arrays ;
+  for (var idx2=0, len2=ary2.length; idx2<len2; idx2++) {
+    observer.a = ary2[idx2] ;
+    observer.a.replace(0,0, 'A B C'.w()) ;
+    
+    var ary = 'A B C'.w() ; // test against a different object.
+    equals(observer.a.isEqual(ary), true) ;
+    
+    ary = 'A B'.w() ;
+    equals(observer.a.isEqual(ary), false) ;
+    
+    ary = 'X Y Z'.w() ;
+    equals(observer.a.isEqual(ary), false) ;
+    
+    equals(observer.a.isEqual(observer.a), true) ;
+  }
+});

data/frameworks/sproutcore/frameworks/runtime/tests/system/binding.js

@@ -0,0 +1,190 @@
+// ========================================================================
+// SC.Binding Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+var fromObject, toObject, binding ; // global variables
+
+module("basic object binding", {
+  
+  setup: function() {
+    fromObject = SC.Object.create({ value: 'start' }) ;
+    toObject = SC.Object.create({ value: 'end' }) ;
+    binding = SC.Binding.from("value", fromObject).to("value", toObject).connect() ;
+    SC.Binding.flushPendingChanges() ; // actually sets up up the connection
+  }
+});
+  
+test("binding is connected", function() {
+  equals(binding.isConnected, YES, "binding.isConnected") ;
+});
+
+test("binding has actually been setup", function() {
+  equals(binding._connectionPending, NO, "binding._connectionPending") ;
+});
+
+test("changing fromObject should mark binding as dirty", function() {
+  fromObject.set("value", "change") ;
+  equals(binding._changePending, YES) ;
+});
+
+test("fromObject change should propogate to toObject only after flush", function() {
+  fromObject.set("value", "change") ;
+  equals(toObject.get("value"), "end") ;
+  SC.Binding.flushPendingChanges() ;
+  equals(toObject.get("value"), "change") ;    
+});
+
+test("changing toObject should mark binding as dirty", function() {
+  toObject.set("value", "change") ;
+  equals(binding._changePending, YES) ;
+});
+
+test("toObject change should propogate to fromObject only after flush", function() {
+  toObject.set("value", "change") ;
+  equals(fromObject.get("value"), "start") ;
+  SC.Binding.flushPendingChanges() ;
+  equals(fromObject.get("value"), "change") ;    
+});
+
+module("one way binding", {
+  
+  setup: function() {
+    fromObject = SC.Object.create({ value: 'start' }) ;
+    toObject = SC.Object.create({ value: 'end' }) ;
+    binding = SC.Binding.from("value", fromObject).to("value", toObject).oneWay().connect() ;
+    SC.Binding.flushPendingChanges() ; // actually sets up up the connection
+  }
+  
+});
+  
+test("changing fromObject should mark binding as dirty", function() {
+  fromObject.set("value", "change") ;
+  equals(binding._changePending, YES) ;
+});
+
+test("fromObject change should propogate after flush", function() {
+  fromObject.set("value", "change") ;
+  equals(toObject.get("value"), "end") ;
+  SC.Binding.flushPendingChanges() ;
+  equals(toObject.get("value"), "change") ;    
+});
+
+test("changing toObject should not make binding dirty", function() {
+  toObject.set("value", "change") ;
+  equals(binding._changePending, NO) ;
+});
+
+test("toObject change should NOT propogate", function() {
+  toObject.set("value", "change") ;
+  equals(fromObject.get("value"), "start") ;
+  SC.Binding.flushPendingChanges() ;
+  equals(fromObject.get("value"), "start") ;    
+});
+
+var first, second, third, binding1, binding2 ; // global variables
+
+module("chained binding", {
+  
+  setup: function() {
+    first = SC.Object.create({ output: 'first' }) ;
+    
+    second = SC.Object.create({ 
+      input: 'second',
+      output: 'second',
+      
+      inputDidChange: function() {
+        this.set("output", this.get("input")) ;
+      }.observes("input")  
+    }) ;
+    
+    third = SC.Object.create({ input: "third" }) ;
+    
+    binding1 = SC.Binding.from("output", first).to("input", second).connect() ;
+    binding2 = SC.Binding.from("output", second).to("input", third).connect() ;
+    SC.Binding.flushPendingChanges() ; // actually sets up up the connection
+  }
+  
+});
+
+test("changing first output should propograte to third after flush", function() {
+  first.set("output", "change") ;
+  equals("change", first.get("output"), "first.output") ;
+  ok("change" !== third.get("input"), "third.input") ;
+  
+  SC.Binding.flushPendingChanges() ;
+  
+  // bindings should not have bending changes
+  equals(NO, binding1._changePending, "binding1._changePending === NO") ;
+  equals(NO, binding2._changePending, "binding2._changePending === NO") ;
+  
+  equals("change", first.get("output"), "first.output") ;
+  equals("change", second.get("input"), "second.input") ;
+  equals("change", second.get("output"), "second.output") ;
+  equals("change", third.get("input"), "third.input") ;
+});
+
+module("Custom Binding", {
+  
+  setup: function() {
+	Bon1 = SC.Object.extend({
+		value1: "hi",
+		value2: 83,
+		array1: []
+	});
+	
+	bon2 = SC.Object.create({
+		val1: "hello",
+		val2: 25,
+		arr: [1,2,3,4]
+	});
+	
+	TestNamespace = {
+      bon2: bon2,
+      Bon1: Bon1
+    } ;
+  },
+  
+  teardown: function() { 
+    delete Bon1 ;
+    delete bon2 ;
+	//delete TestNamespace;
+  }
+});
+
+test("Binding value1 such that it will recieve only single values", function() {
+	bon1 = Bon1.create({
+		value1Binding: SC.Binding.single("TestNamespace.bon2.val1"),
+		array1Binding: SC.Binding.single("TestNamespace.bon2.arr")
+	});
+	SC.Binding.flushPendingChanges();
+	var a = new Array (23,31,12,21);
+	bon2.set("arr", a);
+	bon2.set("val1","changed");
+	SC.Binding.flushPendingChanges();
+	equals(bon2.get("val1"),bon1.get("value1"));
+	equals("@@MULT@@",bon1.get("array1"));
+	bon1.destroy();
+});
+
+test("Single binding using notEmpty function.", function() {
+	bond = Bon1.create ({
+	  array1Binding: SC.Binding.single("TestNamespace.bon2.arr").notEmpty(null,'(EMPTY)')
+	});
+	SC.Binding.flushPendingChanges();
+	bon2.set("arr", []);
+	SC.Binding.flushPendingChanges();
+	equals("(EMPTY)",bond.get("array1"));
+});
+
+test("Binding with transforms, function to check the type of value", function() {
+	jon = Bon1.create({
+		value1Binding: SC.Binding.transform(function(val1) {
+			return (SC.typeOf(val1) == SC.T_STRING)? val1 : "";
+		}).from("TestNamespace.bon2.val1")
+	});
+	SC.Binding.flushPendingChanges();
+	bon2.set("val1","changed");
+	SC.Binding.flushPendingChanges();
+	equals(jon.get("value1"), bon2.get("val1"));
+});

data/frameworks/sproutcore/frameworks/runtime/tests/system/object/base.js

@@ -0,0 +1,135 @@
+// ========================================================================
+// SC.Object Base Tests
+// ========================================================================
+/*globals module test ok isObj equals expects same */
+
+var obj, obj1, don, don1 ; // global variables
+
+module("A new SC.Object instance", {
+  
+  setup: function() {
+    obj = SC.Object.create({
+      foo: "bar",
+      total: 12345,
+      aMethodThatExists: function() {},
+      aMethodThatReturnsTrue: function() { return true; },
+      aMethodThatReturnsFoobar: function() { return "Foobar"; },
+      aMethodThatReturnsFalse: function() { return NO; }
+    });
+  },
+  
+  teardown: function() {
+    obj = undefined ;
+  }
+  
+});
+
+test("Should identify it's methods using the 'respondsTo' method", function() {
+  equals(obj.respondsTo('aMethodThatExists'), true) ;
+  equals(obj.respondsTo('aMethodThatDoesNotExist'), false) ;
+});
+
+test("Should return false when asked to perform a method it does not have", function() {
+  equals(obj.tryToPerform('aMethodThatDoesNotExist'), false) ;
+});
+
+test("Should pass back the return YES if method returned YES, NO if method not implemented or returned NO", function() {
+  equals(obj.tryToPerform('aMethodThatReturnsTrue'), YES, 'method that returns YES') ;
+  equals(obj.tryToPerform('aMethodThatReturnsFoobar'), YES, 'method that returns non-NO') ;
+  equals(obj.tryToPerform('aMethodThatReturnsFalse'), NO, 'method that returns NO') ;
+  equals(obj.tryToPerform('imaginaryMethod'), NO, 'method that is not implemented') ;
+});
+
+test("Should return it's properties when requested using SC.Object#get", function() {
+  equals(obj.get('foo'), 'bar') ;
+  equals(obj.get('total'), 12345) ;
+});
+
+test("Should allow changing of those properties by calling SC.Object#set", function() {
+  equals(obj.get('foo'), 'bar') ;
+  equals(obj.get('total'), 12345) ;
+  
+  obj.set( 'foo', 'Chunky Bacon' ) ;
+  obj.set( 'total', 12 ) ;
+  
+  equals(obj.get('foo'), 'Chunky Bacon') ;
+  equals(obj.get('total'), 12) ;
+});
+
+test("Should only advertise changes once per request to SC.Object#didChangeFor", function() {
+  obj.set( 'foo', 'Chunky Bacon' );
+  equals(obj.didChangeFor( this, 'foo' ), true) ;
+  equals(obj.didChangeFor( this, 'foo' ), false) ;
+});
+
+test("Should advertise changes once per request to SC.Object#didChangeFor when setting property to NULL", function() {
+  obj.set( 'foo', null );
+  equals(obj.didChangeFor( this, 'foo' ), true) ;
+  equals(obj.didChangeFor( this, 'foo' ), false) ;
+});
+
+test("When the object is destroyed the 'isDestroyed' status should change accordingly", function() {
+	equals(obj.get('isDestroyed'), NO);
+	obj.destroy();
+	equals(obj.get('isDestroyed'), YES);
+});
+
+
+module("SC.Object instance extended", {  
+  setup: function() {
+    obj = SC.Object.extend();
+	obj1 = obj.create();
+	don = SC.Object.extend();
+	don1 = don.create();
+  },
+  
+  teardown: function() {
+    obj = undefined ;
+    obj1 = undefined ;
+    don = undefined ;
+    don1 = undefined ;
+  }
+  
+});
+
+test("Checking the instance of method for an object", function() {
+	equals(obj1.instanceOf(obj), YES);
+	equals(obj1.instanceOf(don), NO);
+});
+
+test("Checking the kind of method for an object", function() {
+	equals(obj1.kindOf(obj), YES);
+	equals(obj1.kindOf(don), NO);
+});
+
+
+module("SC.Object superclass", {  
+  setup: function() {
+    obj = SC.Object.extend ({
+	  method1: function() {
+		return "hello";
+	  }
+	});
+	obj1 = obj.extend();
+	don = obj1.create ({
+	  method2: function() {
+		  return this.superclass();
+		}
+	});
+  },
+
+  teardown: function() {
+	obj = undefined ;
+    obj1 = undefined ;
+    don = undefined ;
+  }
+});
+
+test("Checking the superclass method for an existing function", function() {
+	equals(don.method2().method1(), "hello");
+});
+
+test("Checking the subclassOf function on an object and its subclass", function(){
+	equals(obj1.subclassOf(obj), YES);
+	equals(obj.subclassOf(obj1), NO);
+});