sproutcore 1.6.0.beta.3-java → 1.6.0-java

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

@@ -0,0 +1,203 @@
+// ==========================================================================
+// Project:   SC.DataSource Unit Test
+// Copyright: ©2011 Junction Networks and contributors.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+/*globals JN module test ok equals same stop start */
+
+var MyApp, wasCalled, resetWasCalled;
+module("SC.DataSource", {
+  setup: function () {
+    MyApp = window.MyApp = {};
+    MyApp.store = SC.Store.create();
+    MyApp.Foo = SC.Record.extend();
+
+    MyApp.DataSource = SC.DataSource.extend({
+      fetch: function (store, query) {
+        wasCalled = true;
+        equals(arguments.length, 2);
+        return YES;
+      },
+
+      createRecord: function (store, storeKey, params) {
+        wasCalled = true;
+        equals(arguments.length, 3);
+        return YES;
+      },
+
+      updateRecord: function (store, storeKey, params) {
+        wasCalled = true;
+        equals(arguments.length, 3);
+        return YES;
+      },
+
+      retrieveRecord: function (store, storeKey, params) {
+        wasCalled = true;
+        equals(arguments.length, 3);
+        return YES;
+      },
+
+      destroyRecord: function (store, storeKey, params) {
+        wasCalled = true;
+        equals(arguments.length, 3);
+        return YES;
+      },
+
+      reset: function() {
+        resetWasCalled = true;
+        return this;
+      }
+    });
+    SC.RunLoop.begin();
+  },
+
+  teardown: function () {
+    SC.RunLoop.end();
+  }
+});
+
+test("The dataSource will forward calls to the appropriate methods", function () {
+  var ds = MyApp.DataSource.create();
+  MyApp.store.set('dataSource', ds);
+  ok(MyApp.store.find(SC.Query.remote(MyApp.Foo)),
+     "the fetch should return a record array");
+  ok(wasCalled, "`fetch` should have been called");
+  wasCalled = NO;
+
+  ok(MyApp.store.find(MyApp.Foo, "testing retrieve"),
+     "retrieve should return a new record (because the dataSource handled the request YES)");
+  ok(wasCalled, "`retrieve` should have been called");
+  wasCalled = NO;
+
+  var rec = MyApp.store.createRecord(MyApp.Foo, {});
+
+  equals(MyApp.store.commitRecord(MyApp.Foo, 'foo', rec.get('storeKey')), YES,
+         "commiting a new record should return YES");
+  ok(wasCalled, "`createRecord` should have been called");
+  wasCalled = NO;
+
+  MyApp.store.writeStatus(rec.get('storeKey'), SC.Record.READY_CLEAN);
+
+  rec.set('zero', 0);
+  equals(MyApp.store.commitRecord(MyApp.Foo, 'foo', rec.get('storeKey')), YES,
+         "updating a record should return YES");
+  ok(wasCalled, "`updateRecord` should have been called");
+  wasCalled = NO;
+
+  MyApp.store.writeStatus(rec.get('storeKey'), SC.Record.READY_CLEAN);
+
+  rec.destroy();
+  // broken in SC.Store
+  equals(MyApp.store.commitRecord(MyApp.Foo, 'foo', rec.get('storeKey')), YES,
+     "destroying the record should return YES");
+  ok(wasCalled, "`destroyRecord` should have been called");
+});
+
+test("The dataSource will return YES when all records committed return YES", function () {
+  var ds = MyApp.DataSource.create({
+    createRecord: function () { return YES; },
+    updateRecord: function () { return YES; },
+    destroyRecord: function () { return YES; }
+  });
+
+  MyApp.store.set('dataSource', ds);
+
+  var rec1 = MyApp.store.createRecord(MyApp.Foo, {}),
+      rec2, rec3;
+
+  equals(MyApp.store.commitRecords(), YES,
+         "commiting a single new record should return YES");
+
+  MyApp.store.writeStatus(rec1.get('storeKey'), SC.Record.READY_CLEAN);
+
+  rec1.set('zero', 0);
+  rec2 = MyApp.store.createRecord(MyApp.Foo, {});
+
+  equals(MyApp.store.commitRecords(), YES,
+         "commiting records for an 'update' and 'create' should return YES");
+
+  MyApp.store.writeStatus(rec1.get('storeKey'), SC.Record.READY_CLEAN);
+  MyApp.store.writeStatus(rec2.get('storeKey'), SC.Record.READY_CLEAN);
+
+  rec1.destroy();
+  rec2.set('one', 1);
+  rec3 = MyApp.store.createRecord(MyApp.Foo, {});
+
+  equals(MyApp.store.commitRecords(), YES,
+         "commiting records for an 'update', 'create', and 'destroy' should return YES");
+});
+
+test("The dataSource will return SC.MIXED_STATE when all records committed return YES and NO", function () {
+  var ds = MyApp.DataSource.create({
+    createRecord: function () { return NO; },
+    updateRecord: function () { return YES; },
+    destroyRecord: function () { return NO; }
+  });
+
+  MyApp.store.set('dataSource', ds);
+
+  var rec1 = MyApp.store.createRecord(MyApp.Foo, {}),
+      rec2, rec3;
+
+  equals(MyApp.store.commitRecords(), NO,
+         "commiting a single new record should return NO");
+
+  MyApp.store.writeStatus(rec1.get('storeKey'), SC.Record.READY_CLEAN);
+
+  rec1.set('zero', 0);
+  rec2 = MyApp.store.createRecord(MyApp.Foo, {});
+
+  equals(MyApp.store.commitRecords(), SC.MIXED_STATE,
+         "commiting records for an 'update' and 'create' should return %@".fmt(SC.MIXED_STATE));
+
+  MyApp.store.writeStatus(rec1.get('storeKey'), SC.Record.READY_CLEAN);
+  MyApp.store.writeStatus(rec2.get('storeKey'), SC.Record.READY_CLEAN);
+
+  rec1.destroy();
+  rec2.set('one', 1);
+  rec3 = MyApp.store.createRecord(MyApp.Foo, {});
+
+  equals(MyApp.store.commitRecords(), SC.MIXED_STATE,
+         "commiting records for an 'update', 'create', and 'destroy' should return %@".fmt(SC.MIXED_STATE));
+});
+
+test("The dataSource will return NO when all records committed return NO", function () {
+  var ds = MyApp.DataSource.create({
+    createRecord: function () { return NO; },
+    updateRecord: function () { return NO; },
+    destroyRecord: function () { return NO; }
+  });
+  MyApp.store.set('dataSource', ds);
+
+  var rec1 = MyApp.store.createRecord(MyApp.Foo, {}),
+      rec2, rec3;
+
+  equals(MyApp.store.commitRecords(), NO,
+         "commiting a single new record should return NO");
+
+  MyApp.store.writeStatus(rec1.get('storeKey'), SC.Record.READY_CLEAN);
+
+  rec1.set('zero', 0);
+  rec2 = MyApp.store.createRecord(MyApp.Foo, {});
+
+  equals(MyApp.store.commitRecords(), NO,
+         "commiting records for an 'update' and 'create' should return NO");
+
+  MyApp.store.writeStatus(rec1.get('storeKey'), SC.Record.READY_CLEAN);
+  MyApp.store.writeStatus(rec2.get('storeKey'), SC.Record.READY_CLEAN);
+
+  rec1.destroy();
+  rec2.set('one', 1);
+  rec3 = MyApp.store.createRecord(MyApp.Foo, {});
+
+  equals(MyApp.store.commitRecords(), NO,
+         "commiting records for an 'update', 'create', and 'destroy' should return NO");
+});
+
+test("The store calls reset on the dataSource when reset", function(){
+  MyApp.store.set('dataSource', MyApp.DataSource.create());
+  resetWasCalled = NO; // Just to be sure
+
+  MyApp.store.reset();
+  ok(resetWasCalled, "should have called reset");
+});

