sproutcore 1.5.0.pre.5 → 1.5.0.rc.1

data/lib/frameworks/sproutcore/frameworks/statechart/tests/event_handling/responder/root_responder.js

@@ -0,0 +1,74 @@
+// ==========================================================================
+// SC.Statechart Unit Test
+// ==========================================================================
+/*globals SC statechart */
+
+window.statechart = null;
+var responder, fooInvokedCount;
+
+// ..........................................................
+// CONTENT CHANGING
+// 
+
+module("SC.Statechart: No Concurrent States - Root Responder Default Responder Tests", {
+  setup: function() {
+    fooInvokedCount = 0;
+    
+    window.statechart = SC.Statechart.create({
+      
+      rootState: SC.State.design({
+        
+        initialSubstate: 'a',
+        
+        a: SC.State.design({
+          foo: function() { 
+            fooInvokedCount++;
+            this.gotoState('b'); 
+          }
+        }),
+        
+        b: SC.State.design({
+          foo: function() {
+            fooInvokedCount++;
+            this.gotoState('a'); 
+          }
+        })
+        
+      })
+      
+    });
+    
+    window.statechart.initStatechart();
+    
+    responder = SC.RootResponder.responder;
+    
+    SC.RunLoop.begin();
+    responder.set('defaultResponder', 'statechart');
+    SC.RunLoop.end();
+  },
+  
+  teardown: function() {
+    window.statechart = null;
+    responder = null;
+    SC.RootResponder.responder.set('defaultResponder', null);
+  }
+});
+
+test("click button", function() {
+  equals(fooInvokedCount, 0, 'foo should not have been invoked');
+  equals(statechart.stateIsCurrentState('a'), true, 'state a should be a current state');
+  equals(statechart.stateIsCurrentState('b'), false, 'state b should not be a current state');
+  
+  responder.sendAction('foo');
+  
+  equals(fooInvokedCount, 1, 'foo should have been invoked once');
+  equals(statechart.stateIsCurrentState('a'), false, 'state a should not be a current state');
+  equals(statechart.stateIsCurrentState('b'), true, 'state b should be a current state');
+  
+  responder.sendAction('foo');
+  
+  equals(fooInvokedCount, 2, 'foo should have been invoked twice');
+  equals(statechart.stateIsCurrentState('a'), true, 'state a should be a current state');
+  equals(statechart.stateIsCurrentState('b'), false, 'state b should not be a current state');
+  
+});

data/lib/frameworks/sproutcore/frameworks/statechart/tests/state/initial_substate.js

@@ -0,0 +1,67 @@
+// ==========================================================================
+// SC.State Unit Test
+// ==========================================================================
+/*globals SC externalState1 externalState2 */
+
+var statechart, root, monitor, stateA, stateB, stateC, stateD, stateE, stateF;
+
+module("SC.Statechart: State Initial Substate Tests", {
+  setup: function() {
+
+    statechart = SC.Statechart.create({
+      
+      monitorIsActive: YES,
+      
+      rootState: SC.State.design({
+        
+        initialSubstate: 'a',
+        
+        a: SC.State.design({
+          initialSubstate: 'c',
+          c: SC.State.design(),
+          d: SC.State.design()
+        }),
+        
+        b: SC.State.design({
+          e: SC.State.design(),
+          f: SC.State.design()
+        })
+        
+      })
+      
+    });
+    
+    statechart.initStatechart();
+    
+    root = statechart.get('rootState');
+    monitor = statechart.get('monitor');
+    stateA = statechart.getState('a');
+    stateB = statechart.getState('b');
+    stateC = statechart.getState('c');
+    stateD = statechart.getState('d');
+    stateE = statechart.getState('e');
+    stateF = statechart.getState('f');
+  },
+  
+  teardown: function() {
+    statechart = root = stateA = stateB = stateC = stateD = stateE = stateF = null;
+  }
+});
+
+test("check initial substates", function() {
+  equals(root.get('initialSubstate'), stateA, "root state's initial substate should be state A");
+  equals(stateA.get('initialSubstate'), stateC, "state a's initial substate should be state c");
+  equals(stateC.get('initialSubstate'), null, "state c's initial substate should be null");
+  equals(stateD.get('initialSubstate'), null, "state d's initial substate should be null");
+  equals(SC.kindOf(stateB.get('initialSubstate'), SC.EmptyState), true, "state b's initial substate should be an empty state");
+  equals(stateE.get('initialSubstate'), null, "state e's initial substate should be null");
+  equals(stateF.get('initialSubstate'), null, "state f's initial substate should be null");
+});
+
+test("go to state b and confirm current state is an empty state", function() {
+  equals(stateC.get('isCurrentState'), true);
+  monitor.reset();
+  statechart.gotoState(stateB);
+  ok(monitor.matchSequence().begin().exited(stateC, stateA).entered(stateB, stateB.get('initialSubstate')).end());
+  equals(stateB.getPath('initialSubstate.isCurrentState'), true, "state b\'s initial substate should be the current state");
+});

