sproutcore 0.9.0

data/frameworks/sproutcore/tests/controllers/controller.rhtml

@@ -0,0 +1,273 @@
+<% # ========================================================================
+   # SC.Controller Unit Test
+   # ========================================================================
+%>
+<% content_for('final') do %>
+
+<script>
+
+ControllerSetup = function() {
+  
+  // stub in required method implementations.
+  this.klass = SC.Controller.extend({
+    
+    // used to configure different tests.
+    isCommitEnabled: YES,  isDiscardEnabled: YES,
+    isCommitSuccessful: YES, isDiscardSuccessful: YES,
+
+    changesCommitted: NO,  changesDiscarded: NO,
+    
+    commitChangesImmediately: NO,
+    
+    canCommitChanges: function() { return this.get('isCommitEnabled') ; },
+    performCommitChanges: function() { 
+      return this.changesCommitted = this.get('isCommitSuccessful') ; 
+    },
+
+    canDiscardChanges: function() { return this.get('isDiscardEnabled') ; },
+    performDiscardChanges: function() { 
+      return this.changesDiscarded = this.get('isDiscardSuccessful') ; 
+    }
+    
+  }) ;
+
+  // create dummy
+  this.c = this.klass.create() ;
+
+ } ;
+
+Test.context("Single SC.Controller", {
+  
+  "hasChanges should be true after change": function() {
+      this.c.get('hasChanges').shouldEqual(NO) ;
+      this.c.editorDidChange() ;
+      this.c.get('hasChanges').shouldEqual(YES) ;
+  },
+  
+  "hasChanges should be false after commit": function() {
+      this.c.editorDidChange() ;
+      this.c.get('hasChanges').shouldEqual(YES) ;
+      this.c.commitChanges() ;
+      this.c.get('hasChanges').shouldEqual(NO) ;
+  },
+  
+  "hasChanges should be false after discard": function() {
+      this.c.editorDidChange() ;
+      this.c.get('hasChanges').shouldEqual(YES) ;
+      this.c.discardChanges() ;
+      this.c.get('hasChanges').shouldEqual(NO) ;
+  },
+  
+  "hasChanges should be true if commit fails": function() {
+    this.c.editorDidChange() ;
+    
+    // disable canCommit
+    this.c.isCommitEnabled = NO ;
+    this.c.commitChanges().shouldNotEqual(YES) ;
+    this.c.get('hasChanges').shouldEqual(YES) ;
+    
+    // disable performCommit
+    this.c.isCommitEnabled = YES ;  this.c.isCommitSuccessful = NO ;
+    this.c.commitChanges().shouldNotEqual(YES) ;
+    this.c.get('hasChanges').shouldEqual(YES) ;
+  },
+  
+  "hasChanges should be true if discard fails": function() {
+    this.c.editorDidChange() ;
+    
+    // disable canCommit
+    this.c.isDiscardEnabled = NO ;
+    this.c.discardChanges().shouldNotEqual(YES) ;
+    this.c.get('hasChanges').shouldEqual(YES) ;
+    
+    // disable performCommit
+    this.c.isDiscardEnabled = YES ;  this.c.isDiscardSuccessful = NO ;
+    this.c.discardChanges().shouldNotEqual(YES) ;
+    this.c.get('hasChanges').shouldEqual(YES) ;
+  },
+  
+  "commit should fail if there are no changes to commit": function() {
+    this.c.get('hasChanges').shouldEqual(NO) ;
+    $ok(this.c.commitChanges()).shouldEqual(NO) ;
+  },
+
+  "discard should fail if there are no changes to commit": function() {
+    this.c.get('hasChanges').shouldEqual(NO) ;
+    $ok(this.c.discardChanges()).shouldEqual(NO) ;
+  },
+  
+  "changes should commit immediately if enabled": function() {
+    this.c.set('commitChangesImmediately', YES) ;
+    this.c.editorDidChange() ;
+    this.c._commitTimeout.shouldNotBeNull() ;
+  },
+
+  "changes should NOT commit immediately UNLESS enabled": function() {
+    this.c.set('commitChangesImmediately', NO) ;
+    this.c.editorDidChange() ;
+    (this.c._commitTimeout == null).shouldEqual(YES) ;
+  },
+  
+  setup: function() {
+    ControllerSetup.call(this) ;
+  }
+  
+}) ;
+
+Test.context("Chained SC.Controllers", {
+  
+  "root.hasChanges should be true after child.change": function() {
+      this.root.get('hasChanges').shouldEqual(NO) ;
+      this.child.editorDidChange() ;
+      this.root.get('hasChanges').shouldEqual(YES) ;
+  },
+  
+  "child.hasChanges should be FALSE after root.commit": function() {
+      this.child.editorDidChange() ;
+      this.child.get('hasChanges').shouldEqual(YES) ;
+      this.root.commitChanges() ;
+      this.child.get('hasChanges').shouldEqual(NO) ;
+  },
+
+  "child.hasChanges should be FALSE after root.discard": function() {
+      this.child.editorDidChange() ;
+      this.child.get('hasChanges').shouldEqual(YES) ;
+      this.root.discardChanges() ;
+      this.child.get('hasChanges').shouldEqual(NO) ;
+  },
+
+  "root.hasChanges should be FALSE after child.commit if root DOES NOT have other changes": function() {
+      // edit child only
+      this.child.editorDidChange() ;
+      this.root.get('hasChanges').shouldEqual(YES) ;
+
+      this.child.commitChanges() ;
+      this.root.get('hasChanges').shouldEqual(NO) ;
+  },  
+
+  "root.hasChanges should be TRUE after child.commit if root DOES have other changes": function() {
+      // edit child and root
+      this.child.editorDidChange() ;
+      this.root.editorDidChange() ;
+      
+      this.root.get('hasChanges').shouldEqual(YES) ;
+      this.child.commitChanges() ;
+      this.root.get('hasChanges').shouldEqual(YES) ;
+  },  
+
+  "root.hasChanges should be FALSE after child.discard if root DOES NOT have other changes": function() {
+      // edit child only
+      this.child.editorDidChange() ;
+      
+      this.root.get('hasChanges').shouldEqual(YES) ;
+      this.child.discardChanges() ;
+      this.root.get('hasChanges').shouldEqual(NO) ;
+  },
+  
+  "root.hasChanges should be TRUE after child.discard if root DOES have other changes": function() {
+      // edit child and root
+      this.child.editorDidChange() ;
+      this.root.editorDidChange() ;
+      
+      this.root.get('hasChanges').shouldEqual(YES) ;
+      this.child.discardChanges() ;
+      this.root.get('hasChanges').shouldEqual(YES) ;
+  },
+
+
+  "child.hasChanges should be TRUE if another child cannot commit": function() {
+    // edit child and child2
+    this.child.editorDidChange() ;
+    this.child2.editorDidChange() ;
+    
+    // disable canCommit in child2
+    this.child2.isCommitEnabled = NO ;
+    
+    // now try to commit.  child not be committed.
+    $ok(this.root.commitChanges()).shouldEqual(NO) ;
+    
+    // verify child.
+    this.child.changesCommitted.shouldEqual(NO) ;
+    this.child.get('hasChanges').shouldEqual(YES) ;
+    this.root.get('hasChanges').shouldEqual(YES) ;
+  },
+
+  "child.hasChanges should be TRUE if another child cannot discard": function() {
+    // edit child and child2
+    this.child.editorDidChange() ;
+    this.child2.editorDidChange() ;
+    
+    // disable canCommit in child2
+    this.child2.isDiscardEnabled = NO ;
+    
+    // now try to commit.  child not be committed.
+    $ok(this.root.discardChanges()).shouldEqual(NO) ;
+    
+    // verify child.
+    this.child.changesDiscarded.shouldEqual(NO) ;
+    this.child.get('hasChanges').shouldEqual(YES) ;
+    this.root.get('hasChanges').shouldEqual(YES) ;
+  },
+
+  "root.hasChanges should be TRUE if any child fails to commit": function() {
+    // NOTE: Commits are not atomic.  IN this case, child2 fails while child1 succeeds.
+    // the hasChanges state of child2 and root must both be TRUE in this case, but 
+    // child1's state is undefined.  It may have commited or it may not.
+
+    this.child.editorDidChange() ;
+    this.child2.editorDidChange() ;
+    this.child2.isCommitSuccessful = NO ;
+    
+    $ok(this.root.commitChanges()).shouldEqual(NO) ;
+    this.root.get('hasChanges').shouldEqual(YES) ;
+    this.child2.get('hasChanges').shouldEqual(YES) ;
+  },
+
+  "root.hasChanges should be TRUE if any child fails to discard": function() {
+    // NOTE: Commits are not atomic.  IN this case, child2 fails while child1 succeeds.
+    // the hasChanges state of child2 and root must both be TRUE in this case, but 
+    // child1's state is undefined.  It may have commited or it may not.
+
+    this.child.editorDidChange() ;
+    this.child2.editorDidChange() ;
+    this.child2.isDiscardSuccessful = NO ;
+    
+    $ok(this.root.discardChanges()).shouldEqual(NO) ;
+    this.root.get('hasChanges').shouldEqual(YES) ;
+    this.child2.get('hasChanges').shouldEqual(YES) ;
+  },
+
+  "child.commitChangesImmediately should be inherited from the root": function()
+  {
+    var Klass = SC.Controller.extend({ commitChangesImmediately: NO });
+    
+    // child created with context passed...
+    var root  = Klass.create({ commitChangesImmediately: YES });
+    var child = Klass.create({ context: root });
+    root.get('commitChangesImmediately').shouldEqual(YES);
+    child.get('commitChangesImmediately').shouldEqual(YES);
+    
+    // context set after creation...
+    var root  = Klass.create({ commitChangesImmediately: YES });
+    var child = Klass.create();
+    root.get('commitChangesImmediately').shouldEqual(YES);
+    child.get('commitChangesImmediately').shouldEqual(NO);
+    child.set('context', root);
+    child.get('commitChangesImmediately').shouldEqual(YES);
+  },
+
+
+  // this.root is the root controller, 
+  // this.child belongs to the root parent.
+  // this.child2 belongs to the root parent also.  This is used only for a few tests.
+  setup: function() {
+    ControllerSetup.call(this) ;
+    this.root = this.c;
+    this.child = this.klass.create({ context: this.root }) ;
+    this.child2 = this.klass.create({ context: this.root }) ;
+  }
+  
+}) ;
+</script>
+
+<% end %>

