sproutcore 1.4.0-java

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

@@ -0,0 +1,155 @@
+// ========================================================================
+// SC.Observable Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+var revMatches = NO , ObjectA;
+
+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, value, rev) {
+        revMatches = (rev === target.propertyRevision) ;
+        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');
+});
+
+test("revision passed to observers should match .propertyRevision", function() {
+    
+  equals(revMatches, true) ;
+  
+});
+
+test("should invalidate function property cache when notifyPropertyChange is called", function() {
+  
+  var a = SC.Object.create({
+    _b: null,
+    b: function(key, value) {
+      if (value !== undefined) {
+        this._b = value;
+        return this;
+      }
+      return this._b;
+    }.property()
+  });
+  
+  a.set('b', 'foo');
+  equals(a.get('b'), 'foo', 'should have set the correct value for property b');
+  
+  a._b = 'bar';
+  a.notifyPropertyChange('b');
+  a.set('b', 'foo');
+  equals(a.get('b'), 'foo', 'should have invalidated the cache so that the newly set value is actually set');
+  
+});

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

@@ -0,0 +1,79 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2010 Sprout Systems, Inc. and contributors.
+//            portions copyright @2009 Apple Inc.
+// License:   Licensed 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');
+});

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

@@ -0,0 +1,81 @@
+var ObjectA;
+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/lib/frameworks/sproutcore/frameworks/runtime/tests/private/observer_queue/isObservingSuspended.js

@@ -0,0 +1,55 @@
+// ==========================================================================
+// Project:   SproutCore Costello - Property Observing Library
+// Copyright: ©2006-2010 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2010 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+var callCount, obj;
+
+module("SC.Observers.isObservingSuspended", {
+  setup: function() {
+    callCount = 0;
+    
+    obj = SC.Object.create({ 
+      foo: "bar",
+
+      fooDidChange: function() { 
+        callCount++; 
+      }.observes('foo')
+    });
+  }
+});
+
+test("suspending observers stops notification", function() {
+  SC.Observers.suspendPropertyObserving();
+  SC.Observers.suspendPropertyObserving();
+  obj.set("foo");
+  equals(callCount, 0, 'should not notify observer while suspended');
+
+  SC.Observers.resumePropertyObserving();
+  equals(callCount, 0, 'should not notify observer while still suspended');
+  
+  SC.Observers.resumePropertyObserving();
+  equals(callCount, 1, 'should notify observer when resumed');
+  
+});
+
+// ..........................................................
+// SPECIAL CASES
+// 
+
+// this test verifies a specific bug in the SC.Observing.propertyDidChange method.
+test("suspended notifications should work when nesting property change groups", function() {
+  
+  SC.Observers.suspendPropertyObserving();
+  obj.beginPropertyChanges();
+  obj.set("foo");
+  equals(callCount, 0, 'should not notify observer while suspended');
+
+  obj.endPropertyChanges();
+  equals(callCount, 0, 'should not notify observer while suspended');
+
+  SC.Observers.resumePropertyObserving();
+  equals(callCount, 1, 'should notify observer when resumed');
+});

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

