sproutit-sproutcore 1.0.20090721145236 → 1.0.20090721145251

data/frameworks/sproutcore/frameworks/foundation/tests/system/request.js

@@ -0,0 +1,127 @@
+// ========================================================================
+// SC.Request Base Tests
+// ========================================================================
+/*globals module test ok isObj equals expects */
+
+var url, request, contents ;
+
+module("SC.Request", {
+  
+  setup: function() {
+    url = sc_static("file_exists.json"); //"/static/sproutcore/en/desktop/_src/desktop.platform/english.lproj/file_exists.json" ;
+    request = SC.Request.getUrl(url) ;
+    contents = null ;
+  },
+  
+  teardown: function() {
+    delete url ;
+    delete request ;
+    delete contents ;
+  }
+  
+});
+
+test("Basic Requirements", function() {
+  ok(SC.Request, "SC.Request is defined") ;
+  ok("" != url, "url variable is not empty") ;
+  ok(request !== null, "request object is not null") ;
+  ok(contents === null, "contents is null" ) ;
+});
+
+test("Test Asynchronous GET Request", function() {
+  request.addObserver("response", function(response) {
+      contents = request.get("rawResponse") ;
+  });
+  
+  request.send() ;
+  
+  stop() ; // stops the test runner
+  setTimeout( function(){
+    ok(contents !== null, 'request.send() should return a response') ;
+    ok(SC.$ok(contents), 'contents should not be an error ');
+    if (SC.$ok(contents)) equals(contents.responseText, '{"message": "Yay!"}', "should match retrieved message") ;
+    window.start() ; // starts the test runner
+  }, 3000); // a shorter timeout fails when a lot of unit tests are running...
+});
+
+test("Test Synchronous GET Request", function() {
+
+  request.set("isAsynchronous", NO);  
+  request.send();
+  contents = request.get("rawResponse");
+  
+  ok(contents !== null) ;
+  ok(SC.$ok(contents), 'contents should not be an error ');
+  if (SC.$ok(contents)) equals(contents.responseText, '{"message": "Yay!"}', 'should match retrieved message') ;
+});
+
+test("Test Asynchronous GET Request, auto-deserializing JSON", function() {
+  request.set("isJSON", YES);
+  
+  request.addObserver("response", function(response){
+      contents = request.get("response");
+  });
+  
+  request.send();
+  
+  stop() ; // stops the test runner
+  setTimeout( function(){
+    ok(contents !== null) ;
+    ok(SC.$ok(contents), 'contents should not be an error ');
+    if (SC.$ok(contents)) same({"message": "Yay!"}, contents) ;
+    window.start() ; // starts the test runner
+  }, 1000);
+});
+
+test("Test Synchronous GET Request, auto-deserializing JSON", function() {
+  request.set("isAsynchronous", false);
+  request.set("isJSON", true);
+  
+  request.send();
+  
+  var contents = request.get("response");
+  
+  ok(contents !== null, 'contents should not be null') ;
+  ok(SC.$ok(contents), 'contents should not be an error');
+  if (SC.$ok(contents)) same(contents, {"message": "Yay!"}, 'contents should have message') ;
+});
+
+
+test("Test if Request body is being auto-serializing to JSON", function() {
+  request.set("isAsynchronous", false);
+  request.set("isJSON", true);
+  var objectToPost={"content": "garbage"};
+  
+  request.send(objectToPost);
+  var jsonEncoded = request.get('body');
+  var contents = request.get("response");
+  
+  equals(jsonEncoded, '{"content":"garbage"}', "The json object passed in send should be encoded and set as the body");
+});
+
+
+test("Test Multiple Asynchronous GET Request - two immediate, and two in serial", function() {
+  var requestCount = 3;
+  var responseCount = 0;
+
+  var observer = function(response) {
+    responseCount++;
+    if(requestCount<=7) {
+      SC.Request.getUrl(url).addObserver("response", observer).send();
+      requestCount++;
+    }
+  };
+  
+  
+  SC.Request.getUrl(url).notify(this, observer).send();
+  SC.Request.getUrl(url).notify(this, observer).send();
+  SC.Request.getUrl(url).notify(this, observer).send();
+  
+  stop() ; // stops the test runner
+  setTimeout( function(){
+    equals(requestCount, 8, "requestCount should be 4");
+    equals(responseCount, 6, "responseCount should be 4");
+    window.start() ; // starts the test runne
+  }, 3000);
+});
+

