sproutcore 1.5.0.pre.3 → 1.5.0.pre.4

data/lib/frameworks/sproutcore/frameworks/datastore/system/child_array.js

@@ -52,7 +52,7 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
     @property {SC.Store}
   */
   store: function() {
-    return this.get('record').get('store');
+    return this.getPath('record.store');
   }.property('record').cacheable(),
   
   /**
@@ -62,7 +62,7 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
     @property {Number}
   */
   storeKey: function() {
-    return this.get('record').get('storeKey');
+    return this.getPath('record.storeKey');
   }.property('record').cacheable(),
   
   /**
@@ -118,7 +118,8 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
   objectAt: function(idx) {
     var recs      = this._records, 
         children = this.get('readOnlyChildren'),
-        hash, ret;
+        hash, ret, pname = this.get('propertyName'),
+        parent = this.get('record');
     var len = children ? children.length : 0;
     
     if (!children) return undefined; // nothing to do
@@ -131,7 +132,7 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
     if (!hash) return undefined;
     
     // not in cache, materialize
-    recs[idx] = ret = this._materializeChild(hash);
+    recs[idx] = ret = parent.registerNestedRecord(hash, pname, pname+'.'+idx);
     
     return ret;
   },
@@ -143,20 +144,32 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
   replace: function(idx, amt, recs) {
     var children = this.get('editableChildren'), 
         len      = recs ? (recs.get ? recs.get('length') : recs.length) : 0,
-        record   = this.get('record'),
+        record   = this.get('record'), newRecs,
         
         pname    = this.get('propertyName'),
-        cr, recordType;  
-    children.replace(idx, amt, recs);
-    for(var i = idx; i <= idx+amt; i+=1){
-      this.objectAt(i);
-    }
+        cr, recordType;
+    newRecs = this._processRecordsToHashes(recs);
+    children.replace(idx, amt, newRecs);
     // notify that the record did change...
     record.recordDidChange(pname);
-    
+  
     return this;
   },
   
+  _processRecordsToHashes: function(recs){
+    var store, sk;
+    recs = recs || [];
+    recs.forEach( function(me, idx){
+      if (me.isNestedRecord){
+        store = me.get('store');
+        sk = me.storeKey;
+        recs[idx] = store.readDataHash(sk);
+      }
+    });
+    
+    return recs;
+  },
+  
   /*
   calls normalize on each object in the array
   */