data/frameworks/sproutcore/tests/controllers/object.rhtml

@@ -0,0 +1,327 @@
+<% # ========================================================================
+   # SC.ObjectController Unit Test
+   # ========================================================================
+%>
+<% content_for('final') do %>
+
+<script>
+
+// An ObjectController will make a content object or an array of content objects 
+Test.context("SC.ObjectController", {
+    
+    "hasNoContent should be true when content != null and false otherwise": function() {
+      this.c.set('content', null) ;
+      this.c.get('hasNoContent').shouldEqual(YES) ;
+      
+      this.c.set('content', this.single) ;
+      this.c.get('hasNoContent').shouldEqual(NO) ;  
+    },
+    
+    "hasSingleContent should be true only when content is a single object": function() {
+      this.c.set('content', null) ;
+      this.c.get('hasSingleContent').shouldEqual(NO) ;
+      
+      this.c.set('content', this.single) ;
+      this.c.get('hasSingleContent').shouldEqual(YES) ;
+      
+      this.c.set('content', this.single_a) ;
+      this.c.get('hasSingleContent').shouldEqual(YES) ;
+      
+      this.c.set('content', this.multiple) ;
+      this.c.get('hasSingleContent').shouldEqual(NO) ;
+    },
+    
+    "hasMultipleContent should be true when content = array with multiple items": function() {
+      this.c.set('content', null) ;
+      this.c.get('hasMultipleContent').shouldEqual(NO) ;
+      
+      this.c.set('content', this.single) ;
+      this.c.get('hasMultipleContent').shouldEqual(NO) ;
+      
+      this.c.set('content', this.single_a) ;
+      this.c.get('hasMultipleContent').shouldEqual(NO) ;
+
+      this.c.set('content', this.multiple) ;
+      this.c.get('hasMultipleContent').shouldEqual(YES) ;
+    },
+    
+    "GET EMPTY: properties should return null": function() {  
+      this.c.set('content', null) ;
+      (this.c.get('test') == null).shouldEqual(YES) ;
+      (this.c.get('value') == null).shouldEqual(YES) ;
+      (this.c.get('flag') == null).shouldEqual(YES) ;
+      (this.c.get('array') == null).shouldEqual(YES) ;
+    },
+
+    "GET EMPTY ARRAY: properties should return null": function() {  
+      this.c.set('content', this.empty_a) ;
+      (this.c.get('test') == null).shouldEqual(YES) ;
+      (this.c.get('value') == null).shouldEqual(YES) ;
+      (this.c.get('flag') == null).shouldEqual(YES) ;
+      (this.c.get('array') == null).shouldEqual(YES) ;
+    },
+    
+    "GET SINGLE: should return properties of content": function() {
+      this.c.set('content', this.single) ;
+
+      this.c.get('test').shouldEqual('NAME0') ;
+      this.c.get('value').shouldEqual(0) ;
+      this.c.get('flag').shouldEqual(YES) ;
+      this.c.get('array').shouldEqualEnum([0,0,0]) ;
+    },
+
+    "GET SINGLE ARRAY: should return properties of first content object": function() {
+      this.c.set('content', this.single_a) ;
+
+      this.c.get('test').shouldEqual('NAME0') ;
+      this.c.get('value').shouldEqual(0) ;
+      this.c.get('flag').shouldEqual(YES) ;
+      this.c.get('array').shouldEqualEnum([0,0,0]) ;
+    },
+    
+    "GET MULTIPLE: should return arrays with values from each content object": function() {
+      this.c.set('content', this.multiple) ;
+      
+      this.c.get('test').shouldEqualEnum(['NAME0', 'NAME1']) ;
+      this.c.get('value').shouldEqualEnum([0,1]) ;
+      this.c.get('flag').shouldEqualEnum([YES, NO]) ;
+      
+      // get('array').shouldEqual: [ [0,0,0], [1,1,1] ];
+      var ar = this.c.get('array') ;
+      ar.length.shouldEqual(2) ;
+      ar[0].shouldEqualEnum([0,0,0]) ;
+      ar[1].shouldEqualEnum([1,1,1]) ;
+    },
+
+    "GET CONTROLLER FOR VALUE: should return a controller for the requested value if one exists": function()
+    {
+      this.c.set('content', this.single);
+      
+      this.c.get('test').shouldEqual('NAME0');
+      this.c.get('testController').shouldEqual('NAME0');
+      
+      this.c.get('value').shouldEqual(0);
+      this.c.get('valueController').shouldEqual(0);
+
+      this.c.get('flag').shouldEqual(YES);
+      this.c.get('flagController').shouldEqual(YES);
+
+      this.c.get('array').shouldEqualEnum([0,0,0]);
+      this.c.get('arrayController').instanceOf( SC.ArrayController ).shouldEqual(YES);
+
+      this.c.get('object').instanceOf( SC.Object ).shouldEqual(YES);
+      this.c.get('objectController').instanceOf( SC.ObjectController ).shouldEqual(YES);
+    },
+
+    "SET should notify observers of valueController properties": function()
+    {
+      this.c.set('content', this.single);
+
+      var observer = new Test.Observer;
+      this.c.addObserver( 'objectController', observer );
+      this.c.set('object', SC.Object.create({ test: "NAME12" }));
+      observer.notified.shouldEqual(1);
+    },
+
+    "SET value should reset the valueController property": function()
+    {
+      this.c.set('content', this.single);
+      
+      this.c.set('array', this.single_a);
+      this.c.get('arrayController').get('length').shouldEqual(1);
+      this.c.set('array', this.empty_a);
+      this.c.get('arrayController').get('length').shouldEqual(0);
+    },
+
+    "SET controller content should reset all valueController properties": function()
+    {
+      this.c.set('content', SC.Object.create({ array: [1,2,3] }));
+      this.c.get('arrayController').get('length').shouldEqual(3);
+
+      this.c.set('content', SC.Object.create({ array: [1] }));
+      this.c.get('arrayController').get('length').shouldEqual(1);
+    },
+
+    "SET with no autocommit should store in controller, but not in source object": function() {
+      
+      this.c.set('content', this.single) ;
+      this.c.get('test').shouldEqual('NAME0') ;
+  
+      // edit the content, but don't save.
+      this.c.set('test', 'NAME1') ;
+  
+      this.c.get('hasChanges').shouldEqual(YES) ;
+      this.c.get('test').shouldEqual('NAME1') ;
+      this.single.get('test').shouldEqual('NAME0') ;
+
+      // save content.
+      $ok(this.c.commitChanges()).shouldEqual(YES) ;
+      
+      this.c.get('hasChanges').shouldEqual(NO) ;
+      this.c.get('test').shouldEqual('NAME1') ;
+      this.single.get('test').shouldEqual('NAME1') ;
+     },
+    
+    "SET on null content should allow set but return error on commit": function() {
+      this.c.set('content', null) ;
+      this.c.set('test', 'NAME1') ;
+      
+      $ok(this.c.commitChanges()).shouldEqual(NO) ;
+    },
+    
+    "SET on empty array content should allow set but return error on commit": function() {
+      this.c.set('content', this.empty_a) ;
+      this.c.set('test', 'NAME1') ;
+      
+      $ok(this.c.commitChanges()).shouldEqual(NO) ;
+      
+    },
+    
+    "SET on single array should copy values to object on commit": function() {
+      this.c.set('content', this.single) ;
+      this.c.set('test','NAME1') ;
+      
+      $ok(this.c.commitChanges()).shouldEqual(YES) ;
+      this.single.get('test').shouldEqual('NAME1') ;      
+    },
+    
+    "SET on single-item array should copy values to object on commit": function() {
+      this.c.set('content', this.single_a) ;
+      this.c.set('test','NAME1') ;
+      
+      $ok(this.c.commitChanges()).shouldEqual(YES) ;
+      this.single_a[0].get('test').shouldEqual('NAME1') ;      
+    },
+    
+    "SET on multiple with array values should copy value to content object at the same index": function() {
+      this.c.set('content', this.multiple) ;
+      this.c.set('test', ['NAME2','NAME3'] ) ;
+      
+      $ok(this.c.commitChanges()).shouldEqual(YES) ;
+      this.multiple[0].get('test').shouldEqual('NAME2') ;
+      this.multiple[1].get('test').shouldEqual('NAME3') ;
+    },
+    
+    "SET on multiple with a non-array value should copy same value to each content object": function() {
+      this.c.set('content', this.multiple) ;
+      this.c.set('test', 'NAME2') ;
+      
+      $ok(this.c.commitChanges()).shouldEqual(YES) ;
+      this.multiple[0].get('test').shouldEqual('NAME2') ;
+      this.multiple[1].get('test').shouldEqual('NAME2') ;
+    },
+
+    "Calling performDiscardChanges() should notify property observers of a change": function()
+    {
+      var observer = new Test.Observer;
+
+      this.c.set('content', this.single);
+      this.c.addObserver( 'test', observer );
+
+      // set the property
+      this.c.set('test', 'NAME2');
+      this.c.get('hasChanges').shouldEqual(YES);
+      observer.notified.shouldEqual(1);
+
+      this.c.performDiscardChanges();
+      this.c.get('hasChanges').shouldEqual(NO);
+      observer.notified.shouldEqual(2);
+    },
+
+    "Support commitChanges() on content objects": function() {
+      this.c.set('content', this.single) ;
+      this.c.set('test', 'NAME2') ;
+      
+      $ok(this.c.commitChanges()).shouldEqual(YES) ;
+      this.single.didCommitChanges.shouldEqual(YES) ;
+    },
+    
+    "Support content objects that implement SC.Array but are not arrays": function() {
+      this.c.set('content', this.dummy_a) ;
+
+      // test initial content
+      this.c.get('test').shouldEqualEnum(['NAME0', 'NAME1']) ;
+      this.c.get('value').shouldEqualEnum([0,1]) ;
+      this.c.get('flag').shouldEqualEnum([YES, NO]) ;
+      
+      // get('array').shouldEqual: [ [0,0,0], [1,1,1] ];
+      var ar = this.c.get('array') ;
+      ar.length.shouldEqual(2) ;
+      ar[0].shouldEqualEnum([0,0,0]) ;
+      ar[1].shouldEqualEnum([1,1,1]) ;
+
+
+      // test changing contents
+      this.c.set('test', 'NAME2') ;
+      $ok(this.c.commitChanges()).shouldEqual(YES) ;
+      this.dummy_a.objectAt(0).get('test').shouldEqual('NAME2') ;
+      this.dummy_a.objectAt(0).get('test').shouldEqual('NAME2') ;
+     },
+    
+    "Support content objects that are not Observable": function() {
+      var obj = { 
+        test: 'NAME0', value: 0, flag: YES, array: [0,0,0],
+        
+        commitChanges: function() {
+          this.didCommitChanges = YES ;
+        },
+        
+        didCommitChanges: NO
+      } ;
+      
+      this.c.set('content', obj);
+      this.c.get('test').shouldEqual('NAME0') ;
+      
+      this.c.set('test', 'NAME1') ;
+      $ok(this.c.commitChanges()).shouldEqual(YES) ;
+      
+      obj.test.shouldEqual('NAME1') ;
+      obj.didCommitChanges.shouldEqual(YES) ;      
+    },
+    
+    setup: function() {
+      this.c = SC.ObjectController.create() ;
+      
+      this.single = SC.Object.create({ 
+        test: 'NAME0', value: 0, flag: YES, array: [0,0,0],
+        object: SC.Object.create({ test: 'NAME1', value: 1, flag: NO, array: [1,1,1] }),
+        
+        commitChanges: function() {
+          this.didCommitChanges = YES ;
+        },
+        
+        didCommitChanges: NO
+      }) ;
+      
+      this.multiple = [
+        SC.Object.create({ test: 'NAME0', value: 0, flag: YES, array: [0,0,0] }),
+        SC.Object.create({ test: 'NAME1', value: 1, flag: NO, array: [1,1,1] })
+      ] ;
+      
+      this.single_a = [
+        SC.Object.create({ test: 'NAME0', value: 0, flag: YES, array: [0,0,0] })
+      ] ;
+      
+      this.empty_a = [] ;
+      
+      this.dummy_a = SC.Object.create(SC.Array, {
+        length: 2,
+        
+        replace: function(idx, amt, objects) {
+          this._items.replace(idx,amt,objects) ;
+          this.set('length', this._items.length) ;
+        },
+        
+        objectAt: function(idx) {
+          return this._items.objectAt(idx) ;
+        },
+        
+        _items: this.multiple
+      }) ;
+      
+    }
+}) ;
+
+</script>
+
+<% end %>