sproutit-sproutcore 1.0.0.20090407205609 → 1.0.0.20090408130025

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

@@ -0,0 +1,166 @@
+// ==========================================================================
+// 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 "write" event in the NestedStore portion of the diagram.
+
+var parent, store, child, storeKey, json;
+module("SC.NestedStore#writeDataHash", {
+  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 testWriteDataHash() {
+  var oldrev = store.revisions[storeKey];
+  
+  // perform test
+  var json2 = { foo: "bar" };
+  equals(store.writeDataHash(storeKey, json2, SC.Record.READY_NEW), store, 'should return receiver');
+  
+  // verify
+  equals(store.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'new edit state should be editable');
+  
+  equals(store.readDataHash(storeKey), json2, 'should have new json data hash');
+  equals(store.readStatus(storeKey), SC.Record.READY_NEW, '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');
+  
+  testWriteDataHash();
+});
+
+notest("edit state=LOCKED", function() {
+  
+  // test preconditions
+  store.readDataHash(storeKey);
+  equals(store.storeKeyEditState(storeKey), SC.Store.LOCKED, 'precond - edit state should be locked');
+  
+  testWriteDataHash();
+
+});
+
+notest("edit state=EDITABLE", function() {
+  
+  // test preconditions
+  store.readEditableDataHash(storeKey);
+  equals(store.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'precond - edit state should be editable');
+  
+  testWriteDataHash();
+
+});
+
+// ..........................................................
+// WRITING NEW VS EXISTING
+// 
+
+notest("writing a new 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.writeDataHash(storeKey, json, SC.Record.READY_NEW), store, 'should return receiver');
+  
+  // verify change
+  equals(store.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'new status should be editable');
+  equals(store.readDataHash(storeKey), json, 'should match new json');
+  equals(store.readStatus(storeKey), SC.Record.READY_NEW, '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
+  var json2 = { version: 2 };
+  store.writeDataHash(storeKey, json2, SC.Record.READY_NEW);
+  
+  // verify
+  same(child.readDataHash(storeKey), json2, 'child should pick up change');
+  equals(parent.readDataHash(storeKey), json, 'parent should still have old json');
+  
+  equals(child.readStatus(storeKey), SC.Record.READY_NEW, 'child should pick up new status');
+  equals(parent.readStatus(storeKey), SC.Record.READY_CLEAN, 'parent should still have old status');
+
+});
+
+
+function testLockedOrEditableChild() {
+  // perform change
+  var json2 = { version: 2 };
+  store.writeDataHash(storeKey, json2, SC.Record.READY_NEW);
+  
+  // 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();
+});
+
+
+
+
+
+
+
+
+

data/frameworks/sproutcore/frameworks/datastore/tests/system/record_array/core_methods.js