@@ -170,57 +183,24 @@ SC.ChildArray = SC.Object.extend(SC.Enumerable, SC.Array,
   // INTERNAL SUPPORT
   //  
   
-  /** @private
-    Call to create an object from a hash
-  */
-  _materializeChild: function(hash){
-    var store = this.get('store'),
-        parentRecord = this.get('record'), 
-        recordType = this.get('defaultRecordType'),
-        id, ret, storeKey, pm;
-        
-    // Find the record type
-    if (!parentRecord) return undefined;
-    var nspace = parentRecord.get('childRecordNamespace');
-    // Get the record type.
-    if (hash.type && !SC.none(nspace)) {
-      recordType = nspace[hash.type];
-    }
-
-    if (!recordType || SC.typeOf(recordType) !== SC.T_CLASS) {
-      throw 'ChildrenArray: Error during transform: Invalid record type.';
-    }
-    
-    pm = recordType.prototype.primaryKey || 'childRecordKey';
-    id = hash[pm];
-    storeKey = store.storeKeyExists(recordType, id);
-    if (storeKey){
-      ret = store.materializeRecord(storeKey);
-    } 
-    else {
-      ret = parentRecord.registerChildRecord(recordType, hash);
-    }
-    return ret;
-  },
-
   /** @private 
     Invoked whenever the children array changes.  Observes changes.
   */
   recordPropertyDidChange: function(keys) {
-    
     if (keys && !keys.contains(this.get('propertyName'))) return this;
     
     var children = this.get('readOnlyChildren');
     var prev = this._prevChildren, f = this._childrenContentDidChange;
     
     if (children === prev) return this; // nothing to do
-    
+        
     if (prev) prev.removeObserver('[]', this, f);
     this._prevChildren = children;
     if (children) children.addObserver('[]', this, f);
     
     var rev = (children) ? children.propertyRevision : -1 ;
     this._childrenContentDidChange(children, '[]', children, rev);
+    return this;
   },
 
   /** @private

data/lib/frameworks/sproutcore/frameworks/datastore/system/nested_store.js

@@ -185,7 +185,7 @@ SC.NestedStore = SC.Store.extend(
     @returns {SC.Store} receiver
   */
   reset: function() {
-
+    var nRecords, nr, sk;
     // requires a pstore to reset
     var parentStore = this.get('parentStore');
     if (!parentStore) throw SC.Store.NO_PARENT_STORE_ERROR;
@@ -195,6 +195,10 @@ SC.NestedStore = SC.Store.extend(
     this.revisions  = SC.beget(parentStore.revisions);
     this.statuses   = SC.beget(parentStore.statuses);
     
+    // beget nested records references
+    this.childRecords = parentStore.childRecords ? SC.beget(parentStore.childRecords) : {};
+    this.parentRecords = parentStore.parentRecords ? SC.beget(parentStore.parentRecords) : {};
+    
     // also, reset private temporary objects
     this.chainedChanges = this.locks = this.editables = null;
     this.changelog = null ;
@@ -266,7 +270,8 @@ SC.NestedStore = SC.Store.extend(
     store.
   */
   _lock: function(storeKey) {
-    var locks = this.locks, rev, editables;
+    var locks = this.locks, rev, editables, 
+        pk, pr, path, tup, obj, key;
     
     // already locked -- nothing to do
     if (locks && locks[storeKey]) return this;
@@ -288,7 +293,24 @@ SC.NestedStore = SC.Store.extend(
     }
     
     if (pstore && editState === SC.Store.EDITABLE) {
-      this.dataHashes[storeKey] = SC.clone(pstore.dataHashes[storeKey], YES);
+      
+      pk = this.childRecords[storeKey];
+      if (pk){
+        // Since this is a nested record we have to actually walk up the parent chain
+        // to get to the root parent and clone that hash. And then reconstruct the 
+        // memory space linking.
+        this._lock(pk);
+        pr = this.parentRecords[pk];
+        if (pr) {
+          path = pr[storeKey];
+          tup = path ? SC.tupleForPropertyPath(path, this.dataHashes[pk]) : null;
+          if (tup){ obj = tup[0]; key = tup[1]; }
+          this.dataHashes[storeKey] = obj && key ? obj[key] : null;
+        }
+      }
+      else {
+        this.dataHashes[storeKey] = SC.clone(pstore.dataHashes[storeKey], YES);
+      }
       if (!editables) editables = this.editables = [];
       editables[storeKey] = 1 ; // mark as editable
       
@@ -375,7 +397,6 @@ SC.NestedStore = SC.Store.extend(
   
   /** @private - book-keeping for a single data hash. */
   dataHashDidChange: function(storeKeys, rev, statusOnly, key) {
-    
     // update the revision for storeKey.  Use generateStoreKey() because that
     // gaurantees a universally (to this store hierarchy anyway) unique 
     // key value.

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

@@ -147,6 +147,10 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       newStoreClass = SC.NestedStore;
     }
     
+    // Replicate parent records references
+    attrs.childRecords = this.childRecords ? SC.clone(this.childRecords) : {};
+    attrs.parentRecords = this.parentRecords ? SC.clone(this.parentRecords) : {};
+    
     var ret    = newStoreClass.create(attrs),
         nested = this.nestedStores;
         
@@ -265,6 +269,16 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
   */
   queryErrors: null,
   
+  /**
+    A hash of child Records and there immediate parents
+  */
+  childRecords: null,
+  
+  /**
+    A hash of parent records with registered children
+  */
+  parentRecords: null,
+  
   // ..........................................................
   // CORE ATTRIBUTE API
   // 
@@ -378,6 +392,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     if (!editables) editables = this.editables = [];
     editables[storeKey] = 1 ; // use number for dense array support
     
+    var that = this;
+    this._propagateToChildren(storeKey, function(storeKey){
+      that.writeDataHash(storeKey, null, status);
+    });
+    
     return this ;
   },
 
@@ -480,10 +499,15 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       storeKey = storeKeys;
     }
     
+    var that = this;
     for(idx=0;idx<len;idx++) {
       if (isArray) storeKey = storeKeys[idx];
       this.revisions[storeKey] = rev;
       this._notifyRecordPropertyChange(storeKey, statusOnly, key);
+      
+      this._propagateToChildren(storeKey, function(storeKey){
+        that.dataHashDidChange(storeKey, null, statusOnly, key);
+      });
     }
     
     return this ;
@@ -671,27 +695,33 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     // OK, no locking issues.  So let's just copy them changes. 
     // get local reference to values.
     var len = changes.length, i, storeKey, myDataHashes, myStatuses, 
-      myEditables, myRevisions, chDataHashes, chStatuses, chRevisions;
+      myEditables, myRevisions, myParentRecords, myChildRecords, 
+      chDataHashes, chStatuses, chRevisions, chParentRecords, chChildRecords;
     
-    myRevisions  = this.revisions ;
-    myDataHashes = this.dataHashes;
-    myStatuses   = this.statuses;
-    myEditables  = this.editables ;
+    myRevisions     = this.revisions ;
+    myDataHashes    = this.dataHashes;
+    myStatuses      = this.statuses;
+    myEditables     = this.editables ;
+    myParentRecords = this.parentRecords ? this.parentRecords : this.parentRecords ={} ;
+    myChildRecords  = this.childRecords ? this.childRecords : this.childRecords = {} ;
     
     // setup some arrays if needed
     if (!myEditables) myEditables = this.editables = [] ;
-    
-    chDataHashes = nestedStore.dataHashes;
-    chRevisions  = nestedStore.revisions ;
-    chStatuses   = nestedStore.statuses;
+    chDataHashes    = nestedStore.dataHashes;
+    chRevisions     = nestedStore.revisions ;
+    chStatuses      = nestedStore.statuses;
+    chParentRecords = nestedStore.parentRecords || {};
+    chChildRecords  = nestedStore.childRecords || {};
     
     for(i=0;i<len;i++) {
       storeKey = changes[i];
 
       // now copy changes
-      myDataHashes[storeKey] = chDataHashes[storeKey];
-      myStatuses[storeKey]   = chStatuses[storeKey];
-      myRevisions[storeKey]  = chRevisions[storeKey];
+      myDataHashes[storeKey]    = chDataHashes[storeKey];
+      myStatuses[storeKey]      = chStatuses[storeKey];
+      myRevisions[storeKey]     = chRevisions[storeKey];
+      myParentRecords[storeKey] = chParentRecords[storeKey];
+      myChildRecords[storeKey]  = chChildRecords[storeKey];
       
       myEditables[storeKey] = 0 ; // always make dataHash no longer editable
       
@@ -1081,11 +1111,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     // any busy or ready state or destroyed dirty state is not allowed
     if ((status & K.BUSY)  || 
         (status & K.READY) || 
-        (status == K.DESTROYED_DIRTY)) { 
+        (status === K.DESTROYED_DIRTY)) { 
       throw id ? K.RECORD_EXISTS_ERROR : K.BAD_STATE_ERROR;
       
     // allow error or destroyed state only with id
-    } else if (!id && (status==SC.DESTROYED_CLEAN || status==SC.ERROR)) {
+    } else if (!id && (status===SC.DESTROYED_CLEAN || status===SC.ERROR)) {
       throw K.BAD_STATE_ERROR;
     }
     
@@ -1111,7 +1141,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     ret = this.materializeRecord(storeKey);
     if (ret) ret.propagateToAggregates();
     return ret;
-  },
+  },  
   
   /**
     Creates an array of new records.  You must pass an array of dataHashes 
@@ -1168,7 +1198,13 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     // remove the data hash, set new status
     this.removeDataHash(storeKey, status);
     this.dataHashDidChange(storeKey);
-            
+    
+    // Handle all the child Records
+    var that = this;
+    this._propagateToChildren(storeKey, function(storeKey){
+      that.unloadRecord(null, null, storeKey, newStatus);
+    });
+      
     return this ;
   },
   
@@ -1244,7 +1280,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       return this; // nothing to do
       
     // error out if empty
-    } else if (status == K.EMPTY) {
+    } else if (status === K.EMPTY) {
       throw K.NOT_FOUND_ERROR ;
       
     // error out if busy
@@ -1252,7 +1288,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
       throw K.BUSY_ERROR ;
       
     // if new status, destroy but leave in clean state
-    } else if (status == K.READY_NEW) {
+    } else if (status === K.READY_NEW) {
       status = K.DESTROYED_CLEAN ;
       
     // otherwise, destroy in dirty state
@@ -1273,6 +1309,11 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     if(this.get('commitRecordsAutomatically')){
       this.invokeLast(this.commitRecords);
     }
+    
+    var that = this;
+    this._propagateToChildren(storeKey, function(storeKey){
+      that.destroyRecord(null, null, storeKey);
+    });
         
     return this ;
   },
@@ -1318,6 +1359,66 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     return this ;
   },
   
+  /**
+    register a Child Record to the parent
+  */
+  registerChildToParent: function(parentStoreKey, childStoreKey, path){
+    var prs, crs, oldPk, oldChildren, pkRef;
+    // Check the child to see if it has a parent
+    crs = this.childRecords || {};
+    prs = this.parentRecords || {};
+    // first rid of the old parent
+    oldPk = crs[childStoreKey];
+    if (oldPk){
+      oldChildren = prs[oldPk];
+      delete oldChildren[childStoreKey];
+      // this.recordDidChange(null, null, oldPk, key);
+    }
+    pkRef = prs[parentStoreKey] || {};
+    pkRef[childStoreKey] = path || YES;
+    prs[parentStoreKey] = pkRef;
+    crs[childStoreKey] = parentStoreKey;
+    // sync the status of the child
+    this.writeStatus(childStoreKey, this.statuses[parentStoreKey]);
+    this.childRecords = crs;
+    this.parentRecords = prs;
+  },
+  
+  /**
+    materialize the parent when passing in a store key for the child
+  */
+  materializeParentRecord: function(childStoreKey){
+    var pk, crs;
+    if (SC.none(childStoreKey)) return null;
+    crs = this.childRecords;
+    pk = crs ? this.childRecords[childStoreKey] : null ;
+    if (SC.none(pk)) return null;
+    
+    return this.materializeRecord(pk);
+  },
+  
+  /**
+    function for retrieving a parent record key
+  */
+  parentStoreKeyExists: function(storeKey){
+    if (SC.none(storeKey)) return ;
+    var crs = this.childRecords || {};
+    return crs[storeKey];
+  },
+  
+  /**
+    function that propigates a function all to all children
+  */
+  _propagateToChildren: function(storeKey, func){
+    // Handle all the child Records
+    if ( SC.none(this.parentRecords) ) return;
+    var children = this.parentRecords[storeKey] || {};
+    if (SC.none(func)) return;
+    for (var key in children) {
+      if (children.hasOwnProperty(key)) func(key);
+    }
+  },
+  
   /**
     Notes that the data for the given record id has changed.  The record will
     be committed to the server the next time you commit the root store.  Only
@@ -1910,7 +2011,6 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     // DESTROYED_DIRTY
     if (!(status & K.BUSY)) {
       throw K.BAD_STATE_ERROR; // should never be called in this state
-      
     }
     
     // otherwise, determine proper state transition
@@ -1978,7 +2078,13 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     
     statusOnly = dataHash || newId ? NO : YES;
     this.dataHashDidChange(storeKey, null, statusOnly);
-    
+
+    // Force record to refresh its cached properties based on store key
+    var record = this.materializeRecord(storeKey);
+    if (record != null) {
+      record.notifyPropertyChange('status');
+    }
+
     return this ;
   },
   
@@ -2004,6 +2110,12 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     this.removeDataHash(storeKey, status) ;
     this.dataHashDidChange(storeKey);
 
+    // Force record to refresh its cached properties based on store key
+    var record = this.materializeRecord(storeKey);
+    if (record != null) {
+      record.notifyPropertyChange('status');
+    }
+
     return this ;
   },
 
@@ -2019,7 +2131,7 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
 
     // EMPTY, ERROR, READY_CLEAN, READY_NEW, READY_DIRTY, DESTROYED_CLEAN,
     // DESTROYED_DIRTY
-    if (!(status & K.BUSY)) throw K.BAD_STATE_ERROR; 
+    if (!(status & K.BUSY)) { throw K.BAD_STATE_ERROR; }
 
     // otherwise, determine proper state transition
     else status = K.ERROR ;
@@ -2033,6 +2145,12 @@ SC.Store = SC.Object.extend( /** @scope SC.Store.prototype */ {
     this.writeStatus(storeKey, status) ;
     this.dataHashDidChange(storeKey, null, YES);
 
+    // Force record to refresh its cached properties based on store key
+    var record = this.materializeRecord(storeKey);
+    if (record != null) {
+      record.notifyPropertyChange('status');
+    }
+
     return this ;
   },
 

data/lib/frameworks/sproutcore/frameworks/datastore/tests/data_sources/fixtures.js

@@ -107,10 +107,15 @@ test("Update and commit a record", function() {
       fixture = fixtures.fixtureForStoreKey(store, storeKey);
 
   equals(fixture.name, rec.get('name'), 'precond - fixture state should match name');
+  equals(rec.get('status'), SC.Record.READY_CLEAN, "Status should be READY_CLEAN because no changes have been made");
 
   rec.set('name', 'foo');
+  equals(rec.get('status'), SC.Record.READY_DIRTY, "Status should be READY_DIRTY after changing name");
+
   store.commitRecords();
-  
+  equals(store.readStatus(storeKey), SC.Record.READY_CLEAN, "Status in store should be READY_CLEAN after save");
+  equals(rec.get('status'), SC.Record.READY_CLEAN, "Status in record should be READY_CLEAN after save");
+
   fixture = fixtures.fixtureForStoreKey(store, storeKey);
   equals(fixture.name, rec.get('name'), 'fixture state should update to match new name');
     

data/lib/frameworks/sproutcore/frameworks/datastore/tests/integration/cyclical_relationship.js

@@ -95,7 +95,7 @@ module("Cyclical relationships", {
 test("getting all contacts in a group", function() {
   var group  = AB.store.find(AB.Group, 100);
   var expected = AB.store.find(AB.Contact).filterProperty('group', group);
-  same(group.get('contacts'), expected, 'contacts');
+  same(group.get('contacts').toArray(), expected, 'contacts');
 });
 
 test("finding favoriteContacts", function() {

data/lib/frameworks/sproutcore/frameworks/datastore/tests/models/nested_records/{parentless.js → data_store.js}

@@ -1,5 +1,5 @@
 /**
- * Complex Nested Records (SC.ChildRecord) Unit Test
+ * Nested Records and the Data Store(SC.Record) Unit Test
  *
  * @author Evin Grano
  */
@@ -10,18 +10,14 @@
 var NestedRecord, store, storeKeys; 
 
 var initModels = function(){
-  NestedRecord.Directory = SC.ChildRecord.extend({
+  NestedRecord.Directory = SC.Record.extend({
     /** Child Record Namespace */
-    childRecordNamespace: NestedRecord,
-    primaryKey: 'id',
-    id: SC.Record.attr(Number),
+    nestedRecordNamespace: NestedRecord,
     name: SC.Record.attr(String),
-    contents: SC.Record.toMany('SC.Record', { nested: true })
+    contents: SC.Record.toMany('SC.Record', { isNested: true })
   });
   
-  NestedRecord.File = SC.ChildRecord.extend({
-    primaryKey: 'id',
-    id: SC.Record.attr(Number),
+  NestedRecord.File = SC.Record.extend({
     name: SC.Record.attr(String)
   });
   
@@ -30,7 +26,7 @@ var initModels = function(){
 // ..........................................................
 // Basic SC.Record Stuff
 // 
-module("Parentless SC.ChildRecord", {
+module("Data Store Tests for Nested Records", {
 
   setup: function() {
     NestedRecord = SC.Object.create({
@@ -43,21 +39,21 @@ module("Parentless SC.ChildRecord", {
       {
         type: 'Directory',
         name: 'Dir 1',
-        id: 1,
+        guid: 1,
         contents: [
           {
             type: 'Directory',
             name: 'Dir 2',
-            id: 2,
+            guid: 2,
             contents: [
               {
                 type: 'File',
-                id: 3,
+                guid: 3,
                 name: 'File 1'
               },
               {
                 type: 'File',
-                id: 4,
+                guid: 4,
                 name: 'File 2'
               } 
             ]
@@ -87,12 +83,12 @@ test("Proper Initialization",function() {
   
   // First
   first = store.materializeRecord(storeKeys[0]);
-  ok(SC.kindOf(first, SC.ChildRecord), "first record is a kind of a SC.ChildRecord Object");
+  ok(SC.kindOf(first, SC.Record), "first record is a kind of a SC.Record Object");
   ok(SC.instanceOf(first, NestedRecord.Directory), "first record is a instance of a NestedRecord.Directory Object");
   
   // Second
   second = store.materializeRecord(storeKeys[1]);
-  ok(SC.kindOf(second, SC.ChildRecord), "second record is a kind of a SC.ChildRecord Object");
+  ok(SC.kindOf(second, SC.Record), "second record is a kind of a SC.Record Object");
   ok(SC.instanceOf(second, NestedRecord.File), "second record is a instance of a NestedRecord.File Object");
 });
 
@@ -132,3 +128,53 @@ test("Can Push onto child array",function() {
   });
 
 });
+
+test("Use in Nested Store", function(){
+  var nstore, dir, c, file,
+      pk, id, nFile, nDir;
+  
+  // First, find the first file
+  dir = store.find(NestedRecord.Directory, 1);
+  ok(dir, "Directory id:1 exists"); 
+  equals(dir.get('name'), 'Dir 1', "Directory id:1 has a name of 'Dir 1'");
+  c = dir.get('contents');
+  ok(c, "Content of Directory id:1 exists");
+  dir = c.objectAt(0);
+  ok(dir, "Directory id:2 exists"); 
+  equals(dir.get('name'), 'Dir 2', "Directory id:2 has a name of 'Dir 2'");
+  c = dir.get('contents');
+  ok(c, "Content of Directory id:2 exists");
+  file = c.objectAt(0);
+  ok(file, "File id:1 exists"); 
+  equals(file.get('name'), 'File 1', "File id:1 has a name of 'File 1'");
+  
+  // Second, create nested store
+  nstore = store.chain();
+  SC.RunLoop.begin();
+  pk = file.get('primaryKey');
+  id = file.get(pk);
+  nFile = nstore.find(NestedRecord.File, id);
+  SC.RunLoop.end();
+  ok(nFile, "Nested > File id:1 exists"); 
+  equals(nFile.get('name'), 'File 1', "Nested > File id:1 has a name of 'File 1'");
+  
+  // Third, change the name of the nested store and see what happens
+  nFile.set('name', 'Change Name');
+  equals(nFile.get('name'), 'Change Name', "Nested > File id:1 has changed the name to 'Changed Name'");
+  equals(file.get('name'), 'File 1', "Base > File id:1 still has the name of 'File 1'");
+  nDir = nstore.find(NestedRecord.Directory, 1);
+  
+  // Fourth, commit the changes
+  nstore.commitChanges();
+  nstore.destroy();
+  nstore = null;
+  equals(file.get('name'), 'Change Name', "Base > File id:1 has changed to name of 'Changed Name'");
+  
+  // Fifth, double check that the change exists
+  dir = store.find(NestedRecord.Directory, 1);
+  file = dir.get('contents').objectAt(0).get('contents').objectAt(0);
+  equals(dir.get('status'), SC.Record.READY_DIRTY, 'Base > Directory id:1 has a READY_DIRTY State');
+  equals(file.get('status'), SC.Record.READY_DIRTY, 'Base > File id:1 has a READY_DIRTY State');
+  equals(file.get('name'), 'Change Name', "Base > File id:1 has actually changed to name of 'Changed Name'");
+  
+});