data/lib/frameworks/sproutcore/frameworks/statechart/tests/state/is_current_state.js

@@ -5,10 +5,6 @@
 
 var statechart = null;
 
-// ..........................................................
-// CONTENT CHANGING
-// 
-
 module("SC.Statechart: State - isCurrentState Property Tests", {
   setup: function() {
 

data/lib/frameworks/sproutcore/frameworks/statechart/tests/{namespace/access_substates.js → state/namespacing.js}

@@ -5,10 +5,6 @@
 
 var statechart1, statechart2, statechart3, statechart4;
 
-// ..........................................................
-// CONTENT CHANGING
-// 
-
 module("SC.Statechart: Namespace - Access Substate Tests", {
   setup: function() {
     

data/lib/frameworks/sproutcore/frameworks/statechart/tests/state/plugin/mixin.js

@@ -0,0 +1,68 @@
+// ==========================================================================
+// SC.Statechart Unit Test
+// ==========================================================================
+/*globals SC TestState */
+
+TestState = null;
+var obj, MixinA, MixinB, stateA, stateB, stateC;
+
+module("SC.State.plugin: Mixin Tests", {
+  setup: function() {
+    
+    MixinA = {
+      isMixinA: YES
+    };
+    
+    MixinB = {
+      isMixinB: YES
+    };
+
+    TestState = SC.State.extend({
+      isTestState: YES
+    });
+
+    obj = SC.Object.create(SC.StatechartManager, {
+      
+      initialState: 'stateA',
+      
+      stateA: SC.State.plugin('TestState'),
+      
+      stateB: SC.State.plugin('TestState', MixinA),
+      
+      stateC: SC.State.plugin('TestState', MixinA, MixinB)
+      
+    });
+    
+    stateA = obj.getState('stateA');
+    stateB = obj.getState('stateB');
+    stateC = obj.getState('stateC');
+
+  },
+  
+  teardown: function() {
+    obj = TestState = MixinA = MixinB = null;
+    stateA = stateB = stateC = null;
+  }
+
+});
+
+test("check plugin state A", function() {
+  ok(SC.kindOf(stateA, TestState));
+  ok(stateA.get('isTestState'));
+  ok(!stateA.get('isMixinA'));
+  ok(!stateA.get('isMixinB'));
+});
+
+test("check plugin state B", function() {
+  ok(SC.kindOf(stateB, TestState));
+  ok(stateB.get('isTestState'));
+  ok(stateB.get('isMixinA'));
+  ok(!stateB.get('isMixinB'));
+});
+
+test("check plugin state C", function() {
+  ok(SC.kindOf(stateC, TestState));
+  ok(stateC.get('isTestState'));
+  ok(stateC.get('isMixinA'));
+  ok(stateC.get('isMixinB'));
+});

data/lib/frameworks/sproutcore/frameworks/statechart/tests/{without_concurrent_states/state_plugin.js → state/plugin/nesting.js}

@@ -7,11 +7,7 @@ var statechart = null;
 externalState1 = null;
 externalState2 = null;
 
-// ..........................................................
-// CONTENT CHANGING
-// 
-
-module("SC.Statechart Mixin: Basic Unit test", {
+module("SC.State.plugin: Nest States Tests", {
   setup: function() {
     
     externalState1 = SC.State.extend({

data/lib/frameworks/sproutcore/frameworks/statechart/tests/state/state_observes.js

@@ -0,0 +1,235 @@
+// ==========================================================================
+// SC.State Unit Test
+// ==========================================================================
+/*globals SC obj1 obj2 obj3 */
+
+window.obj1 = null;
+window.obj2 = null;
+window.obj3 = null;
+var statechart1, statechart2, TestState;
+var stateA, stateB, stateC, stateD;
+
+module("SC.Statechart: stateObserves Tests", {
+	
+  setup: function() {
+
+    obj1 = SC.Object.create({
+      foo: 'abc'
+    });
+    
+    obj2 = SC.Object.create({
+      bar: 'xyz'
+    });
+    
+    obj3 = SC.Object.create({
+      mah: 123
+    });
+    
+    TestState = SC.State.extend({
+      
+      notifyStateObserveHandlerInvoked: function(handler, target, key) {
+        this['%@Invoked'.fmt(handler)] = {
+          target: target,
+          key: key
+        };
+      }
+      
+    });
+
+    statechart1 = SC.Statechart.create({
+		
+		  autoInitStatechart: YES,
+		  
+		  initialState: 'stateA',
+		
+      stateA: TestState.design({
+        
+        testProp: null,
+        
+        testProp2: obj3,
+        
+        testPropChanged: function(target, key) {
+          this.notifyStateObserveHandlerInvoked('testPropChanged', target, key);
+        }.stateObserves('testProp'),
+        
+        testProp2Changed: function(target, key) {
+          this.notifyStateObserveHandlerInvoked('testProp2Changed', target, key);
+        }.stateObserves('.testProp2.mah'),
+        
+    	  fooChanged: function(target, key) {
+          this.notifyStateObserveHandlerInvoked('fooChanged', target, key);
+    		}.stateObserves('obj1.foo'),
+    		
+    		barChanged: function(target, key) {
+    		  this.notifyStateObserveHandlerInvoked('barChanged', target, key);
+    		}.stateObserves('obj2.bar')
+        
+      }),
+      
+      stateB: TestState.design()
+		
+    });
+    
+    stateA = statechart1.getState('stateA');
+    stateB = statechart1.getState('stateB');
+    
+    statechart2 = SC.Statechart.create({
+      
+      autoInitStatechart: YES,
+      
+      initialState: 'stateC',
+      
+      stateC: TestState.design({
+      
+        mahChanged: function(target, key) {
+          this.notifyStateObserveHandlerInvoked('mahChanged', target, key);
+        }.stateObserves('obj1.foo', 'obj2.bar')
+        
+      }),
+      
+      stateD: TestState.design()
+      
+    });
+    
+    stateC = statechart2.getState('stateC');
+    stateD = statechart2.getState('stateD');
+
+  },
+  
+  teardown: function() {
+    window.obj1 = undefined;
+    window.obj2 = undefined;
+    window.obj3 = undefined;
+    statechart1 = statechart2 = null;
+    stateA = stateB = stateC = stateD = null;
+    TestState = null;
+  }
+
+});
+
+test("check state observe handlers when obj1's foo is changed", function() {
+  ok(!stateA.fooChangedInvoked, "state A's fooChanged should not be invoked");
+  ok(!stateA.barChangedInvoked, "state A's barChanged should not be invoked");
+  ok(!stateC.mahChangedInvoked, "state C's mahChanged should not be invoked");
+  ok(obj1.hasObserverFor('foo'), "obj1 should have observers for property foo");
+  
+  obj1.set('foo', 100);
+  
+  ok(stateA.fooChangedInvoked, "state A's fooChanged should be invoked");
+  equals(stateA.fooChangedInvoked.target, obj1, "target should be obj1");
+  equals(stateA.fooChangedInvoked.key, 'foo', "key should be foo");
+  
+  ok(!stateA.barChangedInvoked, "state A's barChanged should not be invoked");
+  
+  ok(stateC.mahChangedInvoked, "state C's mahChanged should be invoked");
+  equals(stateC.mahChangedInvoked.target, obj1, "target should be obj1");
+  equals(stateC.mahChangedInvoked.key, 'foo', "key should be foo");
+});
+
+test("check state observe handlers when obj2's bar is changed", function() {
+  ok(!stateA.fooChangedInvoked, "state A's fooChanged should not be invoked");
+  ok(!stateA.barChangedInvoked, "state A's barChanged should not be invoked");
+  ok(!stateC.mahChangedInvoked, "state C's mahChanged should not be invoked");
+  ok(obj2.hasObserverFor('bar'), "obj2 should have observers for property bar");
+  
+  obj2.notifyPropertyChange('bar');
+  
+  ok(!stateA.fooChangedInvoked, "state A's fooChanged should not be invoked");
+  
+  ok(stateA.barChangedInvoked, "state A's barChanged should be invoked");
+  equals(stateA.barChangedInvoked.target, obj2, "target should be obj2");
+  equals(stateA.barChangedInvoked.key, 'bar', "key should be bar");
+  
+  ok(stateC.mahChangedInvoked, "state C's mahChanged should be invoked");
+  equals(stateC.mahChangedInvoked.target, obj2, "target should be obj1");
+  equals(stateC.mahChangedInvoked.key, 'bar', "key should be bar");
+});
+
+test("check state observe handlers when state A's testProp is changed", function() {
+  ok(!stateA.testPropChangedInvoked, "state A's testPropChanged should not be invoked");
+  ok(stateA.hasObserverFor('testProp'), "state A should have observers for property testProp");
+  
+  stateA.notifyPropertyChange('testProp');
+  
+  ok(stateA.testPropChangedInvoked, "state A's testPropChanged should be invoked");
+  equals(stateA.testPropChangedInvoked.target, stateA, "target should be stateA");
+  equals(stateA.testPropChangedInvoked.key, 'testProp', "key should be testProp");
+});
+
+test("check state observe handlers when state A's testProp2.mah is changed", function() {
+  ok(!stateA.testProp2ChangedInvoked, "state A's testProp2Changed should not be invoked");
+  ok(!stateA.hasObserverFor('testProp2'), "state A should have observers for property testProp2");
+  ok(stateA.get('testProp2').hasObserverFor('mah'), "state A's testProp2 should have observers for property mah");
+  
+  stateA.notifyPropertyChange('testProp2');
+  
+  ok(!stateA.testProp2ChangedInvoked, "state A's testProp2Changed should not be invoked");
+  
+  stateA.get('testProp2').notifyPropertyChange('mah');
+  
+  ok(stateA.testProp2ChangedInvoked, "state A's testProp2Changed should be invoked");
+  equals(stateA.testProp2ChangedInvoked.target, obj3, "target should be obj3");
+  equals(stateA.testProp2ChangedInvoked.key, 'mah', "key should be mah");
+});
+
+test("change current states and check state observe handlers when objs' property change", function() {
+  ok(!stateA.fooChangedInvoked, "state A's fooChanged should not be invoked");
+  ok(!stateA.barChangedInvoked, "state A's barChanged should not be invoked");
+  ok(!stateA.testPropChangedInvoked, "state A's testPropChanged should not be invoked");
+  ok(!stateA.testProp2ChangedInvoked, "state A's testProp2Changed should not be invoked");
+  ok(!stateC.mahChangedInvoked, "state C's mahChanged should not be invoked");
+  
+  statechart1.gotoState('stateB');
+  statechart2.gotoState('stateD');
+  
+  ok(!obj1.hasObserverFor('foo'), "obj1 should not have observers for property foo");
+  ok(!obj2.hasObserverFor('bar'), "obj2 should not have observers for property bar");
+  ok(!stateA.hasObserverFor('testProp'), "state A should not have observers for property testProp");
+  ok(!stateA.get('testProp2').hasObserverFor('mah'), "state A's testProp2 should not have observers for property mah");
+  
+  obj1.notifyPropertyChange('foo');
+  obj2.notifyPropertyChange('bar');
+  stateA.notifyPropertyChange('testProp');
+  stateA.get('testProp2').notifyPropertyChange('mah');
+  
+  ok(!stateA.fooChangedInvoked, "state A's fooChanged should not be invoked");
+  ok(!stateA.barChangedInvoked, "state A's barChanged should not be invoked");
+  ok(!stateA.testPropChangedInvoked, "state A's testPropChanged should not be invoked");
+  ok(!stateA.testProp2ChangedInvoked, "state A's testProp2Changed should not be invoked");
+  ok(!stateC.mahChangedInvoked, "state C's mahChanged should not be invoked");
+  
+  statechart1.gotoState('stateA');
+  statechart2.gotoState('stateC');
+  
+  ok(obj1.hasObserverFor('foo'), "obj1 should have observers for property foo");
+  ok(obj2.hasObserverFor('bar'), "obj2 should have observers for property bar");
+  ok(stateA.hasObserverFor('testProp'), "state A should have observers for property testProp");
+  ok(stateA.get('testProp2').hasObserverFor('mah'), "state A's testProp2 should not have observers for property mah");
+  
+  obj1.notifyPropertyChange('foo');
+  obj2.notifyPropertyChange('bar');
+  stateA.notifyPropertyChange('testProp');
+  stateA.get('testProp2').notifyPropertyChange('mah');
+  
+  ok(stateA.fooChangedInvoked, "state A's fooChanged should be invoked");
+  ok(stateA.barChangedInvoked, "state A's barChanged should be invoked");
+  ok(stateA.testPropChangedInvoked, "state A's testPropChanged should be invoked");
+  ok(stateA.testProp2ChangedInvoked, "state A's testProp2Changed should be invoked");
+  ok(stateC.mahChangedInvoked, "state C's mahChanged should be invoked");
+});
+
+test("destroy statecharts and check that objs have not observers", function() {
+  ok(obj1.hasObserverFor('foo'), "obj1 should have observers for property foo");
+  ok(obj2.hasObserverFor('bar'), "obj2 should have observers for property bar");
+  ok(stateA.hasObserverFor('testProp'), "state A should have observers for property testProp");
+  ok(stateA.get('testProp2').hasObserverFor('mah'), "state A's testProp2 should have observers for property mah");
+  
+  statechart1.destroy();
+  statechart2.destroy();
+  
+  ok(!obj1.hasObserverFor('foo'), "obj1 should not have observers for property foo");
+  ok(!obj2.hasObserverFor('bar'), "obj2 should not have observers for property bar");
+  ok(!stateA.hasObserverFor('testProp'), "state A should not have observers for property testProp");
+  ok(!stateA.get('testProp2').hasObserverFor('mah'), "state A's testProp2 should not have observers for property mah");
+});
+