sproutit-sproutcore 1.0.0.20090407205609 → 1.0.0.20090408130025

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

@@ -0,0 +1,99 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Apple, Inc. and contributors.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+/*globals module ok equals same test MyApp */
+
+// NOTE: The test below are based on the Data Hashes state chart.  This models
+// the "discard" event in the NestedStore portion of the diagram.
+
+var parent, store, child, storeKey, json, args;
+module("SC.NestedStore#discardChanges", {
+  setup: function() {
+    parent = SC.Store.create();
+    
+    json = {
+      string: "string",
+      number: 23,
+      bool:   YES
+    };
+    args = null;
+    
+    storeKey = SC.Store.generateStoreKey();
+
+    parent.writeDataHash(storeKey, json, SC.Record.READY_CLEAN);
+    parent.editables = null;
+    
+    store = parent.chain(); // create nested store
+    child = store.chain();  // test multiple levels deep
+
+    // commitChangesFromNestedStore() should never be called.  Capture info
+    // about call.
+    parent.commitChangesFromNestedStore =
+    child.commitChangesFromNestedStore =
+    store.commitChangesFromNestedStore = function(store, changes, force) {
+      if (!args) args = [];
+      args.push({ 
+        target: this, 
+        store: store, 
+        changes: changes, 
+        force: force 
+      });
+    };
+    
+  }
+});
+
+// ..........................................................
+// BASIC STATE TRANSITIONS
+//
+
+function testStateTransition() {
+
+  // attempt to commit
+  equals(store.discardChanges(), store, 'should return receiver');
+  
+  // verify result
+  equals(store.storeKeyEditState(storeKey), SC.Store.INHERITED, 'data edit state');
+  equals(store.get('hasChanges'), NO, 'hasChanges should be NO');
+  equals(store.readDataHash(storeKey), json, 'data hash should return parent hash again');
+  equals(store.readStatus(storeKey), parent.readStatus(storeKey), 'should return record status from parent');
+  ok(!store.chainedChanges || !store.chainedChanges.length, 'should have no chainedChanges queued');
+  
+  // should NOT invoke commitChangesFromNestedStore
+  equals(args, null, 'should not call commitChangesFromNestedStore');
+}
+
+notest("state = INHERITED", function() {
+  equals(store.storeKeyEditState(storeKey), SC.Store.INHERITED, 'precond - data edit state');
+  testStateTransition();
+});
+
+
+notest("state = LOCKED", function() {
+  
+  store.readDataHash(storeKey); // force to locked mode
+  equals(store.storeKeyEditState(storeKey), SC.Store.LOCKED, 'precond - data edit state');
+  testStateTransition();
+});
+
+notest("state = EDITABLE", function() {
+  
+  // write in some data to store
+  store.writeDataHash(storeKey, json);
+  store.dataHashDidChange(storeKey);
+  
+  // check preconditions
+  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();
+});
+
+
+// ..........................................................
+// SPECIAL CASES
+// 
+
+// TODO: Add more special cases for SC.NestedStore#discardChanges

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

