sproutit-sproutcore 1.0.20090721145281 → 1.0.20090721145282

data/frameworks/sproutcore/frameworks/datastore/tests/models/record/storeDidChangeProperties.js

@@ -8,6 +8,8 @@
 var store, child, Foo, json, foo ;
 module("SC.Record#storeDidChangeProperties", {
   setup: function() {
+    SC.RunLoop.begin();
+    
     store = SC.Store.create();
     Foo = SC.Record.extend({
       
@@ -33,7 +35,9 @@ module("SC.Record#storeDidChangeProperties", {
     };
     
     foo = store.createRecord(Foo, json);
-    store.writeStatus(foo.storeKey, SC.Record.READY_CLEAN); 
+    store.writeStatus(foo.storeKey, SC.Record.READY_CLEAN);
+    
+    SC.RunLoop.end();
   }
 });
 
@@ -42,9 +46,9 @@ function checkPreconditions() {
   equals(foo.fooCnt, 0, 'precond - fooCnt');
 }
 
-function expect(expectedStatusCnt, expectedFooCnt) {
-  equals(foo.statusCnt, expectedStatusCnt, 'status should have changed');
-  equals(foo.fooCnt, expectedFooCnt, 'foo should have changed');
+function expect(fooObject, expectedStatusCnt, expectedFooCnt) {
+  equals(fooObject.statusCnt, expectedStatusCnt, 'status should have changed');
+  equals(fooObject.fooCnt, expectedFooCnt, 'foo should have changed');
 }
 
 // ..........................................................
@@ -56,7 +60,7 @@ test("should change status only if statusOnly=YES", function() {
   
   foo.storeDidChangeProperties(YES);
 
-  expect(1,0);
+  expect(foo,1,0);
 });
 
 
@@ -65,7 +69,7 @@ test("should change attrs  & status if statusOnly=NO", function() {
   
   foo.storeDidChangeProperties(NO);
   
-  expect(1,1);
+  expect(foo,1,1);
 });
 
 // ..........................................................
@@ -74,65 +78,84 @@ test("should change attrs  & status if statusOnly=NO", function() {
 
 test("editing a clean record should change all", function() {
   checkPreconditions();
+  SC.RunLoop.begin();
   foo.writeAttribute("foo", "bar");
-  expect(1,1);
+  SC.RunLoop.end();
+  expect(foo,1,1);
 });
 
 test("destroying a record should change all", function() {
   checkPreconditions();
+  SC.RunLoop.begin();
   foo.destroy();
-  expect(1,1);
+  SC.RunLoop.end();
+  expect(foo,1,1);
 });
 
 test("refreshing a record should change status", function() {
   checkPreconditions();
+  SC.RunLoop.begin();
   foo.refresh();
-  expect(1,0);
+  SC.RunLoop.end();
+  expect(foo,1,0);
 });
 
 test("committing attribute changes from nested store should change attrs", function() {
   checkPreconditions();
   
+  SC.RunLoop.begin();
   var child = store.chain();
   var foo2 = child.materializeRecord(foo.storeKey);
   foo2.writeAttribute('foo', 'bar');
-  
+  SC.RunLoop.end();
   // no changes should happen yet on foo.
-  expect(0,0);
+  expect(foo,0,0);
   
+  SC.RunLoop.begin();
   // commit
   child.commitChanges();
+  SC.RunLoop.end();
 
   // now changes
-  expect(1,1);
+  expect(foo,1,1);
 });
 
 test("changing attributes on a parent store should notify child store if inherited", function() {
-  
   var child = store.chain();
   var oldfoo = foo;
-  foo = child.materializeRecord(foo.storeKey);
+  var parentfoo = store.materializeRecord(foo.storeKey);
+  var childfoo = child.materializeRecord(foo.storeKey);
   equals(child.storeKeyEditState(foo.storeKey), SC.Store.INHERITED, 'precond - foo should be inherited from parent store');
   
-  oldfoo.writeAttribute('foo', 'bar');
+  SC.RunLoop.begin();
+  parentfoo.writeAttribute('foo', 'bar');
+  SC.RunLoop.end();
   
-  expect(1,1); // should reflect on child
+  expect(childfoo,1,1); // should reflect on child
 });
 
 test("changing attributes on a parent store should NOT notify child store if locked", function() {
   
   var child = store.chain();
   var oldfoo = foo;
-  foo = child.materializeRecord(foo.storeKey);
-  foo.readAttribute('foo');
+  var parentfoo = store.materializeRecord(foo.storeKey);
+  var childfoo = child.materializeRecord(foo.storeKey);
+  childfoo.readAttribute('foo');
   equals(child.storeKeyEditState(foo.storeKey), SC.Store.EDITABLE, 'precond - foo should be locked from parent store');
   
-  oldfoo.writeAttribute('foo', 'bar');
-  
-  expect(0,0); // should not reflect on child
-  
+  SC.RunLoop.begin();
+  parentfoo.writeAttribute('foo', 'bar');
+  SC.RunLoop.end();
+  expect(childfoo,0,0); // should not reflect on child
+  expect(parentfoo,1,1);
   // discarding changes should update
+
+  // NOTE: recourds should change immediately on commit/discard changes.
+  // test results here BEFORE run loop ends
+  SC.RunLoop.begin();
   child.discardChanges(); // make it match parent again
-  expect(1,1);
+  expect(childfoo,1,1); //the childfoo record is reset to whatever the parentValue is.
+  SC.RunLoop.end();
+
 });
 

data/frameworks/sproutcore/frameworks/datastore/tests/models/record/writeAttribute.js

@@ -8,17 +8,20 @@
 var store, Foo, json, foo ;
 module("SC.Record#writeAttribute", {
   setup: function() {
+    SC.RunLoop.begin();
     store = SC.Store.create();
     Foo = SC.Record.extend();
     json = { 
       foo: "bar", 
       number: 123,
       bool: YES,
-      array: [1,2,3] 
+      array: [1,2,3],
+      guid: 1
     };
     
     foo = store.createRecord(Foo, json);
-    store.writeStatus(foo.storeKey, SC.Record.READY_CLEAN); 
+    store.writeStatus(foo.storeKey, SC.Record.READY_CLEAN);
+    SC.RunLoop.end();
   }
 });
 
@@ -30,9 +33,11 @@ test("first time writing should mark record as dirty", function() {
   // precondition
   equals(foo.get('status'), SC.Record.READY_CLEAN, 'precond - start clean');
 
+  SC.RunLoop.begin();
   // action
   foo.writeAttribute("bar", "baz");
-
+  SC.RunLoop.end();
+  
   // evaluate
   equals(foo.get('status'), SC.Record.READY_DIRTY, 'should make READY_DIRTY after write');
 });
@@ -42,14 +47,18 @@ test("state change should be deferred if writing inside of a beginEditing()/endE
   // precondition
   equals(foo.get('status'), SC.Record.READY_CLEAN, 'precond - start clean');
 
+  SC.RunLoop.begin();
   // action
   foo.beginEditing();
+  
   foo.writeAttribute("bar", "baz");
-
+  
   equals(foo.get('status'), SC.Record.READY_CLEAN, 'should not change state yet');
 
   foo.endEditing();
-
+  
+  SC.RunLoop.end();
+  
   // evaluate
   equals(foo.get('status'), SC.Record.READY_DIRTY, 'should make READY_DIRTY after write');
   
@@ -69,3 +78,18 @@ test("raises exception if you try to write an attribute before an attribute hash
   equals(cnt, 1, 'should raise exception');
 });
 
+
+test("Writing to an attribute in chained store sets correct status", function() {
+  
+  var chainedStore = store.chain() ;
+  
+  var chainedRecord = chainedStore.find(Foo, foo.readAttribute('guid'));
+  equals(chainedRecord.get('status'), SC.Record.READY_CLEAN, 'precon - status should be READY_CLEAN');
+  
+  chainedRecord.writeAttribute('foo', 'newValue');
+  //chainedRecord.set('foo', 'newValue');
+  
+  equals(chainedRecord.get('status'), SC.Record.READY_DIRTY, 'status should be READY_DIRTY');
+  
+});
+

data/frameworks/sproutcore/frameworks/datastore/tests/models/record_attribute.js

@@ -6,7 +6,8 @@
 /*globals module ok equals same test MyApp */
 
 // test core array-mapping methods for RecordArray with RecordAttribute
-var storeKeys, rec;
+var storeKeys, rec, rec2, bar ;
+
 module("SC.RecordAttribute core methods", {
   setup: function() {
 
@@ -51,13 +52,14 @@ module("SC.RecordAttribute core methods", {
       relatedToComputed: SC.Record.toOne(function() {
         // not using .get() to avoid another transform which will 
         // trigger an infinite loop
-        return (this.readAttribute('relatedToComputed').indexOf("foo")==0) ? MyApp.Foo : MyApp.Bar;
+        return (this.readAttribute('relatedToComputed').indexOf("foo")===0) ? MyApp.Foo : MyApp.Bar;
       })
       
     });
     
     MyApp.Bar = SC.Record.extend({});
     
+    SC.RunLoop.begin();
     storeKeys = MyApp.store.loadRecords(MyApp.Foo, [
       { 
         guid: 'foo1', 
@@ -93,6 +95,8 @@ module("SC.RecordAttribute core methods", {
       { guid: 'bar1', city: "Chicago" }
     ]);
     
+    SC.RunLoop.end();
+    
     rec = MyApp.store.find(MyApp.Foo, 'foo1');
     rec2 = MyApp.store.find(MyApp.Foo, 'foo2');
     
@@ -146,7 +150,7 @@ test("reading date should parse ISO date", function() {
 });
 
 test("reading date should parse non-ISO date", function() {
-  var d = new Date(2009,6,10,8,55,50);
+  var d = new Date(1244624150000);
   equals(rec2.get('nonIsoDate').toString(), d.toString(), 'should have matched date');
 });
 
@@ -182,10 +186,15 @@ test("writing a value should override default value", function() {
 test("writing to a to-one relationship should update set guid", function() {
   var rec2 = MyApp.store.find(MyApp.Foo, 'foo2');
   equals(rec2.get('id'), 'foo2', 'precond - should find record 2');
+
   equals(rec2.get('relatedTo'), rec, 'precond - should get rec1 instance for rec2.relatedTo');
-  
+
   rec2.set('relatedTo', rec2);
+
   equals(rec2.readAttribute('relatedTo'), 'foo2', 'should write ID for set record to relatedTo attribute');
+  
+  equals(rec2.get('relatedTo'), rec2, 'should get foo record that was just set');
+
 });
 
 test("writing to a to-one computed relationship should update set guid", function() {

data/frameworks/sproutcore/frameworks/datastore/tests/system/nested_store/chain.js

@@ -8,6 +8,22 @@
 // This file tests the initial state of the store when it is first created
 // either independently or as a chained store.
 
+var Rec = SC.Record.extend({
+  
+  title: SC.Record.attr(String),
+  
+  fired: NO,
+  
+  reset: function() { 
+    this.fired = NO;
+  },
+  
+  titleDidChange: function() {
+    this.fired = YES;
+  }.observes('title')
+    
+});
+
 // ..........................................................
 // SC.Store#chain - init
 // 
@@ -38,3 +54,96 @@ test("initial setup for chained store", function() {
   ok(!store.editables, 'should not have editables');
 }); 
 
+
+// ..........................................................
+// SPECIAL CASES
+// 
+
+test("chained store changes should propogate reliably", function() {
+  var parent = SC.Store.create(), rec, store, rec2;
+
+  SC.run(function() {
+    parent.loadRecords(Rec, [{ title: "foo", guid: 1 }]);
+  });
+  
+  rec = parent.find(Rec, 1);
+  ok(rec && rec.get('title')==='foo', 'precond - base store should have record');
+
+  // run several times to make sure this works reliably when used several 
+  // times in the same app
+  
+  // trial 1
+  SC.RunLoop.begin();
+  store = parent.chain();
+  rec2  = store.find(Rec, 1);
+  ok(rec2 && rec2.get('title')==='foo', 'chain store should have record');
+  
+  rec.reset();
+  rec2.set('title', 'bar');
+  SC.RunLoop.end();
+  
+  equals(rec2.get('title'), 'bar', 'chained rec.title should changed');
+  equals(rec.get('title'), 'foo', 'original rec.title should NOT change');
+  equals(store.get('hasChanges'), YES, 'chained store.hasChanges');
+  equals(rec.fired, NO, 'original rec.title should not have notified');
+  
+  SC.RunLoop.begin();
+  rec.reset();
+  store.commitChanges();
+  store.destroy();
+  SC.RunLoop.end();
+
+  equals(rec.get('title'), 'bar', 'original rec.title should change');
+  equals(rec.fired, YES, 'original rec.title should have notified');  
+
+
+  // trial 2
+  SC.RunLoop.begin();
+  store = parent.chain();
+  rec2  = store.find(Rec, 1);
+  ok(rec2 && rec2.get('title')==='bar', 'chain store should have record');
+  
+  rec.reset();
+  rec2.set('title', 'baz');
+  SC.RunLoop.end();
+  
+  equals(rec2.get('title'), 'baz', 'chained rec.title should changed');
+  equals(rec.get('title'), 'bar', 'original rec.title should NOT change');
+  equals(store.get('hasChanges'), YES, 'chained store.hasChanges');
+  equals(rec.fired, NO, 'original rec.title should not have notified');
+  
+  SC.RunLoop.begin();
+  rec.reset();
+  store.commitChanges();
+  store.destroy();
+  SC.RunLoop.end();
+
+  equals(rec.get('title'), 'baz', 'original rec.title should change');
+  equals(rec.fired, YES, 'original rec.title should have notified');  
+  
+
+  // trial 1
+  SC.RunLoop.begin();
+  store = parent.chain();
+  rec2  = store.find(Rec, 1);
+  ok(rec2 && rec2.get('title')==='baz', 'chain store should have record');
+  
+  rec.reset();
+  rec2.set('title', 'FOO2');
+  SC.RunLoop.end();
+  
+  equals(rec2.get('title'), 'FOO2', 'chained rec.title should changed');
+  equals(rec.get('title'), 'baz', 'original rec.title should NOT change');
+  equals(store.get('hasChanges'), YES, 'chained store.hasChanges');
+  equals(rec.fired, NO, 'original rec.title should not have notified');
+  
+  SC.RunLoop.begin();
+  rec.reset();
+  store.commitChanges();
+  store.destroy();
+  SC.RunLoop.end();
+
+  equals(rec.get('title'), 'FOO2', 'original rec.title should change');
+  equals(rec.fired, YES, 'original rec.title should have notified');  
+  
+});

data/frameworks/sproutcore/frameworks/datastore/tests/system/nested_store/commitChanges.js

@@ -11,6 +11,7 @@
 var parent, store, child, storeKey, json, args;
 module("SC.NestedStore#commitChanges", {
   setup: function() {
+    
     parent = SC.Store.create();
     
     json = {
@@ -45,25 +46,30 @@ module("SC.NestedStore#commitChanges", {
 // BASIC STATE TRANSITIONS
 //
 
-function testStateTransition(shouldIncludeStoreKey) {
+function testStateTransition(shouldIncludeStoreKey, shouldCallParent) {
 
   // attempt to commit
   equals(store.commitChanges(), store, 'should return receiver');
   
   // verify result
   equals(store.storeKeyEditState(storeKey), SC.Store.INHERITED, 'data edit state');
-  equals(args.length, 1, 'should have called commitChangesFromNestedStore');
 
-  var opts = args[0] || {}; // avoid exceptions
-  equals(opts.target, parent, 'should have called on parent store');
-  
-  // verify if changes passed to callback included storeKey
-  var changes = opts.changes;
-  var didInclude = changes && changes.contains(storeKey);
-  if (shouldIncludeStoreKey) {
-    ok(didInclude, 'passed set of changes should include storeKey');
+  if (shouldCallParent === NO) {
+    ok(!args || args.length===0, 'should not call commitChangesFromNestedStore');    
   } else {
-    ok(!didInclude, 'passed set of changes should NOT include storeKey');
+    equals(args.length, 1, 'should have called commitChangesFromNestedStore');
+
+    var opts = args[0] || {}; // avoid exceptions
+    equals(opts.target, parent, 'should have called on parent store');
+
+    // verify if changes passed to callback included storeKey
+    var changes = opts.changes;
+    var didInclude = changes && changes.contains(storeKey);
+    if (shouldIncludeStoreKey) {
+      ok(didInclude, 'passed set of changes should include storeKey');
+    } else {
+      ok(!didInclude, 'passed set of changes should NOT include storeKey');
+    }
   }
   
   equals(store.get('hasChanges'), NO, 'hasChanges should be cleared');
@@ -78,7 +84,7 @@ test("state = INHERITED", function() {
   // check preconditions
   equals(store.storeKeyEditState(storeKey), SC.Store.INHERITED, 'precond - data edit state');
 
-  testStateTransition(NO);
+  testStateTransition(NO, NO);
 });
 
 
@@ -93,7 +99,7 @@ test("state = LOCKED", function() {
   equals(store.storeKeyEditState(storeKey), SC.Store.LOCKED, 'precond - data edit state');
   ok(!store.chainedChanges || !store.chainedChanges.contains(storeKey), 'locked record should not be in chainedChanges set');
 
-  testStateTransition(NO);
+  testStateTransition(NO, NO);
 });
 
 test("state = EDITABLE", function() {
@@ -106,7 +112,7 @@ test("state = EDITABLE", function() {
   equals(store.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'precond - data edit state');
   ok(store.chainedChanges  && store.chainedChanges.contains(storeKey), 'editable record should be in chainedChanges set');
 
-  testStateTransition(YES);
+  testStateTransition(YES, YES);
 });
 
 
@@ -114,4 +120,52 @@ test("state = EDITABLE", function() {
 // SPECIAL CASES
 // 
 
-// TODO: Add more special cases for SC.NestedStore#commitChanges
+test("commiting a changed record should immediately notify outstanding records in parent store", function() {
+
+  var Rec = SC.Record.extend({
+    
+    fooCnt: 0,
+    fooDidChange: function() { this.fooCnt++; }.observes('foo'),
+    
+    statusCnt: 0,
+    statusDidChange: function() { this.statusCnt++; }.observes('status'),
+    
+    reset: function() { this.fooCnt = this.statusCnt = 0; },
+    
+    equals: function(fooCnt, statusCnt, str) {
+      if (!str) str = '' ;
+      equals(this.get('fooCnt'), fooCnt, str + ':fooCnt');
+      equals(this.get('statusCnt'), statusCnt, str + ':statusCnt');
+    }
+    
+  });
+
+  SC.RunLoop.begin();
+    
+  var store = SC.Store.create();
+  var prec  = store.createRecord(Rec, { foo: "bar", guid: 1 });
+  
+  var child = store.chain();
+  var crec  = child.find(Rec, prec.get('id'));
+  
+  // check assumptions
+  ok(!!crec, 'prerec - should find child record');
+  equals(crec.get('foo'), 'bar', 'prerec - child record should have foo');
+  
+  // modify child record - should not modify parent
+  prec.reset();
+  crec.set('foo', 'baz');
+  equals(prec.get('foo'), 'bar', 'should not modify parent before commit');
+  prec.equals(0,0, 'before commitChanges');
+  
+  // commit changes - note: still inside runloop
+  child.commitChanges();
+  equals(prec.get('foo'), 'baz', 'should push data to parent');
+  prec.equals(1,1, 'after commitChanges'); // should notify immediately
+  
+  SC.RunLoop.end();
+  
+  // should not notify again after runloop - nothing to do
+  prec.equals(1,1,'after runloop ends - should not notify again');
+  
+});

data/frameworks/sproutcore/frameworks/datastore/tests/system/nested_store/commitChangesFromNestedStore.js

@@ -31,12 +31,15 @@ module("SC.NestedStore#commitChangesFromNestedStore", {
 
 test("copies changed data hashes, statuses, and revisions", function() {
   
+  SC.RunLoop.begin();
+  
   // verify preconditions
   equals(store.readDataHash(storeKey), null, 'precond - should not have data yet');
   ok(child.chainedChanges.contains(storeKey), 'precond - child changes should include storeKey');
   
   // perform action
   equals(store.commitChangesFromNestedStore(child, child.chainedChanges, NO), store, 'should return receiver');
+  SC.RunLoop.end();
   
   // verify new status
   equals(store.readDataHash(storeKey), json, 'now should have json');
@@ -47,6 +50,8 @@ test("copies changed data hashes, statuses, and revisions", function() {
 
 test("adds lock on any items not already locked", function() {
 
+  SC.RunLoop.begin();
+
   var storeKey2 = SC.Store.generateStoreKey();
   var json2 = { kind: "json2" };
   
@@ -65,6 +70,7 @@ test("adds lock on any items not already locked", function() {
   
   // now commit back to parent
   equals(store.commitChangesFromNestedStore(child, changes, NO), store, 'should return reciever');
+  SC.RunLoop.end();
   
   // and verify that both have locks
   ok(store.locks[storeKey], 'storeKey should have lock after commit (actual: %@)'.fmt(store.locks[storeKey]));
@@ -74,6 +80,8 @@ test("adds lock on any items not already locked", function() {
 
 test("adds items in chainedChanges to reciever chainedChanges", function() {
 
+  SC.RunLoop.begin();
+
   var key1 = SC.Store.generateStoreKey();
 
   store.dataHashDidChange(key1);
@@ -81,6 +89,7 @@ test("adds items in chainedChanges to reciever chainedChanges", function() {
   ok(child.chainedChanges.contains(storeKey), 'precond - child.chainedChanges should contain store key');
   
   equals(store.commitChangesFromNestedStore(child, child.chainedChanges, NO), store, 'should return receiver');
+  SC.RunLoop.end();
 
   // changelog should merge nested store & existing
   ok(store.chainedChanges.contains(key1), 'chainedChanges should still contain key1');
@@ -89,6 +98,8 @@ test("adds items in chainedChanges to reciever chainedChanges", function() {
 
 test("should set hasChanges to YES if has changes", function() {
   
+  SC.RunLoop.begin();
+  
   var changes = child.chainedChanges;
   ok(changes.length>0, 'precond - should have some changes in child');
   equals(store.get('hasChanges'), NO, 'precond - store should not have changes');
@@ -99,6 +110,8 @@ test("should set hasChanges to YES if has changes", function() {
 
 test("should set hasChanges to NO if no changes", function() {
   
+  SC.RunLoop.begin();
+  
   child = store.chain() ; // get a new child store
   
   var changes = child.chainedChanges || SC.Set.create();
@@ -106,6 +119,8 @@ test("should set hasChanges to NO if no changes", function() {
   equals(store.get('hasChanges'), NO, 'precond - store should not have changes');
   
   store.commitChangesFromNestedStore(child, changes, NO);
+  SC.RunLoop.end();
+  
   equals(store.get('hasChanges'), NO, 'store should NOT now have changes');
 });
 
@@ -115,6 +130,8 @@ test("should set hasChanges to NO if no changes", function() {
 
 test("committing changes should chain back each step", function() {
 
+  SC.RunLoop.begin();
+
   // preconditions
   equals(child.readDataHash(storeKey), json, 'precond - child should have data');
   equals(store.readDataHash(storeKey), null, 'precond - store should not have data');
@@ -122,14 +139,16 @@ test("committing changes should chain back each step", function() {
   
   // do commits
   child.commitChanges();
+
   equals(store.get('hasChanges'), YES, 'store should now have changes');
   equals(store.readDataHash(storeKey), json, 'store should now have json');
   
   store.commitChanges();
   equals(store.get('hasChanges'), NO, 'store should no longer have changes');
   equals(parent.readDataHash(storeKey), json, 'parent should now have json');
+  SC.RunLoop.end();
+  
 });
 
 
 
-

data/frameworks/sproutcore/frameworks/datastore/tests/system/nested_store/dataHashDidChange.js

@@ -20,8 +20,11 @@ module("SC.NestedStore#dataHashDidChange", {
     };
     
     storeKey = SC.Store.generateStoreKey();
-
+    
+    SC.RunLoop.begin();
     parent.writeDataHash(storeKey, json, SC.Record.READY_CLEAN);
+    SC.RunLoop.end();
+    
     parent.editables = null; // manually patch to setup test state
     
     store = parent.chain(); // create nested store