sproutcore 1.0.1046 → 1.0.1049.pre.1

data/frameworks/sproutcore/frameworks/datastore/tests/models/nested_records/nested_record_array.js

@@ -0,0 +1,337 @@
+/**
+ * Nested Record Array of SC.ChildRecords Unit Test
+ *
+ * @author Evin Grano
+ */
+
+// ..........................................................
+// Basic Set up needs to move to the setup and teardown
+// 
+var NestedRecord, store, testParent, testParent2; 
+
+var initModels = function(){
+  NestedRecord.ParentRecordTest = SC.Record.extend({
+    /** Child Record Namespace */
+    childRecordNamespace: NestedRecord,
+
+    name: SC.Record.attr(String),
+    elements: SC.Record.toMany('SC.ChildRecord', { nested: true })
+  });
+
+  NestedRecord.ChildRecordTest1 = SC.ChildRecord.extend({
+    name: SC.Record.attr(String),
+    value: SC.Record.attr(String)
+  });
+  
+  NestedRecord.ChildRecordTest2 = SC.ChildRecord.extend({
+     name: SC.Record.attr(String),
+     info: SC.Record.attr(String),
+     value: SC.Record.attr(String)
+   });
+};
+
+// ..........................................................
+// Basic SC.Record with an Array of Children
+// 
+module("Basic SC.Record w/ a Parent > Array of Children", {
+
+  setup: function() {
+    NestedRecord = SC.Object.create({
+      store: SC.Store.create()
+    });
+    store = NestedRecord.store;
+    initModels();
+    SC.RunLoop.begin();
+    testParent = store.createRecord(NestedRecord.ParentRecordTest, {
+      name: 'Parent Name',
+      elements: [
+        {
+          type: 'ChildRecordTest1',
+          name: 'Child 1',
+          value: 'eeney'
+        },
+        {
+          type: 'ChildRecordTest2',
+          name: 'Child 2',
+          info: 'This is the other type',
+          value: 'meeney'
+        },
+        {
+          type: 'ChildRecordTest1',
+          name: 'Child 3',
+          value: 'miney'
+        },
+        {
+          type: 'ChildRecordTest1',
+          name: 'Child 4',
+          value: 'moe'
+        }
+      ]
+    });
+
+    // FIXME: [EG] this configuration should work
+    testParent2 = store.createRecord(NestedRecord.ParentRecordTest, {
+      name: 'Parent 2',
+      elements: []
+    });
+    SC.RunLoop.end();
+  },
+
+  teardown: function() {
+    delete NestedRecord.ParentRecordTest;
+    delete NestedRecord.ChildRecordTest;
+    testParent = null;
+    testParent2 = null;
+    store = null;
+    NestedRecord = null;
+  }
+});
+
+test("Function: readAttribute()", function() {
+  var elemsAry = testParent.readAttribute('elements');
+  ok(elemsAry, "check to see that the child records array exists");
+  equals(elemsAry.get('length'), 4, "checking to see that the length of the elements array is 4");
+  same(elemsAry[0], 
+    {
+      type: 'ChildRecordTest1',
+      name: 'Child 1',
+      value: 'eeney'
+    },
+    "check to see if the first child is as expected"); 
+  same(elemsAry[3], 
+    {
+      type: 'ChildRecordTest1',
+      name: 'Child 4',
+      value: 'moe'
+    },
+    "check to see if the last child is as expected"); 
+});
+
+test("Function: writeAttribute()", function() {
+    
+  testParent.writeAttribute('elements', 
+    [
+      {
+        type: 'ChildRecordTest1',
+        name: 'Tom',
+        value: 'Jones'
+      },
+      {
+        type: 'ChildRecordTest1',
+        name: 'Dick',
+        value: 'Smothers'
+      },
+      {
+        type: 'ChildRecordTest1',
+        name: 'Harry',
+        value: 'Balls'
+      }
+    ]
+  );
+  var elemsAry = testParent.readAttribute('elements');
+  ok(elemsAry, "after writeAttribute(), check to see that the child records array exists");
+  equals(elemsAry.length, 3, "after writeAttribute(), checking to see that the length of the elements array is 3");
+  same(elemsAry[0], 
+    {
+      type: 'ChildRecordTest1',
+      name: 'Tom',
+      value: 'Jones'
+    },
+    "check to see if the first child is as expected"); 
+  same(elemsAry[2], 
+    {
+      type: 'ChildRecordTest1',
+      name: 'Harry',
+      value: 'Balls'
+    },
+    "check to see if the last child is as expected"); 
+});
+
+test("Basic Read", function() {
+  
+  // Test general gets
+  equals(testParent.get('name'), 'Parent Name', "get should be correct for name attribute");
+  equals(testParent.get('nothing'), null, "get should be correct for invalid key");
+  
+  // Test Child Record creation
+  var arrayOfCRs = testParent.get('elements');
+  // Check Model Class information
+  
+  ok(SC.instanceOf(arrayOfCRs, SC.ChildArray), "check that get() creates an actual instance of a SC.ChildArray");
+  equals(arrayOfCRs.get('length'), 4, "check that the length of the array of child records is 4");
+  var cr = arrayOfCRs.objectAt(0);
+  ok(SC.kindOf(cr, SC.ChildRecord), "check that first ChildRecord from the get() creates an actual instance that is a kind of a SC.ChildRecord Object");
+  ok(SC.instanceOf(cr, NestedRecord.ChildRecordTest1), "check that first ChildRecord from the get() creates an actual instance of a ChildRecordTest1 Object");
+  
+  // Check reference information
+  var pm = cr.get('primaryKey');
+  var key = cr.get(pm);
+  var storeRef = store.find(NestedRecord.ChildRecordTest1, key);
+  ok(storeRef, 'check that first ChildRecord that the store has the instance of the child record with proper primary key');
+  equals(cr, storeRef, "check the parent reference to the first child is the same as the direct store reference");
+  
+  // Check to see if the attributes of a Child Record match the refrence of the parent
+  var parentArray = testParent.readAttribute('elements');
+  ok(!SC.instanceOf(parentArray, SC.ChildArray), "check that get() creates an actual instance of a SC.ChildArray");
+  same(parentArray[0], storeRef.get('attributes'), "check that the ChildRecord's attributes are the same as the ParentRecord's readAttribute for the reference");
+  
+  // // Duplication check
+  var sameArray = testParent.get('elements');
+  ok(sameArray, 'check to see that we get an array on the second call to the parent for the child records');
+  equals(sameArray.get('length'), 4, "check that the length of the array of child records is still 4");
+  var sameCR = sameArray.objectAt(0);
+  ok(sameCR, "check to see if we have an instance of a child record again");
+  var oldKey = cr.get(pm), newKey = sameCR.get(pm);
+  equals(oldKey, newKey, "check to see if the primary key are the same");
+  equals(SC.guidFor(cr), SC.guidFor(sameCR), "check to see if the guid are the same");
+  same(sameCR, cr, "check to see that it is the same child record as before");
+});
+
+test("Basic Write", function() {
+  
+  // Test general gets
+  testParent.set('name', 'New Parent Name');
+  equals(testParent.get('name'), 'New Parent Name', "set() should change name attribute");
+  testParent.set('nothing', 'nothing');
+  equals(testParent.get('nothing'), 'nothing', "set should change non-existent property to a new property");
+  
+  // Test Child Record creation
+  var oldCR = testParent.get('elements');
+  var newChildren = [
+   { type: 'ChildRecordTest1', name: 'Tom', value: 'Jones'},
+   { type: 'ChildRecordTest1', name: 'Dick', value: 'Smothers'},
+   { type: 'ChildRecordTest1', name: 'Harry', value: 'Balls'}
+  ];
+
+  testParent.set('elements', newChildren);
+  var newArray = testParent.get('elements');
+  ok(SC.instanceOf(newArray, SC.ChildArray), "check that get() creates an actual instance of a SC.ChildArray");
+  equals(newArray.get('length'), 3, "after set() on parent, check that the length of the array of child records is 3");
+  var cr = newArray.objectAt(0);
+
+  ok(SC.kindOf(cr, SC.ChildRecord), "check that first ChildRecord from the get() creates an actual instance that is a kind of a SC.ChildRecord Object");
+  ok(SC.instanceOf(cr, NestedRecord.ChildRecordTest1), "check that first ChildRecord from the get() creates an actual instance of a ChildRecordTest1 Object");
+});
+
+test("Basic Write: reference tests", function() {
+   var pm, elems, cr, key, storeRef, newElems;
+   
+   elems = testParent.get('elements');
+   cr = elems.objectAt(0);
+   // TODO: [EG] Add test to make sure the number of ChildRecords in store
+   
+   // Check reference information
+   pm = cr.get('primaryKey');
+   key = cr.get(pm);
+   storeRef = store.find(NestedRecord.ChildRecordTest1, key);
+   ok(storeRef, 'after a set() with an object, checking that the store has the instance of the child record with proper primary keys');
+   equals(cr, storeRef, "after a set with an object, checking the parent reference is the same as the direct store reference");
+   
+   // Check for changes on the child bubble to the parent.
+   cr.set('name', 'Child Name Change');
+   equals(cr.get('name'), 'Child Name Change', "after a set('name', <new>) on child, checking that the value is updated");
+   ok(cr.get('status') & SC.Record.DIRTY, 'check that the child record is dirty');
+   ok(testParent.get('status') & SC.Record.DIRTY, 'check that the parent record is dirty');
+   newElems = testParent.get('elements');
+   var newCR = newElems.objectAt(0);
+   same(newCR, cr, "after a set('name', <new>) on child, checking to see that the parent has recieved the changes from the child record");
+   var readAttrsArray = testParent.readAttribute('elements');
+   ok(readAttrsArray, "checks to make sure the readAttibute works with a change to the name in the first child.");
+   equals(readAttrsArray.length, 4, "after set() on parent, check that the length of the attribute array of child records is 4");
+   same(readAttrsArray[0], newCR.get('attributes'), "after a set('name', <new>) on child, readAttribute on the parent should be correct for info child attributes");
+});
+
+test("Basic Array Functionality: pushObject", function() {   
+  var elements, elementsAttrs, cr, crFirst, crLast;
+  // Add something to the array
+  elements = testParent.get('elements');
+  // PushObject Tests
+  elements.pushObject({ type: 'ChildRecordTest1', name: 'Testikles', value: 'God Of Fertility'});
+  elements = testParent.get('elements');
+  equals(elements.get('length'), 5, "after pushObject() on parent, check that the length of the array of child records is 5");
+  cr = elements.objectAt(4);
+  ok(SC.kindOf(cr, SC.ChildRecord), "check that newly added ChildRecord creates an actual instance that is a kind of a SC.ChildRecord Object");
+  ok(SC.instanceOf(cr, NestedRecord.ChildRecordTest1), "check that newly added ChildRecord creates an actual instance of a ChildRecordTest1 Object");
+  equals(cr.get('name'), 'Testikles', "after a pushObject on parent, check to see if it has all the right values for the attributes");
+  ok(cr.get('status') & SC.Record.DIRTY, 'check that the child record is dirty');
+  ok(testParent.get('status') & SC.Record.DIRTY, 'check that the parent record is dirty'); 
+  
+  // Verify the Attrs
+  elementsAttrs = testParent.readAttribute('elements');
+  equals(elementsAttrs.length, 5, "after pushObject() on parent, check that the length of the attribute array of child records is 5");
+  crFirst = elements.objectAt(0).get('attributes');
+  crLast = elements.objectAt(4).get('attributes');
+  same(elementsAttrs[0], crFirst, "verify that parent attributes are the same as the first individual child attributes");
+  same(elementsAttrs[4], crLast, "verify that parent attributes are the same as the last individual child attributes");  
+});
+
+test("Basic Array Functionality: popObject", function() {   
+  var elements, elementsAttrs, cr, crFirst, crLast;
+  // Add something to the array
+  elements = testParent.get('elements');
+  // PushObject Tests
+  elements.popObject();
+  elements = testParent.get('elements');
+  equals(elements.get('length'), 3, "after popObject() on parent, check that the length of the array of child records is 3");
+  ok(testParent.get('status') & SC.Record.DIRTY, 'check that the parent record is dirty'); 
+  
+  // Verify the Attrs
+  elementsAttrs = testParent.readAttribute('elements');
+  equals(elementsAttrs.length, 3, "after pushObject() on parent, check that the length of the attribute array of child records is 3");
+  crFirst = elements.objectAt(0).get('attributes');
+  crLast = elements.objectAt(2).get('attributes');
+  same(elementsAttrs[0], crFirst, "verify that parent attributes are the same as the first individual child attributes");
+  same(elementsAttrs[2], crLast, "verify that parent attributes are the same as the last individual child attributes");
+});
+
+test("Basic Array Functionality: shiftObject", function() {   
+  var elements, cr;
+  // Add something to the array
+  elements = testParent.get('elements');
+  // PushObject Tests
+  elements.shiftObject();
+  elements = testParent.get('elements');
+  equals(elements.get('length'), 3, "after shiftObject() on parent, check that the length of the array of child records is 3");
+  ok(testParent.get('status') & SC.Record.DIRTY, 'check that the parent record is dirty'); 
+});
+
+test("Basic Array Functionality: unshiftObject", function() {   
+  var elements, elementsAttrs, cr, crFirst, crLast;
+  // Add something to the array
+  elements = testParent.get('elements');
+  // PushObject Tests
+  elements.unshiftObject({ type: 'ChildRecordTest1', name: 'Testikles', value: 'God Of Fertility'});
+  elements = testParent.get('elements');
+  equals(elements.get('length'), 5, "after pushObject() on parent, check that the length of the array of child records is 5");
+  cr = elements.objectAt(0);
+  ok(SC.kindOf(cr, SC.ChildRecord), "check that newly added ChildRecord creates an actual instance that is a kind of a SC.ChildRecord Object");
+  ok(SC.instanceOf(cr, NestedRecord.ChildRecordTest1), "check that newly added ChildRecord creates an actual instance of a ChildRecordTest1 Object");
+  equals(cr.get('name'), 'Testikles', "after a pushObject on parent, check to see if it has all the right values for the attributes");
+  ok(cr.get('status') & SC.Record.DIRTY, 'check that the child record is dirty');
+  ok(testParent.get('status') & SC.Record.DIRTY, 'check that the parent record is dirty'); 
+  
+  // Verify the Attrs
+  elementsAttrs = testParent.readAttribute('elements');
+  equals(elementsAttrs.length, 5, "after pushObject() on parent, check that the length of the attribute array of child records is 5");
+  crFirst = elements.objectAt(0).get('attributes');
+  crLast = elements.objectAt(4).get('attributes');
+  same(elementsAttrs[0], crFirst, "verify that parent attributes are the same as the first individual child attributes");
+  same(elementsAttrs[4], crLast, "verify that parent attributes are the same as the last individual child attributes");  
+});
+
+test("Create Parent with Broken Child Array", function(){
+  var elements = testParent2.get('elements');
+  ok (!SC.none(elements), "elements should be something");
+  var isChildRecordArrays = elements.instanceOf(SC.ChildArray);
+  ok(isChildRecordArrays, 'elements array is of right type');
+
+  var length = elements.get('length');
+  equals(length, 0, 'length should be zero');
+
+  elements.pushObject({type: 'ChildRecordTest1',name: 'Child 1',value: 'eeney'});
+  length = elements.get('length');
+  equals(length, 1, 'length should be one');
+
+});
+
+

