sproutcore 1.6.0.beta.2-x86-mingw32

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

@@ -0,0 +1,530 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Apple Inc. and contributors.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+/*globals module ok equals same test MyApp */
+
+// test querying through find() on the store
+module("SC.Query querying find() on a store", {
+  setup: function() {
+    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({
+
+      fetch: function(store, query) {
+        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'));    
+          }
+        }
+        
+        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; 
+        
+        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 },
+      { guid: 3, firstName: "Emily", lastName: "Parker", bornIn: 1975, married: true },
+      { 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)');  
+});
+
+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');
+});
+
+// ..........................................................
+// RECORD ARRAY CACHING
+// 
+ 
+test("caching for a single store", function() {
+  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');
+  equals(r1.get('store'), MyApp.store, 'return object should be owned by store');
+  equals(r2, r1, 'should return same record array for multiple calls');
+});
+
+test("find() caching for a chained store", function() {
+  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');
+});
+
+test("data source must get the right calls", function() {
+  var ds = MyApp.store.get('dataSource');
+  
+  ds.reset();  
+  var records = MyApp.store.find(MyApp.Foo);
+  var q = SC.Query.local(MyApp.Foo);
+  ds.fetchEquals(MyApp.store, q, 'after fetch');
+});
+
+// ..........................................................
+// RECORD PROPERTIES
+// 
+
+test("should find records based on boolean", function() {
+  SC.RunLoop.begin();
+  var q = SC.Query.local(MyApp.Foo, "married=YES");
+  var records = MyApp.store.find(q);
+  equals(records.get('length'), 4, 'record length should be 4');
+  SC.RunLoop.end();
+});
+
+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);
+  equals(records.get('length'), 1, 'record length should be 1');
+  equals(records.objectAt(0).get('firstName'), 'John', 'name should be John');
+  SC.RunLoop.end();
+});
+
+test("should find records based on SC.Query", function() {
+  var q = SC.Query.create({
+    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');
+});
+
+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);
+  ok(r2.get('firstName') !== 'Jane', 'precond - firstName is not Jane');
+  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(); 
+  
+  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 records = MyApp.store.find(q);
+  equals(records.get('length'), 4, 'record length should be 2');
+
+  same(records.getEach('firstName'), 'John John Jane Jane'.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 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');
+});
+
+test("loading more data into the store should propagate to record array with query", function() {
+
+  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();
+  var newStoreKeys = MyApp.store.loadRecords(MyApp.Foo, [
+    { 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');  
+});
+
+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" },
+    { guid: 22, firstName: "Barbara", lastName: "Jones" }
+  ];
+
+  MyApp.store3.loadRecords(MyApp.Foo, recordsToLoad);
+  
+  SC.RunLoop.end();
+  
+  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');  
+});
+
+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.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');  
+});
+
+
+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 }, 
+        { 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);
+    equals(r.get('length'), 3, 'should return additional record');
+  });
+
+  r = store.find(Rec);
+  equals(r.get('length'), 3, 'should return additional record');  
+});
+

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

@@ -0,0 +1,23 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Apple Inc. and contributors.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+/*globals module ok equals same test MyApp */
+
+// This file tests the initial state of the store when it is first created
+// either independently or as a chained store.
+
+module("SC.Store#init");
+
+test("initial setup for root store", function() {
+  var store = SC.Store.create();
+  
+  equals(SC.typeOf(store.dataHashes), SC.T_HASH, 'should have dataHashes');
+  equals(SC.typeOf(store.revisions), SC.T_HASH, 'should have revisions');
+  equals(SC.typeOf(store.statuses), SC.T_HASH, 'should have statuses');
+  ok(!store.editables, 'should not have editables');
+  ok(!store.recordErrors, 'should not have recordErrors');
+  ok(!store.queryErrors, 'should not have queryErrors');
+}); 
+

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

@@ -0,0 +1,64 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Apple Inc. and contributors.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+/*globals module ok equals same test MyApp */
+
+var store, dataHashes;
+var Person;
+
+
+module("SC.Store#loadRecord", {
+  setup: function() {
+  
+    Person = SC.Record.extend({
+      first: SC.Record.attr(String, { isRequired: YES}),
+      last: SC.Record.attr(String),
+      age: SC.Record.attr(Number),
+      isAlive: SC.Record.attr(Boolean)
+    });
+    
+    SC.RunLoop.begin();
+
+    store = SC.Store.create();
+    
+    dataHashes = [ 
+    
+    Person.create({ 
+      guid: 1,
+      first: "John",
+      last: "Sproutish",
+      age: 35,
+      isAlive: YES}),
+      
+    Person.create({
+      guid: 2,
+      first: "Sarah",
+      last: "Coop",
+      age: 28,
+      isAlive: YES })];
+
+    SC.RunLoop.end();
+  }
+});
+
+test("loadRecord loads new / update existing record in store", function() {
+  var aDataHash = dataHashes[0];  
+  var storeKey = store.loadRecord(Person, aDataHash);
+  ok(storeKey, "A store key is generated for a new record.");
+  
+  var doesStoreKeyResolveToPK = aDataHash.get('guid') === store.idFor(storeKey);
+  ok(doesStoreKeyResolveToPK, "The storeKey resolves to the correct Primary Key");
+  
+  var isStatusCorrect = store.peekStatus(storeKey) & SC.Record.READY_CLEAN;
+  ok(isStatusCorrect, "Record is in SC.Record.READY_CLEAN state after loading into store.");
+  
+  // Change the record
+  aDataHash['age'] = 40;
+  var storeKeyAfterUpdate = store.loadRecord(Person, aDataHash);
+  ok(storeKey === storeKeyAfterUpdate, "When the same record is loaded a second time its store key remains unchanged.");
+  
+  var record = store.materializeRecord(storeKey);
+  ok(record.get('age') === 40, "Record in store is updated with new values from data hash.");  
+});