@@ -0,0 +1,395 @@
+// ========================================================================
+// SC.Binding Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+var fromObject, toObject, binding, Bon1, bon2 ; // 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("binding should have synced on connect", function() {
+  equals(toObject.get("value"), "start", "toObject.value should match fromObject.value");
+});
+
+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"), "start") ;
+  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") ;    
+});
+
+test("suspended observing during bindings", function() {
+
+  // setup special binding
+  fromObject = SC.Object.create({
+    value1: 'value1',
+    value2: 'value2'
+  });
+  
+  toObject = SC.Object.create({
+    value1: 'value1',
+    value2: 'value2',
+    
+    callCount: 0,
+    
+    observer: function() {
+      equals(this.get('value1'), 'CHANGED', 'value1 when observer fires');
+      equals(this.get('value2'), 'CHANGED', 'value2 when observer fires');
+      this.callCount++;
+    }.observes('value1', 'value2')
+  });
+  
+  toObject.bind('value1', fromObject, 'value1');
+  toObject.bind('value2', fromObject, 'value2');
+
+  // change both value1 + value2, then  flush bindings.  observer should only
+  // fire after bindings are done flushing.
+  fromObject.set('value1', 'CHANGED').set('value2', 'CHANGED');
+  SC.Binding.flushPendingChanges();
+  
+  equals(toObject.callCount, 2, 'should call observer twice');
+});
+
+test("binding will disconnect", function() {
+  binding.disconnect();
+  equals(binding.isConnected, NO, "binding.isConnected");
+});
+
+test("binding disconnection actually works", function() {
+  binding.disconnect();
+  fromObject.set('value', 'change');
+  SC.Binding.flushPendingChanges();
+  equals(toObject.get('value'), 'start');
+});
+
+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"), "start") ;
+  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") ;
+  
+  var didChange = YES;
+  while(didChange) didChange = SC.Binding.flushPendingChanges() ;
+  
+  // bindings should not have bending changes
+  equals(binding1._changePending, NO, "binding1._changePending") ;
+  equals(binding2._changePending, NO, "binding2._changePending") ;
+  
+  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() {
+	var bon1 = Bon1.create({
+		value1Binding: SC.Binding.single("TestNamespace.bon2.val1"),
+		array1Binding: SC.Binding.single("TestNamespace.bon2.arr")
+	});
+	SC.Binding.flushPendingChanges();
+	var a = [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() {
+	var 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() {
+	var 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"));
+});
+
+test("two bindings to the same value should sync in the order they are initialized", function() {
+
+  SC.LOG_BINDINGS = YES;
+
+  SC.RunLoop.begin();
+
+  window.a = SC.Object.create({ 
+    foo: "bar" 
+  });
+  
+  var a = window.a;
+  
+  window.b = SC.Object.create({ 
+    foo: "baz",
+    fooBinding: "a.foo",
+    
+    C: SC.Object.extend({
+      foo: "bee",
+      fooBinding: "*owner.foo"
+    }),
+    
+    init: function() {
+      sc_super();
+      this.set('c', this.C.create({ owner: this }));
+    }
+    
+  });
+  
+  var b = window.b;
+
+  SC.LOG_BINDINGS = YES;
+    
+  SC.RunLoop.end();
+  
+  equals(a.get('foo'), "bar", 'a.foo should not change');
+  equals(b.get('foo'), "bar", 'a.foo should propogate up to b.foo');
+  equals(b.c.get('foo'), "bar", 'a.foo should propogate up to b.c.foo');
+  
+  window.a = window.b = null ;
+  
+});
+
+module("AND binding", {
+
+  setup: function() {
+    // temporarily set up two source objects in the SC namespace so we can
+    // use property paths to access them
+    SC.testControllerA = SC.Object.create({ value: NO });
+    SC.testControllerB = SC.Object.create({ value: NO });
+
+    toObject = SC.Object.create({
+      value: null,
+      valueBinding: SC.Binding.and('SC.testControllerA.value', 'SC.testControllerB.value')
+    });
+  },
+
+  teardown: function() {
+    delete SC.testControllerA;
+    delete SC.testControllerB;
+  }
+  
+});
+
+test("toObject.value should be YES if both sources are YES", function() {
+  SC.RunLoop.begin();
+  SC.testControllerA.set('value', YES);
+  SC.testControllerB.set('value', YES);
+  SC.RunLoop.end();
+
+  SC.Binding.flushPendingChanges();
+  equals(toObject.get('value'), YES);
+});
+
+test("toObject.value should be NO if either source is NO", function() {
+  SC.RunLoop.begin();
+  SC.testControllerA.set('value', YES);
+  SC.testControllerB.set('value', NO);
+  SC.RunLoop.end();
+
+  SC.Binding.flushPendingChanges();
+  equals(toObject.get('value'), NO);
+
+  SC.RunLoop.begin();
+  SC.testControllerA.set('value', YES);
+  SC.testControllerB.set('value', YES);
+  SC.RunLoop.end();
+
+  SC.Binding.flushPendingChanges();
+  equals(toObject.get('value'), YES);
+
+  SC.RunLoop.begin();
+  SC.testControllerA.set('value', NO);
+  SC.testControllerB.set('value', YES);
+  SC.RunLoop.end();
+
+  SC.Binding.flushPendingChanges();
+  equals(toObject.get('value'), NO);
+});
+
+module("OR binding", {
+
+  setup: function() {
+    // temporarily set up two source objects in the SC namespace so we can
+    // use property paths to access them
+    SC.testControllerA = SC.Object.create({ value: NO });
+    SC.testControllerB = SC.Object.create({ value: null });
+
+    toObject = SC.Object.create({
+      value: null,
+      valueBinding: SC.Binding.or('SC.testControllerA.value', 'SC.testControllerB.value')
+    });
+  },
+
+  teardown: function() {
+    delete SC.testControllerA;
+    delete SC.testControllerB;
+  }
+  
+});
+
+test("toObject.value should be first value if first value is truthy", function() {
+  SC.RunLoop.begin();
+  SC.testControllerA.set('value', 'first value');
+  SC.testControllerB.set('value', 'second value');
+  SC.RunLoop.end();
+
+  SC.Binding.flushPendingChanges();
+  equals(toObject.get('value'), 'first value');
+});
+
+test("toObject.value should be second value if first is falsy", function() {
+  SC.RunLoop.begin();
+  SC.testControllerA.set('value', NO);
+  SC.testControllerB.set('value', 'second value');
+  SC.RunLoop.end();
+
+  SC.Binding.flushPendingChanges();
+  equals(toObject.get('value'), 'second value');
+});
+
+module("Binding with '[]'", {
+  setup: function() {
+    fromObject = SC.Object.create({ value: [] });
+    toObject = SC.Object.create({ value: '' });
+    binding = SC.Binding.transform(function(v) {
+      return v ? v.join(',') : '';
+    }).from("value.[]", fromObject).to("value", toObject).connect();
+  }
+});
+
+test("Binding refreshes after a couple of items have been pushed in the array", function() {
+  fromObject.get('value').pushObjects(['foo', 'bar']);
+  SC.Binding.flushPendingChanges();
+  equals(toObject.get('value'), 'foo,bar');
+});