@@ -0,0 +1,180 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Apple, Inc. and contributors.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+/*globals module ok equals same test MyApp */
+
+// NOTE: The test below are based on the Data Hashes state chart.  This models
+// the "read" event in the NestedStore portion of the diagram.
+
+var parent, store, child, storeKey, json;
+module("SC.NestedStore#readDataHash", {
+  setup: function() {
+    parent = SC.Store.create();
+    
+    json = {
+      string: "string",
+      number: 23,
+      bool:   YES
+    };
+    
+    storeKey = SC.Store.generateStoreKey();
+
+    parent.writeDataHash(storeKey, json, SC.Record.READY_CLEAN);
+    parent.editables = null; // manually patch to setup test state
+    
+    store = parent.chain(); // create nested store
+    child = store.chain();  // for deep nested
+  }
+});
+
+// ..........................................................
+// BASIC STATE TRANSITIONS
+// 
+
+notest("data state=INHERITED, lockOnRead=YES, parent editable=NO", function() {
+  // preconditions
+  equals(store.get('lockOnRead'), YES, 'precond - lockOnRead should be YES');
+  equals(store.storeKeyEditState(storeKey), SC.Store.INHERITED, 'precond - storeKey should be inherited from parent');
+  var oldrev = store.revisions[storeKey]; // save old rev for testing later
+
+  // perform read
+  equals(store.readDataHash(storeKey), json, 'should return json');
+
+  // verify
+  equals(store.storeKeyEditState(storeKey), SC.Store.LOCKED, 'storeKey should be read-locked now');
+  ok(store.dataHashes.hasOwnProperty(storeKey), 'should copy reference to json');
+
+  // test revisions...
+  equals(store.revisions[storeKey], oldrev, 'should not change revision');
+  if (!SC.none(oldrev)) {
+    ok(store.revisions.hasOwnProperty(storeKey), 'should copy reference to revision');
+  }
+});
+
+
+notest("data state=INHERITED, lockOnRead=NO, parent editable=NO", function() {
+  // preconditions
+  store.set('lockOnRead', NO);
+  
+  equals(store.get('lockOnRead'), NO, 'precond - lockOnRead should be NO');
+  equals(store.storeKeyEditState(storeKey), SC.Store.INHERITED, 'precond - storeKey should be inherited from parent');
+  var oldrev = store.revisions[storeKey]; // save old rev for testing later
+
+  // perform read
+  equals(store.readDataHash(storeKey), json, 'should return json');
+
+  // verify
+  equals(store.storeKeyEditState(storeKey), SC.Store.INHERITED, 'storeKey should still be inherited');
+  ok(!store.dataHashes.hasOwnProperty(storeKey), 'should NOT copy reference to json');
+
+  // test revisions...
+  equals(store.revisions[storeKey], oldrev, 'should not change revision');
+  if (!SC.none(oldrev)) {
+    ok(store.revisions.hasOwnProperty(storeKey), 'should copy reference to revision');
+  }
+});
+
+
+notest("data state=INHERITED, lockOnRead=YES, parent editable=YES", function() {
+
+  // preconditions
+  
+  // first, make parentStore record editable.  an editable record needs to be
+  // cloned into nested stores on lock to avoid un-monitored edits
+  parent.readEditableDataHash(storeKey);
+  equals(parent.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'precond - parent storeKey should be editable');
+  equals(store.get('lockOnRead'), YES, 'precond - lockOnRead should be YES');
+  equals(store.storeKeyEditState(storeKey), SC.Store.INHERITED, 'precond - storeKey should be inherited from parent');
+  var oldrev = store.revisions[storeKey]; // save old rev for testing later
+
+  // perform read
+  var ret = store.readDataHash(storeKey);
+  same(ret, json, 'should return equivalent json object');
+  ok(!(ret === json), 'should return clone of json instance not exact same instance');
+
+  // verify new state
+  equals(store.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'storeKey should be locked');
+  ok(store.dataHashes.hasOwnProperty(storeKey), 'should have reference to json');
+
+  // test revisions...
+  equals(store.revisions[storeKey], oldrev, 'should not change revision');
+  if (!SC.none(oldrev)) {
+    ok(store.revisions.hasOwnProperty(storeKey), 'should copy reference to revision');
+  }
+});
+
+notest("data state=LOCKED", function() {
+  
+  // preconditions
+  store.set('lockOnRead', YES); // make sure reading will lock
+  var ret1 = store.readDataHash(storeKey);
+  equals(store.storeKeyEditState(storeKey), SC.Store.LOCKED, 'precond - data state should be LOCKED');
+  var oldrev = store.revisions[storeKey];
+  
+  // perform read
+  var ret2 = store.readDataHash(storeKey);
+  
+  // verify
+  equals(ret1, ret2, 'should read same data hash once locked');
+  equals(store.storeKeyEditState(storeKey), SC.Store.LOCKED, 'should remain in locked state');
+
+  // test revisions
+  equals(store.revisions[storeKey], oldrev, 'should not change revision');
+  if (!SC.none(oldrev)) {
+    ok(store.revisions.hasOwnProperty(storeKey), 'should copy reference to revision');
+  }
+});
+
+notest("data state=EDITABLE", function() {
+  
+  // preconditions
+  store.set('lockOnRead', YES); // make sure reading will lock
+  var ret1 = store.readEditableDataHash(storeKey);
+  equals(store.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'precond - data state should be EDITABLE');
+  var oldrev = store.revisions[storeKey];
+  
+  // perform read
+  var ret2 = store.readDataHash(storeKey);
+  
+  // verify
+  equals(ret1, ret2, 'should read same data hash once editable');
+  equals(store.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'should remain in editable state');
+
+  // test revisions
+  equals(store.revisions[storeKey], oldrev, 'should not change revision');
+  if (!SC.none(oldrev)) {
+    ok(store.revisions.hasOwnProperty(storeKey), 'should copy reference to revision');
+  }
+});
+
+notest("should return null when accessing an unknown storeKey", function() {
+  equals(store.readDataHash(20000000), null, 'shuld return null for non-existant store key');
+  equals(store.storeKeyEditState(20000000), SC.Store.LOCKED, 'should put into locked edit state');
+});
+
+// ..........................................................
+// SPECIAL CASES
+//
+
+notest("locking deep nested store when top-level parent is editable and middle store is inherited", function() {
+
+  // first, make the parent store data hash editable
+  json = parent.readEditableDataHash(storeKey);
+  equals(parent.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'parent edit state should be EDITABLE');
+  equals(store.storeKeyEditState(storeKey), SC.Store.INHERITED, 'middle store edit state should be INHERITED');
+  equals(child.storeKeyEditState(storeKey), SC.Store.INHERITED, 'child store edit state should be INHERITED');
+  
+  // now read data hash from child, locking child
+  var json2 = child.readDataHash(storeKey);
+  equals(child.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'child store edit state should be locked after reading data');
+  
+  // now edit the root json and make sure it does NOT propogate.
+  json.newItem = "bar";
+  ok(child.readDataHash(storeKey).newItem !== 'bar', 'child json should not pick up edit from parent store since it is now locked');
+});
+
+
+
+

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

