sproutcore 1.4.0-java

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

@@ -0,0 +1,219 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2010 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.
+
+// ..........................................................
+// UTILITIES
+// 
+
+var TestRecord = SC.Record.extend();
+var TestRecord2 = SC.Record.extend();
+
+function queryEquals(q, location, recordType, conditions, extra, desc) {
+  if (desc===undefined && typeof extra === 'string') {
+    desc = extra;  extra = undefined ;
+  }
+  if (!desc) desc = '';
+  
+  ok(!!q, desc + ': should have a query');
+  equals(q.get('isFrozen'), YES, desc + ": should be frozen");
+  
+  if (q) {
+    if (location) {
+      equals(q.get('location'), location, desc + ": should have location");
+    }
+    
+    if (recordType && recordType.isEnumerable) {
+      same(q.get('recordTypes'), recordType, desc + ': should have recordTypes (plural)');
+    } else {
+      equals(q.get('recordType'), recordType, desc + ': should have recordType (singular)');
+    }
+    
+    equals(q.get('conditions'), conditions, desc + ': should have conditions');
+        
+    if (extra) {
+      for (var key in extra) {
+        if (!extra.hasOwnProperty(key)) continue;
+        equals(q.get(key), extra[key], desc + ': should have extra key ' + key);
+      }
+    }
+  }
+} 
+
+// ..........................................................
+// 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
+    }
+  });
+
+  function invokeWith() {
+    return SC.Query[methodName].apply(SC.Query, arguments);
+  }
+  
+  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 conditions", function() {
+
+    var q1, q2, q3, q4, q5, q6, q7;
+    
+    q1 = invokeWith(TestRecord, 'foobar');
+    queryEquals(q1, loc, TestRecord, 'foobar', 'first query');
+
+    q2 = invokeWith(TestRecord, 'foobar');
+    equals(q2, q1, 'second call to queryFor(TestRecord, foobar) should return cached instance');
+
+    q3 = invokeWith(TestRecord2, 'foobar');
+    queryEquals(q3, loc, TestRecord2, 'foobar', 'query(TestRecord2, foobar)');
+    ok(q3 !== q1, 'different recordType same conditions should return new query');
+
+    q4 = invokeWith(TestRecord, 'baz');
+    queryEquals(q4, loc, TestRecord, 'baz', 'query(TestRecord2, baz)');
+    ok(q4 !== q1, 'different conditions should return new query');
+
+    q5 = invokeWith(TestRecord, 'baz');
+    equals(q5, q4, 'second call for different conditions should return cache');
+  });
+  
+  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');
+
+    q2 = invokeWith(null, 'foobar');
+    equals(q2, q1, 'should return cached value');
+  });
+
+  test("query with recordtype, conditions, and parameters hash", function() {
+    var opts  = { opt1: 'bar', opt2: 'baz' },
+        q1, q2;
+
+    q1 = invokeWith(TestRecord, 'foo', opts);
+    queryEquals(q1, loc, TestRecord, 'foo', { parameters: opts }, 'first query');
+
+    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');
+  });
+
+  test("query with recordtype, conditions, and parameters array", function() {
+    var opts  = ['foo', 'bar'],
+        q1, q2;
+
+    q1 = invokeWith(TestRecord, 'foo', opts);
+    queryEquals(q1, loc, TestRecord, 'foo', { parameters: opts }, 'first query should include parameters prop');
+
+    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');
+  });
+
+  test("passing query object", function() {
+
+    var local = SC.Query.local(TestRecord),
+        remote = SC.Query.remote(TestRecord),
+        q;
+        
+    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');
+
+    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');
+  });
+  
+  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');
+
+  });
+
+  
+}
+
+performBasicTests('local', SC.Query.LOCAL);
+performBasicTests('remote', SC.Query.REMOTE);

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