@@ -0,0 +1,175 @@
+// ==========================================================================
+// 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 */
+
+// test core array-mapping methods for RecordArray
+var store, storeKey, json, rec, storeKeys, recs;
+module("SC.RecordArray core methods", {
+  setup: function() {
+    // setup dummy store
+    store = SC.Store.create();
+    storeKey = SC.Record.storeKeyFor('foo');
+    json = {  guid: "foo", foo: "bar" };
+    store.writeDataHash(storeKey, json, SC.Record.READY_CLEAN); 
+    
+    
+    // get record
+    rec = store.materializeRecord(storeKey);
+    equals(rec.get('foo'), 'bar', 'record should have json');
+    
+    // get record array.
+    storeKeys = [storeKey];
+    recs = SC.RecordArray.create({ store: store, storeKeys: storeKeys });
+  }
+});
+
+// ..........................................................
+// LENGTH
+// 
+
+test("should pass through length", function() {
+  equals(recs.get('length'), storeKeys.length, 'rec should pass through length');  
+});
+
+test("changing storeKeys length should change length of rec array also", function() {
+
+  var oldlen = recs.get('length');
+  
+  storeKeys.pushObject(SC.Store.generateStoreKey()); // change length
+  
+  ok(storeKeys.length > oldlen, 'precond - storeKeys.length should have changed');
+  equals(recs.get('length'), storeKeys.length, 'rec should pass through length');    
+});
+
+// ..........................................................
+// objectAt
+// 
+
+test("should materialize record for object", function() {
+  equals(storeKeys[0], storeKey, 'precond - storeKeys[0] should be storeKey');
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');
+});
+
+test("reading past end of array length should return undefined", function() {
+  equals(recs.objectAt(2000), undefined, 'recs.objectAt(2000) should be undeinfed');
+});
+
+test("modifying the underlying storeKey should change the returned materialized record", function() {
+  // read record once to make it materialized
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');  
+  
+  // create a new record.
+  var rec2 = store.createRecord(SC.Record, { foo: "rec2" });
+  var storeKey2 = rec2.get('storeKey');
+  
+  // add to beginning of storeKey array
+  storeKeys.unshiftObject(storeKey2);
+  equals(recs.get('length'), 2, 'should now have length of 2');
+  equals(recs.objectAt(0), rec2, 'objectAt(0) should return new record');
+  equals(recs.objectAt(1), rec, 'objectAt(1) should return old record');
+});
+
+test("reading a record not loaded in store should trigger retrieveRecord", function() {
+  var callCount = 0;
+
+  // patch up store to record a call and to make it look like data is not 
+  // loaded.
+  store.removeDataHash(storeKey, SC.Record.EMPTY);
+  store.retrieveRecord = function() { callCount++; };
+  
+  equals(store.readStatus(storeKeys.objectAt(0)), SC.Record.EMPTY, 'precond - storeKey must not be loaded');
+  
+  var rec = recs.objectAt(0);
+  equals(callCount, 1, 'store.retrieveRecord() should have been called');
+});
+
+
+// ..........................................................
+// replace()
+// 
+
+test("adding a record to the record array should pass through storeKeys", function() {
+  // read record once to make it materialized
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');  
+  
+  // create a new record.
+  var rec2 = store.createRecord(SC.Record, { foo: "rec2" });
+  var storeKey2 = rec2.get('storeKey');
+  
+  // add record to beginning of record array
+  recs.unshiftObject(rec2);
+
+  // verify record array
+  equals(recs.get('length'), 2, 'should now have length of 2');
+  equals(recs.objectAt(0), rec2, 'recs.objectAt(0) should return new record');
+  equals(recs.objectAt(1), rec, 'recs.objectAt(1) should return old record');
+  
+  // verify storeKeys
+  equals(storeKeys.objectAt(0), storeKey2, 'storeKeys[0] should return new storeKey');
+  equals(storeKeys.objectAt(1), storeKey, 'storeKeys[1] should return old storeKey');
+});
+
+// ..........................................................
+// Property Observing
+// 
+
+test("changing the underlying storeKeys should notify observers of records", function() {
+
+  // setup observer
+  var obj = SC.Object.create({
+    cnt: 0,
+    observer: function() { this.cnt++; }
+  });
+  recs.addObserver('[]', obj, obj.observer); 
+  
+  // now modify storeKeys
+  storeKeys.pushObject(SC.Store.generateStoreKey());
+  equals(obj.cnt, 1, 'observer should have fired after changing storeKeys');
+});
+
+test("swapping storeKey array should change recordArray and observers", function() {
+
+  // setup alternate storeKeys
+  var rec2 = store.createRecord(SC.Record, { foo: "rec2" });
+  var storeKey2 = rec2.get('storeKey');
+  var storeKeys2 = [storeKey2];
+
+  // setup observer
+  var obj = SC.Object.create({
+    cnt: 0,
+    observer: function() { this.cnt++; }
+  });
+  recs.addObserver('[]', obj, obj.observer); 
+  
+  // read record once to make it materialized
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');  
+
+
+  // now swap storeKeys
+  obj.cnt = 0 ;
+  recs.set('storeKeys', storeKeys2);
+  
+  // verify observer fired and record changed
+  equals(obj.cnt, 1, 'observer should have fired after swap');
+  equals(recs.objectAt(0), rec2, 'recs.objectAt(0) should return new rec');
+  
+  // modify storeKey2, make sure observer fires and content changes
+  obj.cnt = 0;
+  storeKeys2.unshiftObject(storeKey);
+  equals(obj.cnt, 1, 'observer should have fired after edit');
+  equals(recs.get('length'), 2, 'should reflect new length');
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should return pushed rec');  
+
+});
+
+
+
+
+
+
+
+
+

data/frameworks/sproutcore/frameworks/datastore/tests/system/store/cancelRecord.js

@@ -0,0 +1,54 @@
+// ==========================================================================
+// 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 */
+
+var store, storeKey1,storeKey2;
+var json1, json2;
+var storeKey6, storeKey7;
+
+module("SC.Store#cancelRecord", {
+  setup: function() {
+    
+    store = SC.Store.create();
+    
+    json1 = {
+      guid: "cancelGUID1",
+      string: "string",
+      number: 23,
+      bool:   YES
+    };
+    json2 = {
+      guid: "cancelGUID2",
+      string: "string",
+      number: 23,
+      bool:   YES
+    };
+    
+    storeKey1 = SC.Store.generateStoreKey();
+    store.writeDataHash(storeKey1, json1, SC.Record.EMPTY);
+    storeKey2 = SC.Store.generateStoreKey();
+    store.writeDataHash(storeKey2, json2, SC.Record.READY_NEW);
+    }
+});
+
+test("Check for error state handling and make sure that the method executes.", function() {
+  var throwError=false;
+  try{
+    store.cancelRecord(undefined, undefined, storeKey1);
+    throwError=false;
+  }catch (error){
+    throwError=true;
+  }
+  ok(throwError, "cancelRecord should throw and error if the record status is EMPTY or ERROR");
+  try{
+    store.cancelRecord(undefined, undefined, storeKey2);
+    throwError=true;    
+  }catch (error){
+    throwError=false;
+  }
+  ok(throwError, " cancelRecord was succesfully executed.");
+  
+});