@@ -0,0 +1,126 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Apple, Inc. and contributors.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+/*globals module ok equals same test MyApp */
+
+// NOTE: The test below are based on the Data Hashes state chart.  This models
+// the "read_editable" event in the NestedStore portion of the diagram.
+
+var parent, store, storeKey, json;
+module("SC.NestedStore#readEditableDataHash", {
+  setup: function() {
+    parent = SC.Store.create();
+    
+    json = {
+      string: "string",
+      number: 23,
+      bool:   YES
+    };
+    
+    storeKey = SC.Store.generateStoreKey();
+
+    parent.writeDataHash(storeKey, json, SC.Record.READY_CLEAN);
+    parent.editables = null ; // manually reset for testing state
+    
+    store = parent.chain();
+  }
+});
+
+notest("data state=INHERITED, parent editable = NO", function() {
+  
+  // test preconditions
+  equals(parent.storeKeyEditState(storeKey), SC.Store.LOCKED, 'precond - parent edit state should be LOCKED');
+  equals(store.storeKeyEditState(storeKey), SC.Store.INHERITED, 'precond - edit state should be INHERITED');
+  var oldrev = store.revisions[storeKey] ;
+
+  // perform read
+  var ret = store.readEditableDataHash(storeKey);
+  
+  // validate
+  same(ret, json, 'should return equivalent json object');
+  ok(!(ret===json), 'should not return same json instance');
+  
+  equals(store.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'edit state should be editable');
+  
+  // should not change revisions, but should copy it...
+  equals(store.revisions[storeKey], oldrev, 'should not change revision');
+  if (!SC.none(oldrev)) {
+    ok(store.revisions.hasOwnProperty(storeKey), 'should clone revision reference');
+  }
+});
+
+notest("data state=INHERITED, parent editable = YES", function() {
+  
+  // test preconditions
+  parent.readEditableDataHash(storeKey);
+  equals(parent.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'precond - parent edit state should be EDITABLE');
+  equals(store.storeKeyEditState(storeKey), SC.Store.INHERITED, 'precond - edit state should be INHERITED');
+  var oldrev = store.revisions[storeKey] ;
+
+  // perform read
+  var ret = store.readEditableDataHash(storeKey);
+  
+  // validate
+  same(ret, json, 'should return equivalent json object');
+  ok(!(ret===json), 'should not return same json instance');
+  
+  equals(store.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'edit state should be editable');
+  
+  // should not change revisions, but should copy it...
+  equals(store.revisions[storeKey], oldrev, 'should not change revision');
+  if (!SC.none(oldrev)) {
+    ok(store.revisions.hasOwnProperty(storeKey), 'should clone revision reference');
+  }
+  
+});
+
+notest("data state=LOCKED", function() {
+  
+  // test preconditions
+  store.readDataHash(storeKey);
+  equals(store.storeKeyEditState(storeKey), SC.Store.LOCKED, 'precond - edit state should be LOCKED');
+  var oldrev = store.revisions[storeKey] ;
+
+  // perform read
+  var ret = store.readEditableDataHash(storeKey);
+  
+  // validate
+  same(ret, json, 'should return equivalent json object');
+  ok(!(ret===json), 'should not return same json instance');
+  
+  equals(store.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'edit state should be editable');
+  
+  // should not change revisions, but should copy it...
+  equals(store.revisions[storeKey], oldrev, 'should not change revision');
+  if (!SC.none(oldrev)) {
+    ok(store.revisions.hasOwnProperty(storeKey), 'should clone revision reference');
+  }
+  
+});
+
+notest("data state=EDITABLE", function() {
+  
+  // test preconditions
+  json = store.readEditableDataHash(storeKey); // get editable json
+  equals(store.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'precond - edit state should be EDITABLE');
+  var oldrev = store.revisions[storeKey] ;
+
+  // perform read
+  var ret = store.readEditableDataHash(storeKey);
+  
+  // validate
+  equals(ret, json, 'should return same editable json instance');
+  
+  equals(store.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'edit state should be editable');
+  
+  // should not change revisions, but should copy it...
+  equals(store.revisions[storeKey], oldrev, 'should not change revision');
+  if (!SC.none(oldrev)) {
+    ok(store.revisions.hasOwnProperty(storeKey), 'should clone revision reference');
+  }
+  
+});
+
+

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

