sproutit-sproutcore 1.0.0.20090407205609 → 1.0.0.20090408130025

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

@@ -0,0 +1,46 @@
+// ==========================================================================
+// 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 MyFoo = null ;
+module("SC.Record#unknownProperty", {
+  setup: function() {
+    MyApp = SC.Object.create({
+      store: SC.Store.create()
+    })  ;
+  
+    MyApp.Foo = SC.Record.extend();
+    MyApp.json = { 
+      foo: "bar", 
+      number: 123,
+      bool: YES,
+      array: [1,2,3] 
+    };
+    
+    MyApp.foo = MyApp.store.createRecord(MyApp.Foo, MyApp.json);
+  }
+});
+
+test("get() returns attributes with no type changes if they exist", function() {
+  'foo number bool array'.w().forEach(function(key) {
+    equals(MyApp.foo.get(key), MyApp.json[key], "MyApp.foo.get(%@) should === attribute".fmt(key));
+  });
+});
+
+test("get() unknown attribute returns undefined", function() {
+  equals(MyApp.foo.get('imaginary'), undefined, 'imaginary property should be undefined');
+});
+
+test("set() unknown property should add to dataHash", function() {
+  MyApp.foo.set('blue', '0x00f');
+  equals(MyApp.store.dataHashes[MyApp.foo.storeKey].blue, '0x00f', 'should add blue attribute');
+});
+
+test("set() should replace existing property", function() {
+  MyApp.foo.set('foo', 'baz');
+  equals(MyApp.store.dataHashes[MyApp.foo.storeKey].foo, 'baz', 'should update foo attribute');
+});
+

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

@@ -0,0 +1,71 @@
+// ==========================================================================
+// 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, Foo, json, foo ;
+module("SC.Record#writeAttribute", {
+  setup: function() {
+    store = SC.Store.create();
+    Foo = SC.Record.extend();
+    json = { 
+      foo: "bar", 
+      number: 123,
+      bool: YES,
+      array: [1,2,3] 
+    };
+    
+    foo = store.createRecord(Foo, json);
+    store.writeStatus(foo.storeKey, SC.Record.READY_CLEAN); 
+  }
+});
+
+test("returns receiver", function() {
+  equals(foo.writeAttribute("bar", "baz"), foo, 'should return receiver');
+});
+
+test("first time writing should mark record as dirty", function() {
+  // precondition
+  equals(foo.get('status'), SC.Record.READY_CLEAN, 'precond - start clean');
+
+  // action
+  foo.writeAttribute("bar", "baz");
+
+  // evaluate
+  equals(foo.get('status'), SC.Record.READY_DIRTY, 'should make READY_DIRTY after write');
+});
+
+test("state change should be deferred if writing inside of a beginEditing()/endEditing() pair", function() {
+
+  // precondition
+  equals(foo.get('status'), SC.Record.READY_CLEAN, 'precond - start clean');
+
+  // action
+  foo.beginEditing();
+  foo.writeAttribute("bar", "baz");
+
+  equals(foo.get('status'), SC.Record.READY_CLEAN, 'should not change state yet');
+
+  foo.endEditing();
+
+  // evaluate
+  equals(foo.get('status'), SC.Record.READY_DIRTY, 'should make READY_DIRTY after write');
+  
+}) ;
+
+test("raises exception if you try to write an attribute before an attribute hash has been set", function() {
+  store.removeDataHash(foo.storeKey);
+  equals(store.readDataHash(foo.storeKey), null, 'precond - should not have store key');
+  
+  var e, cnt=0 ;
+  try {
+    foo.writeAttribute("foo", "bar");
+  } catch(e) {
+    equals(e, SC.Record.BAD_STATE_ERROR, 'should throw BAD_STATE_ERROR');
+    cnt++;
+  }
+  equals(cnt, 1, 'should raise exception');
+});
+

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