data/frameworks/sproutcore/frameworks/datastore/tests/system/store/commitChangesFromNestedStore.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 */
+
+var store, child, storeKey, json;
+module("SC.Store#commitChangesFromNestedStore", {
+  setup: function() {
+    store = SC.Store.create();
+    
+    json = {
+      string: "string",
+      number: 23,
+      bool:   YES
+    };
+    
+    storeKey = SC.Store.generateStoreKey();
+
+    child = store.chain();  // test multiple levels deep
+
+    // wirte basic status
+    child.writeDataHash(storeKey, json, SC.Record.READY_DIRTY);
+    child.dataHashDidChange(storeKey);
+    child.changelog = SC.Set.create();
+    child.changelog.add(storeKey);
+  }
+});
+
+test("copies changed data hashes, statuses, and revisions", function() {
+  
+  // 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');
+  
+  // verify new status
+  equals(store.readDataHash(storeKey), json, 'now should have json');
+  equals(store.readStatus(storeKey), SC.Record.READY_DIRTY, 'now should have status');
+  equals(store.revisions[storeKey], child.revisions[storeKey], 'now shoulave have revision from child');  
+    
+});
+
+test("adds items in changelog to reciever changelog", function() {
+
+  var key1 = SC.Store.generateStoreKey();
+
+  store.changelog = SC.Set.create();
+  store.changelog.add(key1);
+  
+  ok(child.changelog.contains(storeKey), 'precond - child.changelog should contain store key');
+  
+  equals(store.commitChangesFromNestedStore(child, child.chainedChanges, NO), store, 'should return receiver');
+
+  // changelog should merge nested store & existing
+  ok(store.changelog.contains(key1), 'changelog should still contain key1');
+  ok(store.changelog.contains(storeKey), 'changelog should also contain storeKey');
+});
+
+test("ignores changed data hashes not passed in changes set", function() {
+  
+  // preconditions
+  equals(store.readDataHash(storeKey), null, 'precond - should not have data yet');
+
+  // perform action
+  equals(store.commitChangesFromNestedStore(child, SC.Set.create(), NO), store, 'should return receiver');
+
+  // verify results
+  equals(store.readDataHash(storeKey), null, 'should not copy data hash for storeKey');
+  
+});
+
+function createConflict(force) {
+  var json2 = { kind: "json2" };
+  var json3 = { kind: "json3" };
+  
+  // create a lock conflict.  use a new storeKey since the old one has been
+  // setup in a way that won't work for this.
+  storeKey = SC.Store.generateStoreKey();
+  
+  // step 1: add data to root store
+  store.writeDataHash(storeKey, json, SC.Record.READY_CLEAN);
+  store.dataHashDidChange(storeKey);
+  
+  // step 2: read data in chained store.  this will create lock
+  child.readDataHash(storeKey);
+  ok(child.locks[storeKey], 'child store should now have lock');
+  
+  // step 3: modify root store again
+  store.writeDataHash(storeKey, json2, SC.Record.READY_CLEAN);
+  store.dataHashDidChange(storeKey);
+
+  // step 4: modify data in chained store so we have something to commit.
+  child.writeDataHash(storeKey, json3, SC.Record.READY_DIRTY);
+  child.dataHashDidChange(storeKey);
+  
+  // just to make sure verify that the lock and revision in parent do not 
+  // match
+  ok(child.locks[storeKey] !== store.revisions[storeKey], 'child.lock (%@) should !== store.revision (%@)'.fmt(child.locks[storeKey], store.revisions[storeKey]));
+  
+  // step 5: now try to commit changes from child store.  This should throw
+  // an exception.
+  var errorCount = 0;
+  try {
+    child.commitChanges(force);
+  } catch(e) {
+    equals(e, SC.Store.CHAIN_CONFLICT_ERROR, 'should throw CHAIN_CONFLICT_ERROR');
+    errorCount++;
+  }  
+  
+  return errorCount ;
+}
+
+test("throws exception if any record fails optimistic locking test", function() {
+  var errorCount = createConflict(NO);
+  equals(errorCount, 1, 'should have raised error');
+});
+
+test("does not throw exception if optimistic locking fails but force option is passed", function() {
+  var errorCount = createConflict(YES);
+  equals(errorCount, 0, 'should not raise error');
+});
+