data/frameworks/sproutcore/frameworks/foundation/tests/system/root_responder/makeKeyPane.js

@@ -0,0 +1,124 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Apple, Inc. and contributors.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+/*global module test equals context ok same Q$ htmlbody */
+module("SC.RootResponder#makeKeyPane");
+
+test("returns receiver", function() {
+  var p1 = SC.Pane.create(), p2 = SC.Pane.create({ acceptsKeyPane: YES });
+  var r = SC.RootResponder.create();
+  
+  equals(r.makeKeyPane(p1), r, 'returns receiver even if pane does not accept key pane');
+  equals(r.makeKeyPane(p2), r, 'returns receiver');
+});
+
+test("changes keyPane to new pane if pane accepts key focus", function() {
+  var p1 = SC.Pane.create({ acceptsKeyPane: NO }) ;
+  var p2 = SC.Pane.create({ acceptsKeyPane: YES });
+  var r = SC.RootResponder.create();
+  
+  r.makeKeyPane(p1);
+  ok(r.get('keyPane') !== p1, 'keyPane should not change to view that does not accept key');
+
+  r.makeKeyPane(p2);
+  equals(r.get('keyPane'), p2, 'keyPane should change to view that does accept key');
+  
+});
+
+test("setting nil sets key pane to mainPane if mainPane accepts key focus", function() {
+  var main = SC.Pane.create({ acceptsKeyPane: YES });
+  var key = SC.Pane.create({ acceptsKeyPane: YES });
+  var r = SC.RootResponder.create({ mainPane: main, keyPane: key });
+  
+  // try to clear keyPane -- mainPane accepts key
+  r.makeKeyPane(null);
+  equals(r.get('keyPane'), main, 'keyPane should be main pane');
+  
+  r.makeKeyPane(key); // reset
+  main.acceptsKeyPane = NO ;
+  r.makeKeyPane(null); // try to clean - mainPane does not accept key
+  equals(r.get('keyPane'), null, 'keyPane should be null, not main');
+  
+  // try another variety.  if keyPane is currently null and we try to set to
+  // null do nothing, even if main DOES accept key.
+  r.keyPane = null ;
+  main.acceptsKeyPane = NO;
+  r.makeKeyPane(null);
+  equals(r.get('keyPane'), null, 'keyPane should remain null');
+});
+
+var p1, p2, r, callCount ;
+module("SC.RootResponder#makeKeyPane - testing notifications", {
+  setup: function() {
+    p1 = SC.Pane.create({ acceptsKeyPane: YES });    
+    p2 = SC.Pane.create({ acceptsKeyPane: YES });    
+    r = SC.RootResponder.create();
+    callCount = 0 ;
+  },
+  
+  teardown: function() { p1 = p2 = r ; }
+});
+
+test("should call willLoseKeyPaneTo on current keyPane", function() {
+  r.keyPane = p1; //setup test
+  p1.willLoseKeyPaneTo = function(pane) {
+    equals(pane, p2, 'should pass new pane');
+    callCount++;
+  };
+  
+  r.makeKeyPane(p2);
+  equals(callCount, 1, 'should invoke');
+});
+
+test("should call willBecomeKeyPaneFrom on new keyPane", function() {
+  r.keyPane = p1; //setup test
+  p2.willBecomeKeyPaneFrom = function(pane) {
+    equals(pane, p1, 'should pass old pane');
+    callCount++;
+  };
+  
+  r.makeKeyPane(p2);
+  equals(callCount, 1, 'should invoke');
+});
+
+
+test("should call didLoseKeyPaneTo on old keyPane", function() {
+  r.keyPane = p1; //setup test
+  p1.didLoseKeyPaneTo = function(pane) {
+    equals(pane, p2, 'should pass new pane');
+    callCount++;
+  };
+  
+  r.makeKeyPane(p2);
+  equals(callCount, 1, 'should invoke');
+});
+
+test("should call didBecomeKeyPaneFrom on new keyPane", function() {
+  r.keyPane = p1; //setup test
+  p2.didBecomeKeyPaneFrom = function(pane) {
+    equals(pane, p1, 'should pass old pane');
+    callCount++;
+  };
+  
+  r.makeKeyPane(p2);
+  equals(callCount, 1, 'should invoke');
+});
+
+test("should not invoke callbacks if setting keyPane to itself", function() {
+  r.keyPane = p1; //setup test
+  // instrument ...
+  p1.didLoseKeyPaneTo = p1.willLoseKeyPaneTo = p1.willBecomeKeyPaneFrom = p1.didBecomeKeyPaneFrom = function() { callCount++; };
+  
+  r.makeKeyPane(p1);
+  equals(callCount, 0, 'did not invoke any callbacks');
+});
+
+
+
+
+
+
+

