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

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

@@ -11,13 +11,13 @@ module("SC.NestedStore#commitChangesFromNestedStore", {
     SC.RunLoop.begin();
 
     parent = SC.Store.create();
-    
+
     json = {
       string: "string",
       number: 23,
       bool:   YES
     };
-    
+
     storeKey = SC.Store.generateStoreKey();
 
     store = parent.chain();
@@ -34,22 +34,22 @@ module("SC.NestedStore#commitChangesFromNestedStore", {
 });
 
 test("copies changed data hashes, statuses, and revisions", function() {
-  
+
   SC.RunLoop.begin();
-  
+
   // verify preconditions
   equals(store.readDataHash(storeKey), null, 'precond - should not have data yet');
   ok(child.chainedChanges.contains(storeKey), 'precond - child changes should include storeKey');
-  
+
   // perform action
   equals(store.commitChangesFromNestedStore(child, child.chainedChanges, NO), store, 'should return receiver');
   SC.RunLoop.end();
-  
+
   // verify new status
   equals(store.readDataHash(storeKey), json, 'now should have json');
   equals(store.readStatus(storeKey), SC.Record.READY_DIRTY, 'now should have status');
-  equals(store.revisions[storeKey], child.revisions[storeKey], 'now shoulave have revision from child');  
-    
+  equals(store.revisions[storeKey], child.revisions[storeKey], 'now shoulave have revision from child');
+
 });
 
 test("adds lock on any items not already locked", function() {
@@ -58,40 +58,40 @@ test("adds lock on any items not already locked", function() {
 
   var storeKey2 = SC.Store.generateStoreKey();
   var json2 = { kind: "json2" };
-  
+
   // verify preconditions
   store.readDataHash(storeKey);
   ok(store.locks[storeKey], 'precond - storeKey should have lock');
   ok(!store.locks[storeKey2], 'precond - storeKey2 should not have lock');
-  
+
   // write another record into child store to commit changes.
   child.writeDataHash(storeKey2, json2, SC.Record.READY_DIRTY);
   child.dataHashDidChange(storeKey2);
-  
+
   var changes = child.chainedChanges ;
   ok(changes.contains(storeKey), 'precond - child.chainedChanges should contain storeKey');
   ok(changes.contains(storeKey2), 'precond - child.chainedChanges should contain storeKey2');
-  
+
   // now commit back to parent
-  equals(store.commitChangesFromNestedStore(child, changes, NO), store, 'should return reciever');
+  equals(store.commitChangesFromNestedStore(child, changes, NO), store, 'should return receiver');
   SC.RunLoop.end();
-  
+
   // and verify that both have locks
   ok(store.locks[storeKey], 'storeKey should have lock after commit (actual: %@)'.fmt(store.locks[storeKey]));
   ok(store.locks[storeKey2], 'storeKey2 should have lock after commit (actual: %@)'.fmt(store.locks[storeKey2]));
-  
+
 });
 
-test("adds items in chainedChanges to reciever chainedChanges", function() {
+test("adds items in chainedChanges to receiver chainedChanges", function() {
 
   SC.RunLoop.begin();
 
   var key1 = SC.Store.generateStoreKey();
 
   store.dataHashDidChange(key1);
-  
+
   ok(child.chainedChanges.contains(storeKey), 'precond - child.chainedChanges should contain store key');
-  
+
   equals(store.commitChangesFromNestedStore(child, child.chainedChanges, NO), store, 'should return receiver');
   SC.RunLoop.end();
 
@@ -101,36 +101,36 @@ test("adds items in chainedChanges to reciever chainedChanges", function() {
 });
 
 test("should set hasChanges to YES if has changes", function() {
-  
+
   SC.RunLoop.begin();
-  
+
   var changes = child.chainedChanges;
   ok(changes.length>0, 'precond - should have some changes in child');
   equals(store.get('hasChanges'), NO, 'precond - store should not have changes');
-  
+
   store.commitChangesFromNestedStore(child, changes, NO);
   equals(store.get('hasChanges'), YES, 'store should now have changes');
 });
 
 test("should set hasChanges to NO if no changes", function() {
-  
+
   SC.RunLoop.begin();
-  
+
   child = store.chain() ; // get a new child store
-  
+
   var changes = child.chainedChanges || SC.Set.create();
   ok(!changes || !changes.length, 'precond - should have not have changes in child');
   equals(store.get('hasChanges'), NO, 'precond - store should not have changes');
-  
+
   store.commitChangesFromNestedStore(child, changes, NO);
   SC.RunLoop.end();
-  
+
   equals(store.get('hasChanges'), NO, 'store should NOT now have changes');
 });
 
 // ..........................................................
 // SPECIAL CASES
-// 
+//
 
 test("committing changes should chain back each step", function() {
 
@@ -140,18 +140,18 @@ test("committing changes should chain back each step", function() {
   equals(child.readDataHash(storeKey), json, 'precond - child should have data');
   equals(store.readDataHash(storeKey), null, 'precond - store should not have data');
   equals(parent.readDataHash(storeKey), null, 'precond - parent should not have data');
-  
+
   // do commits
   child.commitChanges();
 
   equals(store.get('hasChanges'), YES, 'store should now have changes');
   equals(store.readDataHash(storeKey), json, 'store should now have json');
-  
+
   store.commitChanges();
   equals(store.get('hasChanges'), NO, 'store should no longer have changes');
   equals(parent.readDataHash(storeKey), json, 'parent should now have json');
   SC.RunLoop.end();
-  
+
 });
 
 

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

@@ -6,22 +6,28 @@
 /*globals module ok equals same test MyApp */
 
 // test core array-mapping methods for RecordArray
-var store, storeKey, json, rec, storeKeys, recs;
+var store, storeKey, json, rec, storeKey2, json2, rec2, storeKeys, recs;
 module("SC.RecordArray core methods", {
   setup: function() {
     // setup dummy store
     store = SC.Store.create();
+
     storeKey = SC.Record.storeKeyFor('foo');
-    json = {  guid: "foo", foo: "bar" };
-    store.writeDataHash(storeKey, json, SC.Record.READY_CLEAN); 
-    
-    
-    // get record
+    json = { guid: "foo", foo: "bar" };
+    store.writeDataHash(storeKey, json, SC.Record.READY_CLEAN);
+
+    storeKey2 = SC.Record.storeKeyFor('baz');
+    json2 = { guid: "baz", baz: "bash" };
+    store.writeDataHash(storeKey2, json2, SC.Record.READY_CLEAN);
+
+    // get records
     rec = store.materializeRecord(storeKey);
-    equals(rec.get('foo'), 'bar', 'record should have json');
-    
+    equals(rec.get('foo'), 'bar', 'precond - record should have json');
+    rec2 = store.materializeRecord(storeKey2);
+    equals(rec2.get('baz'), 'bash', 'precond - record 2 should have json');
+
     // get record array.
-    storeKeys = [storeKey];
+    storeKeys = [storeKey, storeKey2];
     recs = SC.RecordArray.create({ store: store, storeKeys: storeKeys });
   }
 });
@@ -32,25 +38,25 @@ test("initial status", function() {
 
 // ..........................................................
 // LENGTH
-// 
+//
 
 test("should pass through length", function() {
-  equals(recs.get('length'), storeKeys.length, 'rec should pass through length');  
+  equals(recs.get('length'), storeKeys.length, 'rec should pass through length');
 });
 
 test("changing storeKeys length should change length of rec array also", function() {
 
   var oldlen = recs.get('length');
-  
+
   storeKeys.pushObject(SC.Store.generateStoreKey()); // change length
-  
+
   ok(storeKeys.length > oldlen, 'precond - storeKeys.length should have changed');
-  equals(recs.get('length'), storeKeys.length, 'rec should pass through length');    
+  equals(recs.get('length'), storeKeys.length, 'rec should pass through length');
 });
 
 // ..........................................................
 // objectAt
-// 
+//
 
 test("should materialize record for object", function() {
   equals(storeKeys[0], storeKey, 'precond - storeKeys[0] should be storeKey');
@@ -63,67 +69,70 @@ test("reading past end of array length should return undefined", function() {
 
 test("modifying the underlying storeKey should change the returned materialized record", function() {
   // read record once to make it materialized
-  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');  
-  
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');
+
   // create a new record.
   SC.RunLoop.begin();
-  var rec2 = store.createRecord(SC.Record, { foo: "rec2" });
+  var rec3 = store.createRecord(SC.Record, { foo: "rec3" });
   SC.RunLoop.end();
 
-  var storeKey2 = rec2.get('storeKey');
-  
+  var storeKey3 = rec3.get('storeKey');
+
   // add to beginning of storeKey array
-  storeKeys.unshiftObject(storeKey2);
-  equals(recs.get('length'), 2, 'should now have length of 2');
-  equals(recs.objectAt(0), rec2, 'objectAt(0) should return new record');
-  equals(recs.objectAt(1), rec, 'objectAt(1) should return old record');
+  storeKeys.unshiftObject(storeKey3);
+  equals(recs.get('length'), 3, 'should now have length of 3');
+  equals(recs.objectAt(0), rec3, 'objectAt(0) should return new record');
+  equals(recs.objectAt(1), rec, 'objectAt(1) should return old record 1');
+  equals(recs.objectAt(2), rec2, 'objectAt(2) should return old record 2');
 });
 
 test("reading a record not loaded in store should trigger retrieveRecord", function() {
   var callCount = 0;
 
-  // patch up store to record a call and to make it look like data is not 
+  // patch up store to record a call and to make it look like data is not
   // loaded.
   store.removeDataHash(storeKey, SC.Record.EMPTY);
   store.retrieveRecord = function() { callCount++; };
-  
+
   equals(store.peekStatus(storeKeys.objectAt(0)), SC.Record.EMPTY, 'precond - storeKey must not be loaded');
-  
+
   var rec = recs.objectAt(0);
   equals(callCount, 1, 'store.retrieveRecord() should have been called');
 });
 
 // ..........................................................
 // replace()
-// 
+//
 
 test("adding a record to the record array should pass through storeKeys", function() {
   // read record once to make it materialized
-  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');  
-  
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');
+
   // create a new record.
   SC.RunLoop.begin();
-  var rec2 = store.createRecord(SC.Record, { foo: "rec2" });
+  var rec3 = store.createRecord(SC.Record, { foo: "rec3" });
   SC.RunLoop.end();
-  
-  var storeKey2 = rec2.get('storeKey');
-  
+
+  var storeKey3 = rec3.get('storeKey');
+
   // add record to beginning of record array
-  recs.unshiftObject(rec2);
-  
+  recs.unshiftObject(rec3);
+
   // verify record array
-  equals(recs.get('length'), 2, 'should now have length of 2');
-  equals(recs.objectAt(0), rec2, 'recs.objectAt(0) should return new record');
-  equals(recs.objectAt(1), rec, 'recs.objectAt(1) should return old record');
-  
+  equals(recs.get('length'), 3, 'should now have length of 3');
+  equals(recs.objectAt(0), rec3, 'recs.objectAt(0) should return new record');
+  equals(recs.objectAt(1), rec, 'recs.objectAt(1) should return old record 1');
+  equals(recs.objectAt(2), rec2, 'recs.objectAt(2) should return old record 2');
+
   // verify storeKeys
-  equals(storeKeys.objectAt(0), storeKey2, 'storeKeys[0] should return new storeKey');
-  equals(storeKeys.objectAt(1), storeKey, 'storeKeys[1] should return old storeKey');
+  equals(storeKeys.objectAt(0), storeKey3, 'storeKeys[0] should return new storeKey');
+  equals(storeKeys.objectAt(1), storeKey, 'storeKeys[1] should return old storeKey 1');
+  equals(storeKeys.objectAt(2), storeKey2, 'storeKeys[2] should return old storeKey 2');
 });
 
 // ..........................................................
 // Property Observing
-// 
+//
 
 test("changing the underlying storeKeys should notify observers of records", function() {
 
@@ -132,8 +141,8 @@ test("changing the underlying storeKeys should notify observers of records", fun
     cnt: 0,
     observer: function() { this.cnt++; }
   });
-  recs.addObserver('[]', obj, obj.observer); 
-  
+  recs.addObserver('[]', obj, obj.observer);
+
   // now modify storeKeys
   storeKeys.pushObject(SC.Store.generateStoreKey());
   equals(obj.cnt, 1, 'observer should have fired after changing storeKeys');
@@ -145,7 +154,7 @@ test("swapping storeKey array should change recordArray and observers", function
   SC.RunLoop.begin();
   var rec2 = store.createRecord(SC.Record, { foo: "rec2" });
   SC.RunLoop.end();
-  
+
   var storeKey2 = rec2.get('storeKey');
   var storeKeys2 = [storeKey2];
 
@@ -154,24 +163,36 @@ test("swapping storeKey array should change recordArray and observers", function
     cnt: 0,
     observer: function() { this.cnt++; }
   });
-  recs.addObserver('[]', obj, obj.observer); 
-  
+  recs.addObserver('[]', obj, obj.observer);
+
   // read record once to make it materialized
-  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');  
-  
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should materialize record');
+
   // now swap storeKeys
   obj.cnt = 0 ;
   recs.set('storeKeys', storeKeys2);
-  
+
   // verify observer fired and record changed
   equals(obj.cnt, 1, 'observer should have fired after swap');
   equals(recs.objectAt(0), rec2, 'recs.objectAt(0) should return new rec');
-  
+
   // modify storeKey2, make sure observer fires and content changes
   obj.cnt = 0;
   storeKeys2.unshiftObject(storeKey);
   equals(obj.cnt, 1, 'observer should have fired after edit');
   equals(recs.get('length'), 2, 'should reflect new length');
-  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should return pushed rec');  
+  equals(recs.objectAt(0), rec, 'recs.objectAt(0) should return pushed rec');
+
+});
+
+test("find works with query", function(){
+  var filtered = recs.find(SC.Query.create({ conditions: "foo = 'bar'" }));
+
+  equals(filtered.get('length'), 1);
+  equals(filtered.objectAt(0), rec);
+});
 
+test("find works as enumerable", function(){
+  var filtered = recs.find(function(r){ return r.get('foo') === 'bar'; });
+  equals(filtered, rec);
 });

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

@@ -167,7 +167,6 @@ test("calling storeDidChangeStoreKeys() with a matching recordType should not un
 
 test("adding an array observer to a SC.RecordArray should cause the array to flush", function() {
   var callCount = 0;
-  debugger;
 
   recs.addArrayObservers({
     didChange: function() {

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

@@ -11,13 +11,13 @@ module("SC.Store#commitChangesFromNestedStore", {
     SC.RunLoop.begin();
 
     store = SC.Store.create();
-    
+
     json = {
       string: "string",
       number: 23,
       bool:   YES
     };
-    
+
     storeKey = SC.Store.generateStoreKey();
 
     child = store.chain();  // test multiple levels deep
@@ -33,46 +33,46 @@ module("SC.Store#commitChangesFromNestedStore", {
 });
 
 test("copies changed data hashes, statuses, and revisions", function() {
-  
+
   SC.RunLoop.begin();
-  
+
   // verify preconditions
   equals(store.readDataHash(storeKey), null, 'precond - should not have data yet');
   ok(child.chainedChanges.contains(storeKey), 'precond - child changes should include storeKey');
-  
+
   // perform action
   equals(store.commitChangesFromNestedStore(child, child.chainedChanges, NO), store, 'should return receiver');
-  
+
   // verify new status
   equals(store.readDataHash(storeKey), json, 'now should have json');
   equals(store.readStatus(storeKey), SC.Record.READY_DIRTY, 'now should have status');
-  equals(store.revisions[storeKey], child.revisions[storeKey], 'now shoulave have revision from child');  
-    
+  equals(store.revisions[storeKey], child.revisions[storeKey], 'now shoulave have revision from child');
+
   SC.RunLoop.end();
 });
 
-test("adds items in changelog to reciever changelog", function() {
+test("adds items in changelog to receiver changelog", function() {
 
   var key1 = SC.Store.generateStoreKey();
 
   SC.RunLoop.begin();
-  
+
   store.changelog = SC.Set.create();
   store.changelog.add(key1);
-  
+
   ok(child.changelog.contains(storeKey), 'precond - child.changelog should contain store key');
-  
+
   equals(store.commitChangesFromNestedStore(child, child.chainedChanges, NO), store, 'should return receiver');
 
   // changelog should merge nested store & existing
   ok(store.changelog.contains(key1), 'changelog should still contain key1');
   ok(store.changelog.contains(storeKey), 'changelog should also contain storeKey');
-  
+
   SC.RunLoop.end();
 });
 
 test("ignores changed data hashes not passed in changes set", function() {
-  
+
   // preconditions
   equals(store.readDataHash(storeKey), null, 'precond - should not have data yet');
 
@@ -81,25 +81,25 @@ test("ignores changed data hashes not passed in changes set", function() {
 
   // verify results
   equals(store.readDataHash(storeKey), null, 'should not copy data hash for storeKey');
-  
+
 });
 
 function createConflict(force) {
   var json2 = { kind: "json2" };
   var json3 = { kind: "json3" };
-  
+
   // create a lock conflict.  use a new storeKey since the old one has been
   // setup in a way that won't work for this.
   storeKey = SC.Store.generateStoreKey();
-  
+
   // step 1: add data to root store
   store.writeDataHash(storeKey, json, SC.Record.READY_CLEAN);
   store.dataHashDidChange(storeKey);
-  
+
   // step 2: read data in chained store.  this will create lock
   child.readDataHash(storeKey);
   ok(child.locks[storeKey], 'child store should now have lock');
-  
+
   // step 3: modify root store again
   store.writeDataHash(storeKey, json2, SC.Record.READY_CLEAN);
   store.dataHashDidChange(storeKey);
@@ -107,11 +107,11 @@ function createConflict(force) {
   // step 4: modify data in chained store so we have something to commit.
   child.writeDataHash(storeKey, json3, SC.Record.READY_DIRTY);
   child.dataHashDidChange(storeKey);
-  
-  // just to make sure verify that the lock and revision in parent do not 
+
+  // just to make sure verify that the lock and revision in parent do not
   // match
   ok(child.locks[storeKey] !== store.revisions[storeKey], 'child.lock (%@) should !== store.revision (%@)'.fmt(child.locks[storeKey], store.revisions[storeKey]));
-  
+
   // step 5: now try to commit changes from child store.  This should throw
   // an exception.
   var errorCount = 0;
@@ -120,8 +120,8 @@ function createConflict(force) {
   } catch(e) {
     equals(e, SC.Store.CHAIN_CONFLICT_ERROR, 'should throw CHAIN_CONFLICT_ERROR');
     errorCount++;
-  }  
-  
+  }
+
   return errorCount ;
 }