@@ -0,0 +1,115 @@
+// ==========================================================================
+// 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 storeKeys, rec;
+module("SC.RecordArray core methods", {
+  setup: function() {
+
+    MyApp = SC.Object.create({
+      store: SC.Store.create()
+    });
+    
+    MyApp.Foo = SC.Record.extend({
+      
+      // test simple reading of a pass-through prop
+      firstName: SC.Record.attr(String),
+
+      // test mapping to another internal key
+      otherName: SC.Record.attr(String, { key: "firstName" }),
+      
+      // test mapping Date
+      date: SC.Record.attr(Date),
+      
+      // used to test default value
+      defaultValue: SC.Record.attr(String, {
+        defaultValue: "default"
+      }),
+      
+      // test toOne relationships
+      foo: SC.Record.attr('MyApp.Foo')
+      
+    });
+    
+    storeKeys = MyApp.store.loadRecords(MyApp.Foo, [
+      { guid: 1, 
+        firstName: "John", lastName: "Doe", 
+        date: "2009-03-01T20:30-08:00" 
+      },
+      
+      { guid: 2, firstName: "Jane", lastName: "Doe", foo: 1 }
+    ]);
+    
+    rec = MyApp.store.find(MyApp.Foo, 1);
+    equals(rec.storeKey, storeKeys[0], 'should find record');
+  }
+});
+
+// ..........................................................
+// READING
+// 
+
+test("pass-through should return builtin value" ,function() {
+  equals(rec.get('firstName'), 'John', 'reading prop should get attr value');
+});
+
+test("returns default value if underyling value is empty", function() {
+  equals(rec.get('defaultValue'), 'default', 'reading prop should return default value');
+});
+
+test("naming a key should read alternate attribute", function() {
+  equals(rec.get('otherName'), 'John', 'reading prop otherName should get attr from firstName');
+});
+
+test("getting toOne relationship should map guid to a real record", function() {
+  var rec2 = MyApp.store.find(MyApp.Foo, 2);
+  equals(rec2.get('id'), 2, 'precond - should find record 2');
+  equals(rec2.get('foo'), rec, 'should get rec1 instance for rec2.foo');
+});
+
+test("reading date should parse ISO date", function() {
+  var d = new Date(1235968200000); // should be proper date
+  equals(rec.get('date').toString(), d.toString(), 'should have matched date');
+});
+
+// ..........................................................
+// WRITING
+// 
+
+test("writing pass-through should simply set value", function() {
+  rec.set("firstName", "Foo");
+  equals(rec.readAttribute("firstName"), "Foo", "should write string");
+
+  rec.set("firstName", 23);
+  equals(rec.readAttribute("firstName"), 23, "should write number");
+
+  rec.set("firstName", YES);
+  equals(rec.readAttribute("firstName"), YES, "should write bool");
+  
+});
+
+test("writing a value should override default value", function() {
+
+  equals(rec.get('defaultValue'), 'default', 'precond - returns default');
+  rec.set('defaultValue', 'not-default');
+  equals(rec.get('defaultValue'), 'not-default', 'newly written value should replace default value');
+});
+
+test("writing to a to-one relationship should update set guid", function() {
+  var rec2 = MyApp.store.find(MyApp.Foo, 2);
+  equals(rec2.get('id'), 2, 'precond - should find record 2');
+  equals(rec2.get('foo'), rec, 'precond - should get rec1 instance for rec2.foo');
+  
+  rec2.set('foo', rec2);
+  equals(rec2.readAttribute('foo'), 2, 'should write ID for set record to foo attribute');
+});
+
+test("writing a date should generate an ISO date" ,function() {
+  var date = new Date(1238650083966);
+  equals(rec.set('date', date), rec, 'returns reciever');
+  equals(rec.readAttribute('date'), '2009-04-01T22:28:03-07:00', 'should have new time (%@)'.fmt(date.toString()));
+});

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

@@ -0,0 +1,40 @@
+// ==========================================================================
+// 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 */
+
+// This file tests the initial state of the store when it is first created
+// either independently or as a chained store.
+
+// ..........................................................
+// SC.Store#chain - init
+// 
+module("SC.Store#chain - init");
+
+notest("initial setup for chained store", function() {
+  var parent = SC.Store.create();
+  var store  = parent.chain();
+  
+  ok(store !== parent, 'chain should return new child store');
+  
+  equals(store.get('parentStore'), parent, 'should have parentStore');
+  
+  equals(SC.typeOf(store.dataHashes), SC.T_HASH, 'should have dataHashes');
+  parent.dataHashes.foo = 'bar';
+  equals(store.dataHashes.foo, 'bar', 'dataHashes should inherit from parent');
+    
+  equals(SC.typeOf(store.revisions), SC.T_HASH, 'should have revisions');
+  parent.revisions.foo = 'bar';
+  equals(store.revisions.foo, 'bar', 'revisions should inherit from parent');
+
+  equals(SC.typeOf(store.statuses), SC.T_HASH, 'should have statuses');
+  parent.statuses.foo = 'bar';
+  equals(store.statuses.foo, 'bar', 'statuses should inherit from parent');
+  
+  ok(!store.locks, 'should not have locks');
+  ok(!store.chainedChanges, 'should not have chainedChanges');
+  ok(!store.editables, 'should not have editables');
+}); 
+

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

