sproutit-sproutcore 1.0.0.20090416161445 → 1.0.0.20090720093355

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

@@ -21,7 +21,7 @@ module("SC.FixturesDataSource", {
     { guid: '134',name: 'Music', fileType: 'music', url: '/emily_parker/Music', isDirectory: true, parent: '10', children: 'Collection', createdAt: 'June 15, 2007', modifiedAt: 'June 15, 2007', filetype: 'directory', isShared: true, sharedAt: 'October 15, 2007', sharedUntil: 'March 31, 2008', sharedUrl: '2fhty', isPasswordRequired: true},
     { guid: '135',name: 'Pictures', fileType: 'pictures', url: '/emily_parker/Pictures', isDirectory: true, parent: '10', children: 'Collection', createdAt: 'June 15, 2007', modifiedAt: 'June 15, 2007', filetype: 'directory', isShared: true, sharedAt: 'October 15, 2007', sharedUntil: 'March 31, 2008', sharedUrl: '2fhty', isPasswordRequired: true},
     { guid: '13', name: 'Auto Insurance', fileType: 'folder', url: '/emily_parker/Documents/Auto%20Insurance', isDirectory: true, parent: '11', children: 'Collection', createdAt: 'June 15, 2007', modifiedAt: 'October 21, 2007', filetype: 'directory', isShared: false},
-    { guid: '14', name: 'Birthday Invitation.pdf', fileType: 'file', url: '/emily_parker/Documents/Birthday%20Invitation', isDirectory: false, parent: '11', createdAt: 'October 17, 2007', modifiedAt: 'October 21, 2007', filetype: 'pdf', isShared: false},
+    { guid: '150', name: 'Birthday Invitation.pdf', fileType: 'file', url: '/emily_parker/Documents/Birthday%20Invitation', isDirectory: false, parent: '11', createdAt: 'October 17, 2007', modifiedAt: 'October 21, 2007', filetype: 'pdf', isShared: false},
     { guid: '136', name: 'Software', fileType: 'software', url: '/emily_parker/Software', isDirectory: true, parent: '10', children: 'Collection', createdAt: 'June 15, 2007', modifiedAt: 'June 15, 2007', filetype: 'directory', isShared: true, sharedAt: 'October 15, 2007', sharedUntil: 'March 31, 2008', sharedUrl: '2fhty', isPasswordRequired: true}
     ];
     
@@ -30,13 +30,37 @@ module("SC.FixturesDataSource", {
 });
 
 test("Verify findAll() loads all fixture data", function() {
-  var result = store.findAll(Sample.File);
+  var result = store.findAll(Sample.File),
+      rec, storeKey, dataHash;
+      
   ok(result, 'should return a result');
   equals(result.get('length'), Sample.File.FIXTURES.get('length'), 'should return records for each item in FIXTURES');
+  
+  // verify storeKeys actually return Records
+  var idx, len = result.get('length'), expected = [];
+  for(idx=0;idx<len;idx++) {
+    rec = result.objectAt(idx);
+    storeKey = rec ? rec.get('storeKey') : null;
+    dataHash = storeKey ? store.readDataHash(storeKey) : null;
+
+    ok(!!dataHash, 'storeKey at result[%@] (%@) should return dataHash'.fmt(idx, storeKey));
+    
+    expected.push(rec); // save record for later test
+  }
+  
+  // verify multiple calls to findAll() returns SAME data
+  result = store.findAll(Sample.File);
+  
+  equals(result.get('length'), expected.length, 'second result should have same length as first');
+  len = result.get('length');
+  for(idx=0;idx<len;idx++) {
+    rec = result.objectAt(idx);
+    equals(rec, expected[idx], 'record returned at index %@ should be same as previous'.fmt(idx));
+  }
 });
 
 test("Verify find() loads data from store", function() {
-  var sk=store.find(Sample.File, "14");
+  var sk=store.find(Sample.File, "150");
   equals(sk.get('name'), 'Birthday Invitation.pdf', 'returns record should have name from fixture');
 });
 
@@ -83,4 +107,15 @@ test("Update and commit a record", function() {
   fixture = fixtures.fixtureForStoreKey(store, storeKey);
   equals(fixture.name, rec.get('name'), 'fixture state should update to match new name');
     
+});
+
+test("Using SC.Query on fetch()", function() {
+  
+  var fixtures = store.get('dataSource');
+  
+  var q = SC.Query.create({recordType: Sample.File});
+  
+  var storeKeys = fixtures.fetch(store, q);
+  equals(storeKeys.length, 9, 'storeKeys length should be 9');
+
 });

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

@@ -0,0 +1,94 @@
+// ==========================================================================
+// 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 ManyArray with ManyAttribute
+var storeKeys, rec;
+module("SC.ManyAttribute 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 toMany relationships
+      fooMany: SC.Record.toMany('MyApp.Foo')
+      
+    });
+    
+    storeKeys = MyApp.store.loadRecords(MyApp.Foo, [
+      { guid: 1, firstName: "John", lastName: "Doe" },
+      { guid: 2, firstName: "Jane", lastName: "Doe" },
+      { guid: 3, firstName: "Emily", lastName: "Parker", fooMany: [1,2] },
+      { guid: 4, firstName: "Johnny", lastName: "Cash" }
+    ]);
+    
+    rec = MyApp.store.find(MyApp.Foo, 1);
+    rec2 = MyApp.store.find(MyApp.Foo, 2);
+    rec3 = MyApp.store.find(MyApp.Foo, 3);
+    rec4 = MyApp.store.find(MyApp.Foo, 4);
+    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("getting toMany relationship should map guid to real records", function() {
+  var rec3 = MyApp.store.find(MyApp.Foo, 3);
+  equals(rec3.get('id'), 3, 'precond - should find record 3');
+  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');
+});
+
+// ..........................................................
+// WRITING
+// 
+
+test("writing to a to-many relationship should update set guids", function() {
+  var rec3 = MyApp.store.find(MyApp.Foo, 3);
+  equals(rec3.get('id'), 3, 'precond - should find record 3');
+  equals(rec3.get('fooMany').objectAt(0), rec, 'should get rec1 instance for rec3.fooMany');
+  
+  rec3.set('fooMany', [rec2, rec4]);
+  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');
+});
+
+test("pushing an object to a to-many relationship attribute should update set guids", function() {
+  var rec3 = MyApp.store.find(MyApp.Foo, 3);
+  equals(rec3.get('id'), 3, 'precond - should find record 3');
+  equals(rec3.get('fooMany').length(), 2, 'should be 2 foo instances related');
+  
+  rec3.get('fooMany').pushObject(rec4);
+  
+  equals(rec3.get('fooMany').length(), 3, 'should be 3 foo instances related');
+  
+  equals(rec3.get('fooMany').objectAt(0), rec, 'should get rec instance for rec3.fooMany');
+  equals(rec3.get('fooMany').objectAt(1), rec2, 'should get rec2 instance for rec3.fooMany');
+  equals(rec3.get('fooMany').objectAt(2), rec4, 'should get rec4 instance for rec3.fooMany');
+});

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

