sproutcore 1.7.1.beta → 1.8.0

data/lib/frameworks/sproutcore/frameworks/statechart/tests/state/methods/route_triggered.js

@@ -0,0 +1,161 @@
+// ==========================================================================
+// SC Unit Test
+// ==========================================================================
+/*globals SC */
+
+var sc, del, foo;
+
+module("SC.State: routeTriggered method Tests", {
+  
+  setup: function() {
+    
+    del = SC.Object.create(SC.StatechartDelegate, {
+      
+      info: {},
+      
+      returnValue: YES,
+      
+      statechartShouldStateHandleTriggeredRoute: function(statechart, state, context) {
+        this.info.statechartShouldStateHandleTriggeredRoute = {
+          statechart: statechart, 
+          state: state, 
+          context: context
+        };
+        
+        return this.get('returnValue');
+      },
+      
+      statechartStateCancelledHandlingTriggeredRoute: function(statechart, state, context) {
+        this.info.statechartStateCancelledHandlingTriggeredRoute = {
+          statechart: statechart, 
+          state: state, 
+          context: context
+        };
+      }
+      
+    });
+    
+    sc = SC.Statechart.create({
+      
+      initialState: 'foo',
+      
+      delegate: del,
+    
+      foo: SC.State.design({
+        
+        info: {},
+        
+        location: 'foo/bar',
+        
+        createStateRouteHandlerContext: function(attr) {
+          this.info.createStateRouteHandlerContext = {
+            attr: attr
+          };
+          return sc_super();
+        },
+        
+        handleTriggeredRoute: function(context) {
+          this.info.handleTriggeredRoute = {
+            context: context
+          };
+        }
+        
+      })
+      
+    });
+    
+    sc.initStatechart();
+    foo = sc.getState('foo');
+  },
+  
+  teardown: function() {
+    sc = del = foo = null;
+  }
+  
+});
+
+test("invoke routeTriggered where delegate does allow state to handle route", function() {
+  var info, context, params = { value: 'test' };
+  
+  foo.routeTriggered(params);
+
+  info = foo.info.createStateRouteHandlerContext;
+
+  ok(info, "state.createStateRouteHandlerContext should have been invoked");
+  ok(info.attr, "state.createStateRouteHandlerContext should be provided attr param");
+  
+  info = foo.info.handleTriggeredRoute;
+  
+  ok(info, "state.handleTriggeredRoute should have been invoked");
+  
+  context = info.context;
+  
+  ok(SC.kindOf(context, SC.StateRouteHandlerContext), "state.handleTriggeredRoute should be provided a state route handler context object");
+  equals(context.get('state'), foo, "context.state should be state foo");
+  equals(context.get('location'), 'foo/bar', "context.location should be 'foo/bar'");
+  equals(context.get('params'), params, "context.params should be value passed to state.routeTriggered method");
+  equals(context.get('handler'), foo.routeTriggered, "context.handler should be reference to state.routeTriggered");
+  
+  info = del.info.statechartShouldStateHandleTriggeredRoute;
+  
+  ok(info, "del.statechartShouldStateHandleTriggeredRoute should have been invoked");
+  equals(info.statechart, sc, "del.statechartShouldStateHandleTriggeredRoute should be provided a statechart");
+  equals(info.state, foo, "del.statechartShouldStateHandleTriggeredRoute should be provided a state");
+  
+  context = info.context;
+  
+  ok(SC.kindOf(context, SC.StateRouteHandlerContext), "state.statechartShouldStateHandleTriggeredRoute should be provided a state route handler context object");
+  equals(context.get('state'), foo, "context.state should be state foo");
+  equals(context.get('location'), 'foo/bar', "context.location should be 'foo/bar'");
+  equals(context.get('params'), params, "context.params should be value passed to state.routeTriggered method");
+  equals(context.get('handler'), foo.routeTriggered, "context.handler should be reference to state.routeTriggered");
+  
+  info = del.info.statechartStateCancelledHandlingTriggeredRoute;
+  
+  ok(!info, "del.statechartStateCancelledHandlingTriggeredRoute should have been invoked");
+});
+
+test("invoke routeTriggered where delegate does not allow state to handle route", function() {
+  var info, context, params = { value: 'test' };
+  
+  del.set('returnValue', NO);
+  foo.routeTriggered(params);
+
+  info = foo.info.createStateRouteHandlerContext;
+
+  ok(info, "state.createStateRouteHandlerContext should have been invoked");
+  ok(info.attr, "state.createStateRouteHandlerContext should be provided attr param");
+  
+  info = foo.info.handleTriggeredRoute;
+  
+  ok(!info, "state.handleTriggeredRoute should have been invoked");
+  
+  info = del.info.statechartShouldStateHandleTriggeredRoute;
+  
+  ok(info, "del.statechartShouldStateHandleTriggeredRoute should have been invoked");
+  equals(info.statechart, sc, "del.statechartShouldStateHandleTriggeredRoute should be provided a statechart");
+  equals(info.state, foo, "del.statechartShouldStateHandleTriggeredRoute should be provided a state");
+  
+  context = info.context;
+  
+  ok(SC.kindOf(context, SC.StateRouteHandlerContext), "state.statechartShouldStateHandleTriggeredRoute should be provided a state route handler context object");
+  equals(context.get('state'), foo, "context.state should be state foo");
+  equals(context.get('location'), 'foo/bar', "context.location should be 'foo/bar'");
+  equals(context.get('params'), params, "context.params should be value passed to state.routeTriggered method");
+  equals(context.get('handler'), foo.routeTriggered, "context.handler should be reference to state.routeTriggered");
+  
+  info = del.info.statechartStateCancelledHandlingTriggeredRoute;
+  
+  ok(info, "del.statechartStateCancelledHandlingTriggeredRoute should have been invoked");
+  equals(info.statechart, sc, "del.statechartStateCancelledHandlingTriggeredRoute should be provided a statechart");
+  equals(info.state, foo, "del.statechartStateCancelledHandlingTriggeredRoute should be provided a state");
+  
+  context = info.context;
+  
+  ok(SC.kindOf(context, SC.StateRouteHandlerContext), "state.statechartStateCancelledHandlingTriggeredRoute should be provided a state route handler context object");
+  equals(context.get('state'), foo, "context.state should be state foo");
+  equals(context.get('location'), 'foo/bar', "context.location should be 'foo/bar'");
+  equals(context.get('params'), params, "context.params should be value passed to state.routeTriggered method");
+  equals(context.get('handler'), foo.routeTriggered, "context.handler should be reference to state.routeTriggered");
+  
+});