@@ -0,0 +1,116 @@
+// ==========================================================================
+// 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 "commit" event in the NestedStore portion of the diagram.
+
+var parent, store, child, storeKey, json, args;
+module("SC.NestedStore#commitChanges", {
+  setup: function() {
+    parent = SC.Store.create();
+    
+    json = {
+      string: "string",
+      number: 23,
+      bool:   YES
+    };
+    args = null;
+    
+    storeKey = SC.Store.generateStoreKey();
+
+    store = parent.chain(); // create nested store
+    child = store.chain();  // test multiple levels deep
+    
+    // override commitChangesFromNestedStore() so we can ensure it is called
+    // save call history for later evaluation
+    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(shouldIncludeStoreKey) {
+
+  // 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');
+  equals(args[0].target, parent, 'should have called on parent store');
+  
+  // verify if changes passed to callback included storeKey
+  var changes = args[0].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');
+  ok(!store.chainedChanges || store.chainedChanges.length===0, 'should have empty chainedChanges set');
+}
+
+notest("state = INHERITED", function() {
+  
+  // write in some data to parent
+  parent.writeDataHash(storeKey, json);
+  
+  // check preconditions
+  equals(store.storeKeyEditState(storeKey), SC.Store.INHERITED, 'precond - data edit state');
+
+  testStateTransition(NO);
+});
+
+
+notest("state = LOCKED", function() {
+  
+  // write in some data to parent
+  parent.writeDataHash(storeKey, json);
+  parent.editables = null ; // manually force to lock state
+  store.readDataHash(storeKey);
+  
+  // check preconditions
+  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);
+});
+
+notest("state = EDITABLE", function() {
+  
+  // write in some data to parent
+  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(YES);
+});
+
+
+// ..........................................................
+// SPECIAL CASES
+// 
+
+// TODO: Add more special cases for SC.NestedStore#commitChanges

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

@@ -0,0 +1,135 @@
+// ==========================================================================
+// 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 parent, store, child, storeKey, json;
+module("SC.NestedStore#commitChangesFromNestedStore", {
+  setup: function() {
+    parent = SC.Store.create();
+    
+    json = {
+      string: "string",
+      number: 23,
+      bool:   YES
+    };
+    
+    storeKey = SC.Store.generateStoreKey();
+
+    store = parent.chain();
+    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);
+  }
+});
+
+notest("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');  
+    
+});
+
+notest("adds lock on any items not already locked", function() {
+
+  var storeKey2 = SC.Store.generateStoreKey();
+  var json2 = { kind: "json2" };
+  
+  // verify preconditions
+  store.readDataHash(storeKey);
+  ok(store.locks[storeKey], 'precond - storeKey should have lock');
+  ok(!store.locks[storeKey2], 'precond - storeKey2 should not have lock');
+  
+  // write another record into child store to commit changes.
+  child.writeDataHash(storeKey2, json2, SC.Record.READY_DIRTY);
+  child.dataHashDidChange(storeKey2);
+  
+  var changes = child.chainedChanges ;
+  ok(changes.contains(storeKey), 'precond - child.chainedChanges should contain storeKey');
+  ok(changes.contains(storeKey2), 'precond - child.chainedChanges should contain storeKey2');
+  
+  // now commit back to parent
+  equals(store.commitChangesFromNestedStore(child, changes, NO), store, 'should return reciever');
+  
+  // and verify that both have locks
+  ok(store.locks[storeKey], 'storeKey should have lock after commit (actual: %@)'.fmt(store.locks[storeKey]));
+  ok(store.locks[storeKey2], 'storeKey2 should have lock after commit (actual: %@)'.fmt(store.locks[storeKey2]));
+  
+});
+
+notest("adds items in chainedChanges to reciever chainedChanges", function() {
+
+  var key1 = SC.Store.generateStoreKey();
+
+  store.dataHashDidChange(key1);
+  
+  ok(child.chainedChanges.contains(storeKey), 'precond - child.chainedChanges should contain store key');
+  
+  equals(store.commitChangesFromNestedStore(child, child.chainedChanges, NO), store, 'should return receiver');
+
+  // changelog should merge nested store & existing
+  ok(store.chainedChanges.contains(key1), 'chainedChanges should still contain key1');
+  ok(store.chainedChanges.contains(storeKey), 'chainedChanges should also contain storeKey');
+});
+
+notest("should set hasChanges to YES if has changes", function() {
+  
+  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');
+  
+  store.commitChangesFromNestedStore(child, changes, NO);
+  equals(store.get('hasChanges'), YES, 'store should now have changes');
+});
+
+notest("should set hasChanges to NO if no changes", function() {
+  
+  child = store.chain() ; // get a new child store
+  
+  var changes = child.chainedChanges || SC.Set.create();
+  ok(!changes || !changes.length, 'precond - should have not have changes in child');
+  equals(store.get('hasChanges'), NO, 'precond - store should not have changes');
+  
+  store.commitChangesFromNestedStore(child, changes, NO);
+  equals(store.get('hasChanges'), NO, 'store should NOT now have changes');
+});
+
+// ..........................................................
+// SPECIAL CASES
+// 
+
+notest("committing changes should chain back each step", function() {
+
+  // preconditions
+  equals(child.readDataHash(storeKey), json, 'precond - child should have data');
+  equals(store.readDataHash(storeKey), null, 'precond - store should not have data');
+  equals(parent.readDataHash(storeKey), null, 'precond - parent should not have data');
+  
+  // 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');
+});
+
+
+
+

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