@@ -0,0 +1,163 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Apple, Inc. and contributors.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+/*globals module ok equals same test MyApp */
+
+// NOTE: The test below are based on the Data Hashes state chart.  This models
+// the "remove" event in the NestedStore portion of the diagram.
+
+var parent, store, child, storeKey, json;
+module("SC.NestedStore#removeDataHash", {
+  setup: function() {
+    parent = SC.Store.create();
+    
+    json = {
+      string: "string",
+      number: 23,
+      bool:   YES
+    };
+    
+    storeKey = SC.Store.generateStoreKey();
+
+    parent.writeDataHash(storeKey, json, SC.Record.READY_CLEAN);
+    parent.editables = null; // manually patch to setup test state
+    
+    store = parent.chain(); // create nested store
+    child = store.chain();  // test multiple levels deep
+  }
+});
+
+// ..........................................................
+// BASIC STATE TRANSITIONS
+// 
+
+// The transition from each base state performs the same operation, so just
+// run the same test on each state.
+function testRemoveDataHash() {
+  var oldrev = store.revisions[storeKey];
+  
+  // perform test
+  equals(store.removeDataHash(storeKey, SC.Record.DESTROYED_CLEAN), store, 'should return receiver');
+  
+  // verify
+  equals(store.storeKeyEditState(storeKey), SC.Store.LOCKED, 'new edit state should be locked');
+  
+  equals(store.readDataHash(storeKey), null, 'should have NO json data');
+  equals(store.readStatus(storeKey), SC.Record.DESTROYED_CLEAN, 'should have new status');
+
+  equals(store.revisions[storeKey], oldrev, 'should not change revision');
+  if (!SC.none(oldrev)) {
+    ok(store.revisions.hasOwnProperty(storeKey), 'should clone reference to revision');
+  }
+}
+
+
+notest("edit state=INHERITED", function() {
+  
+  // test preconditions
+  equals(store.storeKeyEditState(storeKey), SC.Store.INHERITED, 'precond - edit state should be inherited');
+  
+  testRemoveDataHash();
+});
+
+notest("edit state=LOCKED", function() {
+  
+  // test preconditions
+  store.readDataHash(storeKey);
+  equals(store.storeKeyEditState(storeKey), SC.Store.LOCKED, 'precond - edit state should be locked');
+  
+  testRemoveDataHash();
+
+});
+
+notest("edit state=EDITABLE", function() {
+  
+  // test preconditions
+  store.readEditableDataHash(storeKey);
+  equals(store.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'precond - edit state should be editable');
+  
+  testRemoveDataHash();
+
+});
+
+// ..........................................................
+// REMOVE NON-EXISTING 
+// 
+
+notest("remove a non-existing hash", function() {
+  storeKey = SC.Store.generateStoreKey(); // new store key!
+  equals(parent.readDataHash(storeKey), null, 'precond - parent should not have a data hash for store key yet');
+  equals(store.storeKeyEditState(storeKey), SC.Store.INHERITED, 'precond - edit status should be inherited');
+  
+  // perform write
+  equals(store.removeDataHash(storeKey, SC.Record.DESTROYED_CLEAN), store, 'should return receiver');
+  
+  // verify change
+  equals(store.storeKeyEditState(storeKey), SC.Store.LOCKED, 'new status should be locked');
+  equals(store.readDataHash(storeKey), null, 'should still be null');
+  equals(store.readStatus(storeKey), SC.Record.DESTROYED_CLEAN, 'should have new record status');
+});
+
+// ..........................................................
+// PROPOGATING TO NESTED STORES
+// 
+
+notest("change should propogate to child if child edit state = INHERITED", function() {
+
+  // verify preconditions
+  equals(child.storeKeyEditState(storeKey), SC.Store.INHERITED, 'precond - child edit state should be INHERITED');
+
+  // perform change
+  store.removeDataHash(storeKey, SC.Record.DESTROYED_CLEAN);
+  
+  // verify
+  same(child.readDataHash(storeKey), null, 'child should pick up change');
+  equals(parent.readDataHash(storeKey), json, 'parent should still have old json');
+  
+  equals(child.readStatus(storeKey), SC.Record.DESTROYED_CLEAN, 'child should pick up new status');
+  equals(parent.readStatus(storeKey), SC.Record.READY_CLEAN, 'parent should still have old status');
+
+});
+
+
+function testLockedOrEditableChild() {
+  // perform change
+  store.removeDataHash(storeKey, SC.Record.DESTROYED_CLEAN);
+  
+  // verify
+  same(child.readDataHash(storeKey), json, 'child should NOT pick up change');
+  equals(parent.readDataHash(storeKey), json, 'parent should still have old json');
+  
+  equals(child.readStatus(storeKey), SC.Record.READY_CLEAN, 'child should pick up new status');
+  equals(parent.readStatus(storeKey), SC.Record.READY_CLEAN, 'parent should still have old status');
+}
+
+
+notest("change should not propogate to child if child edit state = LOCKED", function() {
+
+  // verify preconditions
+  child.readDataHash(storeKey);
+  equals(child.storeKeyEditState(storeKey), SC.Store.LOCKED, 'precond - child edit state should be LOCKED');
+
+  testLockedOrEditableChild();
+});
+
+notest("change should not propogate to child if child edit state = EDITABLE", function() {
+
+  // verify preconditions
+  child.readEditableDataHash(storeKey);
+  equals(child.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'precond - child edit state should be EDITABLE');
+
+  testLockedOrEditableChild();
+});
+
+
+
+
+
+
+
+
+