data/frameworks/sproutcore/frameworks/datastore/tests/system/store/commitRecord.js

@@ -0,0 +1,127 @@
+// ==========================================================================
+// 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 */
+
+var store, storeKey1, storeKey2, storeKey3, storeKey4, storeKey5, storeKey6;
+var storeKey7, json, json1, json2, json3, json4, json5, json6, json7;
+
+module("SC.Store#commitRecord", {
+  setup: function() {
+    
+    store = SC.Store.create();
+    
+    json1 = {
+      guid: "commitGUID1",
+      string: "string",
+      number: 23,
+      bool:   YES
+    };
+    json2 = {
+      guid: "commitGUID2",
+      string: "string",
+      number: 23,
+      bool:   YES
+    };
+    json3 = {
+      guid: "commitGUID3",
+      string: "string",
+      number: 23,
+      bool:   YES
+    };
+    json4 = {
+      guid: "commitGUID4",
+      string: "string",
+      number: 23,
+      bool:   YES
+    };
+    json5 = {
+      guid: "commitGUID5",
+      string: "string",
+      number: 23,
+      bool:   YES
+    };
+    json6 = {
+      guid: "commitGUID6",
+      string: "string",
+      number: 23,
+      bool:   YES
+    };
+    json7 = {
+      guid: "commitGUID7",
+      string: "string",
+      number: 23,
+      bool:   YES
+    };
+    
+    storeKey1 = SC.Store.generateStoreKey();
+    store.writeDataHash(storeKey1, json1, SC.Record.READY_CLEAN);
+    storeKey2 = SC.Store.generateStoreKey();
+    store.writeDataHash(storeKey2, json2, SC.Record.READY_NEW);
+    storeKey3 = SC.Store.generateStoreKey();
+    store.writeDataHash(storeKey3, json3, SC.Record.READY_DIRTY);
+    storeKey4 = SC.Store.generateStoreKey();
+    store.writeDataHash(storeKey4, json4, SC.Record.DESTROYED_DIRTY);
+    storeKey5 = SC.Store.generateStoreKey();
+    store.writeDataHash(storeKey5, json5, SC.Record.READY_EMPTY);
+    storeKey6 = SC.Store.generateStoreKey();
+    store.writeDataHash(storeKey6, json6, SC.Record.READY_ERROR);
+    storeKey7 = SC.Store.generateStoreKey();
+    store.writeDataHash(storeKey7, json7, SC.Record.READY_DESTROYED_CLEAN);
+  }
+});
+
+test("Confirm that all the states are switched as expected after running commitRecord", function() {
+  var throwError=false, msg;
+  
+  store.commitRecord(undefined, undefined, storeKey1);
+  status = store.readStatus( storeKey1);
+  equals(status, SC.Record.READY_CLEAN, "the status shouldn't have changed. It should be READY_CLEAN ");
+  
+  store.commitRecord(undefined, undefined, storeKey2);
+  status = store.readStatus( storeKey2);
+  equals(status, SC.Record.BUSY_CREATING, "the status should be SC.Record.BUSY_CREATING");
+
+  store.commitRecord(undefined, undefined, storeKey3);
+  status = store.readStatus( storeKey3);
+  equals(status, SC.Record.BUSY_COMMITTING, "the status should be SC.Record.BUSY_COMMITTING");
+  
+  store.commitRecord(undefined, undefined, storeKey4);
+  status = store.readStatus( storeKey4);
+  equals(status, SC.Record.BUSY_DESTROYING, "the status should be SC.Record.BUSY_DESTROYING");
+   
+   
+  
+  try{
+    store.commitRecord(undefined, undefined, storeKey5);
+    throwError=false;
+    msg='';
+  }catch(error1){
+    throwError=true;
+    msg=error1.message;
+  }
+  equals(msg, SC.Record.NOT_FOUND_ERROR.message, "commitRecord should throw the following error");
+  
+  try{
+    store.commitRecord(undefined, undefined, storeKey6);
+    throwError=false;
+    msg='';
+  }catch(error2){
+    throwError=true;
+    msg=error2.message;
+  }
+  equals(msg, SC.Record.NOT_FOUND_ERROR.message, "commitRecord should throw the following error");
+  
+  try{
+    store.commitRecord(undefined, undefined, storeKey7);
+    throwError=false;
+    msg='';
+  }catch(error3){
+    throwError=true;
+    msg=error3.message;
+  }
+  equals(msg, SC.Record.NOT_FOUND_ERROR.message, "commitRecord should throw the following error");
+  
+});