@@ -0,0 +1,110 @@
+// ==========================================================================
+// 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 "did_change" event in the NestedStore portion of the diagram.
+
+var parent, store, child, storeKey, json;
+module("SC.NestedStore#dataHashDidChange", {
+  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
+// 
+
+
+function testStateTransition(fromState, toState) {
+
+  // verify preconditions
+  equals(store.get('hasChanges'), NO, 'should not have changes');
+  equals(store.storeKeyEditState(storeKey), fromState, 'precond - storeKey edit state');
+  if (store.chainedChanges) {
+    ok(!store.chainedChanges.contains(storeKey), 'changedChanges should NOT include storeKey');
+  }
+
+  var oldrev = store.revisions[storeKey];
+  
+  // perform action
+  equals(store.dataHashDidChange(storeKey), store, 'should return receiver');
+
+  // verify results
+  equals(store.storeKeyEditState(storeKey), toState, 'store key edit state is in same state');
+
+  // verify revision
+  ok(oldrev !== store.revisions[storeKey], 'revisions should change. was: %@ - now: %@'.fmt(oldrev, store.revisions[storeKey]));
+  ok(store.chainedChanges.contains(storeKey), 'changedChanges should now include storeKey');
+  
+  equals(store.get('hasChanges'), YES, 'should have changes');
+} 
+
+notest("edit state = INHERITED, parent editable = NO", function() {
+
+  // verify preconditions
+  equals(parent.storeKeyEditState(storeKey), SC.Store.LOCKED, 'precond - parent store edit state is not EDITABLE');
+  
+  testStateTransition(SC.Store.INHERITED, SC.Store.LOCKED);
+}) ;
+
+notest("edit state = INHERITED, parent editable = YES", function() {
+
+  // verify preconditions
+  parent.readEditableDataHash(storeKey);
+  equals(parent.storeKeyEditState(storeKey), SC.Store.EDITABLE, 'precond - parent store edit state is EDITABLE');
+
+  testStateTransition(SC.Store.INHERITED, SC.Store.EDITABLE);
+}) ;
+
+notest("edit state = LOCKED", function() {
+  store.readDataHash(storeKey); // lock
+  testStateTransition(SC.Store.LOCKED, SC.Store.LOCKED);
+}) ;
+
+notest("edit state = EDITABLE", function() {
+  store.readEditableDataHash(storeKey); // make editable
+  testStateTransition(SC.Store.EDITABLE, SC.Store.EDITABLE);
+}) ;
+
+// ..........................................................
+// SPECIAL CASES
+// 
+
+notest("calling with array of storeKeys will edit all store keys", function() {
+  
+  var storeKeys = [storeKey, SC.Store.generateStoreKey()], idx ;
+  store.dataHashDidChange(storeKeys, 2000) ;
+  for(idx=0;idx<storeKeys.length;idx++) {
+    equals(store.revisions[storeKeys[idx]], 2000, 'storeKey at index %@ should have new revision'.fmt(idx));
+    ok(store.chainedChanges.contains(storeKeys[idx]), 'chainedChanges should include storeKey at index %@'.fmt(idx));
+  }
+});
+
+notest("marking change should update revision but leave lock alone", function() {
+  parent.dataHashDidChange(storeKey); // make sure parent has a revision
+  store.readDataHash(storeKey); // cause a lock
+  store.dataHashDidChange(storeKey); // update revision
+  
+  equals(store.locks[storeKey], parent.revisions[storeKey], 'lock should have parent revision');
+  ok(store.revisions[storeKey] !== parent.revisions[storeKey], 'revision should not match parent rev');  
+});
+