sproutcore 1.7.1.beta → 1.8.0

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

@@ -23,7 +23,7 @@ module("SC.NestedStore#commitChangesFromNestedStore", {
     store = parent.chain();
     child = store.chain();  // test multiple levels deep
 
-    // wirte basic status
+    // write basic status
     child.writeDataHash(storeKey, json, SC.Record.READY_DIRTY);
     child.dataHashDidChange(storeKey);
     child.changelog = SC.Set.create();

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

@@ -150,7 +150,7 @@ test("data state=EDITABLE", function() {
 });
 
 test("should return null when accessing an unknown storeKey", function() {
-  equals(store.readDataHash(20000000), null, 'shuld return null for non-existant store key');
+  equals(store.readDataHash(20000000), null, 'should return null for non-existent store key');
   equals(store.storeKeyEditState(20000000), SC.Store.LOCKED, 'should put into locked edit state');
 });
 

data/lib/frameworks/sproutcore/frameworks/datastore/tests/system/query/compare.js

@@ -36,7 +36,21 @@ module("SC.Query comparison of records", {
     rec3 = MyApp.store.find(MyApp.Foo,3);
     rec4 = MyApp.store.find(MyApp.Foo,4);
     rec5 = MyApp.store.find(MyApp.Foo,5);
-    
+    rec6 = MyApp.store.createRecord(MyApp.Foo, { firstName: "Clark", lastName: "Douglas", active: true });
+    rec7 = MyApp.store.createRecord(MyApp.Foo, { firstName: "Amy", lastName: "Simmons", active: true });
+    rec8 = MyApp.store.createRecord(MyApp.Foo, { firstName: "Fred", lastName: "Chambers", active: false });
+    rec9 = MyApp.store.createRecord(MyApp.Foo, { firstName: "Mari", lastName: "Chambers", active: false });
+    rec10 = MyApp.store.createRecord(MyApp.Foo, { firstName: "Glenn", lastName: "Armour", active: true });
+    rec11 = MyApp.store.createRecord(MyApp.Foo, { firstName: "Jake", lastName: "Timmons", active: true });
+    rec12 = MyApp.store.createRecord(MyApp.Foo, { firstName: "John", lastName: "Fitzgerald", active: true });
+    rec13 = MyApp.store.createRecord(MyApp.Foo, { firstName: "Carly", lastName: "Anderson", active: true });
+    rec14 = MyApp.store.createRecord(MyApp.Foo, { firstName: "Clark", lastName: "Thompson", active: true });
+    rec15 = MyApp.store.createRecord(MyApp.Foo, { firstName: "Indi", lastName: "Karish", active: true });
+    rec16 = MyApp.store.createRecord(MyApp.Foo, { firstName: "Yi Jia", lastName: "Li", active: true });
+    rec17 = MyApp.store.createRecord(MyApp.Foo, { firstName: "Marcel", lastName: "Frontenac", active: true });
+    rec18 = MyApp.store.createRecord(MyApp.Foo, { firstName: "Amie", lastName: "Frontenac", active: true });
+    rec19 = MyApp.store.createRecord(MyApp.Foo, { firstName: "Amelie", lastName: "Auguste", active: true });
+    rec20 = MyApp.store.createRecord(MyApp.Foo, { firstName: "Percy", lastName: "Douglas", active: true });
     
     q = SC.Query.create();
   }
@@ -88,6 +102,44 @@ test("no order should result in comparison by guid", function() {
   q.orderBy = null;
   q.parse();
   equals(q.compare(rec1,rec2), -1, 'guid 1 should be before guid 2');
+/**
+  This test was added to prove new code that switched from ordering by guid
+  if there is no orderBy property on the query to ordering by storeKey if
+  there is no orderBy property.  The reason is that new records that haven't
+  been committed may not have a guid and therefore comparing null to null
+  would result in the order changing slightly in Chrome when the array length
+  grew over 10 items long.  For some reason if every comparison in the sort
+  returns 0, the first item and second item swap places and then the new first
+  and the middle item swap places (or vice versa).  If you get objectAt(0) on
+  this type of RecordArray, it cycles between three different values.
+
+  See it in action in Chrome 17.0 on Mac:
+
+  > [0,1,2,3,4,5,6,7,8,9].sort(function(a,b) { return 0; })
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+  > [0,1,2,3,4,5,6,7,8,9,10].sort(function(a,b) { return 0; })
+    [5, 0, 2, 3, 4, 1, 6, 7, 8, 9, 10]
+    // WTF?  So the next time the RecordArray flushes its array will be
+    // [5, 0, 2, 3, 4, 1, 6, 7, 8, 9, 10] and it keeps changing each flush.
+  > [5, 0, 2, 3, 4, 1, 6, 7, 8, 9, 10].sort(function(a,b) { return 0; })
+    [1, 5, 2, 3, 4, 0, 6, 7, 8, 9, 10]
+*/
+test("storeKeys should maintain order between repeat calls to orderStoreKeys even if the array is longer than 10 items and the matching records have no ids", function() {
+  var records,
+      storeKeysSorted1,
+      storeKeysSorted2,
+      storeKeys;
+
+  q.orderBy = null;
+  q.parse();
+
+  records = MyApp.store.find(MyApp.Foo);
+  records.flush();
+
+  storeKeys = records.get('storeKeys');
+  storeKeysSorted1 = SC.Query.orderStoreKeys(records.get('storeKeys'), q, MyApp.store).copy();
+  storeKeysSorted2 = SC.Query.orderStoreKeys(records.get('storeKeys'), q, MyApp.store).copy();
+  ok(storeKeysSorted1.isEqual(storeKeysSorted2), 'Each time you call orderStoreKeys, it should return the same order if the storeKeys haven\'t changed');
 });
 
 test("comparing non existent properties", function() {
@@ -142,3 +194,4 @@ test("specifying a custom orderBy comparison function", function() {
   equals(q.compare(rec1,rec2), 1, 'guid 2 should be before guid 1');
   equals(usedCustomFunction, YES, 'we should have used our custom comparison function');
 });
+

data/lib/frameworks/sproutcore/frameworks/datastore/tests/system/query/evaluation.js

@@ -110,42 +110,62 @@ test("should evaluate all comparators", function() {
   q.conditions = "'Tea pot' ENDS_WITH 'a cup'";
   q.parse();
   ok(q._tokenTree.evaluate() === false, "'Tea pot' ENDS_WITH 'a cup' should be false");
+
+  q.conditions = "'baguette fille bouteille fée' ENDS_WITH 'ille'";
+  q.parse();
+  ok(q._tokenTree.evaluate() === false, "'baguette fille bouteille fée' ENDS_WITH 'ille' should be false");
+
+  q.conditions = "'baguette fille bouteille' ENDS_WITH 'ille'";
+  q.parse();
+  ok(q._tokenTree.evaluate() === true, "'baguette fille bouteille' ENDS_WITH 'ille' should be true");
+
+  q.conditions = "'fée' ENDS_WITH 'ille'";
+  q.parse();
+  ok(q._tokenTree.evaluate() === false, "'fée' ENDS_WITH 'ille' should be false");
+
+  q.conditions = "'fille baguette bouteílle' ENDS_WITH 'ille'";
+  q.parse();
+  ok(q._tokenTree.evaluate() === false, "'fille baguette bouteílle' ENDS_WITH 'ille' should be false");
+
+  q.conditions = "'fille baguette bouteílle' ENDS_WITH 'ílle'";
+  q.parse();
+  ok(q._tokenTree.evaluate() === true, "'fille baguette bouteílle' ENDS_WITH 'ílle' should be true");
   
   q.conditions = "'Tea pot' CONTAINS 'Tea pot'";
   q.parse();
-  ok(q._tokenTree.evaluate() == true, "'Tea pot' CONTAINS 'Tea pot' should be true");
+  ok(q._tokenTree.evaluate() === true, "'Tea pot' CONTAINS 'Tea pot' should be true");
   
   q.conditions = "'Tea pot' CONTAINS 'Tea'";
   q.parse();
-  ok(q._tokenTree.evaluate() == true, "'Tea pot' CONTAINS 'Tea' should be true");
+  ok(q._tokenTree.evaluate() === true, "'Tea pot' CONTAINS 'Tea' should be true");
   
   q.conditions = "'Tea pot' CONTAINS 'pot'";
   q.parse();
-  ok(q._tokenTree.evaluate() == true, "'Tea pot' CONTAINS 'pot' should be true");
+  ok(q._tokenTree.evaluate() === true, "'Tea pot' CONTAINS 'pot' should be true");
   
   q.conditions = "'Tea pot' CONTAINS 'a po'";
   q.parse();
-  ok(q._tokenTree.evaluate() == true, "'Tea pot' CONTAINS 'a po' should be true");
+  ok(q._tokenTree.evaluate() === true, "'Tea pot' CONTAINS 'a po' should be true");
   
   q.conditions = "'Tea pot' CONTAINS 'a cup'";
   q.parse();
-  ok(q._tokenTree.evaluate() == false, "'Tea pot' CONTAINS 'a cup' should be false");
+  ok(q._tokenTree.evaluate() === false, "'Tea pot' CONTAINS 'a cup' should be false");
   
   q.conditions = "{myTeapot} CONTAINS 'Tea'";
   q.parse();
-  ok(q._tokenTree.evaluate(null,{myTeapot: ['Tea','pot']}) == true, "['Tea', 'pot'] CONTAINS 'Tea' should be true");
+  ok(q._tokenTree.evaluate(null,{myTeapot: ['Tea','pot']}) === true, "['Tea', 'pot'] CONTAINS 'Tea' should be true");
 
   q.conditions = "{myTeapot} CONTAINS 'pot'";
   q.parse();
-  ok(q._tokenTree.evaluate(null,{myTeapot: ['Tea','pot']}) == true, "['Tea', 'pot'] CONTAINS 'pot' should be true");
+  ok(q._tokenTree.evaluate(null,{myTeapot: ['Tea','pot']}) === true, "['Tea', 'pot'] CONTAINS 'pot' should be true");
 
   q.conditions = "{myTeapot} CONTAINS 'coffee'";
   q.parse();
-  ok(q._tokenTree.evaluate(null,{myTeapot: ['Tea','pot']}) == false, "['Tea', 'pot'] CONTAINS 'coffee' should be false");
+  ok(q._tokenTree.evaluate(null,{myTeapot: ['Tea','pot']}) === false, "['Tea', 'pot'] CONTAINS 'coffee' should be false");
   
   q.conditions = "'Tea pot' MATCHES {myCup}";
   q.parse();
-  ok(q._tokenTree.evaluate(null,{myCup: /a\sp/}) === true, "'Tea pot' MATCHES /a\sp/ should be true");
+  ok(q._tokenTree.evaluate(null,{myCup: /a\sp/}) === true, "'Tea pot' MATCHES /a\\sp/ should be true");
   
   q.conditions = "'Tea pot' MATCHES {myCup}";
   q.parse();

data/lib/frameworks/sproutcore/frameworks/datastore/tests/system/query/parse.js

@@ -217,7 +217,7 @@ test("token tree should build", function() {
   q.parse();
   ok(q._tokenList.length == 13, 'list should have 13 tokens');
   ok(!q._tokenTree.error, 'there should be no errors');
-  ok(q._tokenTree.tokenValue == 'AND', 'tree root shoud be AND');
+  ok(q._tokenTree.tokenValue == 'AND', 'tree root should be AND');
   
 });
 

data/lib/frameworks/sproutcore/frameworks/datastore/tests/system/record_array/core_methods.js

@@ -64,7 +64,7 @@ test("should materialize record for object", function() {
 });
 
 test("reading past end of array length should return undefined", function() {
-  equals(recs.objectAt(2000), undefined, 'recs.objectAt(2000) should be undeinfed');
+  equals(recs.objectAt(2000), undefined, 'recs.objectAt(2000) should be undefined');
 });
 
 test("modifying the underlying storeKey should change the returned materialized record", function() {

data/lib/frameworks/sproutcore/frameworks/datastore/tests/system/record_array/flush.js

@@ -94,7 +94,7 @@ test("calling storeDidChangeStoreKeys() with a matching recordType", function()
 
   recs.storeDidChangeStoreKeys([storeKey], SC.Set.create().add(SC.Record));
 
-  orig.unshift(storeKey); // update - must be first b/c id.bar < id.foo
+  orig.push(storeKey); // update - must be last b/c id.bar.storeKey < id.foo.storeKey
   equals(recs.get('needsFlush'), NO, 'should not need flush anymore');
   same(recs.get('storeKeys'), orig, 'storeKeys should now be updated - rec1[%@]{%@} = %@, rec2[%@]{%@} = %@'.fmt(
     rec.get('id'), rec.get('storeKey'), rec,

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

@@ -49,6 +49,6 @@ test("Check for error state handling and make sure that the method executes.", f
   }catch (error){
     throwError=false;
   }
-  ok(throwError, " cancelRecord was succesfully executed.");
+  ok(throwError, " cancelRecord was successfully executed.");
   
 });

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

@@ -22,7 +22,7 @@ module("SC.Store#commitChangesFromNestedStore", {
 
     child = store.chain();  // test multiple levels deep
 
-    // wirte basic status
+    // write basic status
     child.writeDataHash(storeKey, json, SC.Record.READY_DIRTY);
     child.dataHashDidChange(storeKey);
     child.changelog = SC.Set.create();

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

@@ -13,9 +13,9 @@ module("SC.Store#commitRecord", {
   setup: function() {
 
     ds = SC.DataSource.create({
-      
+
       callCount: 0,
-      
+
       commitRecords: function(store, toCreate, toUpdate, toDestroy, params) {
         this.toCreate = toCreate;
         this.toUpdate = toUpdate;
@@ -23,17 +23,17 @@ module("SC.Store#commitRecord", {
         this.params = params;
         this.callCount++;
       },
-      
+
       reset: function() {
         this.toCreate = this.toUpdate = this.toDestroy = this.params = null;
         this.callCount = 0 ;
       },
-      
+
       expect: function(callCount, toCreate, toUpdate, toDestroy, params) {
         if (callCount !== undefined) {
           equals(this.callCount, callCount, 'expect datasource.commitRecords to be called X times');
         }
-        
+
         if (toCreate !== undefined) {
           same(this.toCreate, toCreate, 'expect toCreate to have items');
         }
@@ -41,7 +41,7 @@ module("SC.Store#commitRecord", {
         if (toUpdate !== undefined) {
           same(this.toUpdate, toUpdate, 'expect toUpdate to have items');
         }
-        
+
         if (toDestroy !== undefined) {
           same(this.toDestroy, toDestroy, 'expect toDestroy to have items');
         }
@@ -50,11 +50,11 @@ module("SC.Store#commitRecord", {
           same(this.params, params, 'expect params to have items');
         }
       }
-      
+
     });
-    
+
     store = SC.Store.create().from(ds);
-    
+
     json1 = {
       guid: "commitGUID1",
       string: "string",
@@ -97,7 +97,7 @@ module("SC.Store#commitRecord", {
       number: 23,
       bool:   YES
     };
-    
+
     SC.RunLoop.begin();
     storeKey1 = SC.Store.generateStoreKey();
     store.writeDataHash(storeKey1, json1, SC.Record.READY_CLEAN);
@@ -108,11 +108,11 @@ module("SC.Store#commitRecord", {
     storeKey4 = SC.Store.generateStoreKey();
     store.writeDataHash(storeKey4, json4, SC.Record.DESTROYED_DIRTY);
     storeKey5 = SC.Store.generateStoreKey();
-    store.writeDataHash(storeKey5, json5, SC.Record.READY_EMPTY);
+    store.writeDataHash(storeKey5, json5, SC.Record.EMPTY);
     storeKey6 = SC.Store.generateStoreKey();
-    store.writeDataHash(storeKey6, json6, SC.Record.READY_ERROR);
+    store.writeDataHash(storeKey6, json6, SC.Record.ERROR);
     storeKey7 = SC.Store.generateStoreKey();
-    store.writeDataHash(storeKey7, json7, SC.Record.READY_DESTROYED_CLEAN);
+    store.writeDataHash(storeKey7, json7, SC.Record.DESTROYED_CLEAN);
     SC.RunLoop.end();
   }
 });
@@ -123,7 +123,7 @@ test("Confirm that all the states are switched as expected after running commitR
   store.commitRecord(undefined, undefined, storeKey1);
   status = store.readStatus( storeKey1);
   equals(status, SC.Record.READY_CLEAN, "the status shouldn't have changed. It should be READY_CLEAN ");
-  
+
   store.commitRecord(undefined, undefined, storeKey2);
   status = store.readStatus( storeKey2);
   equals(status, SC.Record.BUSY_CREATING, "the status should be SC.Record.BUSY_CREATING");
@@ -131,45 +131,37 @@ test("Confirm that all the states are switched as expected after running commitR
   store.commitRecord(undefined, undefined, storeKey3);
   status = store.readStatus( storeKey3);
   equals(status, SC.Record.BUSY_COMMITTING, "the status should be SC.Record.BUSY_COMMITTING");
-  
+
   store.dataSourceDidComplete(storeKey3);
   status = store.readStatus( storeKey3);
   equals(status, SC.Record.READY_CLEAN, "the status should be SC.Record.READY_CLEAN");
-  
+
   store.commitRecord(undefined, undefined, storeKey4);
   status = store.readStatus( storeKey4);
   equals(status, SC.Record.BUSY_DESTROYING, "the status should be SC.Record.BUSY_DESTROYING");
-  
-  try {
-    store.commitRecord(undefined, undefined, storeKey5);
-    throwError=false;
-    msg='';
-  }catch(error1){
-    throwError=true;
-    msg=error1.message;
-  }
-  equals(msg, SC.Record.NOT_FOUND_ERROR.message, "commitRecord should throw the following error");
-  
+
+  store.dataSourceDidDestroy(storeKey4);
+  status = store.readStatus(storeKey4);
+  equals(status, SC.Record.DESTROYED_CLEAN, "the status should be SC.Record.DESTROYED_CLEAN");
+
+  store.commitRecord(undefined, undefined, storeKey5);
+  status = store.readStatus( storeKey5);
+  equals(status, SC.Record.EMPTY, "the status should be SC.Record.EMPTY");
+
   try{
     store.commitRecord(undefined, undefined, storeKey6);
     throwError=false;
     msg='';
-  }catch(error2){
+  }catch(error){
     throwError=true;
-    msg=error2.message;
+    msg=error.message;
   }
   equals(msg, SC.Record.NOT_FOUND_ERROR.message, "commitRecord should throw the following error");
-  
-  try{
-    store.commitRecord(undefined, undefined, storeKey7);
-    throwError=false;
-    msg='';
-  }catch(error3){
-    throwError=true;
-    msg=error3.message;
-  }
-  equals(msg, SC.Record.NOT_FOUND_ERROR.message, "commitRecord should throw the following error");
-  
+
+  store.commitRecord(undefined, undefined, storeKey7);
+  status = store.readStatus( storeKey7);
+  equals(status, SC.Record.DESTROYED_CLEAN, "the status should be SC.Record.DESTROYED_CLEAN");
+
 });
 
 test("calling commitRecords() without explicit storeKeys", function() {
@@ -179,16 +171,16 @@ test("calling commitRecords() without explicit storeKeys", function() {
 
   st = store.readStatus( storeKey1);
   equals(st, SC.Record.READY_CLEAN, "storeKey1 - the status shouldn't have changed. It should be READY_CLEAN ");
-  
+
   st = store.readStatus( storeKey2);
   equals(st, SC.Record.BUSY_CREATING, "storeKey2 - the status should be SC.Record.BUSY_CREATING");
 
   st = store.readStatus( storeKey3);
   equals(st, SC.Record.BUSY_COMMITTING, "storeKey3 - the status should be SC.Record.BUSY_COMMITTING");
-  
+
   st = store.readStatus( storeKey4);
   equals(st, SC.Record.BUSY_DESTROYING, "storeKey4 - the status should be SC.Record.BUSY_DESTROYING");
-  
+
   ds.expect(1, [storeKey2], [storeKey3], [storeKey4]);
 });
 
@@ -202,7 +194,7 @@ test("calling commitRecords() with params", function() {
   store.commitRecords(null,null,null,p);
   ds.expect(1, [], [], [], p);
   ds.reset();
-  
+
   // call commit records with no storeKeys and no params should not invoke ds
   store.commitRecords(null,null,null,null);
   ds.expect(0);
@@ -211,7 +203,7 @@ test("calling commitRecords() with params", function() {
 test("calling commitRecords() with callbacks", function() {
   var wasCalled = NO;
   var cb = function(){wasCalled = YES;};
-  
+
   store.commitRecord(null, null, storeKey2, {}, cb);
   ok(store._callback_queue[storeKey2], "should have a callback in the queue");
   ok(!wasCalled, "wasn't called yet");

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

@@ -11,11 +11,11 @@ module("SC.Query querying find() on a store", {
     SC.RunLoop.begin();
     // setup dummy app and store
     MyApp = SC.Object.create({});
-    
+
     // setup a dummy model
     MyApp.Foo = SC.Record.extend();
     MyApp.Bar = SC.Record.extend();
-    
+
     // setup data source that just returns cached storeKeys
     MyApp.DataSource = SC.DataSource.create({
 
@@ -23,42 +23,42 @@ module("SC.Query querying find() on a store", {
         this.query = query;
         this.store = store;
         this.fetchCount++ ;
-        
+
         // used by tests to verify remote queries
         if (query.get('location') === SC.Query.REMOTE) {
           if (query.get('recordType') === MyApp.Foo) {
-            store.loadQueryResults(query, this.get('storeKeys'));    
+            store.loadQueryResults(query, this.get('storeKeys'));
           }
         }
-        
+
         return YES ;
       },
-      
+
       reset: function() {
         this.query = this.store = null ;
         this.fetchCount = this.prepareCount = 0 ;
       },
-      
+
       fetchEquals: function(store, query, count, desc) {
         if (desc===undefined && typeof count === 'string') {
           desc = count;  count = undefined;
         }
-        if (count===undefined) count = 1; 
-        
+        if (count===undefined) count = 1;
+
         equals(this.store, store, desc + ': should get store');
         equals(this.query, query, desc + ': should get query');
         equals(this.fetchCount, count, desc + ': should get count');
       },
-      
+
       destroyRecord: function(store, storeKey){
         store.dataSourceDidDestroy(storeKey);
         return YES;
       }
-      
+
     });
-    
+
     MyApp.store = SC.Store.create().from(MyApp.DataSource);
-    
+
     var records = [
       { guid: 1, firstName: "John", lastName: "Doe", married: true },
       { guid: 2, firstName: "Jane", lastName: "Doe", married: false },
@@ -66,40 +66,40 @@ module("SC.Query querying find() on a store", {
       { guid: 4, firstName: "Johnny", lastName: "Cash", married: true },
       { guid: 5, firstName: "Bert", lastName: "Berthold", married: true }
     ];
-    
+
     // load some data
     MyApp.DataSource.storeKeys = MyApp.store.loadRecords(MyApp.Foo, records);
     SC.RunLoop.end();
-    
+
     SC.RunLoop.begin();
     // for sanity check, load two record types
     MyApp.store.loadRecords(MyApp.Bar, records);
     SC.RunLoop.end();
-    
+
   },
-  
+
   teardown: function() {
     MyApp = null ;
     SC.Record.subclasses.clear(); //reset
   }
-  
+
 });
 
 // ..........................................................
 // FINDING SINGLE RECORDS
-// 
+//
 
 test("find(recordType, id)", function() {
-  
+
   equals(MyApp.store.find('MyApp.Foo', 1).get('firstName'), 'John', 'should return foo(1)');
-  equals(MyApp.store.find(MyApp.Foo, 1).get('firstName'), 'John', 'should return foo(1)');  
+  equals(MyApp.store.find(MyApp.Foo, 1).get('firstName'), 'John', 'should return foo(1)');
 });
 
 test("find(record)", function() {
-  
+
   var rec1 = MyApp.store.find(MyApp.Foo, 1);
   equals(MyApp.store.find(rec1), rec1, 'find(rec1) should return rec1');
-  
+
   var rec2 = MyApp.store.chain().find(rec1);
   ok(rec2 !== rec1, 'nested.find(rec1) should not return same instance');
   equals(rec2.get('storeKey'), rec1.get('storeKey'), 'nested.find(rec1) should return same record in nested store');
@@ -107,10 +107,10 @@ test("find(record)", function() {
 
 // ..........................................................
 // RECORD ARRAY CACHING
-// 
- 
+//
+
 test("caching for a single store", function() {
-  var r1 = MyApp.store.find(MyApp.Foo);  
+  var r1 = MyApp.store.find(MyApp.Foo);
   var r2 = MyApp.store.find(MyApp.Foo);
   ok(!!r1, 'should return a record array');
   ok(r1.isEnumerable, 'returned item should be enumerable');
@@ -119,21 +119,21 @@ test("caching for a single store", function() {
 });
 
 test("find() caching for a chained store", function() {
-  var r1 = MyApp.store.find(MyApp.Foo);  
-  
+  var r1 = MyApp.store.find(MyApp.Foo);
+
   var child = MyApp.store.chain();
   var r2 = child.find(MyApp.Foo);
   var r3 = child.find(MyApp.Foo);
 
   ok(!!r1, 'should return a record array from base store');
   equals(r1.get('store'), MyApp.store, 'return object should be owned by store');
-  
+
   ok(!!r2, 'should return a recurd array from child store');
   equals(r2.get('store'), child, 'return object should be owned by child store');
-  
+
   ok(r2 !== r1, 'return value for child store should not be same as parent');
   equals(r3, r2, 'return value from child store should be the same after multiple calls');
-  
+
   // check underlying queries
   ok(!!r1.get('query'), 'record array should have a query');
   equals(r2.get('query'), r1.get('query'), 'record arrays from parent and child stores should share the same query');
@@ -141,8 +141,8 @@ test("find() caching for a chained store", function() {
 
 test("data source must get the right calls", function() {
   var ds = MyApp.store.get('dataSource');
-  
-  ds.reset();  
+
+  ds.reset();
   var records = MyApp.store.find(MyApp.Foo);
   var q = SC.Query.local(MyApp.Foo);
   ds.fetchEquals(MyApp.store, q, 'after fetch');
@@ -150,7 +150,7 @@ test("data source must get the right calls", function() {
 
 // ..........................................................
 // RECORD PROPERTIES
-// 
+//
 
 test("should find records based on boolean", function() {
   SC.RunLoop.begin();
@@ -161,7 +161,7 @@ test("should find records based on boolean", function() {
 });
 
 test("should find records based on query string", function() {
-  
+
   SC.RunLoop.begin();
   var q = SC.Query.local(MyApp.Foo, { conditions:"firstName = 'John'" });
   var records = MyApp.store.find(q);
@@ -172,12 +172,12 @@ test("should find records based on query string", function() {
 
 test("should find records based on SC.Query", function() {
   var q = SC.Query.create({
-    recordType: MyApp.Foo, 
+    recordType: MyApp.Foo,
     conditions:"firstName = 'Jane'"
   });
-  
+
   var records = MyApp.store.find(q);
-  
+
   equals(records.get('length'), 1, 'record length should be 1');
   equals(records.objectAt(0).get('firstName'), 'Jane', 'name should be Jane');
 });
@@ -185,10 +185,10 @@ test("should find records based on SC.Query", function() {
 test("modifying a record should update RecordArray automatically", function() {
   var q    = SC.Query.local(MyApp.Foo, "firstName = 'Jane'"),
       recs = MyApp.store.find(q);
-      
+
   equals(recs.get('length'), 1, 'record length should be 1');
   equals(recs.objectAt(0).get('firstName'), 'Jane', 'name should be Jane');
-  
+
   SC.RunLoop.begin();
 
   var r2 = MyApp.store.find(MyApp.Foo, 3);
@@ -196,84 +196,84 @@ test("modifying a record should update RecordArray automatically", function() {
   r2.set('firstName', 'Jane');
 
   SC.RunLoop.end();
-  
+
   equals(recs.get('length'), 2, 'record length should increase');
   same(recs.getEach('firstName'), ['Jane', 'Jane'], 'check all firstNames are Jane');
-  
+
   // try the other direction...
   SC.RunLoop.begin();
   r2.set('firstName', 'Ester');
-  SC.RunLoop.end(); 
-  
+  SC.RunLoop.end();
+
   equals(recs.get('length'), 1, 'record length should decrease');
 
 });
 
 test("should find records based on SC.Query without recordType", function() {
-  
-  var q = SC.Query.local(SC.Record, "lastName = 'Doe'");
-  
+
+  var q = SC.Query.local(SC.Record, { conditions: "lastName = 'Doe'", orderBy: "firstName" });
+
   var records = MyApp.store.find(q);
-  equals(records.get('length'), 4, 'record length should be 2');
+  equals(records.get('length'), 4, 'record length should be 4');
 
-  same(records.getEach('firstName'), 'John John Jane Jane'.w(), 'firstNames should match');
+  same(records.getEach('firstName'), 'Jane Jane John John'.w(), 'firstNames should match');
 });
 
 test("should find records within a passed record array", function() {
 
   SC.RunLoop.begin();
-  
-  var q = SC.Query.create({ 
-    recordType: MyApp.Foo, 
-    conditions: "firstName = 'Emily'" 
+
+  var q = SC.Query.create({
+    recordType: MyApp.Foo,
+    conditions: "firstName = 'Emily'"
   });
 
   var recArray = MyApp.store.find(MyApp.Foo);
   var records  = recArray.find(q);
-  
+
   equals(records.get('length'), 1, 'record length should be 1');
   equals(records.objectAt(0).get('firstName'), 'Emily', 'name should be Emily');
 
   SC.RunLoop.end();
-  
+
 });
 
 test("sending a new store key array from the data source should update record array", function() {
-  
+
   var q       = SC.Query.remote(MyApp.Foo),
       records = MyApp.store.find(q);
-  
+
   SC.RunLoop.begin();
   equals(records.get('length'), 5, 'record length should be 5');
   SC.RunLoop.end();
-  
+
   var newStoreKeys = MyApp.DataSource.storeKeys.copy();
   newStoreKeys.pop();
-  
+
   // .replace() will call .enumerableContentDidChange()
   SC.RunLoop.begin();
   MyApp.store.loadQueryResults(q, newStoreKeys);
   SC.RunLoop.end();
-  
+
   equals(records.get('length'), 4, 'record length should be 4');
 
 });
 
 
 test("loading more data into the store should propagate to record array", function() {
-  
+
   var records = MyApp.store.find(MyApp.Foo);
-  
+
   equals(records.get('length'), 5, 'record length before should be 5');
 
   SC.RunLoop.begin();
-  
+
   var newStoreKeys = MyApp.store.loadRecords(MyApp.Foo, [
     { guid: 10, firstName: "John", lastName: "Johnson" }
   ]);
-  
+
   SC.RunLoop.end();
-  
+
   equals(records.get('length'), 6, 'record length after should be 6');
 });
 
@@ -281,7 +281,7 @@ test("loading more data into the store should propagate to record array with que
 
   var q = SC.Query.local(MyApp.Foo, "firstName = 'John'"),
       records = MyApp.store.find(q);
-  
+
   equals(records.get('length'), 1, 'record length before should be 1');
 
   SC.RunLoop.begin();
@@ -289,110 +289,110 @@ test("loading more data into the store should propagate to record array with que
     { guid: 10, firstName: "John", lastName: "Johnson" }
   ]);
   SC.RunLoop.end();
-  
+
   // .replace() will call .enumerableContentDidChange()
   // and should fire original SC.Query again
   equals(records.get('length'), 2, 'record length after should be 2');
-  
+
   // subsequent updates to store keys should also work
   SC.RunLoop.begin();
   var newStoreKeys2 = MyApp.store.loadRecords(MyApp.Foo, [
     { guid: 11, firstName: "John", lastName: "Norman" }
   ]);
   SC.RunLoop.end();
-  
+
   equals(records.get('length'), 3, 'record length after should be 3');
 });
 
 test("Loading records after SC.Query should show up", function() {
-  
+
   var q = SC.Query.local(MyApp.Foo, "firstName = 'John'"),
       records = MyApp.store.find(q);
-      
+
   equals(records.get('length'), 1, 'record length should be 1');
   equals(records.objectAt(0).get('firstName'), 'John', 'name should be John');
-  
+
   var recordsToLoad = [
     { guid: 20, firstName: "John", lastName: "Johnson" },
     { guid: 21, firstName: "John", lastName: "Anderson" },
     { guid: 22, firstName: "Barbara", lastName: "Jones" }
   ];
-  
+
   SC.RunLoop.begin();
   MyApp.store.loadRecords(MyApp.Foo, recordsToLoad);
   SC.RunLoop.end();
-  
+
   equals(records.get('length'), 3, 'record length should be 3');
-  
+
   equals(records.objectAt(0).get('firstName'), 'John', 'name should be John');
   equals(records.objectAt(1).get('firstName'), 'John', 'name should be John');
   equals(records.objectAt(2).get('firstName'), 'John', 'name should be John');
 });
 
 test("Loading records after getting empty record array based on SC.Query should update", function() {
-  
+
   var q = SC.Query.local(MyApp.Foo, "firstName = 'Maria'");
   var records = MyApp.store.find(q);
   equals(records.get('length'), 0, 'record length should be 0');
-  
+
   var recordsToLoad = [
     { guid: 20, firstName: "Maria", lastName: "Johnson" }
   ];
-  
+
   SC.RunLoop.begin();
   MyApp.store.loadRecords(MyApp.Foo, recordsToLoad);
   SC.RunLoop.end();
-  
+
   equals(records.get('length'), 1, 'record length should be 1');
-  
-  equals(records.objectAt(0).get('firstName'), 'Maria', 'name should be Maria');  
+
+  equals(records.objectAt(0).get('firstName'), 'Maria', 'name should be Maria');
 });
 
 test("Changing a record should make it show up in RecordArrays based on SC.Query", function() {
-  
+
   var q, records, record;
-  
+
   q = SC.Query.local(MyApp.Foo, "firstName = 'Maria'");
   records = MyApp.store.find(q);
   equals(records.get('length'), 0, 'record length should be 0');
-  
+
   SC.RunLoop.begin();
   record = MyApp.store.find(MyApp.Foo, 1);
   record.set('firstName', 'Maria');
   SC.RunLoop.end();
-  
+
   equals(records.get('length'), 1, 'record length should be 1');
   equals(records.objectAt(0).get('firstName'), 'Maria', 'name should be Maria');
 });
 
 test("Deleting a record should make the RecordArray based on SC.Query update accordingly", function() {
-  
+
   var q, records;
 
   q = SC.Query.local(MyApp.Foo, "firstName = 'John'");
   records = MyApp.store.find(q);
   equals(records.get('length'), 1, 'record length should be 1');
-  
+
   SC.RunLoop.begin();
   records.objectAt(0).destroy();
   SC.RunLoop.end();
-  
+
   equals(records.get('length'), 0, 'record length should be 0');
 });
 
 test("Using find() with SC.Query on store with no data source should work", function() {
 
   var q, records, recordsToLoad;
-  
+
   SC.RunLoop.begin();
-  
+
   // create a store with no data source
   MyApp.store3 = SC.Store.create();
-  
+
   q = SC.Query.local(MyApp.Foo, "firstName = 'John'");
   records = MyApp.store3.find(q);
   equals(records.get('length'), 0, 'record length should be 0');
-  
+
   recordsToLoad = [
     { guid: 20, firstName: "John", lastName: "Johnson" },
     { guid: 21, firstName: "John", lastName: "Anderson" },
@@ -400,124 +400,124 @@ test("Using find() with SC.Query on store with no data source should work", func
   ];
 
   MyApp.store3.loadRecords(MyApp.Foo, recordsToLoad);
-  
+
   SC.RunLoop.end();
-  
-  equals(records.get('length'), 2, 'record length should be 2');  
+
+  equals(records.get('length'), 2, 'record length should be 2');
 });
 
 test("Using orderBy in SC.Query returned from find()", function() {
-  
+
   var q, records;
-  
+
   q = SC.Query.local(MyApp.Foo, { orderBy: "firstName ASC" });
   records = MyApp.store.find(q);
   equals(records.get('length'), 5, 'record length should be 5');
-  
-  same(records.getEach('firstName'), ["Bert", "Emily", "Jane", "John", "Johnny"], 'first name should be properly sorted');  
+
+  same(records.getEach('firstName'), ["Bert", "Emily", "Jane", "John", "Johnny"], 'first name should be properly sorted');
 });
 
 test("Using orderBy in SC.Query returned from find() and loading more records to original store key array", function() {
 
   var q, records, newStoreKeys2;
-  
+
   q = SC.Query.local(MyApp.Foo, { orderBy:"firstName ASC" });
   records = MyApp.store.find(q);
   equals(records.get('length'), 5, 'record length should be 5');
-  
+
   equals(records.objectAt(0).get('firstName'), 'Bert', 'name should be Bert');
   equals(records.objectAt(4).get('firstName'), 'Johnny', 'name should be Johnny');
-  
+
   SC.RunLoop.begin();
   newStoreKeys2 = MyApp.store.loadRecords(MyApp.Foo, [
     { guid: 11, firstName: "Anna", lastName: "Petterson" }
   ]);
   SC.RunLoop.end();
-  
+
   equals(records.objectAt(0).get('firstName'), 'Anna', 'name should be Anna');
   equals(records.objectAt(1).get('firstName'), 'Bert', 'name should be Bert');
   equals(records.objectAt(5).get('firstName'), 'Johnny', 'name should be Johnny');
-  
+
 });
 
 
 test("Using orderBy in SC.Query and loading more records to the store", function() {
 
   var q, records;
-  
+
   SC.RunLoop.begin();
   q = SC.Query.local(MyApp.Foo, { orderBy:"firstName ASC" });
   records = MyApp.store.find(q);
   equals(records.get('length'), 5, 'record length should be 5');
   equals(records.objectAt(0).get('firstName'), 'Bert', 'name should be Bert');
-  
+
   MyApp.store.loadRecords(MyApp.Foo, [
     { guid: 11, firstName: "Anna", lastName: "Petterson" }
   ]);
   SC.RunLoop.end();
-  
+
   equals(records.get('length'), 6, 'record length should be 6');
-  
+
   equals(records.objectAt(0).get('firstName'), 'Anna', 'name should be Anna');
   equals(records.objectAt(5).get('firstName'), 'Johnny', 'name should be Johnny');
-  
+
 });
 
 test("Chaining find() queries", function() {
-  
+
   var q, records, q2, records2;
-  
+
   q = SC.Query.local(MyApp.Foo, "lastName='Doe'");
   records = MyApp.store.find(q);
   equals(records.get('length'), 2, 'record length should be 2');
-  
+
   q2 = SC.Query.local(MyApp.Foo, "firstName='John'");
   records2 = records.find(q2);
 
-  equals(records2.get('length'), 1, 'record length should be 1');  
+  equals(records2.get('length'), 1, 'record length should be 1');
   equals(records2.objectAt(0).get('firstName'), 'John', 'name should be John');
-  
+
 });
 
 test("Chaining find() queries and loading more records", function() {
 
   var q, q2, records;
-  
+
   SC.RunLoop.begin();
   q = SC.Query.local(MyApp.Foo, "lastName='Doe'");
   q2 = SC.Query.local(MyApp.Foo, "firstName='John'");
-  
+
   records = MyApp.store.find(q).find(q2);
   equals(records.get('length'), 1, 'record length should be 1');
-  
+
   MyApp.store.loadRecords(MyApp.Foo, [
     { guid: 11, firstName: "John", lastName: "Doe" }
   ]);
   SC.RunLoop.end();
-  
-  equals(records.get('length'), 2, 'record length should be 2');  
+
+  equals(records.get('length'), 2, 'record length should be 2');
 });
 
 
 module("create record");
- 
+
 test("creating record appears in future find()", function() {
   var Rec, store, r;
-  
+
   Rec = SC.Record.extend({ title: SC.Record.attr(String) });
   store = SC.Store.create();
-  
+
   SC.run(function() {
-    store.loadRecords(Rec, 
-      [ { title: "A", guid: 1 }, 
+    store.loadRecords(Rec,
+      [ { title: "A", guid: 1 },
         { title: "B", guid: 2 } ]);
   });
-  
+
   equals(store.find(Rec).get('length'), 2, 'should have two initial record');
 
   SC.run(function() {
     store.createRecord(Rec, { title: "C" });
-    
+
     // NOTE: calling find() here should flush changes to the record arrays
     // so that find() always returns an accurate result
     r = store.find(Rec);
@@ -525,6 +525,6 @@ test("creating record appears in future find()", function() {
   });
 
   r = store.find(Rec);
-  equals(r.get('length'), 3, 'should return additional record');  
+  equals(r.get('length'), 3, 'should return additional record');
 });