sproutit-sproutcore 1.0.20090721145236 → 1.0.20090721145251

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

@@ -0,0 +1,46 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Apple, Inc. and contributors.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+/*globals module ok equals same test MyApp */
+
+var MyFoo = null ;
+module("SC.Record#unknownProperty", {
+  setup: function() {
+    MyApp = SC.Object.create({
+      store: SC.Store.create()
+    })  ;
+  
+    MyApp.Foo = SC.Record.extend();
+    MyApp.json = { 
+      foo: "bar", 
+      number: 123,
+      bool: YES,
+      array: [1,2,3] 
+    };
+    
+    MyApp.foo = MyApp.store.createRecord(MyApp.Foo, MyApp.json);
+  }
+});
+
+test("get() returns attributes with no type changes if they exist", function() {
+  'foo number bool array'.w().forEach(function(key) {
+    equals(MyApp.foo.get(key), MyApp.json[key], "MyApp.foo.get(%@) should === attribute".fmt(key));
+  });
+});
+
+test("get() unknown attribute returns undefined", function() {
+  equals(MyApp.foo.get('imaginary'), undefined, 'imaginary property should be undefined');
+});
+
+test("set() unknown property should add to dataHash", function() {
+  MyApp.foo.set('blue', '0x00f');
+  equals(MyApp.store.dataHashes[MyApp.foo.storeKey].blue, '0x00f', 'should add blue attribute');
+});
+
+test("set() should replace existing property", function() {
+  MyApp.foo.set('foo', 'baz');
+  equals(MyApp.store.dataHashes[MyApp.foo.storeKey].foo, 'baz', 'should update foo attribute');
+});
+

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

@@ -0,0 +1,71 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Apple, Inc. and contributors.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+/*globals module ok equals same test MyApp */
+
+var store, Foo, json, foo ;
+module("SC.Record#writeAttribute", {
+  setup: function() {
+    store = SC.Store.create();
+    Foo = SC.Record.extend();
+    json = { 
+      foo: "bar", 
+      number: 123,
+      bool: YES,
+      array: [1,2,3] 
+    };
+    
+    foo = store.createRecord(Foo, json);
+    store.writeStatus(foo.storeKey, SC.Record.READY_CLEAN); 
+  }
+});
+
+test("returns receiver", function() {
+  equals(foo.writeAttribute("bar", "baz"), foo, 'should return receiver');
+});
+
+test("first time writing should mark record as dirty", function() {
+  // precondition
+  equals(foo.get('status'), SC.Record.READY_CLEAN, 'precond - start clean');
+
+  // action
+  foo.writeAttribute("bar", "baz");
+
+  // evaluate
+  equals(foo.get('status'), SC.Record.READY_DIRTY, 'should make READY_DIRTY after write');
+});
+
+test("state change should be deferred if writing inside of a beginEditing()/endEditing() pair", function() {
+
+  // precondition
+  equals(foo.get('status'), SC.Record.READY_CLEAN, 'precond - start clean');
+
+  // action
+  foo.beginEditing();
+  foo.writeAttribute("bar", "baz");
+
+  equals(foo.get('status'), SC.Record.READY_CLEAN, 'should not change state yet');
+
+  foo.endEditing();
+
+  // evaluate
+  equals(foo.get('status'), SC.Record.READY_DIRTY, 'should make READY_DIRTY after write');
+  
+}) ;
+
+test("raises exception if you try to write an attribute before an attribute hash has been set", function() {
+  store.removeDataHash(foo.storeKey);
+  equals(store.readDataHash(foo.storeKey), null, 'precond - should not have store key');
+  
+  var e, cnt=0 ;
+  try {
+    foo.writeAttribute("foo", "bar");
+  } catch(e) {
+    equals(e, SC.Record.BAD_STATE_ERROR, 'should throw BAD_STATE_ERROR');
+    cnt++;
+  }
+  equals(cnt, 1, 'should raise exception');
+});
+

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