data/frameworks/sproutcore/frameworks/foundation/tests/system/root_responder/makeMainPane.js

@@ -0,0 +1,68 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Apple, Inc. and contributors.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+/*global module test equals context ok same Q$ htmlbody */
+module("SC.RootResponder#makeMainPane");
+
+test("returns receiver", function() {
+  var p1 = SC.Pane.create(), p2 = SC.Pane.create();
+  var r = SC.RootResponder.create();
+  equals(r.makeMainPane(p1), r, 'returns receiver');
+});
+
+test("changes mainPane to new pane", function() {
+  var p1 = SC.Pane.create(), p2 = SC.Pane.create();
+  var r = SC.RootResponder.create();
+  
+  r.makeMainPane(p1);
+  equals(r.get('mainPane'), p1, 'mainPane should be p1');
+
+  r.makeMainPane(p2);
+  equals(r.get('mainPane'), p2, 'mainPane should be p2');
+  
+});
+
+test("if current mainpane is also keypane, automatically make new main pane key also", function() {
+  // acceptsKeyPane is required to allow keyPane to change
+  var p1 = SC.Pane.create({ acceptsKeyPane: YES });
+  var p2 = SC.Pane.create({ acceptsKeyPane: YES });
+
+  var r= SC.RootResponder.create({ mainPane: p1, keyPane: p1 });
+  r.makeMainPane(p2);
+  ok(r.get('keyPane') === p2, 'should change keyPane(%@) p1 = %@ - p2 = %@'.fmt(r.get('keyPane'), p1, p2));
+});
+
+test("should call blurMainTo() on current pane, passing new pane", function() {
+  var callCount = 0;
+  var p2 = SC.Pane.create();
+  var p1 = SC.Pane.create({ 
+    blurMainTo: function(pane) { 
+      callCount++ ;
+      equals(pane, p2, 'should pass new pane');
+    }
+  });
+  
+  var r= SC.RootResponder.create({ mainPane: p1 });
+  r.makeMainPane(p2);
+  equals(callCount, 1, 'should invoke callback');
+});
+
+
+test("should call focusMainFrom() on new pane, passing old pane", function() {
+  var callCount = 0;
+  var p1 = SC.Pane.create();
+  var p2 = SC.Pane.create({ 
+    focusMainFrom: function(pane) { 
+      callCount++ ;
+      equals(pane, p1, 'should pass old pane');
+    }
+  });
+  
+  var r= SC.RootResponder.create({ mainPane: p1 });
+  r.makeMainPane(p2);
+  equals(callCount, 1, 'should invoke callback');
+});
+