data/frameworks/sproutcore/frameworks/datastore/tests/models/nested_records/nested_record_array_complex.js

@@ -0,0 +1,421 @@
+/**
+ * Nested Record Array (SC.ChildRecord) Unit Test
+ *
+ * @author Evin Grano
+ */
+
+// ..........................................................
+// Basic Set up needs to move to the setup and teardown
+// 
+var NestedRecord, store, testParent, peopleData1, peopleData2, personData1, addressData1; 
+
+var initModels = function(){
+  NestedRecord.Group = SC.Record.extend({
+    /** Child Record Namespace */
+    childRecordNamespace: NestedRecord,
+
+    name: SC.Record.attr(String),
+    people: SC.Record.toMany('NestedRecord.Person', { nested: true })
+  });
+
+  NestedRecord.Person = SC.ChildRecord.extend({
+    /** Child Record Namespace */
+    childRecordNamespace: NestedRecord,
+    
+    name: SC.Record.attr(String),
+    addresses: SC.Record.toMany('NestedRecord.Address', { nested: true })
+  });
+  
+  NestedRecord.Address = SC.ChildRecord.extend({
+    street: SC.Record.attr(String),
+    city: SC.Record.attr(String),
+    state: SC.Record.attr(String, {defaultValue: "VA"})
+  });
+};
+
+// ..........................................................
+// Basic SC.ParentRecord with an Array of Children
+// 
+module("Complex SC.ChildRecord: Parent > Array of Children > Array of Children", {
+
+  setup: function() {
+    NestedRecord = SC.Object.create({
+      store: SC.Store.create()
+    });
+    store = NestedRecord.store;
+    initModels();
+    SC.RunLoop.begin();
+    testParent = store.createRecord(NestedRecord.Group, {
+      name: 'Test Group',
+      people: [
+        {
+          type: 'Person',
+          name: 'Barack Obama',
+          addresses: [
+            { type: 'Address', street: '123 Some Street', city: 'Chicago', state: 'IL'},
+            { type: 'Address', street: '222 Socialist Way ', city: 'Washington', state: 'DC'}
+          ]
+        },
+        {
+          type: 'Person',
+          name: 'John Doe',
+          addresses: [
+            { type: 'Address', street: '1111 Cross Street', city: 'Anywhere', state: 'CA'},
+            { type: 'Address', street: '555 18th Street ', city: 'Boulder', state: 'CO'},
+            { type: 'Address', street: '444 Goofy Street ', city: 'Redneck', state: 'AR'}
+          ]
+        },
+        {
+          type: 'Person',
+          name: 'Jane Doe',
+          addresses: [
+            { type: 'Address', street: '987 Crispy Kreme Lane', city: 'Lard', state: 'TX'}
+          ]
+        }
+      ]
+    });
+    SC.RunLoop.end();
+    // Second Array for testings
+    peopleData2 = [
+      {
+        type: 'Person',
+        name: 'Tom Jones',
+        addresses: [
+          { type: 'Address', street: '1 Freezing Circle', city: 'Nome', state: 'AK'},
+          { type: 'Address', street: '444 Not Unusual Love Place', city: 'Las Vegas', state: 'NV'},
+          { type: 'Address', street: '66 On The Road', city: 'Touring', state: 'Anywhere'}
+        ]
+      },
+      {
+        type: 'Person',
+        name: 'Dick Smothers',
+        addresses: [
+          { type: 'Address', street: '1 Mom Likes Best Place', city: 'Tujunga', state: 'CA'}
+        ]
+      }
+    ];
+    
+    personData1 = { 
+      type: 'Person', 
+      name: 'Testikles, God Of Fertility', 
+      addresses: [
+        { type: 'Address', street: '45 Gods and Goddess Place', city: 'Mount', state: 'Olympus'},
+        { type: 'Address', street: '1 Special Circle', city: 'Your Mom', state: 'Your State'}
+      ]
+    };
+    
+    // Address Test Data
+    addressData1 = [
+      { type: 'Address', street: '1 Main Street', city: 'Greenbow', state: 'AL'},
+      { type: 'Address', street: '666 Wall Street', city: 'New York', state: 'NY'},
+      { type: 'Address', street: '4 Dirt Road', city: 'Pleasent', state: 'CO'},
+      { type: 'Address', street: '1 Yellow Brick Road', city: 'Dorothy', state: 'KA'}
+    ];
+  },
+
+  teardown: function() {
+    delete NestedRecord.Group;
+    delete NestedRecord.Person;
+    delete NestedRecord.Address;
+    NestedRecord = null;
+    testParent = null;
+    peopleData1 = null;
+    peopleData2 = null;
+    personData1 = null;
+    addressData1 = null;
+    store = null;
+  }
+});
+
+test("Function: readAttribute()", function() {
+  var ppl;
+  ppl = testParent.readAttribute('people');
+  ok(ppl, "check to see that the child records array exists");
+  equals(ppl.length, 3, "checking to see that the length of the elements array is 3");
+  
+  // Check the first person
+  equals(ppl[0].name, 'Barack Obama', "first person, check to see name is Barack Obama");
+  equals(ppl[0].addresses.length, 2, "first person, check to see length of the addresses is 2");
+  same(ppl[0].addresses[0], { type: 'Address', street: '123 Some Street', city: 'Chicago', state: 'IL'},
+    "check to see if the first person's first address is as expected"); 
+  same(ppl[0].addresses[1], { type: 'Address', street: '222 Socialist Way ', city: 'Washington', state: 'DC'},
+    "check to see if the first person's last address is as expected"); 
+    
+  // Check Last person
+  equals(ppl[2].name, 'Jane Doe', "last person, check to see name is Jane Doe");
+  equals(ppl[2].addresses.length, 1, "last person, check to see length of the addresses is 2");
+  same(ppl[2].addresses[0], { type: 'Address', street: '987 Crispy Kreme Lane', city: 'Lard', state: 'TX'},
+    "check to see if the last person's first address is as expected"); 
+});
+
+test("Function: writeAttribute()", function() {
+  var ppl;
+  testParent.writeAttribute('people', peopleData2);
+  ppl = testParent.readAttribute('people');
+  ok(ppl, "after writeAttribute(), check to see that the child records array exists");
+  equals(ppl.length, 2, "after writeAttribute(), checking to see that the length of the elements array is 2");
+  
+  // Check the first person
+  equals(ppl[0].name, 'Tom Jones', "first person, check to see name is Tom Jones");
+  equals(ppl[0].addresses.length, 3, "first person, check to see length of the addresses is 3");
+  same(ppl[0].addresses[0], { type: 'Address', street: '1 Freezing Circle', city: 'Nome', state: 'AK'},
+    "check to see if the first person's first address is as expected"); 
+  same(ppl[0].addresses[2], { type: 'Address', street: '66 On The Road', city: 'Touring', state: 'Anywhere'},
+    "check to see if the first person's last address is as expected"); 
+    
+  // Check Last person
+  equals(ppl[1].name, 'Dick Smothers', "last person, check to see name is Dick Smothers");
+  equals(ppl[1].addresses.length, 1, "last person, check to see length of the addresses is 2");
+  same(ppl[1].addresses[0], { type: 'Address', street: '1 Mom Likes Best Place', city: 'Tujunga', state: 'CA'},
+    "check to see if the last person's first address is as expected"); 
+  
+});
+
+test("Basic Read, Testing the First Child Array", function() {
+  var pm, ppl, pplAttr, pplDup, p, pDup, pStore, key, oldKey;
+  // Test general gets
+  equals(testParent.get('name'), 'Test Group', "get should be correct for name attribute: Test Group");
+  equals(testParent.get('nothing'), null, "get should be correct for invalid key");
+  
+  // Test Person (Child Record) creation
+  ppl = testParent.get('people');
+  // Check Model Class information
+  
+  ok(SC.instanceOf(ppl, SC.ChildArray), "check that get() creates an actual instance of a SC.ChildArray");
+  equals(ppl.get('length'), 3, "check that the length of the array of child records is 3");
+  p = ppl.objectAt(0);
+  ok(SC.kindOf(p, SC.ChildRecord), "check that first ChildRecord from the get() creates an actual instance that is a kind of a SC.ChildRecord Object");
+  ok(SC.instanceOf(p, NestedRecord.Person), "check that first ChildRecord from the get() creates an actual instance of a Person Object");
+  
+  // Check reference information
+  pm = p.get('primaryKey');
+  key = p.get(pm);
+  pStore = store.find(NestedRecord.Person, key);
+  ok(pStore, 'check that first ChildRecord that the store has the instance of the child record with proper primary key');
+  equals(p, pStore, "check the parent reference to the first child is the same as the direct store reference");
+  
+  // Check to see if the attributes of a Child Record match the refrence of the parent
+  pplAttr = testParent.readAttribute('people');
+  ok(!SC.instanceOf(pplAttr, SC.ChildArray), "check that readAttribute() does not create an actual instance of a SC.ChildArray");
+  same(pplAttr[0], pStore.get('attributes'), "check that the ChildRecord's attributes are the same as the ParentRecord's readAttribute for the reference");
+  
+  // Duplication check
+  pplDup = testParent.get('people');
+  ok(pplDup, 'check to see that we get an array on the second call to the parent for the child records');
+  equals(pplDup.get('length'), 3, "check that the length of the array of child records is still 3");
+  pDup = pplDup.objectAt(0);
+  ok(pDup, "check to see if we have an instance of a child record again");
+  oldKey = p.get(pm);
+  key = pDup.get(pm);
+  equals(key, oldKey, "check to see if the primary keys are the same");
+  equals(SC.guidFor(pDup), SC.guidFor(p), "check to see if the guid are the same");
+  same(pDup, p, "check to see that it is the same child record as before");
+});
+
+test("Basic Read, Testing the Second Child Array", function() {
+  var pDup, pStore;
+  var pm, ppl, pplAttr, p, addrs, addrsDup, addrsAttr, a, aDup, aStore, key, oldKey;
+  
+  // Test Addresses (Child Record) creation
+  ppl = testParent.get('people');
+  p = ppl.objectAt(0);
+  addrs = p.get('addresses');
+  // Check Model Class information
+  
+  ok(SC.instanceOf(addrs, SC.ChildArray), "check that get() creates an actual instance of a SC.ChildArray");
+  equals(addrs.get('length'), 2, "check that the length of the array of child records is 2");
+  a = addrs.objectAt(0);
+  ok(SC.kindOf(a, SC.ChildRecord), "check that first ChildRecord from the get() creates an actual instance that is a kind of a SC.ChildRecord Object");
+  ok(SC.instanceOf(a, NestedRecord.Address), "check that first ChildRecord from the get() creates an actual instance of a Address Object");
+  
+  // Check reference information
+  pm = a.get('primaryKey');
+  key = a.get(pm);
+  aStore = store.find(NestedRecord.Address, key);
+  ok(aStore, 'check that first ChildRecord that the store has the instance of the child record with proper primary key');
+  equals(a, aStore, "check the parent reference to the first child is the same as the direct store reference");
+  
+  // Check to see if the attributes of a Child Record match the refrence of the parent
+  addrsAttr = p.readAttribute('addresses');
+  ok(!SC.instanceOf(addrsAttr, SC.ChildArray), "check that readAttribute() does not create an actual instance of a SC.ChildArray");
+  same(addrsAttr[0], aStore.get('attributes'), "check that the ChildRecord's attributes are the same as the ParentRecord's readAttribute for the reference");
+  pplAttr = testParent.readAttribute('people');
+  ok(!SC.instanceOf(pplAttr[0].addresses, SC.ChildArray), "check from the Group (parent Record) that readAttribute() does not create an actual instance of a SC.ChildArray");
+  same(pplAttr[0].addresses[0], aStore.get('attributes'), "check from the Group (parent Record) that the ChildRecord's attributes are the same as the ParentRecord's readAttribute for the reference");
+  
+  // Duplication check
+  addrsDup = p.get('addresses');
+  ok(addrsDup, 'check to see that we get an array on the second call to the parent for the child records');
+  equals(addrsDup.get('length'), 2, "check that the length of the array of child records is still 2");
+  aDup = addrsDup.objectAt(0);
+  ok(aDup, "check to see if we have an instance of a child record again");
+  oldKey = a.get(pm);
+  key = aDup.get(pm);
+  equals(key, oldKey, "check to see if the primary key are the same");
+  equals(SC.guidFor(aDup), SC.guidFor(a), "check to see if the guid are the same");
+  same(aDup, a, "check to see that it is the same child record as before");
+});
+
+test("Basic Write: Testing the First Child Array", function() {
+  var pm, ppl, p, pAddrs, pAddrsAttr, pStore, key, oldKey, aFirst, aLast;
+  // Test general gets
+  testParent.set('name', 'New Group');
+  equals(testParent.get('name'), 'New Group', "set() should change name attribute");
+  testParent.set('nothing', 'nothing');
+  equals(testParent.get('nothing'), 'nothing', "set should change non-existent property to a new property");
+  
+   testParent.set('people', peopleData2);
+   ppl = testParent.get('people');
+   ok(SC.instanceOf(ppl, SC.ChildArray), "check that get() creates an actual instance of a SC.ChildArray");
+   equals(ppl.get('length'), 2, "after set() on parent, check that the length of the array of child records is 2");
+   p = ppl.objectAt(0);
+   ok(SC.kindOf(p, SC.ChildRecord), "check that first ChildRecord from the get() creates an actual instance that is a kind of a SC.ChildRecord Object");
+   ok(SC.instanceOf(p, NestedRecord.Person), "check that first ChildRecord from the get() creates an actual instance of a Person Object");
+   
+   // TODO: [EG] Add test to make sure the number of ChildRecords in store is correct when we add store recored clearing
+   
+   // Check reference information
+   pm = p.get('primaryKey');
+   key = p.get(pm);
+   pStore = store.find(NestedRecord.Person, key);
+   ok(pStore, 'after a set() with an object, checking that the store has the instance of the child record with proper primary key');
+   equals(pStore, p, "after a set with an object, checking the parent reference is the same as the direct store reference");
+   
+   // Check for changes on the child bubble to the parent.
+   p.set('addresses', addressData1);
+   pAddrs = p.get('addresses');
+   ok(SC.kindOf(pAddrs, SC.ChildArray), "check to see that the set('addresses') has returned a SC.ChildArray");
+   equals(pAddrs.get('length'), 4, "check with a get() that the new address length is 4");
+   pAddrsAttr = p.readAttribute('addresses');
+   equals(pAddrsAttr.length, 4, "check with a readAttribute() that the new address length is 4");
+   aFirst = pAddrs.objectAt(0);
+   aLast = pAddrs.objectAt(3);
+   same(pAddrsAttr[0], aFirst.get('attributes'), "check from the Person (parent Record) that the first Address's attributes are the same as the Person's readAttribute for the reference");
+   same(pAddrsAttr[3], aLast.get('attributes'), "check from the Person (parent Record) that the last Address's attributes are the same as the Person's readAttribute for the reference");
+   ok(p.get('status') & SC.Record.DIRTY, 'check that the person (child record) is dirty');
+   ok(testParent.get('status') & SC.Record.DIRTY, 'check that the group (parent record) is dirty');
+});
+
+test("Basic Write: Testing the Second Child Array", function() {
+  var ppl, pplAttr, p, addrsAttr, addrs, a;
+  
+  ppl = testParent.get('people');
+  p = ppl.objectAt(0);
+  addrs = p.get('addresses');
+  a = addrs.objectAt('0');
+  
+  // New do the test on the address
+  a.set('street', '123 New Street');
+  ok(a.get('status') & SC.Record.DIRTY, 'check that the address (child record) is dirty');
+  ok(p.get('status') & SC.Record.DIRTY, 'check that the person (child record) is dirty');
+  ok(testParent.get('status') & SC.Record.DIRTY, 'check that the group (parent record) is dirty');
+
+  // Check for changes on the child bubble to the parent.
+  addrsAttr = p.readAttribute('addresses');
+  equals(addrsAttr.length, 2, "check the length of the address attribute is still 2");
+  equals(addrsAttr[0], a.get('attributes'), "check to see if the person's address attribute is the same as the address's attributes");
+  
+  // Check the group people stuff
+  pplAttr = testParent.readAttribute('people');
+  equals(pplAttr[0].addresses[0], a.get('attributes'), "check to see if the groups reference's address attribute is the same as the address's attributes");
+});
+
+test("Basic Array Functionality: pushObject", function() {   
+  var ppl, pplAttr, p, pFirst, pLast;
+  // Add something to the array
+  ppl = testParent.get('people');
+  // PushObject Tests
+  ppl.pushObject(personData1);
+  ppl = testParent.get('people');
+  equals(ppl.get('length'), 4, "after pushObject() on parent, check that the length of the array of child records is 4");
+  p = ppl.objectAt(3);
+  ok(SC.kindOf(p, SC.ChildRecord), "check that newly added ChildRecord creates an actual instance that is a kind of a SC.ChildRecord Object");
+  ok(SC.instanceOf(p, NestedRecord.Person), "check that newly added ChildRecord creates an actual instance of a Person Object");
+  equals(p.get('name'), 'Testikles, God Of Fertility', "after a pushObject on parent, check to see if it has all the right values for the attributes");
+  ok(p.get('status') & SC.Record.DIRTY, 'check that the child record is dirty');
+  ok(testParent.get('status') & SC.Record.DIRTY, 'check that the parent record is dirty'); 
+  
+  // Verify the Attrs
+  pplAttr = testParent.readAttribute('people');
+  equals(pplAttr.length, 4, "after pushObject() on parent, check that the length of the attribute array of child records is 4");
+  pFirst = ppl.objectAt(0);
+  pLast = ppl.objectAt(3);
+  same(pplAttr[0], pFirst.get('attributes'), "verify that parent attributes are the same as the first individual child attributes");
+  same(pplAttr[3], pLast.get('attributes'), "verify that parent attributes are the same as the last individual child attributes");  
+});
+
+test("Basic Array Functionality: popObject", function() {   
+  var ppl, pplAttr, p, pFirst, pLast;
+  // Add something to the array
+  ppl = testParent.get('people');
+  // popObject Tests
+  ppl.popObject();
+  ppl = testParent.get('people');
+  equals(ppl.get('length'), 2, "after popObject() on parent, check that the length of the array of child records is 2");
+  p = ppl.objectAt(0);
+  ok(SC.kindOf(p, SC.ChildRecord), "check that newly added ChildRecord creates an actual instance that is a kind of a SC.ChildRecord Object");
+  ok(SC.instanceOf(p, NestedRecord.Person), "check that newly added ChildRecord creates an actual instance of a Person Object");
+  equals(p.get('name'), 'Barack Obama', "after a pushObject on parent, check to see if it has all the right values for the attributes");
+  ok(p.get('status') & SC.Record.DIRTY, 'check that the child record is dirty');
+  ok(testParent.get('status') & SC.Record.DIRTY, 'check that the parent record is dirty'); 
+  
+  // Verify the Attrs
+  pplAttr = testParent.readAttribute('people');
+  equals(pplAttr.length, 2, "after pushObject() on parent, check that the length of the attribute array of child records is 2");
+  pFirst = ppl.objectAt(0);
+  pLast = ppl.objectAt(1);
+  same(pplAttr[0], pFirst.get('attributes'), "verify that parent attributes are the same as the first individual child attributes");
+  same(pplAttr[1], pLast.get('attributes'), "verify that parent attributes are the same as the last individual child attributes");  
+});
+
+test("Basic Array Functionality: shiftObject", function() {   
+  var ppl, p;
+  // Add something to the array
+  ppl = testParent.get('people');
+  // PushObject Tests
+  ppl.shiftObject();
+  ppl = testParent.get('people');
+  equals(ppl.get('length'), 2, "after shiftObject() on parent, check that the length of the array of child records is 2");
+  p = ppl.objectAt('0');
+  equals(p.get('name'), 'John Doe', "after a shiftObject on parent, check to see if it has all the right values for the attributes");
+  ok(testParent.get('status') & SC.Record.DIRTY, 'check that the parent record is dirty'); 
+});
+
+test("Basic Array Functionality: unshiftObject", function() {   
+  var ppl, pplAttr, p, pFirst, pLast;
+  // Add something to the array
+  ppl = testParent.get('people');
+  // PushObject Tests
+  ppl.unshiftObject(personData1);
+  ppl = testParent.get('people');
+  equals(ppl.get('length'), 4, "after unshiftObject() on parent, check that the length of the array of child records is 4");
+  p = ppl.objectAt(0);
+  ok(SC.kindOf(p, SC.ChildRecord), "check that newly added ChildRecord creates an actual instance that is a kind of a SC.ChildRecord Object");
+  ok(SC.instanceOf(p, NestedRecord.Person), "check that newly added ChildRecord creates an actual instance of a Person Object");
+  equals(p.get('name'), 'Testikles, God Of Fertility', "after a pushObject on parent, check to see if it has all the right values for the attributes");
+  ok(p.get('status') & SC.Record.DIRTY, 'check that the child record is dirty');
+  ok(testParent.get('status') & SC.Record.DIRTY, 'check that the parent record is dirty'); 
+  
+  // Verify the Attrs
+  pplAttr = testParent.readAttribute('people');
+  equals(pplAttr.length, 4, "after unshiftObject() on parent, check that the length of the attribute array of child records is 4");
+  pFirst = ppl.objectAt(0);
+  pLast = ppl.objectAt(3);
+  same(pplAttr[0], pFirst.get('attributes'), "verify that parent attributes are the same as the first individual child attributes");
+  same(pplAttr[3], pLast.get('attributes'), "verify that parent attributes are the same as the last individual child attributes");  
+});
+
+test("Test: normalization on complex nested records", function() {
+  var ppl, addresses, pAttrs;
+  // Add something to the array
+  ppl = testParent.get('people');
+  addresses = ppl.objectAt(0).get('addresses');
+  
+  // PushObject Tests
+  addresses.pushObject({ type: 'Address', street: '2 Main Street', city: 'Awesome'});
+  testParent.normalize();
+  pAttrs = testParent.get('attributes');
+  equals(pAttrs.people[0].addresses[2].state, 'VA', "test normalization is the default value of VA");
+});
+
+