@@ -0,0 +1,204 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Apple, Inc. and contributors.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+/*globals module ok equals same test MyApp */
+
+// test core array-mapping methods for RecordArray with RecordAttribute
+var storeKeys, rec;
+module("SC.RecordAttribute 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),
+      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
+      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: 'foo1', 
+        firstName: "John", 
+        lastName: "Doe", 
+        date: "2009-03-01T20:30-08:00",
+        anArray: ['one', 'two', 'three'],
+        anObject: { 'key1': 'value1', 'key2': 'value2' }
+      },
+      
+      { 
+        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' }
+      }
+      
+    ]);
+    
+    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');
+    
+  }
+});
+
+// ..........................................................
+// READING
+// 
+
+test("pass-through should return builtin value" ,function() {
+  equals(rec.get('firstName'), 'John', 'reading prop should get attr value');
+});
+
+test("returns default value if underyling value is empty", function() {
+  equals(rec.get('defaultValue'), 'default', 'reading prop should return default value');
+});
+
+test("naming a key should read alternate attribute", function() {
+  equals(rec.get('otherName'), 'John', 'reading prop otherName should get attr from firstName');
+});
+
+test("getting 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, '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() {
+  var d = new Date(1235968200000); // should be proper date
+  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
+// 
+
+test("writing pass-through should simply set value", function() {
+  rec.set("firstName", "Foo");
+  equals(rec.readAttribute("firstName"), "Foo", "should write string");
+
+  rec.set("firstName", 23);
+  equals(rec.readAttribute("firstName"), 23, "should write number");
+
+  rec.set("firstName", YES);
+  equals(rec.readAttribute("firstName"), YES, "should write bool");
+  
+});
+
+test("writing a value should override default value", function() {
+
+  equals(rec.get('defaultValue'), 'default', 'precond - returns default');
+  rec.set('defaultValue', 'not-default');
+  equals(rec.get('defaultValue'), 'not-default', 'newly written value should replace default value');
+});
+
+test("writing to a to-one relationship should update set guid", function() {
+  var rec2 = MyApp.store.find(MyApp.Foo, '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');
+  
+  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() {
+  var date = new Date(1238650083966);
+  equals(rec.set('date', date), rec, 'returns reciever');
+  equals(rec.readAttribute('date'), '2009-04-01T22:28:03-07:00', 'should have new time (%@)'.fmt(date.toString()));
+});

data/frameworks/sproutcore/frameworks/datastore/tests/system/many_array/core_methods.js

@@ -0,0 +1,178 @@
+// ==========================================================================
+// 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
+var store, storeKey, storeId, rec, storeIds, recs;
+module("SC.ManyArray core methods", {
+  setup: function() {
+    // setup dummy app and store
+    MyApp = SC.Object.create({
+      store: SC.Store.create()
+    });
+    
+    // setup a dummy model
+    MyApp.Foo = SC.Record.extend({});
+    
+    // load some data
+    MyApp.store.loadRecords(MyApp.Foo, [
+      { guid: 1, firstName: "John", lastName: "Doe" },
+      { guid: 2, firstName: "Jane", lastName: "Doe" },
+      { guid: 3, firstName: "Emily", lastName: "Parker" },
+      { guid: 4, firstName: "Johnny", lastName: "Cash" }
+    ]);
+    
+    storeKey = MyApp.store.storeKeyFor(MyApp.Foo, 1);
+    
+    // get record
+    rec = MyApp.store.materializeRecord(storeKey);
+    storeId = rec.get('id');
+    
+    // get many array.
+    storeIds = [1,2,3,4];
+    recs = SC.ManyArray.create({ store: MyApp.store, storeIds: storeIds, recordType: MyApp.Foo });
+    
+  }
+});
+
+// ..........................................................
+// LENGTH
+// 
+
+test("should pass through length", function() {
+  equals(recs.get('length'), storeIds.length, 'rec should pass through length');  
+});
+
+test("changing storeIds length should change length of rec array also", function() {
+
+  var oldlen = recs.get('length');
+  
+  storeIds.pushObject(SC.Store.generateStoreKey()); // change length
+  
+  ok(storeIds.length > oldlen, 'precond - storeKeys.length should have changed');
+  equals(recs.get('length'), storeIds.length, 'rec should pass through length');    
+});
+
+// ..........................................................
+// objectAt
+// 
+
+test("should materialize record for object", function() {
+  equals(storeIds[0], storeId, 'precond - storeIds[0] should be storeId');
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');
+});
+
+test("reading past end of array length should return undefined", function() {
+  equals(recs.objectAt(2000), undefined, 'recs.objectAt(2000) should be undefined');
+});
+
+test("modifying the underlying storeId should change the returned materialized record", function() {
+  // read record once to make it materialized
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');  
+  
+  // create a new record.
+  var rec2 = MyApp.store.createRecord(MyApp.Foo, { guid: 5, firstName: "Fred" });
+  var storeId2 = rec2.get('id');
+  
+  // add to beginning of storeKey array
+  storeIds.unshiftObject(storeId2);
+  equals(recs.get('length'), 5, 'should now have length of 5');
+  equals(recs.objectAt(0), rec2, 'objectAt(0) should return new record');
+  equals(recs.objectAt(1), rec, 'objectAt(1) should return old record');
+});
+
+test("reading a record not loaded in store should trigger retrieveRecord", function() {
+  var callCount = 0;
+
+  // patch up store to record a call and to make it look like data is not 
+  // loaded.
+  
+  MyApp.store.removeDataHash(storeKey, SC.Record.EMPTY);
+  MyApp.store.retrieveRecord = function() { callCount++; };
+  
+  var rec = recs.objectAt(0);
+  equals(MyApp.store.readStatus(rec), SC.Record.EMPTY, 'precond - storeKey must not be loaded');
+  
+  equals(callCount, 1, 'store.retrieveRecord() should have been called');
+});
+
+// ..........................................................
+// replace()
+// 
+
+test("adding a record to the ManyArray should pass through storeIds", function() {
+
+  // read record once to make it materialized
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');  
+  
+  // create a new record.
+  var rec2 = MyApp.store.createRecord(MyApp.Foo, { guid: 5, firstName: "rec2" });
+  var storeId2 = rec2.get('id');
+  
+  // add record to beginning of record array
+  recs.unshiftObject(rec2);
+  
+  // verify record array
+  equals(recs.get('length'), 5, 'should now have length of 2');
+  equals(recs.objectAt(0), rec2, 'recs.objectAt(0) should return new record');
+  equals(recs.objectAt(1), rec, 'recs.objectAt(1) should return old record');
+  
+  // verify storeKeys
+  equals(storeIds.objectAt(0), storeId2, 'storeKeys[0] should return new storeKey');
+  equals(storeIds.objectAt(1), storeId, 'storeKeys[1] should return old storeKey');
+});
+
+// ..........................................................
+// Property Observing
+// 
+
+test("changing the underlying storeIds should notify observers of records", function() {
+
+  // setup observer
+  var obj = SC.Object.create({
+    cnt: 0,
+    observer: function() { this.cnt++; }
+  });
+  recs.addObserver('[]', obj, obj.observer); 
+  
+  // now modify storeKeys
+  storeIds.pushObject(5);
+  equals(obj.cnt, 1, 'observer should have fired after changing storeKeys');
+});
+
+test("swapping storeIds array should change ManyArray and observers", function() {
+
+  // setup alternate storeKeys
+  var rec2 = MyApp.store.createRecord(MyApp.Foo, { guid: 5, firstName: "rec2" });
+  var storeId2 = rec2.get('id');
+  var storeIds2 = [storeId2];
+
+  // setup observer
+  var obj = SC.Object.create({
+    cnt: 0,
+    observer: function() { this.cnt++; }
+  });
+  recs.addObserver('[]', obj, obj.observer); 
+  
+  // read record once to make it materialized
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');  
+  
+  // now swap storeKeys
+  obj.cnt = 0 ;
+  recs.set('storeIds', storeIds2);
+  
+  // verify observer fired and record changed
+  equals(obj.cnt, 1, 'observer should have fired after swap');
+  equals(recs.objectAt(0), rec2, 'recs.objectAt(0) should return new rec');
+  
+  // modify storeKey2, make sure observer fires and content changes
+  obj.cnt = 0;
+  storeIds2.unshiftObject(storeId);
+  equals(obj.cnt, 1, 'observer should have fired after edit');
+  equals(recs.get('length'), 2, 'should reflect new length');
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should return pushed rec');  
+
+});