data/lib/frameworks/sproutcore/frameworks/statechart/tests/state/methods/try_to_handle_event.js

@@ -0,0 +1,288 @@
+// ==========================================================================
+// SC Unit Test
+// ==========================================================================
+/*globals SC */
+
+var sc, root, foo, bar;
+
+module("SC.State: addSubstate method Tests", {
+  
+  setup: function() {
+    
+    sc = SC.Statechart.create({
+      
+      stateWillTryToHandleEvent: function(state, event, handler) {
+        sc_super();
+        this.stateWillTryToHandleEventInfo = {
+          state: state,
+          event: event,
+          handler: handler
+        };
+      },
+
+      stateDidTryToHandleEvent: function(state, event, handler, handled) {
+        sc_super();
+        this.stateDidTryToHandleEventInfo = {
+          state: state,
+          event: event,
+          handler: handler,
+          handled: handled
+        };
+      },
+      
+      initialState: 'foo',
+      
+      foo: SC.State.design({
+        
+        eventHandlerReturnValue: YES,
+        
+        _notifyHandledEvent: function(handler, event, arg1, arg2) {
+          this.handledEventInfo = {
+            handler: handler,
+            event: event,
+            arg1: arg1,
+            arg2: arg2
+          };
+        },
+        
+        eventHandler1: function(arg1, arg2) {
+          this._notifyHandledEvent('eventHandler1', 'eventHandler1', arg1, arg2);
+          return this.get('eventHandlerReturnValue');
+        },
+        
+        eventHandler2: function(event, arg1, arg2) {
+          this._notifyHandledEvent('eventHandler2', event, arg1, arg2);
+          return this.get('eventHandlerReturnValue');
+        }.handleEvents('test1'),
+        
+        eventHandler3: function(event, arg1, arg2) {
+          this._notifyHandledEvent('eventHandler3', event, arg1, arg2);
+          return this.get('eventHandlerReturnValue');
+        }.handleEvents(/^digit[0-9]$/),
+        
+        unknownEvent: function(event, arg1, arg2) {
+          this._notifyHandledEvent('unknownEvent', event, arg1, arg2);
+          return this.get('eventHandlerReturnValue');
+        }
+        
+      })
+      
+    });
+    
+    sc.initStatechart();
+    foo = sc.getState('foo');
+  },
+  
+  teardown: function() {
+    sc = foo = null;
+  }
+  
+});
+
+test("try to invoke state foo's eventHandler1 event handler", function() {
+  
+  var ret = foo.tryToHandleEvent('eventHandler1', 100, 200);
+  
+  var info = foo.handledEventInfo;
+  
+  equals(ret, true, 'foo.tryToHandleEvent should return true');
+  ok(info, 'foo.handledEventInfo should not be null');
+  equals(info.handler, 'eventHandler1', 'foo.eventHandler1 should have been invoked');
+  equals(info.arg1, 100, 'foo.eventHandler1 should handle event 100');
+  equals(info.arg2, 200, 'foo.eventHandler1 should handle event 200');
+
+  info = sc.stateWillTryToHandleEventInfo;
+  
+  ok(info, 'sc.stateWillTryToHandleEvent should have been invoked');
+  equals(info.state, foo, 'sc.stateWillTryToHandleEvent should have been passed state foo');
+  equals(info.event, 'eventHandler1', 'sc.stateWillTryToHandleEvent should have been passed event eventHandler1');
+  equals(info.handler, 'eventHandler1', 'sc.stateWillTryToHandleEvent should have been passed handler eventHandler1');
+  
+  info = sc.stateDidTryToHandleEventInfo;
+  
+  ok(info, 'sc.stateDidTryToHandleEventInfo should have been invoked');
+  equals(info.state, foo, 'sc.stateDidTryToHandleEventInfo should have been passed state foo');
+  equals(info.event, 'eventHandler1', 'sc.stateDidTryToHandleEventInfo should have been passed event eventHandler1');
+  equals(info.handler, 'eventHandler1', 'sc.stateDidTryToHandleEventInfo should have been passed handler eventHandler1');
+  equals(info.handled, true, 'sc.stateDidTryToHandleEventInfo should have been passed handled true');
+  
+});
+
+test("try to invoke state foo's eventHandler2 event handler", function() {
+  
+  var ret = foo.tryToHandleEvent('test1', 100, 200);
+  
+  var info = foo.handledEventInfo;
+  
+  equals(ret, true, 'foo.tryToHandleEvent should return true');
+  ok(info, 'foo.handledEventInfo should not be null');
+  equals(info.handler, 'eventHandler2', 'foo.eventHandler2 should have been invoked');
+  equals(info.event, 'test1', 'foo.eventHandler2 should handle event test1');
+  equals(info.arg1, 100, 'foo.eventHandler2 should handle event 100');
+  equals(info.arg2, 200, 'foo.eventHandler2 should handle event 200');
+
+  info = sc.stateWillTryToHandleEventInfo;
+  
+  ok(info, 'sc.stateWillTryToHandleEvent should have been invoked');
+  equals(info.state, foo, 'sc.stateWillTryToHandleEvent should have been passed state foo');
+  equals(info.event, 'test1', 'sc.stateWillTryToHandleEvent should have been passed event test1');
+  equals(info.handler, 'eventHandler2', 'sc.stateWillTryToHandleEvent should have been passed handler eventHandler2');
+  
+  info = sc.stateDidTryToHandleEventInfo;
+  
+  ok(info, 'sc.stateDidTryToHandleEventInfo should have been invoked');
+  equals(info.state, foo, 'sc.stateDidTryToHandleEventInfo should have been passed state foo');
+  equals(info.event, 'test1', 'sc.stateDidTryToHandleEventInfo should have been passed event test1');
+  equals(info.handler, 'eventHandler2', 'sc.stateDidTryToHandleEventInfo should have been passed handler eventHandler2');
+  equals(info.handled, true, 'sc.stateDidTryToHandleEventInfo should have been passed handled true');
+  
+});
+
+test("try to invoke state foo's eventHandler3 event handler", function() {
+  
+  var ret = foo.tryToHandleEvent('digit3', 100, 200);
+  
+  var info = foo.handledEventInfo;
+  
+  equals(ret, true, 'foo.tryToHandleEvent should return true');
+  ok(info, 'foo.handledEventInfo should not be null');
+  equals(info.handler, 'eventHandler3', 'foo.eventHandler3 should have been invoked');
+  equals(info.event, 'digit3', 'foo.eventHandler3 should handle event test1');
+  equals(info.arg1, 100, 'foo.eventHandler3 should handle event 100');
+  equals(info.arg2, 200, 'foo.eventHandler3 should handle event 200');
+
+  info = sc.stateWillTryToHandleEventInfo;
+  
+  ok(info, 'sc.stateWillTryToHandleEvent should have been invoked');
+  equals(info.state, foo, 'sc.stateWillTryToHandleEvent should have been passed state foo');
+  equals(info.event, 'digit3', 'sc.stateWillTryToHandleEvent should have been passed event digit3');
+  equals(info.handler, 'eventHandler3', 'sc.stateWillTryToHandleEvent should have been passed handler eventHandler3');
+  
+  info = sc.stateDidTryToHandleEventInfo;
+  
+  ok(info, 'sc.stateDidTryToHandleEventInfo should have been invoked');
+  equals(info.state, foo, 'sc.stateDidTryToHandleEventInfo should have been passed state foo');
+  equals(info.event, 'digit3', 'sc.stateDidTryToHandleEventInfo should have been passed event digit3');
+  equals(info.handler, 'eventHandler3', 'sc.stateDidTryToHandleEventInfo should have been passed handler eventHandler3');
+  equals(info.handled, true, 'sc.stateDidTryToHandleEventInfo should have been passed handled true');
+  
+});
+
+test("try to invoke state foo's unknownEvent event handler", function() {
+  
+  var ret = foo.tryToHandleEvent('test', 100, 200);
+  
+  var info = foo.handledEventInfo;
+  
+  equals(ret, true, 'foo.tryToHandleEvent should return true');
+  ok(info, 'foo.handledEventInfo should not be null');
+  equals(info.handler, 'unknownEvent', 'foo.unknownEvent should have been invoked');
+  equals(info.event, 'test', 'foo.unknownEvent should handle event test');
+  equals(info.arg1, 100, 'foo.unknownEvent should handle event 100');
+  equals(info.arg2, 200, 'foo.unknownEvent should handle event 200');
+
+  info = sc.stateWillTryToHandleEventInfo;
+  
+  ok(info, 'sc.stateWillTryToHandleEvent should have been invoked');
+  equals(info.state, foo, 'sc.stateWillTryToHandleEvent should have been passed state foo');
+  equals(info.event, 'test', 'sc.stateWillTryToHandleEvent should have been passed event test');
+  equals(info.handler, 'unknownEvent', 'sc.stateWillTryToHandleEvent should have been passed handler unknownEvent');
+  
+  info = sc.stateDidTryToHandleEventInfo;
+  
+  ok(info, 'sc.stateDidTryToHandleEventInfo should have been invoked');
+  equals(info.state, foo, 'sc.stateDidTryToHandleEventInfo should have been passed state foo');
+  equals(info.event, 'test', 'sc.stateDidTryToHandleEventInfo should have been passed event test');
+  equals(info.handler, 'unknownEvent', 'sc.stateDidTryToHandleEventInfo should have been passed handler unknownEvent');
+  equals(info.handled, true, 'sc.stateDidTryToHandleEventInfo should have been passed handled true');
+  
+});
+
+test("try not to invoke any of state foo's event handlers", function() {
+  
+  foo.unknownEvent = undefined;
+  
+  var ret = foo.tryToHandleEvent('test', 100, 200);
+  
+  var info = foo.handledEventInfo;
+  
+  equals(ret, NO, 'foo.tryToHandleEvent should return false');
+  ok(!info, 'foo.handledEventInfo should be null');
+
+  info = sc.stateWillTryToHandleEventInfo;
+  ok(!info, 'sc.stateWillTryToHandleEvent should not have been invoked');
+
+  info = sc.stateDidTryToHandleEventInfo;
+  ok(!info, 'sc.stateDidTryToHandleEventInfo should not have been invoked');
+  
+});
+
+test("try to invoke state foo's eventHandler1 but tryToHandleEvent returns false", function() {
+  foo.eventHandlerReturnValue = NO;
+  
+  var ret = foo.tryToHandleEvent('eventHandler1', 100, 200);
+  
+  var info = foo.handledEventInfo;
+  
+  equals(ret, NO, 'foo.tryToHandleEvent should return false');
+  ok(info, 'foo.handledEventInfo should be null');
+  equals(info.handler, 'eventHandler1', 'foo.eventHandler1 should have been invoked');
+  equals(info.event, 'eventHandler1', 'foo.eventHandler1 should handle event test');
+  equals(info.arg1, 100, 'foo.eventHandler1 should handle event 100');
+  equals(info.arg2, 200, 'foo.eventHandler1 should handle event 200');
+
+  info = sc.stateWillTryToHandleEventInfo;
+  ok(info, 'sc.stateWillTryToHandleEvent should not have been invoked');
+  equals(info.state, foo, 'sc.stateWillTryToHandleEvent should have been passed state foo');
+  equals(info.event, 'eventHandler1', 'sc.stateWillTryToHandleEvent should have been passed event test');
+  equals(info.handler, 'eventHandler1', 'sc.stateWillTryToHandleEvent should have been passed handler eventHandler1');
+
+  info = sc.stateDidTryToHandleEventInfo;
+  ok(info, 'sc.stateDidTryToHandleEventInfo should not have been invoked');
+  equals(info.state, foo, 'sc.stateDidTryToHandleEventInfo should have been passed state foo');
+  equals(info.event, 'eventHandler1', 'sc.stateDidTryToHandleEventInfo should have been passed event test');
+  equals(info.handler, 'eventHandler1', 'sc.stateDidTryToHandleEventInfo should have been passed handler eventHandler1');
+  equals(info.handled, false, 'sc.stateDidTryToHandleEventInfo should have been passed handled false');
+});
+
+test("try to invoke all of state foo's handlers but tryToHandleEvent returns false", function() {
+  var ret, info;
+  
+  foo.eventHandlerReturnValue = NO;
+  
+  ret = foo.tryToHandleEvent('eventHandler1');
+  
+  equals(ret, NO, 'foo.tryToHandleEvent should return false');
+  info = foo.handledEventInfo;
+  ok(info, 'foo.handledEventInfo should be null');
+  equals(info.handler, 'eventHandler1', 'foo.eventHandler1 should have been invoked');
+  ok(sc.stateWillTryToHandleEventInfo, 'sc.stateWillTryToHandleEvent should not have been invoked');
+  ok(sc.stateDidTryToHandleEventInfo, 'sc.stateDidTryToHandleEventInfo should not have been invoked');
+  
+  ret = foo.tryToHandleEvent('test1');
+  
+  equals(ret, NO, 'foo.tryToHandleEvent should return false for event test1');
+  info = foo.handledEventInfo;
+  ok(info, 'foo.handledEventInfo should be null');
+  equals(info.handler, 'eventHandler2', 'foo.eventHandler2 should have been invoked');
+  ok(sc.stateWillTryToHandleEventInfo, 'sc.stateWillTryToHandleEvent should not have been invoked');
+  ok(sc.stateDidTryToHandleEventInfo, 'sc.stateDidTryToHandleEventInfo should not have been invoked');
+  
+  ret = foo.tryToHandleEvent('digit3');
+  
+  equals(ret, NO, 'foo.tryToHandleEvent should return false for event digit3');
+  info = foo.handledEventInfo;
+  ok(info, 'foo.handledEventInfo should be null');
+  equals(info.handler, 'eventHandler3', 'foo.eventHandler3 should have been invoked');
+  ok(sc.stateWillTryToHandleEventInfo, 'sc.stateWillTryToHandleEvent should not have been invoked');
+  ok(sc.stateDidTryToHandleEventInfo, 'sc.stateDidTryToHandleEventInfo should not have been invoked');
+  
+  ret = foo.tryToHandleEvent('blah');
+  
+  equals(ret, NO, 'foo.tryToHandleEvent should return false for event blah');
+  info = foo.handledEventInfo;
+  ok(info, 'foo.handledEventInfo should be null');
+  equals(info.handler, 'unknownEvent', 'foo.unknownEvent should have been invoked');
+  ok(sc.stateWillTryToHandleEventInfo, 'sc.stateWillTryToHandleEvent should not have been invoked');
+  ok(sc.stateDidTryToHandleEventInfo, 'sc.stateDidTryToHandleEventInfo should not have been invoked');
+});