data/frameworks/sproutcore/frameworks/foundation/tests/system/root_responder/root_responder.js

@@ -0,0 +1,101 @@
+// ========================================================================
+// RootResponder Tests
+// ========================================================================
+/*globals module test ok isObj equals expect */
+
+var sub, newPane, oldPane, lightPane, darkPane, myPane, responder;
+
+
+module("SC.RootResponder", {
+	setup: function() {		
+		sub = SC.Object.create({
+			action: function() { var objectA = "hello"; }
+		});
+		
+		newPane = SC.Pane.create({ owner: this});
+		oldPane = SC.Pane.create({ owner: this});
+		lightPane = SC.Pane.create({ owner: this});
+		darkPane = SC.Pane.create({ owner: this});
+		myPane = SC.Pane.create();
+		responder = SC.RootResponder.create({});
+	},
+	
+	teardown: function() {
+		delete sub;
+	}
+	
+	// var objectA, submit = document.createElement('pane');
+	// 
+	//   triggerMe: function() {
+	//     SC.Event.trigger(submit, 'click');
+	//   }
+	//   
+});
+
+test("Basic requirements", function() {
+  expect(2);
+  ok(SC.RootResponder, "SC.RootResponder");
+  ok(SC.RootResponder.responder, "SC.RootResponder.responder");
+});
+
+test("root_responder.makeMainPane() : Should change the new Pane to key view", function() {
+	responder.makeMainPane(newPane);
+	//Checking the mainPane property
+	equals(responder.get('mainPane'),newPane);
+	equals(responder.get('keyPane'), newPane);
+});
+
+test("root_responder.makeMainPane() : Should notify other panes about the changes", function() {
+	responder.makeMainPane(newPane);
+		
+	//Notify other panes about the changes
+	equals(newPane.get('isMainPane'),YES);
+	equals(oldPane.get('isMainPane'),NO);
+	
+});
+
+test("root_responder.makeKeyPane() : Should make the passed pane as the key pane", function() {
+ responder.makeMainPane(oldPane);
+ equals(responder.get('keyPane'), oldPane);
+ 
+ responder.makeKeyPane(lightPane);
+ equals(responder.get('keyPane'),lightPane);
+}); 
+
+test("root_responder.makeKeyPane() : Should make the main pane as the key pane if null is passed", function() {
+ responder.makeMainPane(lightPane);
+ responder.makeKeyPane(oldPane);
+ // newPane is set as the Main pane
+ equals(responder.get('mainPane'),lightPane);
+ // KeyPane is null as it is not set yet 
+ equals(responder.get('keyPane'), oldPane);
+ 
+ responder.makeKeyPane();
+ // KeyPane is set as the mainPane as null is passed 
+ equals(responder.get('keyPane'),lightPane);
+});
+
+//// CLEANUP
+/// Commenting out this two functions as the methods don't exist
+//// confirm with Charles 
+
+
+
+
+/*
+test("root_responder.removePane() : Should be able to remove panes to set", function() {
+	responder.removePane(darkPane);
+		
+	//Notify other panes about the changes
+	equals(responder.get('mainPane'),null);
+});
+
+test("root_responder.addPane() : Should be able to add panes to set", function() {
+	responder.addPane(darkPane);
+		
+	//Notify other panes about the changes
+	equals(responder.get('mainPane'),lightPane);
+});
+
+*/
+

data/frameworks/sproutcore/frameworks/foundation/tests/system/root_responder/targetForAction.js