@@ -0,0 +1,144 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2010 Apple Inc. and contributors.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+/*globals module ok equals same test MyApp */
+ 
+// test parsing of query string
+var store, storeKey, rec1, rec2, rec3, rec4, rec5, MyApp, q;
+module("SC.Query comparison of records", {
+  setup: function() {
+    
+    SC.RunLoop.begin();
+    
+    // setup dummy app and store
+    MyApp = SC.Object.create({
+      store: SC.Store.create()
+    });
+    
+    // setup a dummy model
+    MyApp.Foo = SC.Record.extend({});
+    
+    // load some data
+    MyApp.store.loadRecords(MyApp.Foo, [
+      { guid: 1, firstName: "John", lastName: "Doe", year: 1974 },
+      { guid: 2, firstName: "Jane", lastName: "Doe", year: 1975 },
+      { guid: 3, firstName: "Emily", lastName: "Parker", year: 1975, active: null },
+      { guid: 4, firstName: "Johnny", lastName: "Cash", active: false },
+      { guid: 5, firstName: "Bert", lastName: "Berthold", active: true }
+    ]);
+    
+    SC.RunLoop.end();
+    
+    rec1 = MyApp.store.find(MyApp.Foo,1);
+    rec2 = MyApp.store.find(MyApp.Foo,2);
+    rec3 = MyApp.store.find(MyApp.Foo,3);
+    rec4 = MyApp.store.find(MyApp.Foo,4);
+    rec5 = MyApp.store.find(MyApp.Foo,5);
+    
+    
+    q = SC.Query.create();
+  }
+});
+ 
+ 
+// ..........................................................
+// TESTS
+// 
+
+test("parse() should work with conditions = null", function(){
+  q.parse();
+});
+ 
+test("building the order", function() {
+  // undefined orderBy
+  q.orderBy = null;
+  q.parse();
+  equals(q._order.length, 0, 'order should be empty');
+  
+  // empty orderBy
+  q.orderBy = "";
+  q.parse();
+  equals(q._order.length, 0, 'order should be empty');
+  
+  // single property
+  q.orderBy = "firstName";
+  q.parse();
+  equals(q._order[0].propertyName,'firstName', 'propertyName should be firstName');
+  
+  // more properties
+  q.orderBy = "lastName, firstName";
+  q.parse();
+  equals(q._order[0].propertyName,'lastName', 'propertyName should be lastName');
+  equals(q._order[1].propertyName,'firstName', 'propertyName should be firstName');
+  
+  // more properties with direction
+  q.orderBy = "lastName, firstName, year DESC";
+  q.parse();
+  equals(q._order[0].propertyName,'lastName', 'propertyName should be lastName');
+  ok(!q._order[0].descending, 'descending should be false');
+  equals(q._order[1].propertyName,'firstName', 'propertyName should be firstName');
+  ok(!q._order[1].descending, 'descending should be false');
+  equals(q._order[2].propertyName,'year', 'propertyName should be year');
+  ok(q._order[2].descending, 'descending should be true');
+});
+
+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');
+});
+
+test("comparing non existent properties", function() {
+  q.orderBy = "year";
+  q.parse();
+  equals(q.compare(rec5,rec1), -1, 'null should be before 1974');
+});
+ 
+test("comparing null and boolean properties", function() {
+  q.orderBy = "active";
+  q.parse();
+  equals(q.compare(rec3,rec4), -1, 'null should be before false');
+  equals(q.compare(rec4,rec5), -1, 'false should be before true');
+});
+ 
+test("comparing number properties", function() {
+  q.orderBy = "year";
+  q.parse();
+  equals(q.compare(rec1,rec2), -1, '1974 should be before 1975');
+  
+  q.orderBy = "year DESC";
+  q.parse();
+  equals(q.compare(rec1,rec2), 1, '1974 should be after 1975 with DESC');
+}); 
+ 
+ 
+test("comparing string properties", function() {
+  q.orderBy = "firstName";
+  q.parse();
+  equals(q.compare(rec1,rec2), 1, 'John should be after Jane');
+  
+  q.orderBy = "firstName DESC";
+  q.parse();
+  equals(q.compare(rec1,rec2), -1, 'John should be before Jane with DESC');
+}); 
+
+test("comparing by equal properties should use guid for order", function() {
+  q.orderBy = "lastName";
+  q.parse();
+  equals(q.compare(rec1,rec2), -1, 'guid 1 should be before guid 2');
+});
+
+test("specifying a custom orderBy comparison function", function() {
+  var usedCustomFunction = NO;
+  q.orderBy = function(rec1, rec2) {
+    // We'll be explicit about our use of a custom comparison function, in
+    // addition to returning later years first.
+    usedCustomFunction = YES;
+    return SC.compare(rec2.get('year'), rec1.get('year'));
+  };
+  q.parse();
+  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/contains.js

@@ -0,0 +1,131 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2010 Apple Inc. and contributors.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+/*globals module ok equals same test MyApp */
+ 
+// test parsing of query string
+var store, storeKey, foo1, foo2, bar1, bar2, baz, barChild, MyApp, q;
+module("SC.Query comparison of records", {
+  setup: function() {
+    
+    SC.RunLoop.begin();
+    
+    // setup dummy app and store
+    MyApp = SC.Object.create({
+      store: SC.Store.create()
+    });
+    
+    // setup a dummy model
+    MyApp.Foo = SC.Record.extend();
+    MyApp.Bar = SC.Record.extend();
+    MyApp.BarChild = MyApp.Bar.extend();
+    MyApp.Baz = SC.Record.extend();
+    
+    // load some data
+    MyApp.store.loadRecords(MyApp.Foo, [
+      { guid: 1, firstName: "John", lastName: "Doe", year: 1974 },
+      { guid: 2, firstName: "Jane", lastName: "Doe", year: 1975 }
+    ]);
+    
+    MyApp.store.loadRecords(MyApp.Bar, [
+      { guid: 3, firstName: "Emily", lastName: "Parker", year: 1975, active: null },
+      { guid: 4, firstName: "Johnny", lastName: "Cash", active: false }
+    ]);
+    
+    MyApp.store.loadRecords(MyApp.Baz, [
+      { guid: 5, firstName: "Bert", lastName: "Berthold", active: true }
+    ]);
+
+    MyApp.store.loadRecords(MyApp.BarChild, [
+      { guid: 6, firstName: "Bert", lastName: "Ernie", active: true }
+    ]);
+    
+    SC.RunLoop.end();
+    
+    foo1 = MyApp.store.find(MyApp.Foo,1);
+    foo2 = MyApp.store.find(MyApp.Foo,2);
+    bar1 = MyApp.store.find(MyApp.Bar,3);
+    bar2 = MyApp.store.find(MyApp.Bar,4);
+    barChild = MyApp.store.find(MyApp.BarChild, 6);
+    baz  = MyApp.store.find(MyApp.Baz,5);
+    
+  },
+  
+  teardown: function() {
+    MyApp = foo1 = foo2 = bar1 = bar2 = baz = barChild = q = null;
+  }
+});
+
+// ..........................................................
+// BASIC TESTS
+// 
+
+test("should only contain records matching recordType or recordTypes", function() {
+  
+  q = SC.Query.create({ recordType: MyApp.Foo });
+  equals(q.contains(foo1), YES, 'q with recordType=Foo should contain record of type Foo');
+  equals(q.contains(bar1), NO, 'q with recordType=Foo should NOT contain record of type Bar');
+  equals(q.contains(barChild), NO, 'q with recordType=Foo should NOT contain record of type BarChild');
+  
+  equals(q.contains(baz),  NO, 'q with recordType=Foo should NOT contain record of type Baz');
+  
+  q = SC.Query.create({ recordTypes: [MyApp.Foo, MyApp.Bar] });
+  equals(q.contains(foo1), YES, 'q with recordTypes=Foo,Bar should contain record of type Foo');
+  equals(q.contains(bar1), YES, 'q with recordTypes=Foo,Bar should contain record of type Bar');
+  equals(SC.kindOf(barChild, MyApp.Bar), YES, 'SC.kindOf(barChild, MyApp.Bar)');
+  
+  equals(q.contains(barChild), YES, 'q with recordTypes=Foo,Bar should contain record of type BarChild');
+
+  equals(q.contains(baz),  NO, 'q with recordTypes=Foo,Bar should NOT contain record of type Baz');
+
+  q = SC.Query.create();
+  equals(q.contains(foo1), YES, 'no recordType should contain record of type Foo');
+  equals(q.contains(bar1), YES, 'no recordType should contain record of type Foo');
+  equals(q.contains(barChild), YES, 'no recordType should contain record of type BarChild');
+  equals(q.contains(baz), YES, 'no recordType should contain record of type Foo');
+  
+});
+
+test("should only contain records within parent scope, if one is defined", function() {
+  
+  q = SC.Query.create({ scope: SC.Set.create().add(foo1).add(bar1) });
+  equals(q.contains(foo1), YES, 'scope=[foo1,bar1] should return YES for foo1');
+  equals(q.contains(foo2), NO, 'scope=[foo1,bar1] should return NO for foo2');
+  equals(q.contains(bar1), YES, 'scope=[bar1] should return YES for bar1');
+  equals(q.contains(bar2), NO, 'scope=[foo1,bar1] should return NO for bar2');
+});
+
+test("should evaluate query against record", function() {
+  q = SC.Query.create({ 
+    conditions: "firstName = {firstName}", 
+    parameters: { firstName: 'Bert' }
+  });
+  
+  equals(q.contains(bar2), NO, 'q(firstName=Bert) should return NO for bar[firstName=Johnny]');
+  equals(q.contains(baz), YES, 'q(firstName=Bert) should return YES for baz[firstName=Bert]');
+  equals(q.contains(barChild), YES, 'q(firstName=Bert) should return YES for barChild[firstName=Bert]');
+
+  var p  = { firstName: "Johnny" };
+  equals(q.contains(bar2, p), YES, 'q(firstName=Johnny) should return YES for bar[firstName=Johnny]');
+  equals(q.contains(baz, p), NO, 'q(firstName=Johnny) should return NO for baz[firstName=Bert]');
+  equals(q.contains(barChild, p), NO, 'q(firstName=Johnny) should return NO for barChild[firstName=Bert]');
+  
+});
+
+test("should consider recordType + query conditions", function() {
+  q = SC.Query.create({
+    conditions: "firstName = {firstName}",
+    recordType: MyApp.Bar,
+    parameters: { firstName: "Bert" }
+  });
+  
+  equals(q.contains(bar1), NO, 'should not contain bar1 (wrong firstName)');
+  equals(q.contains(bar2), NO, 'should not contain bar2 (wrong firstName)');
+  equals(q.contains(barChild), YES, 'should contain barChild');
+  equals(q.contains(baz), NO, 'should contain baz (wrong type)');
+  
+});
+
+