sproutcore 1.9.2 → 1.10.0.rc.1

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

@@ -23,8 +23,8 @@ module("SC.CascadeDataSource", {
         return YES;
       },
 
-      retriveRecords: function () {
-        ok(true, "retriveRecords should be handled by baz");
+      retrieveRecords: function () {
+        ok(true, "retrieveRecords should be handled by baz");
         return NO;
       },
 
@@ -47,8 +47,8 @@ module("SC.CascadeDataSource", {
         return NO;
       },
 
-      retriveRecords: function () {
-        ok(true, "retriveRecords should be handled by baz");
+      retrieveRecords: function () {
+        ok(true, "retrieveRecords should be handled by baz");
         return NO;
       },
 
@@ -124,7 +124,7 @@ test("Verify dataSource returns 'YES' when handled by a child dataSource for fet
   ok(Sample.dataSource.fetch(store, 'query'), "fetch should be handled by bar");
 });
 
-test("Verify dataSource returns 'YES' when handled by a child dataSource for retriveRecords", function () {
+test("Verify dataSource returns 'YES' when handled by a child dataSource for retrieveRecords", function () {
   ok(Sample.dataSource.retrieveRecords(store, [0], ['id']), "retrieveRecords should be handled by baz");
 });
 

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

@@ -10,7 +10,7 @@ var store, fds, storeKey1,storeKey2;
 module("SC.FixturesDataSource", {
   setup: function() {
     SC.RunLoop.begin();
-    
+
     var Sample = (window.Sample= SC.Object.create());
     Sample.File = SC.Record.extend({ test:'hello'});
 
@@ -26,10 +26,10 @@ module("SC.FixturesDataSource", {
     { 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}
     ];
-    
+
     store = SC.Store.create().from(SC.Record.fixtures);
   },
-  
+
   teardown: function() {
     SC.RunLoop.end();
   }
@@ -39,10 +39,10 @@ test("Verify find() loads all fixture data", function() {
 
   var result = store.find(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++) {
@@ -51,13 +51,13 @@ test("Verify find() loads all fixture data", function() {
     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
+
+  // verify multiple calls to find() returns SAME data
   result = store.find(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++) {
@@ -76,10 +76,10 @@ test("Destroy a record and commit", function() {
   var ret      = store.find(Sample.File, "136"),
       storeKey = ret.get('storeKey'),
       fixtures = store.get('dataSource');
-      
+
   ok(ret, 'precond - must have record in store');
   ok(fixtures.fixtureForStoreKey(store, storeKey), 'precond - fixtures should have data for record');
-  
+
   store.destroyRecord(Sample.File, "136");
   store.commitRecords();
   ok(!fixtures.fixtureForStoreKey(store, storeKey), 'fixtures should no longer have data for record');
@@ -90,7 +90,7 @@ test("Create a record and commit it", function() {
   var fixtures = store.get('dataSource'),
       dataHash = { guid: '200', 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 },
       storeKey ;
-  
+
   store.createRecord(Sample.File, dataHash) ;
   store.commitRecords();
 
@@ -103,7 +103,7 @@ test("Update and commit a record", function() {
 
   var rec      = store.find(Sample.File, "10"),
       storeKey = Sample.File.storeKeyFor("10"),
-      fixtures = store.get('dataSource'), 
+      fixtures = store.get('dataSource'),
       fixture = fixtures.fixtureForStoreKey(store, storeKey);
 
   equals(fixture.name, rec.get('name'), 'precond - fixture state should match name');
@@ -118,5 +118,5 @@ 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');
-    
+
 });

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

@@ -3,13 +3,14 @@
  *
  * @author Evin Grano
  */
+/*global ok, equals, test, module */
 
 // ..........................................................
 // Basic Set up needs to move to the setup and teardown
 //
 var NestedRecord, store, storeKeys;
 
-var initModels = function(){
+var initModels = function () {
   NestedRecord.Directory = SC.Record.extend({
     /** Child Record Namespace */
     nestedRecordNamespace: NestedRecord,
@@ -28,7 +29,7 @@ var initModels = function(){
 //
 module("Data Store Tests for Nested Records", {
 
-  setup: function() {
+  setup: function () {
     NestedRecord = SC.Object.create({
       store: SC.Store.create()
     });
@@ -69,7 +70,7 @@ module("Data Store Tests for Nested Records", {
     SC.RunLoop.end();
   },
 
-  teardown: function() {
+  teardown: function () {
     delete NestedRecord.Directory;
     delete NestedRecord.File;
     NestedRecord = null;
@@ -77,7 +78,7 @@ module("Data Store Tests for Nested Records", {
   }
 });
 
-test("Proper Initialization",function() {
+test("Proper Initialization", function () {
   var first, second;
   equals(storeKeys.get('length'), 2, "number of primary store keys should be 2");
 
@@ -92,7 +93,7 @@ test("Proper Initialization",function() {
   ok(SC.instanceOf(second, NestedRecord.File), "second record is a instance of a NestedRecord.File Object");
 });
 
-test("Proper Status",function() {
+test("Proper Status", function () {
   var first, second;
 
   // First
@@ -104,7 +105,7 @@ test("Proper Status",function() {
   equals(second.get('status'), SC.Record.READY_CLEAN, 'second record has a READY_CLEAN State');
 });
 
-test("Can Push onto child array",function() {
+test("Can Push onto child array", function () {
   var first, contents;
 
   // First
@@ -112,7 +113,7 @@ test("Can Push onto child array",function() {
   first = first.get('contents').objectAt(0);
   contents = first.get('contents');
   equals(contents.get('length'), 2, "should have two items");
-  contents.forEach(function(f){
+  contents.forEach(function (f) {
     ok(SC.instanceOf(f, NestedRecord.File), "should be a NestedRecord.File");
     ok(f.get('name'), "should have a name property");
   });
@@ -120,7 +121,7 @@ test("Can Push onto child array",function() {
   contents.pushObject({type: 'File', name: 'File 4', id: 12});
 
   equals(contents.get('length'), 3, "should have three items");
-  contents.forEach(function(f){
+  contents.forEach(function (f) {
     ok(SC.instanceOf(f, NestedRecord.File), "should be a NestedRecord.File");
     ok(f.get('name'), "should have a name property");
     equals(f.get('status'), SC.Record.READY_DIRTY, 'second record has a READY_CLEAN State');
@@ -129,7 +130,7 @@ test("Can Push onto child array",function() {
 
 });
 
-test("Use in Nested Store", function(){
+test("Use in Nested Store", function () {
   var nstore, dir, c, file,
       pk, id, nFile, nDir;
 
@@ -178,3 +179,42 @@ test("Use in Nested Store", function(){
   equals(file.get('name'), 'Change Name', "Base > File id:1 has actually changed to name of 'Changed Name'");
 
 });
+
+test("Store#pushRetrieve for parent updates the child records", function () {
+  var parent = store.materializeRecord(storeKeys[0]),
+    nr = parent.get('contents').firstObject(),
+    newDataHash = {
+      type: 'Directory',
+      name: 'Dir 1 Changed',
+      guid: 1,
+      contents: [
+        {
+          type: 'Directory',
+          name: 'Dir 2 Changed',
+          guid: 2,
+          contents: [
+            {
+              type: 'File',
+              guid: 3,
+              name: 'File 1'
+            },
+            {
+              type: 'File',
+              guid: 4,
+              name: 'File 2'
+            }
+          ]
+        }
+      ]
+    };
+
+  ok(nr, "Got nested record");
+  equals(nr.get('name'), 'Dir 2', "Dir id:2 has correct name");
+
+  SC.run(function () {
+    store.pushRetrieve(null, null, newDataHash, storeKeys[0]);
+    store.flush();
+  });
+  equals(parent.get('name'), 'Dir 1 Changed', 'Dir id:1 name was changed');
+  equals(nr.get('name'), 'Dir 2 Changed', "Dir id:2 name was changed");
+});

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

@@ -291,7 +291,7 @@ test("adding toOne pointing to non existing class should throw error", function(
       foo: SC.Record.toOne(MyApp.DoesNotExist)
     });
   } catch (x) {
-    message = x;
+    message = x.message;
   }
 
   same(message, 'Attempted to create toOne attribute with undefined recordType. Did you forget to sc_require a dependency?');
@@ -304,7 +304,7 @@ test("adding toMany pointing to non existing class should throw error", function
       foo: SC.Record.toMany(MyApp.DoesNotExist)
     });
   } catch (x) {
-    message = x;
+    message = x.message;
   }
 
   same(message, 'Attempted to create toMany attribute with undefined recordType. Did you forget to sc_require a dependency?');

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

@@ -14,6 +14,7 @@
 
 var TestRecord = SC.Record.extend();
 var TestRecord2 = SC.Record.extend();
+var loc;
 
 function queryEquals(q, location, recordType, conditions, extra, desc) {
   if (desc===undefined && typeof extra === 'string') {
@@ -35,7 +36,9 @@ function queryEquals(q, location, recordType, conditions, extra, desc) {
       equals(q.get('recordType'), recordType, desc + ': should have recordType (singular)');
     }
 
-    equals(q.get('conditions'), conditions, desc + ': should have conditions');
+    if (location === 'local') {
+      equals(q.get('conditions'), conditions, desc + ': should have conditions');
+    }
 
     if (extra) {
       for (var key in extra) {
@@ -50,177 +53,283 @@ function queryEquals(q, location, recordType, conditions, extra, desc) {
 // BASIC TESTS
 //
 
-// The local() and remote() builder methods are very similar.  This will
-// perform the same basic tests on both of them.  If you add a builder for a
-// new type of location, you can just call this function again with your new
-// location
-function performBasicTests(methodName, loc) {
-
-  module("SC.Query.%@()".fmt(methodName), {
-    setup: function() {
-      window.TestRecord = TestRecord;
-      window.TestRecord2 = TestRecord2;
-    },
 
-    teardown: function() {
-      window.TestRecord = window.TestRecord2 = null; // cleanup
-    }
-  });
+module("SC.Query.local()", {
+  setup: function() {
+    window.TestRecord = TestRecord;
+    window.TestRecord2 = TestRecord2;
+    loc = 'local';
+  },
 
-  function invokeWith() {
-    return SC.Query[methodName].apply(SC.Query, arguments);
+  teardown: function() {
+    window.TestRecord = window.TestRecord2 = null; // cleanup
   }
+});
 
-  test("basic query with just record type", function() {
-    var q, q1, q2, q3, q4;
+function invokeWith() {
+  return SC.Query[loc].apply(SC.Query, arguments);
+}
 
-    // local
-    q = invokeWith(TestRecord);
-    queryEquals(q, loc, TestRecord, null, 'first query');
+test("basic query with just record type", function() {
+  var q, q1, q2, q3, q4;
 
-    q1 = invokeWith(TestRecord);
-    equals(q1, q, 'second call should return cached value');
+  // local
+  q = invokeWith(TestRecord);
+  queryEquals(q, loc, TestRecord, null, 'first query');
 
-    // using string for record type name should work
-    q2 = invokeWith("TestRecord");
-    equals(q2, q, 'queryFor with string should return cached value');
+  q1 = invokeWith(TestRecord);
+  equals(q1, q, 'second call should return cached value');
 
-    // using an array of a single item should be treated as a single item
-    q3 = invokeWith([TestRecord]);
-    equals(q3, q, 'queryFor([TestRecord]) should return cached value');
+  // using string for record type name should work
+  q2 = invokeWith("TestRecord");
+  equals(q2, q, 'queryFor with string should return cached value');
 
-    // ditto w/ strings
-    q4 = invokeWith(['TestRecord']);
-    equals(q4, q, 'queryFor(["TestRecord"]) with string should return cached value');
+  // using an array of a single item should be treated as a single item
+  q3 = invokeWith([TestRecord]);
+  equals(q3, q, 'queryFor([TestRecord]) should return cached value');
 
-  });
+  // ditto w/ strings
+  q4 = invokeWith(['TestRecord']);
+  equals(q4, q, 'queryFor(["TestRecord"]) with string should return cached value');
 
-  test("query with multiple recordtypes", function() {
+});
 
-    var types = [TestRecord, TestRecord2],
-        q1, q2, a3, q4, q5, set;
+test("query with multiple recordtypes", function() {
 
-    // create first query
-    q1 = invokeWith(types);
-    queryEquals(q1, loc, types, null, 'first query');
+  var types = [TestRecord, TestRecord2],
+      q1, q2, a3, q4, q5, set;
 
-    // try again - should get cache
-    q2 = invokeWith(types);
-    equals(q2, q1, 'second queryFor call should return cached value');
+  // create first query
+  q1 = invokeWith(types);
+  queryEquals(q1, loc, types, null, 'first query');
 
-    // try again - different order
-    q3 = invokeWith([TestRecord2, TestRecord]);
-    equals(q3, q1, 'queryFor with different order of record types should return same cached value');
+  // try again - should get cache
+  q2 = invokeWith(types);
+  equals(q2, q1, 'second queryFor call should return cached value');
 
-    // try again - using a set
-    set = SC.Set.create().add(TestRecord).add(TestRecord2);
-    q4  = invokeWith(set);
-    equals(q4, q1, 'should return cached query even if using an enumerable for types');
+  // try again - different order
+  q3 = invokeWith([TestRecord2, TestRecord]);
+  equals(q3, q1, 'queryFor with different order of record types should return same cached value');
 
-    // try again using strings
-    q5 = invokeWith('TestRecord TestRecord2'.w());
-    equals(q5, q1, 'should return cached query even if string record names are used');
-  });
+  // try again - using a set
+  set = SC.Set.create().add(TestRecord).add(TestRecord2);
+  q4  = invokeWith(set);
+  equals(q4, q1, 'should return cached query even if using an enumerable for types');
 
-  test("query with record type and conditions", function() {
+  // try again using strings
+  q5 = invokeWith('TestRecord TestRecord2'.w());
+  equals(q5, q1, 'should return cached query even if string record names are used');
+});
 
-    var q1, q2, q3, q4, q5, q6, q7;
+test("query with record type and conditions", function() {
 
-    q1 = invokeWith(TestRecord, 'foobar');
-    queryEquals(q1, loc, TestRecord, 'foobar', 'first query');
+  var q1, q2, q3, q4, q5, q6, q7;
 
-    q2 = invokeWith(TestRecord, 'foobar');
-    equals(q2, q1, 'second call to queryFor(TestRecord, foobar) should return cached instance');
+  q1 = invokeWith(TestRecord, 'foobar');
+  queryEquals(q1, loc, TestRecord, 'foobar', 'first query');
 
-    q3 = invokeWith(TestRecord2, 'foobar');
-    queryEquals(q3, loc, TestRecord2, 'foobar', 'query(TestRecord2, foobar)');
-    ok(q3 !== q1, 'different recordType same conditions should return new query');
+  q2 = invokeWith(TestRecord, 'foobar');
+  equals(q2, q1, 'second call to queryFor(TestRecord, foobar) should return cached instance');
 
-    q4 = invokeWith(TestRecord, 'baz');
-    queryEquals(q4, loc, TestRecord, 'baz', 'query(TestRecord2, baz)');
-    ok(q4 !== q1, 'different conditions should return new query');
+  q3 = invokeWith(TestRecord2, 'foobar');
+  queryEquals(q3, loc, TestRecord2, 'foobar', 'query(TestRecord2, foobar)');
+  ok(q3 !== q1, 'different recordType same conditions should return new query');
 
-    q5 = invokeWith(TestRecord, 'baz');
-    equals(q5, q4, 'second call for different conditions should return cache');
-  });
+  q4 = invokeWith(TestRecord, 'baz');
+  queryEquals(q4, loc, TestRecord, 'baz', 'query(TestRecord2, baz)');
+  ok(q4 !== q1, 'different conditions should return new query');
 
-  test("query with record types and conditions hash", function() {
+  q5 = invokeWith(TestRecord, 'baz');
+  equals(q5, q4, 'second call for different conditions should return cache');
+});
 
-    var q = invokeWith([TestRecord, TestRecord2], {});
-    queryEquals(q, loc, [TestRecord, TestRecord2], null, 'first query');
+test("query with record types and conditions hash", function() {
 
-  });
+  var q = invokeWith([TestRecord, TestRecord2], {});
+  queryEquals(q, loc, [TestRecord, TestRecord2], null, 'first query');
 
-  test("query with no record type and with conditions", function() {
-    var q1, q2;
+});
 
-    q1 = invokeWith(null, 'foobar');
-    queryEquals(q1, loc, SC.Record, 'foobar', 'first query');
+test("query with no record type and with conditions", function() {
+  var q1, q2;
 
-    q2 = invokeWith(null, 'foobar');
-    equals(q2, q1, 'should return cached value');
-  });
+  q1 = invokeWith(null, 'foobar');
+  queryEquals(q1, loc, SC.Record, 'foobar', 'first query');
 
-  test("query with recordtype, conditions, and parameters hash", function() {
-    var opts  = { opt1: 'bar', opt2: 'baz' },
-        q1, q2;
+  q2 = invokeWith(null, 'foobar');
+  equals(q2, q1, 'should return cached value');
+});
 
-    q1 = invokeWith(TestRecord, 'foo', opts);
-    queryEquals(q1, loc, TestRecord, 'foo', { parameters: opts }, 'first query');
+test("query with recordtype, conditions, and parameters hash", function() {
+  var opts  = { opt1: 'bar', opt2: 'baz' },
+      q1, q2;
 
-    q2 = invokeWith(TestRecord, 'foo', opts);
-    ok(q1 !== q2, 'second call to queryFor with opts cannot be cached');
-    queryEquals(q1, loc, TestRecord, 'foo', { parameters: opts }, 'second query');
-  });
+  q1 = invokeWith(TestRecord, 'foo', opts);
+  queryEquals(q1, loc, TestRecord, 'foo', { parameters: opts }, 'first query');
 
-  test("query with recordtype, conditions, and parameters array", function() {
-    var opts  = ['foo', 'bar'],
-        q1, q2;
+  q2 = invokeWith(TestRecord, 'foo', opts);
+  ok(q1 !== q2, 'second call to queryFor with opts cannot be cached');
+  queryEquals(q1, loc, TestRecord, 'foo', { parameters: opts }, 'second query');
+});
 
-    q1 = invokeWith(TestRecord, 'foo', opts);
-    queryEquals(q1, loc, TestRecord, 'foo', { parameters: opts }, 'first query should include parameters prop');
+test("query with recordtype, conditions, and parameters array", function() {
+  var opts  = ['foo', 'bar'],
+      q1, q2;
 
-    q2 = invokeWith(TestRecord, 'foo', opts);
-    ok(q1 !== q2, 'second call to queryFor with opts cannot be cached');
-    queryEquals(q1, loc, TestRecord, 'foo', { parameters: opts }, 'second query');
-  });
+  q1 = invokeWith(TestRecord, 'foo', opts);
+  queryEquals(q1, loc, TestRecord, 'foo', { parameters: opts }, 'first query should include parameters prop');
 
-  test("passing query object", function() {
+  q2 = invokeWith(TestRecord, 'foo', opts);
+  ok(q1 !== q2, 'second call to queryFor with opts cannot be cached');
+  queryEquals(q1, loc, TestRecord, 'foo', { parameters: opts }, 'second query');
+});
 
-    var local = SC.Query.local(TestRecord),
-        remote = SC.Query.remote(TestRecord),
-        q;
+test("passing query object", function() {
 
-    q = invokeWith(local);
-    if (loc === SC.Query.LOCAL) {
-      equals(q, local, 'invoking with local query should return same query');
-    } else {
-      ok(q !== local, 'invoke with local query should return new instance');
-    }
-    equals(q.get('location'), loc, 'query should have expected location');
+  var local = SC.Query.local(TestRecord),
+      remote = SC.Query.remote(TestRecord),
+      q;
 
-    q = invokeWith(remote);
-    if (loc === SC.Query.REMOTE) {
-      equals(q, remote, 'invoking with remote query should return same query');
-    } else {
-      ok(q !== remote, 'invoke with remote query should return new instance');
-    }
-    equals(q.get('location'), loc, 'query should have expected location');
-  });
+  q = invokeWith(local);
+  equals(q, local, 'invoking with local query should return same query');
+  equals(q.get('location'), loc, 'query should have expected location');
+
+  q = invokeWith(remote);
+  ok(q !== remote, 'invoke with remote query should return new instance');
+  equals(q.get('location'), loc, 'query should have expected location');
+});
+
+test("no options (matches everything)", function() {
+  var q1, q2;
+
+  q1 = invokeWith();
+  queryEquals(q1, loc, SC.Record, null, 'first query - matches everything');
 
-  test("no options (matches everything)", function() {
-    var q1, q2;
+  q2 = invokeWith();
+  equals(q2, q1, 'should return same cached query');
 
-    q1 = invokeWith();
-    queryEquals(q1, loc, SC.Record, null, 'first query - matches everything');
+});
 
-    q2 = invokeWith();
-    equals(q2, q1, 'should return same cached query');
 
-  });
+module("SC.Query.remote()", {
+  setup: function() {
+    window.TestRecord = TestRecord;
+    window.TestRecord2 = TestRecord2;
+    loc = 'remote';
+  },
 
+  teardown: function() {
+    window.TestRecord = window.TestRecord2 = null; // cleanup
+  }
+});
 
+function invokeWith() {
+  return SC.Query[loc].apply(SC.Query, arguments);
 }
 
-performBasicTests('local', SC.Query.LOCAL);
-performBasicTests('remote', SC.Query.REMOTE);
+test("basic query with just record type", function() {
+  var q, q1, q2, q3, q4;
+
+  // local
+  q = invokeWith(TestRecord);
+  queryEquals(q, loc, TestRecord, null, 'first query');
+
+  q1 = invokeWith(TestRecord);
+  equals(q1, q, 'second call should return cached value');
+
+  // using string for record type name should work
+  q2 = invokeWith("TestRecord");
+  equals(q2, q, 'queryFor with string should return cached value');
+
+  // using an array of a single item should be treated as a single item
+  q3 = invokeWith([TestRecord]);
+  equals(q3, q, 'queryFor([TestRecord]) should return cached value');
+
+  // ditto w/ strings
+  q4 = invokeWith(['TestRecord']);
+  equals(q4, q, 'queryFor(["TestRecord"]) with string should return cached value');
+
+});
+
+test("query with multiple recordtypes", function() {
+
+  var types = [TestRecord, TestRecord2],
+      q1, q2, a3, q4, q5, set;
+
+  // create first query
+  q1 = invokeWith(types);
+  queryEquals(q1, loc, types, null, 'first query');
+
+  // try again - should get cache
+  q2 = invokeWith(types);
+  equals(q2, q1, 'second queryFor call should return cached value');
+
+  // try again - different order
+  q3 = invokeWith([TestRecord2, TestRecord]);
+  equals(q3, q1, 'queryFor with different order of record types should return same cached value');
+
+  // try again - using a set
+  set = SC.Set.create().add(TestRecord).add(TestRecord2);
+  q4  = invokeWith(set);
+  equals(q4, q1, 'should return cached query even if using an enumerable for types');
+
+  // try again using strings
+  q5 = invokeWith('TestRecord TestRecord2'.w());
+  equals(q5, q1, 'should return cached query even if string record names are used');
+});
+
+test("query with record type and options", function() {
+
+  var q1, q2, q3, q4, q5, q6, q7,
+    opts = { foo: 'bar' };
+
+  q1 = invokeWith(TestRecord, opts);
+  queryEquals(q1, loc, TestRecord, opts, 'first query');
+
+  q2 = invokeWith(TestRecord, opts);
+  ok(q2 !== q1, 'second call to queryFor(TestRecord, opts) should return new instance');
+
+  q3 = invokeWith(TestRecord2, opts);
+  queryEquals(q3, loc, TestRecord2, 'foobar', 'query(TestRecord2, foobar)');
+  ok(q3 !== q1, 'different recordType same options should return new query');
+
+  q4 = invokeWith(TestRecord, {});
+  queryEquals(q4, loc, TestRecord, 'baz', 'query(TestRecord2, baz)');
+  ok(q4 !== q1, 'different options should return new query');
+
+  q5 = invokeWith(TestRecord, {});
+  ok(q5 !== q4, 'second call for different options should return new query');
+});
+
+test("query with record types and options hash", function() {
+
+  var q = invokeWith([TestRecord, TestRecord2], {});
+  queryEquals(q, loc, [TestRecord, TestRecord2], null, 'first query');
+
+});
+
+test("passing query object", function() {
+
+  var local = SC.Query.local(TestRecord),
+      remote = SC.Query.remote(TestRecord),
+      q;
+
+  q = invokeWith(local);
+  ok(q !== local, 'invoke with local query should return new instance');
+  equals(q.get('location'), loc, 'query should have expected location');
+
+  q = invokeWith(remote);
+  equals(q, remote, 'invoking with remote query should return same query');
+  equals(q.get('location'), loc, 'query should have expected location');
+});
+
+test("no options (matches everything)", function() {
+  var q1, q2;
+
+  q1 = invokeWith();
+  queryEquals(q1, loc, SC.Record, null, 'first query - matches everything');
+
+  q2 = invokeWith();
+  equals(q2, q1, 'should return same cached query');
+
+});