data/lib/frameworks/sproutcore/frameworks/datastore/tests/models/nested_records/nested_record.js

@@ -9,7 +9,7 @@
 // 
 var NestedRecord, store, testParent, testParent2, childData1; 
 
-var initModels = function(){
+var initModels = function() {
   NestedRecord.ParentRecordTest = SC.Record.extend({
     /** Child Record Namespace */
     nestedRecordNamespace: NestedRecord,
@@ -34,6 +34,7 @@ module("Basic SC.Record Functions w/ Parent > Child", {
     NestedRecord = SC.Object.create({
       store: SC.Store.create()
     });
+    window.NestedRecord = NestedRecord;
     store = NestedRecord.store;
     initModels();
     SC.RunLoop.begin();
@@ -79,6 +80,7 @@ module("Basic SC.Record Functions w/ Parent > Child", {
     store = null;
     childData1 = null;
     NestedRecord = null;
+    delete(window.NestedRecord);
   }
 });
 

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

@@ -360,4 +360,48 @@ test("Create Parent with Broken Child Array", function(){
 
 });
 
+test("pushObject should trigger an arrayContentDidChange with only 1 added item", function() {
+  var didChangeCalls = [], target;
 
+  target = SC.Object.create({
+    willChange: function() {},
+    didChange: function() {
+      didChangeCalls.push(arguments);
+    }
+  });
+
+  testParent.get('elements').addArrayObservers({
+    target: target,
+    willChange: 'willChange',
+    didChange: 'didChange'
+  });
+  testParent.get('elements').pushObject({});
+
+  equals(didChangeCalls.length, 1, 'didChange should only be called once');
+  equals(didChangeCalls[0][0], 4, 'didChange should be called with a start index of 4');
+  equals(didChangeCalls[0][1], 0, 'didChange should be called with a removed count of 0');
+  equals(didChangeCalls[0][2], 1, 'didChange should be called with an added count of 1');
+});
+
+test("replace should trigger an arrayContentDidChange with only 1 added item", function() {
+  var didChangeCalls = [], target;
+
+  target = SC.Object.create({
+    willChange: function() {},
+    didChange: function() {
+      didChangeCalls.push(arguments);
+    }
+  });
+
+  testParent.get('elements').addArrayObservers({
+    target: target,
+    willChange: 'willChange',
+    didChange: 'didChange'
+  });
+  testParent.get('elements').replace(3, 1, [{}]);
+
+  equals(didChangeCalls.length, 1, 'didChange should only be called once');
+  equals(didChangeCalls[0][0], 3, 'didChange should be called with a start index of 3');
+  equals(didChangeCalls[0][1], 1, 'didChange should be called with a removed count of 1');
+  equals(didChangeCalls[0][2], 1, 'didChange should be called with an added count of 1');
+});

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

@@ -42,6 +42,7 @@ module("Complex SC.Record: Parent > Array of Children > Array of Children", {
     NestedRecord = SC.Object.create({
       store: SC.Store.create()
     });
+    window.NestedRecord = NestedRecord;
     store = NestedRecord.store;
     initModels();
     SC.RunLoop.begin();
@@ -117,6 +118,7 @@ module("Complex SC.Record: Parent > Array of Children > Array of Children", {
     delete NestedRecord.Group;
     delete NestedRecord.Person;
     delete NestedRecord.Address;
+    delete window.NestedRecord;
     NestedRecord = null;
     testParent = null;
     peopleData1 = null;

data/lib/frameworks/sproutcore/frameworks/datastore/tests/models/nested_records/nested_record_complex.js

@@ -42,6 +42,7 @@ module("Basic SC.Record Functions w/ a Parent > Child > Child", {
     NestedRecord = SC.Object.create({
       store: SC.Store.create()
     });
+    window.NestedRecord = NestedRecord;
     store = NestedRecord.store;
     initModels();
     SC.RunLoop.begin();
@@ -65,6 +66,7 @@ module("Basic SC.Record Functions w/ a Parent > Child > Child", {
     delete NestedRecord.ParentRecordTest;
     delete NestedRecord.Person;
     delete NestedRecord.Address;
+    delete window.NestedRecord;
     NestedRecord = null;
     testParent = null;
     store = null;

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

@@ -8,33 +8,33 @@
 var MyApp, dataSource;
 module("SC.Record core methods", {
   setup: function() {
-    dataSource = SC.DataSource.create({ 
-      
+    dataSource = SC.DataSource.create({
+
       gotParams: NO,
       wasCommitted: NO,
-      
+
       createRecord: function(store, storeKey, params) {
         this.wasCommitted = YES;
         this.gotParams = params && params['param1'] ? YES: NO;
       }});
-    
+
     MyApp = SC.Object.create({
       store: SC.Store.create().from(dataSource)
     })  ;
-  
+
     MyApp.Foo = SC.Record.extend({});
-    MyApp.json = { 
-      foo: "bar", 
+    MyApp.json = {
+      foo: "bar",
       number: 123,
       bool: YES,
       array: [1,2,3],
       guid: 1
     };
-    
+
     SC.RunLoop.begin();
     MyApp.foo = MyApp.store.createRecord(MyApp.Foo, MyApp.json);
     SC.RunLoop.end();
-    
+
   }
 });
 
@@ -43,13 +43,20 @@ test("statusString", function() {
 });
 
 test("Can commitRecord() specific SC.Record instance", function() {
-  
+
   MyApp.foo.set('foo', 'foobar');
-  
+
   // commit the new record
   MyApp.foo.commitRecord({ param1: 'value1' });
-  
+
   equals(dataSource.wasCommitted, YES, 'Record was committed');
   equals(dataSource.gotParams, YES, 'Params were properly passed through commitRecord');
-  
+
+});
+
+test("JSON encoding an SC.Record should encode the attributes", function(){
+  var str = SC.json.encode(MyApp.foo);
+  var result = SC.json.decode(str);
+
+  same(MyApp.json, result, "original = encoded record");
 });

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

@@ -6,7 +6,7 @@
 /*globals module ok equals same test MyApp */
 
 // test core array-mapping methods for RecordArray with RecordAttribute
-var storeKeys, rec, rec2, bar, MyApp;
+var storeKeys, rec, rec2, rec3, bar, MyApp;
 
 module("SC.RecordAttribute core methods", {
   setup: function() {
@@ -14,118 +14,125 @@ module("SC.RecordAttribute core methods", {
     MyApp = SC.Object.create({
       store: SC.Store.create()
     });
-    
+
     // stick it to the window object so that objectForPropertyPath works
     window.MyApp = MyApp;
-    
+
     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 SC.DateTimes
+      dateTime: SC.Record.attr(SC.DateTime),
+
       // test Array
       anArray: SC.Record.attr(Array),
-      
+
       // test Object
       anObject: SC.Record.attr(Object),
-                                 
+
       // test Number
       aNumber: SC.Record.attr(Number),
-      
+
       // 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 
+        // not using .get() to avoid another transform which will
         // trigger an infinite loop
         return (this.readAttribute('relatedToComputed').indexOf("foo")===0) ? MyApp.Foo : MyApp.Bar;
       }),
-      
+
       // test readONly
       readOnly: SC.Record.attr(String, { isEditable: NO })
-      
+
     });
-    
+
     MyApp.Bar = SC.Record.extend({
       parent: SC.Record.toOne('MyApp.Foo', { aggregate: YES }),
       relatedMany: SC.Record.toMany('MyApp.Foo', { aggregate: YES })
     });
-    
+
     SC.RunLoop.begin();
     storeKeys = MyApp.store.loadRecords(MyApp.Foo, [
-      { 
-        guid: 'foo1', 
-        firstName: "John", 
-        lastName: "Doe", 
+      {
+        guid: 'foo1',
+        firstName: "John",
+        lastName: "Doe",
         date: "2009-03-01T20:30-08:00",
+        dateTime: new Date(1235939425000),
         anArray: ['one', 'two', 'three'],
         anObject: { 'key1': 'value1', 'key2': 'value2' },
         aNumber: '123',
         readOnly: 'foo1'
       },
-      
-      { 
-        guid: 'foo2', 
-        firstName: "Jane", 
-        lastName: "Doe", 
+
+      {
+        guid: 'foo2',
+        firstName: "Jane",
+        lastName: "Doe",
         relatedTo: 'foo1',
         relatedToAggregate: 'bar1',
+        dateTime: "2009-03-01T20:30:25Z",
         anArray: 'notAnArray',
         anObject: 'notAnObject',
         aNumber: '123',
         nonIsoDate: "2009/06/10 8:55:50 +0000"
       },
-      
-      { 
-        guid: 'foo3', 
-        firstName: "Alex", 
-        lastName: "Doe", 
+
+      {
+        guid: 'foo3',
+        firstName: "Alex",
+        lastName: "Doe",
         relatedToComputed: 'bar1',
+        dateTime: SC.DateTime.create(1235939425000),
         anArray: ['one', 'two', 'three'],
         anObject: { 'key1': 'value1', 'key2': 'value2' },
         aNumber: '123'
       }
-      
+
     ]);
-    
+
     MyApp.store.loadRecords(MyApp.Bar, [
       { guid: 'bar1', city: "Chicago", parent: 'foo2', relatedMany: ['foo1', 'foo2'] }
     ]);
-    
+
     SC.RunLoop.end();
-    
+
     rec = MyApp.store.find(MyApp.Foo, 'foo1');
     rec2 = MyApp.store.find(MyApp.Foo, 'foo2');
-    
+    rec3 = MyApp.store.find(MyApp.Foo, 'foo3');
+
     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');
@@ -158,6 +165,13 @@ test("reading date should parse ISO date", function() {
   equals(rec.get('date').toString(), d.toString(), 'should have matched date');
 });
 
+test("reading dateTime should parse ISO date", function() {
+  var ms = 1235939425000;
+  equals(rec.getPath('dateTime.milliseconds'), ms, 'should have parsed Date properly');
+  equals(rec2.getPath('dateTime.milliseconds'), ms, 'should have parsed String properly');
+  equals(rec3.getPath('dateTime.milliseconds'), ms, 'should have parsed SC.DateTime properly');
+});
+
 test("reading date should parse non-ISO date", function() {
   var d = new Date(1244624150000);
   equals(rec2.get('nonIsoDate').toString(), d.toString(), 'should have matched date');
@@ -176,7 +190,7 @@ test("reading computed default value", function() {
 
 // ..........................................................
 // WRITING
-// 
+//
 
 test("writing pass-through should simply set value", function() {
   rec.set("firstName", "Foo");
@@ -187,7 +201,7 @@ test("writing pass-through should simply set value", function() {
 
   rec.set("firstName", YES);
   equals(rec.readAttribute("firstName"), YES, "should write bool");
-  
+
 });
 
 test("writing when isEditable is NO should ignore", function() {
@@ -203,7 +217,7 @@ test("writing a value should override default value", function() {
 });
 
 test("writing a string to a number attribute should store a number" ,function() {
-     equals(rec.set('aNumber', "456"), rec, 'returns reciever');
+     equals(rec.set('aNumber', "456"), rec, 'returns receiver');
      equals(rec.get('aNumber'), 456, 'should have new value');
      equals(typeof rec.get('aNumber'), 'number', 'new value should be a number');
 });
@@ -215,27 +229,27 @@ test("writing a date should generate an ISO date" ,function() {
   var utcDate = new Date(Number(date) + (date.getTimezoneOffset() * 60000)); // Adjust for timezone offset
   utcDate.getTimezoneOffset = function(){ return 0; }; // Hack the offset to respond 0
 
-  equals(rec.set('date', utcDate), rec, 'returns reciever');
+  equals(rec.set('date', utcDate), rec, 'returns receiver');
   equals(rec.readAttribute('date'), '2009-04-02T05:28:03Z', 'should have time in ISO format');
 });
 
 test("writing an attribute should make relationship aggregate dirty" ,function() {
   equals(bar.get('status'), SC.Record.READY_CLEAN, "precond - bar should be READY_CLEAN");
   equals(rec2.get('status'), SC.Record.READY_CLEAN, "precond - rec2 should be READY_CLEAN");
-  
+
   bar.set('city', 'Oslo');
   bar.get('store').flush();
-  
+
   equals(rec2.get('status'), SC.Record.READY_DIRTY, "foo2 should be READY_DIRTY");
 });
 
 test("writing an attribute should make many relationship aggregate dirty" ,function() {
   equals(bar.get('status'), SC.Record.READY_CLEAN, "precond - bar should be READY_CLEAN");
   equals(rec2.get('status'), SC.Record.READY_CLEAN, "precond - rec2 should be READY_CLEAN");
-  
+
   bar.set('city', 'Oslo');
   bar.get('store').flush();
-  
+
   equals(rec.get('status'), SC.Record.READY_DIRTY, "foo1 should be READY_DIRTY");
   equals(rec2.get('status'), SC.Record.READY_DIRTY, "foo2 should be READY_DIRTY");
 });
@@ -243,10 +257,25 @@ test("writing an attribute should make many relationship aggregate dirty" ,funct
 test("writing an attribute should make many relationship aggregate dirty and add the aggregate to the store" ,function() {
   equals(bar.get('status'), SC.Record.READY_CLEAN, "precond - bar should be READY_CLEAN");
   equals(rec2.get('status'), SC.Record.READY_CLEAN, "precond - rec2 should be READY_CLEAN");
-  
+
   bar.set('city', 'Oslo');
 
   var store = bar.get('store');
   ok(store.changelog.contains(rec.get('storeKey')), "foo1 should be in the store's changelog");
   ok(store.changelog.contains(rec2.get('storeKey')), "foo2 should be in the store's changelog");
 });
+
+test("adding attribute with non existing class should throw error", function() {
+  MyApp.InvalidModel = SC.Record.extend({
+    foo: SC.Record.attr("SomethingSomethingSomething")
+  });
+
+  var message;
+  try {
+    MyApp.InvalidModel.prototype.foo.typeClass();
+  } catch (x) {
+    message = x;
+  }
+
+  same(message, 'SomethingSomethingSomething could not be found');
+});