@@ -0,0 +1,238 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Apple, Inc. and contributors.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+/*global module test equals context ok same Q$ htmlbody Dummy */
+
+var r, sender, pane, barView, fooView, defaultResponder;
+var keyPane, mainPane, globalResponder, actionSender ;
+
+var CommonSetup = {
+  setup: function() { 
+    
+    actionSender = null ; // use for sendAction tests
+    var action = function(sender) { actionSender = sender; } ;
+    
+    sender = SC.Object.create();
+    
+    // default responder for each pane
+    defaultResponder = SC.Object.create({ 
+      defaultAction: action 
+    });
+
+    // global default responder set on RootResponder
+    globalResponder = SC.Object.create({ 
+      globalAction: action 
+    });
+    
+    // explicit pane
+    pane = SC.Pane.create({ 
+      acceptsKeyPane: YES,
+      defaultResponder: defaultResponder,
+      childViews: [SC.View.extend({
+        bar: action,  // implement bar action
+        childViews: [SC.View.extend({
+          foo: action // implement foo action
+        })]    
+      })],
+      
+      paneAction: action 
+    });
+    
+    keyPane = SC.Pane.create({
+      acceptsKeyPane: YES,
+      keyAction: action
+    });
+    keyPane.firstResponder = keyPane ;
+
+    mainPane = SC.Pane.create({
+      acceptsKeyPane: YES,
+      mainAction: action
+    });
+    mainPane.firstResponder = mainPane ;
+
+    r = SC.RootResponder.create({
+      mainPane: mainPane, 
+      keyPane:  keyPane,
+      defaultResponder: globalResponder 
+    }); 
+    
+    barView = pane.childViews[0];
+    ok(barView.bar, 'barView should implement bar');
+    
+    fooView = barView.childViews[0];
+    ok(fooView.foo, 'fooView should implement foo');
+    
+    // setup dummy namespace
+    window.Dummy = { 
+      object: SC.Object.create({ foo: action }),
+      hash: { foo: action } 
+    };
+    
+  },
+
+  teardown: function() {
+    r = sender = pane = window.Dummy = barView = fooView = null; 
+    defaultResponder = keyPane = mainPane = globalResponder = null;    
+  }
+};
+
+// ..........................................................
+// targetForAction()
+// 
+module("SC.RootResponder#targetForAction", CommonSetup);
+
+
+test("pass property path string as target", function() {
+  var result = r.targetForAction('foo', 'Dummy.object');
+  
+  equals(result, Dummy.object, 'should find DummyNamespace.object if it implements the action');
+
+  equals(r.targetForAction("foo", "Dummy.hash"), Dummy.hash, 'should return if object found at path and it has function, even if it does not use respondsTo');
+  
+  equals(r.targetForAction('bar', 'Dummy.object'), null, 'should return null if found DummyNamepace.object but does not implement action');
+  
+  equals(r.targetForAction('foo', 'Dummy.imaginary.item'), null, 'should return null if property path could not resolve');  
+});
+
+test("pass real object as target", function() {
+  equals(r.targetForAction('foo', Dummy.object), Dummy.object, 'returns target if respondsTo() action');
+  equals(r.targetForAction('foo', Dummy.hash), Dummy.hash, 'returns target if targets does not implement respondsTo() but does have action');
+  equals(r.targetForAction('bar', Dummy.object), null, 'returns null of target does not implement action name');
+});
+
+test("no target, explicit pane, nested firstResponder", function() {
+  
+  pane.set('firstResponder', fooView) ;
+  equals(r.targetForAction('foo', null, null, pane), fooView, 
+    'should return firstResponder if implementation action');
+    
+  equals(r.targetForAction('bar', null, null, pane), barView, 
+    'should return parent of firstResponder');
+
+  equals(r.targetForAction('paneAction', null, null, pane), pane, 
+    'should return pane action');
+  
+  equals(r.targetForAction('defaultAction', null, null, pane), 
+    defaultResponder, 'should return defaultResponder');
+
+  equals(r.targetForAction('imaginaryAction', null, null, pane), null, 
+    'should return null for not-found action');
+});
+
+
+test("no target, explicit pane, top-level firstResponder", function() {
+  
+  pane.set('firstResponder', barView) ; // fooView is child...
+  
+  equals(r.targetForAction('foo', null, null, pane), null, 
+    'should NOT return child of firstResponder');
+    
+  equals(r.targetForAction('bar', null, null, pane), barView, 
+    'should return firstResponder');
+
+  equals(r.targetForAction('paneAction', null, null, pane), pane, 
+    'should return pane action');
+  
+  equals(r.targetForAction('defaultAction', null, null, pane), 
+    defaultResponder, 'should return defaultResponder');
+
+  equals(r.targetForAction('imaginaryAction', null, null, pane), null, 
+    'should return null for not-found action');
+});
+
+test("no target, explicit pane, pane is first responder", function() {
+  
+  pane.set('firstResponder', pane) ; 
+  
+  equals(r.targetForAction('foo', null, null, pane), null, 
+    'should NOT return child view');
+    
+  equals(r.targetForAction('bar', null, null, pane), null, 
+    'should NOT return child view');
+
+  equals(r.targetForAction('paneAction', null, null, pane), pane, 
+    'should return pane action');
+  
+  equals(r.targetForAction('defaultAction', null, null, pane), 
+    defaultResponder, 'should return defaultResponder');
+
+  equals(r.targetForAction('imaginaryAction', null, null, pane), null, 
+    'should return null for not-found action');
+});
+
+test("no target, explicit pane, no first responder", function() {
+  
+  pane.set('firstResponder', null) ; 
+  
+  equals(r.targetForAction('foo', null, null, pane), null, 
+    'should NOT return child view');
+    
+  equals(r.targetForAction('bar', null, null, pane), null, 
+    'should NOT return child view');
+
+  equals(r.targetForAction('paneAction', null, null, pane), null, 
+    'should NOT return pane');
+  
+  equals(r.targetForAction('defaultAction', null, null, pane), 
+    defaultResponder, 'should return defaultResponder');
+    
+  equals(r.targetForAction('imaginaryAction', null, null, pane), null, 
+    'should return null for not-found action');
+  
+});
+
+test("no target, explicit pane, does not implement action", function() {
+  equals(r.targetForAction('keyAction', null, null, pane), null,
+    'should not return keyPane');
+    
+  equals(r.targetForAction('mainAction', null, null, pane), null,
+    'should not return mainPane');
+
+  equals(r.targetForAction('globalAction', null, null, pane), null,
+    'should not return global defaultResponder');
+});
+
+test("no target, no explicit pane", function() {
+  equals(r.targetForAction('keyAction'), keyPane, 'should find keyPane');
+  equals(r.targetForAction('mainAction'), mainPane, 'should find mainPane');
+  equals(r.targetForAction('globalAction'), globalResponder,
+    'should find global defaultResponder');
+  equals(r.targetForAction('imaginaryAction'), null, 'should return null for not-found action');
+});
+
+// ..........................................................
+// sendAction()
+// 
+module("SC.RootResponder#sendAction", CommonSetup) ;
+
+test("if pane passed, invokes action on pane if found", function() {
+  pane.firstResponder = pane;
+  r.sendAction('paneAction', null, sender, pane);
+  equals(actionSender, sender, 'action did invoke');
+  
+  actionSender = null;
+  r.sendAction('imaginaryAction', null, sender, pane);
+  equals(actionSender, null, 'action did not invoke');
+});
+
+test("searches panes if none passed, invokes action if found", function() {
+  r.sendAction('keyAction', null, sender);
+  equals(actionSender, sender, 'action did invoke');
+  
+  actionSender = null;
+  r.sendAction('imaginaryAction', null, sender);
+  equals(actionSender, null, 'action did not invoke');
+});
+
+test("searches target if passed, invokes action if found", function() {
+  r.sendAction('foo', fooView, sender);
+  equals(actionSender, sender, 'action did invoke');
+  
+  actionSender = null;
+  r.sendAction('imaginaryAction', fooView, sender);
+  equals(actionSender, null, 'action did not invoke');
+});
+