@@ -0,0 +1,30 @@
+// ==========================================================================
+// 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 MyApp;
+module("SC.Record core methods", {
+  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("statusString", function() {
+  equals(MyApp.foo.statusString(), 'READY_NEW', 'status string should be READY_NEW');
+});

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

@@ -0,0 +1,238 @@
+// ==========================================================================
+// 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 normalize method for SC.Record
+var storeKeys, rec;
+module("SC.Record normalize method", {
+  setup: function() {
+
+    MyApp = SC.Object.create({
+      store: SC.Store.create()
+    });
+    
+    MyApp.Foo = SC.Record.extend({
+      
+      guid: SC.Record.attr(String, { defaultValue: function() {
+        var i, rnum, chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz",
+          strLen = 8, ret = '';
+    		for (i=0; i<strLen; i++) {
+    			rnum = Math.floor(Math.random() * chars.length);
+    			ret += chars.substring(rnum,rnum+1);
+    		}
+    		return ret;
+      } }),
+      
+      // test simple reading of a pass-through prop
+      firstName: SC.Record.attr(String),
+
+      // test Array
+      anArray: SC.Record.attr(Array),
+      
+      // used to test default value
+      defaultValue: SC.Record.attr(String, {
+        defaultValue: "default"
+      }),
+      
+      // test toOne relationships
+      relatedTo: SC.Record.toOne('MyApp.Foo', { defaultValue: '1' }),
+      
+      // test toOne relationship computed default
+      relatedToComputed: SC.Record.toOne('MyApp.Foo', { 
+        defaultValue: function() {
+          var num = Math.floor(Math.random()*2+1);
+          return 'foo' + num;
+        }
+      }),
+      
+      // test toMany relationships
+      relatedToMany: SC.Record.toMany('MyApp.Foo')
+ 
+    });
+    
+    MyApp.Bar = SC.Record.extend({
+      // test toOne relationships
+      relatedTo: SC.Record.toOne('MyApp.Bar', { defaultValue: '1' })
+    });
+    
+    storeKeys = MyApp.store.loadRecords(MyApp.Foo, [
+      { 
+        guid: 'foo1', 
+        firstName: 123, 
+        anArray: ['one', 'two', 'three']
+      },
+      
+      { 
+        guid: 'foo2', 
+        firstName: "Jane",
+        relatedTo: 'foo1'
+      },
+      
+      {
+        guid: 'foo3'
+      }
+      
+    ]);
+    
+    rec = MyApp.store.find(MyApp.Foo, 'foo1');
+    rec2 = MyApp.store.find(MyApp.Foo, 'foo2');
+    rec3 = MyApp.store.find(MyApp.Foo, 'foo3');
+    
+    equals(rec.storeKey, storeKeys[0], 'should find record');
+    
+  }
+});
+
+// ..........................................................
+// NORMALIZING
+// 
+
+test("normalizing a pre-populated record" ,function() {
+  
+  equals(rec.attributes()['firstName'], 123, 'hash value of firstName is 123');
+  equals(rec.get('firstName'), '123', 'get value of firstName is 123 string');
+  
+  rec.normalize();
+  
+  var sameValue = rec.attributes()['firstName'] === '123';
+  var relatedTo = rec.attributes()['relatedTo'] === '1';
+  var relatedToComputed = rec.attributes()['relatedToComputed'];
+  
+  var computedValues = ['foo1', 'foo2', 'foo3'];
+  
+  ok(sameValue, 'hash value of firstName after normalizing is 123 string');
+  ok(sameValue, 'hash value of relatedTo should be 1');
+  ok(computedValues.indexOf(relatedToComputed)!==-1, 'hash value of relatedToComputed should be either foo1, foo2 or foo3');
+  
+  equals(rec.get('firstName'), '123', 'get value of firstName after normalizing is 123 string');
+  
+});
+
+test("normalizing an empty record" ,function() {
+  
+  equals(rec3.attributes()['defaultValue'], undefined, 'hash value of defaultValue is undefined');
+  equals(rec3.get('defaultValue'), 'default', 'get value of defaultValue is default');
+  
+  rec3.normalize();
+  
+  equals(rec3.attributes()['defaultValue'], 'default', 'hash value of defaultValue after normalizing is default');
+  equals(rec3.get('defaultValue'), 'default', 'get value of defaultValue after normalizing is default');
+  
+});
+
+test("normalizing with includeNull flag" ,function() {
+  
+  equals(rec3.attributes()['firstName'], undefined, 'hash value of firstName is undefined');
+  equals(rec3.get('firstName'), null, 'get value of firstName is null');
+  
+  rec3.normalize(YES);
+  
+  equals(rec3.attributes()['firstName'], null, 'hash value of firstName after normalizing is null');
+  equals(rec3.get('firstName'), null, 'get value of firstName after normalizing is null');
+  
+});
+
+test("normalizing a new record with toOne should reflect id in data hash" ,function() {
+
+  var recHash = { 
+    guid: 'foo4', 
+    firstName: "Jack",
+    relatedTo: 'foo1'
+  };
+
+  var newRecord = MyApp.store.createRecord(MyApp.Foo, recHash);
+  MyApp.store.commitRecords();
+  
+  equals(newRecord.attributes()['relatedTo'], 'foo1', 'hash value of relatedTo is foo1');
+  equals(newRecord.get('relatedTo'), rec, 'get value of relatedTo is foo1');
+  
+  newRecord.normalize();
+  
+  equals(newRecord.attributes()['relatedTo'], 'foo1', 'hash value of relatedTo after normalizing is still foo1');
+  equals(newRecord.get('relatedTo'), rec, 'get value of relatedTo after normalizing remains foo1');
+  
+});
+
+test("normalizing a new record with toMany should reflect id in data hash" ,function() {
+
+  var recHash = { 
+    guid: 'foo5', 
+    firstName: "Andrew",
+    relatedToMany: ['foo1', 'foo2']
+  };
+
+  var newRecord = MyApp.store.createRecord(MyApp.Foo, recHash);
+  MyApp.store.commitRecords();
+  
+  ok(SC.typeOf(newRecord.attributes()['relatedToMany'])===SC.T_ARRAY, 'should be a hash');
+  equals(newRecord.get('relatedToMany').get('length'), 2, 'number of relatedToMany is 2');
+  
+  newRecord.normalize();
+  
+  ok(SC.typeOf(newRecord.attributes()['relatedToMany'])===SC.T_ARRAY, 'should still be a hash after normalizing');
+  equals(newRecord.get('relatedToMany').get('length'), 2, 'number of relatedToMany is still 2');
+  
+});
+
+test("normalizing a new record with toOne that has broken relationship" ,function() {
+
+  var recHash = { 
+    guid: 'foo5', 
+    firstName: "Andrew",
+    relatedTo: 'foo10' // does not exist
+  };
+
+  var newRecord = MyApp.store.createRecord(MyApp.Foo, recHash);
+  MyApp.store.commitRecords();
+  
+  equals(newRecord.attributes()['relatedTo'], 'foo10', 'should be foo10');
+  
+  newRecord.normalize();
+  
+  equals(newRecord.attributes()['relatedTo'], 'foo10', 'should remain foo10');
+  
+});
+
+test("normalizing a new record with toOne with relationship to wrong recordType" ,function() {
+
+  var recHash = { 
+    guid: 'bar1', 
+    firstName: "Andrew",
+    relatedTo: 'foo1' // does exist but wrong recordType
+  };
+
+  var newRecord = MyApp.store.createRecord(MyApp.Bar, recHash);
+  MyApp.store.commitRecords();
+  
+  equals(newRecord.attributes()['relatedTo'], 'foo1', 'should be foo1');
+  
+  newRecord.normalize();
+  
+  equals(newRecord.attributes()['relatedTo'], 'foo1', 'should remain foo1');
+  
+});
+
+test("normalizing a new record with no guid should work with defaultValue" ,function() {
+  
+  var recHash = { 
+    firstName: "Andrew",
+    relatedTo: 'foo1' // does exist but wrong recordType
+  };
+  
+  var newRecord = MyApp.store.createRecord(MyApp.Foo, recHash);
+  MyApp.store.commitRecords();
+  
+  var firstGuid = newRecord.get('guid');
+  
+  equals(newRecord.get('firstName'), 'Andrew', 'firstName should be Andrew');
+  
+  newRecord.normalize();
+  
+  var findRecord = MyApp.store.find(MyApp.Foo, firstGuid);
+  
+  equals(findRecord.get('guid'), firstGuid, 'guid should be the same as first');
+  
+});

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

@@ -5,9 +5,9 @@
 // ==========================================================================
 /*globals module ok equals same test MyApp */
 
-// test core array-mapping methods for RecordArray
+// test core array-mapping methods for RecordArray with RecordAttribute
 var storeKeys, rec;
-module("SC.RecordArray core methods", {
+module("SC.RecordAttribute core methods", {
   setup: function() {
 
     MyApp = SC.Object.create({
@@ -24,28 +24,81 @@ module("SC.RecordArray core methods", {
       
       // test mapping Date
       date: SC.Record.attr(Date),
+      nonIsoDate: SC.Record.attr(Date, { useIsoDate: false }),
+      
+      // test Array
+      anArray: SC.Record.attr(Array),
+      
+      // test Object
+      anObject: SC.Record.attr(Object),
       
       // used to test default value
       defaultValue: SC.Record.attr(String, {
         defaultValue: "default"
       }),
       
+      // used to test default value
+      defaultComputedValue: SC.Record.attr(Number, {
+        defaultValue: function() {
+          return Math.floor(Math.random()*3+1);
+        }
+      }),
+      
       // test toOne relationships
-      foo: SC.Record.attr('MyApp.Foo')
+      relatedTo: SC.Record.toOne('MyApp.Foo'),
+      
+      // test toOne relationship with computed type
+      relatedToComputed: SC.Record.toOne(function() {
+        // not using .get() to avoid another transform which will 
+        // trigger an infinite loop
+        return (this.readAttribute('relatedToComputed').indexOf("foo")==0) ? MyApp.Foo : MyApp.Bar;
+      })
       
     });
     
+    MyApp.Bar = SC.Record.extend({});
+    
     storeKeys = MyApp.store.loadRecords(MyApp.Foo, [
-      { guid: 1, 
-        firstName: "John", lastName: "Doe", 
-        date: "2009-03-01T20:30-08:00" 
+      { 
+        guid: 'foo1', 
+        firstName: "John", 
+        lastName: "Doe", 
+        date: "2009-03-01T20:30-08:00",
+        anArray: ['one', 'two', 'three'],
+        anObject: { 'key1': 'value1', 'key2': 'value2' }
       },
       
-      { guid: 2, firstName: "Jane", lastName: "Doe", foo: 1 }
+      { 
+        guid: 'foo2', 
+        firstName: "Jane", 
+        lastName: "Doe", 
+        relatedTo: 'foo1',
+        anArray: 'notAnArray',
+        anObject: 'notAnObject',
+        nonIsoDate: "2009/06/10 8:55:50 +0000"
+      },
+      
+      { 
+        guid: 'foo3', 
+        firstName: "Alex", 
+        lastName: "Doe", 
+        relatedToComputed: 'bar1',
+        anArray: ['one', 'two', 'three'],
+        anObject: { 'key1': 'value1', 'key2': 'value2' }
+      }
+      
     ]);
     
-    rec = MyApp.store.find(MyApp.Foo, 1);
+    MyApp.store.loadRecords(MyApp.Bar, [
+      { guid: 'bar1', city: "Chicago" }
+    ]);
+    
+    rec = MyApp.store.find(MyApp.Foo, 'foo1');
+    rec2 = MyApp.store.find(MyApp.Foo, 'foo2');
+    
+    bar = MyApp.store.find(MyApp.Bar, 'bar1');
     equals(rec.storeKey, storeKeys[0], 'should find record');
+    
   }
 });
 
@@ -65,10 +118,26 @@ test("naming a key should read alternate attribute", function() {
   equals(rec.get('otherName'), 'John', 'reading prop otherName should get attr from firstName');
 });
 
+test("getting an array and object", function() {
+  equals(rec.get('anArray').length, 3, 'reading prop anArray should get attr as array');
+  equals((typeof rec.get('anObject')), 'object', 'reading prop anObject should get attr as object');
+});
+
+test("getting an array and object attributes where underlying value is not", function() {
+  equals(rec2.get('anArray').length, 0, 'reading prop anArray should return empty array');
+  equals((typeof rec2.get('anObject')), 'object', 'reading prop anObject should return empty object');
+});
+
 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');
+  var rec2 = MyApp.store.find(MyApp.Foo, 'foo2');
+  equals(rec2.get('id'), 'foo2', 'precond - should find record 2');
+  equals(rec2.get('relatedTo'), rec, 'should get rec1 instance for rec2.relatedTo');
+});
+
+test("getting toOne relationship from computed attribute should map guid to a real record", function() {
+  var rec3 = MyApp.store.find(MyApp.Foo, 'foo3');
+  equals(rec3.get('id'), 'foo3', 'precond - should find record 3');
+  equals(rec3.get('relatedToComputed'), bar, 'should get bar1 instance for rec3.relatedToComputed');
 });
 
 test("reading date should parse ISO date", function() {
@@ -76,6 +145,17 @@ test("reading date should parse ISO date", function() {
   equals(rec.get('date').toString(), d.toString(), 'should have matched date');
 });
 
+test("reading date should parse non-ISO date", function() {
+  var d = new Date(2009,6,10,8,55,50);
+  equals(rec2.get('nonIsoDate').toString(), d.toString(), 'should have matched date');
+});
+
+test("reading computed default value", function() {
+  var value = rec.get('defaultComputedValue');
+  var validValues = [1,2,3,4];
+  ok(validValues.indexOf(value)!==-1, 'should have a value from 1 through 4');
+});
+
 // ..........................................................
 // WRITING
 // 
@@ -100,12 +180,21 @@ test("writing a value should override default value", function() {
 });
 
 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');
+  var rec2 = MyApp.store.find(MyApp.Foo, 'foo2');
+  equals(rec2.get('id'), 'foo2', 'precond - should find record 2');
+  equals(rec2.get('relatedTo'), rec, 'precond - should get rec1 instance for rec2.relatedTo');
+  
+  rec2.set('relatedTo', rec2);
+  equals(rec2.readAttribute('relatedTo'), 'foo2', 'should write ID for set record to relatedTo attribute');
+});
+
+test("writing to a to-one computed relationship should update set guid", function() {
+  var rec3 = MyApp.store.find(MyApp.Foo, 'foo3');
+  equals(rec3.get('id'), 'foo3', 'precond - should find record 2');
+  equals(rec3.get('relatedToComputed'), bar, 'precond - should get bar1 instance for rec3.relatedToComputed');
   
-  rec2.set('foo', rec2);
-  equals(rec2.readAttribute('foo'), 2, 'should write ID for set record to foo attribute');
+  rec3.set('relatedToComputed', rec);
+  equals(rec3.readAttribute('relatedToComputed'), 'foo1', 'should write ID for set record to relatedTo attribute');
 });
 
 test("writing a date should generate an ISO date" ,function() {