data/lib/frameworks/sproutcore/frameworks/statechart/tests/state_transitioning/history_state/standard/without_concurrent_states/context.js

@@ -96,10 +96,10 @@ test("pass no context when going to state a's history state using state", functi
   stateD.gotoState('f');
   stateF.gotoHistoryState('a');
   equals(stateD.get('isCurrentState'), true);
-  equals(stateD.get('enterStateContext'), null);
-  equals(stateA.get('enterStateContext'), null);
-  equals(stateB.get('exitStateContext'), null);
-  equals(stateF.get('exitStateContext'), null);
+  equals(stateD.get('enterStateContext'), null, "state D's enterState method should not be passed a context value");
+  equals(stateA.get('enterStateContext'), null, "state A's enterState method should not be passed a context value");
+  equals(stateB.get('exitStateContext'), null, "state B's enterState method should not be passed a context value");
+  equals(stateF.get('exitStateContext'), null, "state F's enterState method should not be passed a context value");
 });
 
 test("pass context when going to state a's history state using statechart - gotoHistoryState('f', context)", function() {  
@@ -160,32 +160,4 @@ test("pass context when going to state a's history state using state - gotoHisto
   equals(stateA.get('enterStateContext'), context, 'state a should have context upon entering');
   equals(stateB.get('exitStateContext'), context, 'state b should have context upon exiting');
   equals(stateF.get('exitStateContext'), context, 'state f should have context upon exiting');
-});
-
-// 
-// test("pass context when going to state f using state - gotoState('f', context)", function() {  
-//   stateC.gotoState('f', context);
-//   equals(stateF.get('isCurrentState'), true);
-//   equals(stateC.get('exitStateContext'), context, 'state c should have context upon exiting');
-//   equals(stateA.get('exitStateContext'), context, 'state a should have context upon exiting');
-//   equals(stateB.get('enterStateContext'), context, 'state b should have context upon entering');
-//   equals(stateF.get('enterStateContext'), context, 'state f should have context upon entering');
-// });
-// 
-// test("pass context when going to state f using statechart - gotoState('f', stateC, context) ", function() {  
-//   statechart.gotoState('f', stateC, context);
-//   equals(stateF.get('isCurrentState'), true);
-//   equals(stateC.get('exitStateContext'), context, 'state c should have context upon exiting');
-//   equals(stateA.get('exitStateContext'), context, 'state a should have context upon exiting');
-//   equals(stateB.get('enterStateContext'), context, 'state b should have context upon entering');
-//   equals(stateF.get('enterStateContext'), context, 'state f should have context upon entering');
-// });
-// 
-// test("pass context when going to state f using statechart - gotoState('f', stateC, false, context) ", function() {  
-//   statechart.gotoState('f', stateC, false, context);
-//   equals(stateF.get('isCurrentState'), true);
-//   equals(stateC.get('exitStateContext'), context, 'state c should have context upon exiting');
-//   equals(stateA.get('exitStateContext'), context, 'state a should have context upon exiting');
-//   equals(stateB.get('enterStateContext'), context, 'state b should have context upon entering');
-//   equals(stateF.get('enterStateContext'), context, 'state f should have context upon entering');
-// });
+});