sproutcore 1.0.1003 → 1.0.1008

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

@@ -27,6 +27,14 @@ sc_require('models/record');
   @since SproutCore 1.0
 */
 SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
+  
+  /**
+    An (optional) name of the store, which can be useful during debugging,
+    especially if you have multiple nested stores.
+    
+    @property {String}
+  */
+  name: null,
 
   /**
     An array of all the chained stores that current rely on the receiver 
@@ -123,13 +131,23 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     }}}
     
     @param {Hash} attrs optional attributes to set on new store
+    @param {Class} newStoreClass optional the class of the newly-created nested store (defaults to SC.NestedStore)
     @returns {SC.NestedStore} new nested store chained to receiver
   */
-  chain: function(attrs) {
+  chain: function(attrs, newStoreClass) {
     if (!attrs) attrs = {};
     attrs.parentStore = this;
     
-    var ret    = SC.NestedStore.create(attrs),
+    if (newStoreClass) {
+      // Ensure the passed-in class is a type of nested store.
+      if (SC.typeOf(newStoreClass) !== 'class') throw new Error("%@ is not a valid class".fmt(newStoreClass));
+      if (!SC.kindOf(newStoreClass, SC.NestedStore)) throw new Error("%@ is not a type of SC.NestedStore".fmt(newStoreClass));
+    }
+    else {
+      newStoreClass = SC.NestedStore;
+    }
+    
+    var ret    = newStoreClass.create(attrs),
         nested = this.nestedStores;
         
     if (!nested) nested = this.nestedStores = [];
@@ -234,6 +252,28 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   */
   recordArraysWithQuery: null,
   
+  /**
+    An array of SC.Error objects associated with individual records in the
+    store (indexed by store keys).
+    
+    Errors passed form the data source in the call to dataSourceDidError() are
+    stored here.
+    
+    @property {Array}
+  */
+  recordErrors: null,
+  
+  /**
+    A hash of SC.Error objects associated with queries (indexed by the GUID
+    of the query).
+    
+    Errors passed from the data source in the call to dataSourceDidErrorQuery()
+    are stored here.
+    
+    @property {Hash}
+  */
+  queryErrors: null,
+  
   // ..........................................................
   // CORE ATTRIBUTE API
   // 
@@ -482,7 +522,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       // when store needs to propagate out changes in the parent store
       // to nested stores
       if (editState === K.INHERITED) {
-        store._notifyRecordPropertyChange(storeKey, statusOnly);
+        store._notifyRecordPropertyChange(storeKey, statusOnly, key);
 
       } else if (status & SC.Record.BUSY) {
         // make sure nested store does not have any changes before resetting
@@ -495,9 +535,9 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     var changes = this.recordPropertyChanges;
     if (!changes) {
       changes = this.recordPropertyChanges = 
-        { storeKeys:  SC.CoreSet.create(), 
-          records:    SC.CoreSet.create(), 
-          statusOnly: SC.CoreSet.create(),
+        { storeKeys:      SC.CoreSet.create(),
+          records:        SC.CoreSet.create(),
+          hasDataChanges: SC.CoreSet.create(),
           propertyForStoreKeys: {} };
     }
     
@@ -505,15 +545,32 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     if (records && (rec=records[storeKey])) {
       changes.records.push(storeKey);
-      if(statusOnly) changes.statusOnly.push(storeKey);
       
-      // if this is a key specific change, make sure that only those
-      // properties/keys are notified
+      // If there are changes other than just the status we need to record
+      // that information so we do the right thing during the next flush.
+      // Note that if we're called multiple times before flush and one call
+      // has statusOnly=true and another has statusOnly=false, the flush will
+      // (correctly) operate in statusOnly=false mode.
+      if (!statusOnly) changes.hasDataChanges.push(storeKey);
+      
+      // If this is a key specific change, make sure that only those
+      // properties/keys are notified.  However, if a previous invocation of
+      // _notifyRecordPropertyChange specified that all keys have changed, we
+      // need to respect that.
       if (key) {
         if (!(keys = changes.propertyForStoreKeys[storeKey])) {
           keys = changes.propertyForStoreKeys[storeKey] = SC.CoreSet.create();
         }
-        keys.add(key);
+        
+        // If it's '*' instead of a set, then that means there was a previous
+        // invocation that said all keys have changed.
+        if (keys !== '*') {
+          keys.add(key);
+        }
+      }
+      else {
+        // Mark that all properties have changed.
+        changes.propertyForStoreKeys[storeKey] = '*';
       }
     }
     
@@ -532,25 +589,28 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   flush: function() {
     if (!this.recordPropertyChanges) return this;
     
-    var changes     = this.recordPropertyChanges,
-        storeKeys   = changes.storeKeys, 
-        statusOnly  = changes.statusOnly,
-        records     = changes.records, 
-        propertyForStoreKeys  = changes.propertyForStoreKeys,
+    var changes              = this.recordPropertyChanges,
+        storeKeys            = changes.storeKeys,
+        hasDataChanges       = changes.hasDataChanges,
+        records              = changes.records,
+        propertyForStoreKeys = changes.propertyForStoreKeys,
         recordTypes = SC.CoreSet.create(),
-        rec, recordType, status, idx, len, storeKey, keys;
+        rec, recordType, statusOnly, idx, len, storeKey, keys;
     
     storeKeys.forEach(function(storeKey) {
-
       if (records.contains(storeKey)) {
-        status = statusOnly.contains(storeKey) ? YES: NO;
+        statusOnly = hasDataChanges.contains(storeKey) ? NO : YES;
         rec = this.records[storeKey];
         keys = propertyForStoreKeys ? propertyForStoreKeys[storeKey] : null;
         
+        // Are we invalidating all keys?  If so, don't pass any to
+        // storeDidChangeProperties.
+        if (keys === '*') keys = null;
+        
         // remove it so we don't trigger this twice
         records.remove(storeKey);
         
-        if (rec) rec.storeDidChangeProperties(status, keys);
+        if (rec) rec.storeDidChangeProperties(statusOnly, keys);
       }
       
       recordType = SC.Store.recordTypeFor(storeKey);
@@ -561,9 +621,10 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     this._notifyRecordArrays(storeKeys, recordTypes);
 
     storeKeys.clear();
-    statusOnly.clear();
+    hasDataChanges.clear();
     records.clear();
-    propertyForStoreKeys.length = 0; // reset
+    // Provide full reference to overwrite
+    this.recordPropertyChanges.propertyForStoreKeys = {};
     
     return this;
   },
@@ -582,9 +643,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     this.revisions  = {} ;
     this.statuses   = {} ;
 
-    // also reset temporary objects
+    // also reset temporary objects and errors
     this.chainedChanges = this.locks = this.editables = null;
     this.changelog = null ;
+    this.recordErrors = null;
+    this.queryErrors = null;
 
     var records = this.records, storeKey;
     if (records) {
@@ -758,14 +821,15 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @returns {SC.Record} record instance or null
   */
   find: function(recordType, id) {
+    
     // if recordType is passed as string, find object
     if (SC.typeOf(recordType)===SC.T_STRING) {
       recordType = SC.objectForPropertyPath(recordType);
     }
     
     // handle passing a query...
-    if ((arguments.length === 1) && !(recordType && recordType.isRecord)) {
-      if (!recordType) throw "SC.Store#find() must pass recordType or query";
+    if ((arguments.length === 1) && !(recordType && recordType.get && recordType.get('isRecord'))) {
+      if (!recordType) throw new Error("SC.Store#find() must pass recordType or query");
       if (!recordType.isQuery) {
         recordType = SC.Query.local(recordType);
       }
@@ -882,7 +946,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     @returns {SC.Store} receiver
   */
   refreshQuery: function(query) {
-    if (!query) throw "refreshQuery() requires a query";
+    if (!query) throw new Error("refreshQuery() requires a query");
 
     var cache    = this._scst_recordArraysByQuery,
         recArray = cache ? cache[SC.guidFor(query)] : null, 
@@ -1676,6 +1740,30 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     // return storeKeys
     return ret ;
   },
+
+  /**
+    Returns the SC.Error object associated with a specific record.
+
+    @param {Number} storeKey The store key of the record.
+ 
+    @returns {SC.Error} SC.Error or undefined if no error associated with the record.
+  */
+  readError: function(storeKey) {
+    var errors = this.recordErrors ;
+    return errors ? errors[storeKey] : undefined ;
+  },
+
+  /**
+    Returns the SC.Error object associated with a specific query.
+
+    @param {SC.Query} query The SC.Query with which the error is associated.
+ 
+    @returns {SC.Error} SC.Error or undefined if no error associated with the query.
+  */
+  readQueryError: function(query) {
+    var errors = this.queryErrors ;
+    return errors ? errors[SC.guidFor(query)] : undefined ;
+  },
   
   // ..........................................................
   // DATA SOURCE CALLBACKS
@@ -1797,11 +1885,12 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   /**
     Converts the passed record into an error object.
     
-    @param {Number} storeKey record store key to cancel
+    @param {Number} storeKey record store key to error
+    @param {SC.Error} error [optional] an SC.Error instance to associate with storeKey
     @returns {SC.Store} reciever
   */
   dataSourceDidError: function(storeKey, error) {
-    var status = this.readStatus(storeKey), K = SC.Record;
+    var status = this.readStatus(storeKey), errors = this.recordErrors, K = SC.Record;
 
     // EMPTY, ERROR, READY_CLEAN, READY_NEW, READY_DIRTY, DESTROYED_CLEAN,
     // DESTROYED_DIRTY
@@ -1810,6 +1899,12 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     // otherwise, determine proper state transition
     else status = K.ERROR ;
 
+    // Add the error to the array of record errors (for lookup later on if necessary).
+    if (error && error.isError) {
+      if (!errors) errors = this.recordErrors = [];
+      errors[storeKey] = error;
+    }
+
     this.writeStatus(storeKey, status) ;
     this.dataHashDidChange(storeKey, null, YES);
 
@@ -1881,17 +1976,25 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     
     @param {Class} recordType the SC.Record subclass
     @param {Object} id the record id or null
-    @param {Number} storeKey optional store key.  
+    @param {SC.Error} error [optional] an SC.Error instance to associate with id or storeKey
+    @param {Number} storeKey optional store key.
     @returns {Boolean} YES if push was allowed
   */
   pushError: function(recordType, id, error, storeKey) {
-    var K = SC.Record, status;
+    var K = SC.Record, status, errors = this.recordErrors;
 
     if(storeKey===undefined) storeKey = recordType.storeKeyFor(id);
     status = this.readStatus(storeKey);
 
     if(status==K.EMPTY || status==K.ERROR || status==K.READY_CLEAN || status==K.DESTROY_CLEAN){
       status = K.ERROR;
+      
+      // Add the error to the array of record errors (for lookup later on if necessary).
+      if (error && error.isError) {
+        if (!errors) errors = this.recordErrors = [];
+        errors[storeKey] = error;
+      }
+      
       this.writeStatus(storeKey, status) ;
       this.dataHashDidChange(storeKey, null, YES);
       return YES;
@@ -1928,7 +2031,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   */
   loadQueryResults: function(query, storeKeys) {
     if (query.get('location') === SC.Query.LOCAL) {
-      throw "Cannot load query results for a local query";
+      throw new Error("Cannot load query results for a local query");
     }
 
     var recArray = this._findQuery(query, YES, NO);
@@ -2004,10 +2107,18 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     again.
     
     @param {SC.Query} query the query with the error
-    @param {SC.Error} error optional error object to set
+    @param {SC.Error} error [optional] an SC.Error instance to associate with query
     @returns {SC.Store} receiver
   */
   dataSourceDidErrorQuery: function(query, error) {
+    var errors = this.queryErrors;
+
+    // Add the error to the array of query errors (for lookup later on if necessary).
+    if (error && error.isError) {
+      if (!errors) errors = this.queryErrors = {};
+      errors[SC.guidFor(query)] = error;
+    }
+
     return this._scstore_dataSourceDidErrorQuery(query, YES);
   },
 
@@ -2036,6 +2147,19 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     sc_super();
     this.reset();
   },
+  
+  
+  toString: function() {
+    // Include the name if the client has specified one.
+    var name = this.get('name');
+    if (!name) {
+      return sc_super();
+    }
+    else {
+      var ret = sc_super();
+      return "%@ (%@)".fmt(name, ret);
+    }
+  },
 
 
   // ..........................................................
@@ -2170,6 +2294,14 @@ SC.Store.mixin({
     @property {Error}
   */
   NESTED_STORE_UNSUPPORTED_ERROR: new Error("Unsupported In Nested Store"),
+  
+  /**
+    Standard error if you try to retrieve a record in a nested store that is
+    dirty.  (This is allowed on the main store, but not in nested stores.)
+    
+    @property {Error}
+  */
+  NESTED_STORE_RETRIEVE_DIRTY_ERROR: new Error("Cannot Retrieve Dirty Record in Nested Store"),
 
   /**
     Data hash state indicates the data hash is currently editable
@@ -2283,7 +2415,7 @@ SC.Store.mixin({
 
       recordType = this.recordTypeFor(storeKey);
        if (!recordType) {
-        throw "replaceIdFor: storeKey %@ does not exist".fmt(storeKey);
+        throw new Error("replaceIdFor: storeKey %@ does not exist".fmt(storeKey));
       }
 
       // map one direction...

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

@@ -6,7 +6,7 @@
 /*globals module ok equals same test MyApp */
 
 // test core array-mapping methods for ManyArray with ManyAttribute
-var storeKeys, rec;
+var storeKeys, rec, rec2, rec3, rec4;
 var foo1, foo2, foo3, bar1, bar2, bar3;
 
 module("SC.ManyAttribute core methods", {
@@ -34,7 +34,12 @@ module("SC.ManyAttribute core methods", {
       
       // test toMany relationships
       fooMany: SC.Record.toMany('MyApp.Foo'),
-      
+
+      // test toMany relationships with different key
+      fooManyKeyed: SC.Record.toMany('MyApp.Foo', {
+        key: 'fooIds'
+      }),
+
       // test many-to-many relationships with inverse
       barToMany: SC.Record.toMany('MyApp.Bar', {
         inverse: 'fooToMany', isMaster: YES, orderBy: 'name'
@@ -83,7 +88,11 @@ module("SC.ManyAttribute core methods", {
         barToOne: [] 
       },
       
-      { guid: 4, firstName: "Johnny", lastName: "Cash" }
+      { guid: 4,
+        firstName: "Johnny",
+        lastName: "Cash",
+        fooIds: [1,2]
+      }
     ]);
     
     MyApp.store.loadRecords(MyApp.Bar, [
@@ -125,6 +134,13 @@ test("getting toMany relationship should map guid to real records", function() {
   equals(rec3.get('fooMany').objectAt(0), rec, 'should get rec1 instance for rec3.fooMany');
   equals(rec3.get('fooMany').objectAt(1), rec2, 'should get rec2 instance for rec3.fooMany');
 });
+
+test("getting toMany relationship should map guid to real records when using different key", function() {
+  var rec4 = MyApp.store.find(MyApp.Foo, 4);
+  equals(rec4.get('id'), 4, 'precond - should find record 4');
+  equals(rec4.get('fooManyKeyed').objectAt(0), rec, 'should get rec1 instance for rec4.fooManyKeyed');
+  equals(rec4.get('fooManyKeyed').objectAt(1), rec2, 'should get rec2 instance for rec4.fooManyKeyed');
+});
  
 test("getting toMany relation should not change record state", function() {
   equals(rec3.get('status'), SC.Record.READY_CLEAN, 'precond - status should be READY_CLEAN');
@@ -172,7 +188,19 @@ test("writing to a to-many relationship should update set guids", function() {
   SC.RunLoop.end();
   
   equals(rec3.get('fooMany').objectAt(0), rec2, 'should get rec2 instance for rec3.fooMany');
-  equals(rec3.get('fooMany').objectAt(1), rec4, 'should get rec2 instance for rec3.fooMany');
+  equals(rec3.get('fooMany').objectAt(1), rec4, 'should get rec4 instance for rec3.fooMany');
+});
+
+test("writing to a to-many relationship should update set guids when using a different key", function() {
+  var rec4 = MyApp.store.find(MyApp.Foo, 4);
+  equals(rec4.get('id'), 4, 'precond - should find record 4');
+  equals(rec4.get('fooManyKeyed').objectAt(0), rec, 'should get rec1 instance for rec4.fooManyKeyed');
+
+  SC.RunLoop.begin();
+  rec4.set('fooManyKeyed', [rec2, rec3]);
+  SC.RunLoop.end();
+
+  ok(rec4.get('fooIds').isEqual([2,3]), 'should get array of guids (2, 3) for rec4.fooIds');
 });
 
 test("pushing an object to a to-many relationship attribute should update set guids", function() {

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

@@ -0,0 +1,56 @@
+// ==========================================================================
+// 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, Application;
+module("SC.Record Error Methods", {
+  setup: function() {
+
+    Application = {};
+    Application.Thing = SC.Record.extend({
+      name: SC.Record.attr(String)
+    });
+
+    SC.RunLoop.begin();
+    store = SC.Store.create();
+
+    var records = [
+      { guid: 1, name: 'Thing One' },
+      { guid: 2, name: 'Thing Two' }
+    ];
+
+    var types = [ Application.Thing, Application.Thing ];
+
+    store.loadRecords(types, records);
+    SC.RunLoop.end();
+  },
+
+  teardown: function() {
+    store = null;
+    Application = null;
+  }
+});
+
+test("Verify error methods behave correctly", function() {
+  var thing1 = store.find(Application.Thing, 1);
+  var storeKey = thing1.get('storeKey');
+
+  var thing2 = store.find(Application.Thing, 2);
+
+  SC.RunLoop.begin();
+  store.writeStatus(storeKey, SC.Record.BUSY_LOADING);
+  store.dataSourceDidError(storeKey, SC.Record.GENERIC_ERROR);
+  SC.RunLoop.end();
+
+  ok(thing1.get('isError'), "isError on thing1 should be YES");
+  ok(!thing2.get('isError'), "isError on thing2 should be NO");
+
+  equals(thing1.get('errorObject'), SC.Record.GENERIC_ERROR,
+    "get('errorObject') on thing1 should return the correct error object");
+
+  equals(thing2.get('errorObject'), null,
+    "get('errorObject') on thing2 should return null");
+});

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

@@ -6,7 +6,7 @@
 /*globals module ok equals same test MyApp */
 
 // test normalize method for SC.Record
-var storeKeys, rec;
+var storeKeys, rec, rec2, rec3, rec4;
 module("SC.Record normalize method", {
   setup: function() {
 

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

@@ -22,6 +22,15 @@ module("SC.Record#unknownProperty", {
     };
     
     MyApp.foo = MyApp.store.createRecord(MyApp.Foo, MyApp.json);
+    
+    MyApp.FooStrict = SC.Record.extend();
+    
+    SC.mixin(MyApp.FooStrict, {
+      ignoreUnknownProperties: YES
+    });
+    
+    MyApp.fooStrict = MyApp.store.createRecord(MyApp.FooStrict, MyApp.json);
+    
   },
   
   teardown: function() {
@@ -49,3 +58,9 @@ test("set() should replace existing property", function() {
   equals(MyApp.store.dataHashes[MyApp.foo.storeKey].foo, 'baz', 'should update foo attribute');
 });
 
+test("set() on unknown property if model ignoreUnknownProperties=YES should not write it to data hash", function() {
+  MyApp.fooStrict.set('foo', 'baz');
+  equals(MyApp.store.dataHashes[MyApp.fooStrict.storeKey].foo, 'bar', 'should not have written new value to dataHash');
+});
+
+

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

@@ -68,7 +68,7 @@ test("raises exception if you try to write an attribute before an attribute hash
   store.removeDataHash(foo.storeKey);
   equals(store.readDataHash(foo.storeKey), null, 'precond - should not have store key');
   
-  var e, cnt=0 ;
+  var cnt=0 ;
   try {
     foo.writeAttribute("foo", "bar");
   } catch(e) {
@@ -95,3 +95,18 @@ test("Writing to an attribute in chained store sets correct status", function()
   
 });
 
+
+test("Writing a new guid", function(){
+  equals(foo.get('id'), 1, 'foo.id should be 1');
+  foo.set('guid', 2);
+  equals(foo.get('id'), 2, 'foo.id should be 2');
+});
+
+test("Writing primaryKey of 'id'", function(){
+  PrimaryKeyId = SC.Record.extend({ primaryKey: 'id' });
+  var foo2 = store.createRecord(PrimaryKeyId, { id: 1 });
+
+  equals(foo2.get('id'), 1, 'foo2.id should be 1');
+  foo2.set('id', 2);
+  equals(foo2.get('id'), 2, 'foo2.id should be 2');
+});

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

@@ -6,7 +6,7 @@
 /*globals module ok equals same test MyApp */
 
 // test core array-mapping methods for RecordArray with RecordAttribute
-var storeKeys, rec, rec2, bar ;
+var storeKeys, rec, rec2, bar, MyApp;
 
 module("SC.RecordAttribute core methods", {
   setup: function() {

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

@@ -27,7 +27,9 @@ module("SC.RecordAttribute core methods", {
         return (this.readAttribute('relatedToComputed').indexOf("foo")===0) ? MyApp.Foo : MyApp.Bar;
       }),
       
-      bar: SC.Record.toOne('MyApp.Bar', { inverse: 'foo' })
+      bar: SC.Record.toOne('MyApp.Bar', { inverse: 'foo' }),
+      
+      barKeyed: SC.Record.toOne('MyApp.Bar', { key: 'barId' })
       
     });
     
@@ -65,6 +67,13 @@ module("SC.RecordAttribute core methods", {
         anArray: ['one', 'two', 'three'],
         anObject: { 'key1': 'value1', 'key2': 'value2' },
         bar: "bar2"
+      },
+      
+      {
+        guid: 'foo4',
+        firstName: 'Joe',
+        lastName:  'Schmo',
+        barId: 'bar1'
       }
       
     ]);
@@ -108,6 +117,11 @@ test("reading an inverse relationship", function() {
   equals(bar.get('foo'), rec, 'bar.foo should == foo1');  
 });
 
+test("reading a keyed relationship", function(){
+  var rec4 = MyApp.store.find(MyApp.Foo, 'foo4');
+  equals(rec4.get('barKeyed'), bar, 'foo4.barKeyed should == bar');
+});
+
 // ..........................................................
 // WRITING
 // 
@@ -214,3 +228,10 @@ test("modifying a toOne relationship with an inverse from other", function() {
   
 });
 
+test("modifying a keyed toOne relationship", function(){
+  var rec4 = MyApp.store.find(MyApp.Foo, 'foo4');
+
+  rec4.set('barKeyed', bar2);
+
+  equals(rec4.get('barId'), 'bar2', 'foo4.barId should == bar2');
+});

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

@@ -52,6 +52,37 @@ test("initial setup for chained store", function() {
   ok(!store.locks, 'should not have locks');
   ok(!store.chainedChanges, 'should not have chainedChanges');
   ok(!store.editables, 'should not have editables');
+});
+
+test("allow for custom subclasses of SC.NestedStore", function() {
+  var parent = SC.Store.create();
+  
+  // We should get an exception if we specify a "subclass" that's not a class
+  var ex = null;
+  try {
+    var bogus = parent.chain({}, "I am not a class");
+  }
+  catch(e) {
+    ex = e;
+  }
+  ok(ex  &&  ex.message  &&  ex.message.indexOf('not a valid class') !== -1, 'chain should report that our bogus "class" it is not a valid class');
+  
+  // We should get an exception if we specify a class that's not a subclass of
+  // SC.NestedStore
+  ex = null;
+  try {
+    var bogus = parent.chain({}, SC.Store);
+  }
+  catch(e) {
+    ex = e;
+  }
+  ok(ex  &&  ex.message  &&  ex.message.indexOf('is not a type of SC.NestedStore') !== -1, 'chain should report that our class needs to be a subclass of SC.NestedStore');
+  
+  
+  // Our specified (proper!) subclass should be respected.
+  var MyNestedStoreSubclass = SC.NestedStore.extend();
+  var nested = parent.chain({}, MyNestedStoreSubclass);
+  ok(nested.kindOf(MyNestedStoreSubclass), 'our nested store should be the SC.NestedStore subclass we specified');
 }); 
 
 
@@ -59,7 +90,7 @@ test("initial setup for chained store", function() {
 // SPECIAL CASES
 // 
 
-test("chained store changes should propogate reliably", function() {
+test("chained store changes should propagate reliably", function() {
   var parent = SC.Store.create(), rec, store, rec2;
 
   SC.run(function() {