MINT-statemachine 1.2.2

data/spec/noodle.rb

@@ -0,0 +1,23 @@
+class Noodle
+  
+  attr_accessor :shape, :cooked, :tasty
+  
+  def initialize
+    @shape = "farfalla"
+    @cooked = false
+    @tasty = false
+  end
+  
+  def cook
+    @cooked = true
+  end
+
+  def good
+    @tasty = true
+  end
+  
+  def transform(shape)
+    @shape = shape
+  end
+  
+end

data/spec/sm_action_parameterization_spec.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "State Machine Odds And Ends" do
+  include SwitchStatemachine
+
+  before(:each) do
+    create_switch
+  end
+  
+  it "action with one parameter" do
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |value| @status = value } }
+    @sm.set "blue"
+    @status.should eql("blue")
+    @sm.state.should equal(:on)
+  end
+
+  it "action with two parameters" do
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b| @status = [a, b].join(",") } }
+    @sm.set "blue", "green"
+    @status.should eql("blue,green")
+    @sm.state.should equal(:on)
+  end
+
+  it "action with three parameters" do
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } }
+    @sm.set "blue", "green", "red"
+    @status.should eql("blue,green,red")
+    @sm.state.should equal(:on)
+  end
+
+  it "action with four parameters" do
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c, d| @status = [a, b, c, d].join(",") } }
+    @sm.set "blue", "green", "red", "orange"
+    @status.should eql("blue,green,red,orange")
+    @sm.state.should equal(:on)
+  end
+
+  it "action with five parameters" do
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c, d, e| @status = [a, b, c, d, e].join(",") } }
+    @sm.set "blue", "green", "red", "orange", "yellow"
+    @status.should eql("blue,green,red,orange,yellow")
+    @sm.state.should equal(:on)
+  end
+  
+  it "action with six parameters" do
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c, d, e, f| @status = [a, b, c, d, e, f].join(",") } }
+    @sm.set "blue", "green", "red", "orange", "yellow", "indigo"
+    @status.should eql("blue,green,red,orange,yellow,indigo")
+    @sm.state.should equal(:on)
+  end
+
+  it "action with seven parameters" do
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c, d, e, f, g| @status = [a, b, c, d, e, f, g].join(",") } }
+    @sm.set "blue", "green", "red", "orange", "yellow", "indigo", "violet"
+    @status.should eql("blue,green,red,orange,yellow,indigo,violet")
+    @sm.state.should equal(:on)
+  end
+
+  it "action with eight parameters" do
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c, d, e, f, g, h| @status = [a, b, c, d, e, f, g, h].join(",") } }
+    @sm.set "blue", "green", "red", "orange", "yellow", "indigo", "violet", "ultra-violet"
+    @status.should eql("blue,green,red,orange,yellow,indigo,violet,ultra-violet")
+    @sm.state.should equal(:on)
+  end
+  
+  it "calling process_event with parameters" do
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } }
+    @sm.process_event(:set, "blue", "green", "red")
+    @status.should eql("blue,green,red")
+    @sm.state.should equal(:on)
+  end
+
+  it "Insufficient params" do
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, b, c| @status = [a, b, c].join(",") } }
+    lambda { @sm.set "blue", "green" }.should raise_error(Statemachine::StatemachineException, 
+      "Insufficient parameters. (transition action from 'off' state invoked by 'set' event)")
+  end
+  
+  it "infinate args" do
+   Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |*a| @status = a.join(",") } }
+    @sm.set(1, 2, 3)
+    @status.should eql("1,2,3")
+    
+    @sm.state = :off
+    @sm.set(1, 2, 3, 4, 5, 6)
+    @status.should eql("1,2,3,4,5,6")
+  end
+  
+  it "Insufficient params when params are infinate" do
+    Statemachine.build(@sm) { |s| s.trans :off, :set, :on, Proc.new { |a, *b| @status = a.to_s + ":" + b.join(",") } }
+    @sm.set(1, 2, 3)
+    @status.should eql("1:2,3")
+    
+    @sm.state = :off
+   
+    lambda { @sm.set }.should raise_error(Statemachine::StatemachineException, 
+      "Insufficient parameters. (transition action from 'off' state invoked by 'set' event)")
+  end
+end

data/spec/sm_activation_spec.rb

@@ -0,0 +1,116 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "State Activation Callback" do
+  include SwitchStatemachine
+  include ParallelStatemachine
+
+  before(:each) do
+    class ActivationCallback
+      attr_reader :called
+      attr_reader :state
+      attr_reader :abstract_states
+      attr_reader :atomic_states
+
+      def initialize
+        @called = []
+        @state = []
+        @abstract_states = []
+        @atomic_states =[]
+
+      end
+      def activate(state,abstract_states, atomic_states)
+        @called << true
+        @state <<  state
+        @abstract_states << abstract_states
+        @atomic_states <<  atomic_states
+        puts "activate #{@state.last} #{@abstract_states.last} #{@atomic_states.last}"
+      end
+    end
+
+    @callback = ActivationCallback.new
+  end
+  
+  it "should fire on successful state change" do
+    create_switch
+    @sm.activation=@callback.method(:activate)
+    @callback.called.length.should == 0
+    @sm.toggle
+    @callback.called.length.should == 1
+  end
+
+  it "should deliver new active state on state change" do
+    create_switch
+    @sm.activation=@callback.method(:activate)
+    @sm.toggle
+    @callback.state.last.should == :on
+    @callback.atomic_states.last.should == [:on]
+    @callback.abstract_states.last.should == [:root]
+    @sm.toggle
+    @callback.state.last.should == :off
+  end
+
+  it "should deliver new active state on state change of parallel state machine" do
+    create_parallel
+
+    @sm.activation=@callback.method(:activate)
+    @sm.go
+    @callback.called.length.should == 2
+    @callback.state.last.should == :on
+    @callback.abstract_states.last.should.eql? [:operative, :root, :onoff]
+    @callback.atomic_states.last.should == [:locked, :on]
+    @sm.toggle
+    @callback.state.last.should == :off
+    @callback.abstract_states.last.should.eql? [:onoff,:operative,:root]
+    @callback.atomic_states.last.should.eql? [:off,:locked]
+
+  end
+
+  it "activation works for on_entry ticks as well" do
+    create_tick
+    @sm.activation=@callback.method(:activate)
+    @sm.toggle
+    @callback.called.length.should == 2
+    @callback.state.last.should == :off
+    @callback.state.first.should == :on
+    @callback.atomic_states.last.should == [:off]
+    @callback.atomic_states.first.should == [:on]
+    @callback.abstract_states.last.should == [:root]
+  end
+
+  it "activation works for self-transitions as well" do
+    create_tome
+    @sm.activation=@callback.method(:activate)
+    @sm.toggle
+    @callback.called.length.should == 1
+    @callback.state.last.should == :me
+    @callback.atomic_states.last.should == [:me]
+    @callback.abstract_states.last.should == [:root]
+  end
+
+  it "should activate corretly on direct entry to parallel state" do
+    @sm = Statemachine.build do
+      trans :start,:go, :unlocked
+      parallel :p do
+        statemachine :s1 do
+          superstate :operative do
+            trans :locked, :coin, :unlocked, Proc.new {  @cooked = true }
+            trans :unlocked, :coin, :locked
+          end
+        end
+        statemachine :s2 do
+          superstate :onoff do
+            trans :on, :toggle, :off
+            trans :off, :toggle, :on
+          end
+        end
+      end
+    end
+
+    @sm.activation=@callback.method(:activate)
+    @sm.go
+    @callback.state.should.eql? [:unlocked,:on]
+    @callback.called.length.should == 2
+  end
+
+
+end

data/spec/sm_entry_exit_actions_spec.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "State Machine Entry and Exit Actions" do
+
+  before(:each) do
+    @log = []
+    @sm = Statemachine.build do
+      trans :off, :toggle, :on, Proc.new { @log << "on" }
+      trans :on, :toggle, :off, Proc.new { @log << "off" }
+    end
+    @sm.context = self
+  end
+
+  it "entry action" do
+    @sm.get_state(:on).entry_action = Proc.new { @log << "entered_on" }
+    
+    @sm.toggle
+    
+    @log.join(",").should eql("on,entered_on")
+  end
+  
+  it "exit action" do
+    @sm.get_state(:off).exit_action = Proc.new { @log << "exited_off" }
+    
+    @sm.toggle
+    
+    @log.join(",").should eql("exited_off,on")
+  end
+
+  it "exit and entry" do
+    @sm.get_state(:off).exit_action = Proc.new { @log << "exited_off" }
+    @sm.get_state(:on).entry_action = Proc.new { @log << "entered_on" }
+    
+    @sm.toggle
+    
+    @log.join(",").should eql("exited_off,on,entered_on")
+  end
+  
+  it "entry and exit actions may be parameterized" do
+      @sm.get_state(:off).exit_action = Proc.new { |a| @log << "exited_off(#{a})" }
+      @sm.get_state(:on).entry_action = Proc.new { |a, b| @log << "entered_on(#{a},#{b})" }
+      
+      @sm.toggle "one", "two"
+      
+      @log.join(",").should eql("exited_off(one),on,entered_on(one,two)")
+  end
+
+  it "current state is set prior to exit and entry actions" do
+    @sm.get_state(:off).exit_action = Proc.new { @log << @sm.state }
+    @sm.get_state(:on).entry_action =  Proc.new { @log << @sm.state }
+    
+    @sm.toggle
+    
+    @log.join(",").should eql("off,on,on")
+  end
+
+  it "current state is set prior to exit and entry actions even with super states" do
+    @sm = Statemachine::Statemachine.new
+    Statemachine.build(@sm) do
+      superstate :off_super do
+        on_exit Proc.new {@log << @sm.state}
+        state :off
+        event :toggle, :on, Proc.new { @log << "super_on" }
+      end
+      superstate :on_super do
+        on_entry Proc.new { @log << @sm.state }
+        state :on
+        event :toggle, :off, Proc.new { @log << "super_off" }
+      end
+      startstate :off
+    end
+    @sm.context = self
+
+    @sm.toggle
+    @log.join(",").should eql("off,super_on,on")
+  end
+
+  it "entry actions invokes another event" do
+    @sm.get_state(:on).entry_action = Proc.new { @sm.toggle }
+    
+    @sm.toggle
+    @log.join(",").should eql("on,off")
+    @sm.state.should equal(:off)
+  end
+
+  it "startstate's entry action should be called when the statemachine starts" do
+    the_context = self
+    @sm = Statemachine.build do
+      trans :a, :b, :c
+      on_entry_of :a, Proc.new { @log << "entering a" }
+      context the_context
+    end
+    
+    @log.join(",").should eql("entering a")
+  end
+
+  
+  
+end

data/spec/sm_odds_n_ends_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "State Machine Odds And Ends" do
+  include SwitchStatemachine
+
+  before(:each) do
+    create_switch
+  end
+  
+  it "method missing delegates to super in case of no event" do
+    $method_missing_called = false
+    module Blah 
+      def method_missing(message, *args)
+        $method_missing_called = true
+      end
+    end
+    @sm.extend(Blah)
+    @sm.blah
+    $method_missing_called.should eql(true)
+  end
+  
+  it "should raise TransistionMissingException when the state doesn't respond to the event" do
+    lambda { @sm.blah }.should raise_error(Statemachine::TransitionMissingException, "'off' state does not respond to the 'blah' event.")
+  end
+  
+  it "should respond to valid events" do
+    @sm.respond_to?(:toggle).should eql(true)
+    @sm.respond_to?(:blah).should eql(false)
+  end
+  
+  it "should not crash when respond_to? called when the statemachine is not in a state" do
+    @sm.instance_eval { @state = nil }
+    lambda { @sm.respond_to?(:toggle) }.should_not raise_error
+    @sm.respond_to?(:toggle).should eql(false)
+  end
+  
+  it "set state with string" do
+    @sm.state.should equal(:off)
+    @sm.state = "on"
+    @sm.state.should equal(:on)
+  end
+  
+  it "set state with symbol" do
+    @sm.state.should equal(:off)
+    @sm.state = :on
+    @sm.state.should equal(:on)
+  end
+  
+  it "process event accepts strings" do
+    @sm.process_event("toggle")
+    @sm.state.should equal(:on)
+  end
+
+  it "states without transitions are valid" do
+    @sm = Statemachine.build do
+      trans :middle, :push, :stuck
+      startstate :middle
+    end
+    
+    @sm.push
+    @sm.state.should equal(:stuck)
+  end
+
+end
+
+
+

data/spec/sm_parallel_state_spec.rb

@@ -0,0 +1,207 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require "noodle"
+
+describe "Nested parallel" do
+  before(:each) do
+    @out_out_order = false
+    @locked = true
+    @noodle = Noodle.new
+
+    @sm = Statemachine.build do
+      trans :start,:go,:p
+      state :maintenance
+      parallel :p do
+        statemachine :s1 do
+          superstate :operative do
+            trans :locked, :coin, :unlocked, Proc.new {  @cooked = true }
+            trans :unlocked, :coin, :locked
+            event :maintain, :maintenance, Proc.new { @out_of_order = true }
+          end
+        end
+        statemachine :s2 do
+          superstate :onoff do
+            trans :on, :toggle, :off
+            trans :off, :toggle, :on
+          end
+        end
+      end
+    end
+
+    @sm.context = @noodle
+  end
+# @TODO add tests that set a certain state that is part of a parallel state machine
+  # to check if
+  # the other sub statemachine is set to the initial state
+  # the other sub state machines states doe not change if already in this parallel state machine
+  it "supports entering a parallel state" do
+    @sm.state.should eql :start
+    @sm.go
+    @sm.state.should eql :p
+    @sm.states_id.should == [:locked,:on]
+    @sm.coin
+    @sm.state.should eql :p
+    @sm.states_id.should == [:unlocked,:on]
+    @sm.toggle
+    @sm.state.should eql :p
+    @sm.states_id.should == [:unlocked,:off]
+  end
+
+  it "supports leaving a parallel state" do
+    @sm.states_id.should == [:start]
+    @sm.go
+    @sm.states_id.should == [:locked,:on]
+    @sm.maintain
+    @sm.state.should == :maintenance
+
+  end
+
+  it "support testing with 'in' condition for  superstates " do
+    @sm.go
+    @sm.process_event(:coin)
+    @sm.In(:unlocked).should == true
+  end
+
+  it "support testing with 'in' condition for parallel  superstates " do
+    @sm.go
+    @sm.coin
+    @sm.In(:onoff).should == true
+    @sm.In(:operative).should == true
+    @sm.In(:on).should == true
+
+#    @sm.is_in_state?(:second).should == true
+
+    @sm.maintain # TODO not working
+    @sm.In(:maintenance).should == true
+  end
+
+  it "supports process_event for parallel states" do
+    @sm.go
+    @sm.process_event(:coin)
+    @sm.In(:onoff).should == true
+    @sm.In(:operative).should == true
+    @sm.In(:on).should == true
+  end
+
+  it "supports calling transition actions inside parallel state changes" do
+    @noodle.cooked.should equal(false)
+    @sm.go
+    @sm.process_event(:coin)
+    @noodle.cooked.should equal(true)
+  end
+
+  it "supports calling transition actions inside parallel state changes from instant context set by process_event" do
+    @noodle2 = Noodle.new
+    @noodle2.cooked.should equal(false)
+    @sm.go
+    @sm.context = @noodle2
+    @sm.process_event(:coin)
+    @noodle2.cooked.should equal(true)
+  end
+
+  it "should support state recovery" do
+    @sm.states=[:locked,:off]
+    @sm.toggle
+    puts @sm.abstract_states
+  end
+
+  it "should support parallel states inside superstates" do
+    @sm = Statemachine.build do
+      trans :start,:go,:s
+      state :maintenance
+      superstate :s do
+        parallel :p do
+          statemachine :s1 do
+            superstate :operative do
+              trans :locked, :coin, :unlocked, Proc.new {  @cooked = true }
+              trans :unlocked, :coin, :locked
+              event :maintain, :maintenance, Proc.new { @out_of_order = true }
+            end
+          end
+          statemachine :s2 do
+            superstate :onoff do
+              trans :on, :toggle, :off
+              trans :off, :toggle, :on
+            end
+          end
+        end
+      end
+    end
+
+    @sm.go
+    @sm.states.should.eql? [:locked,:off]
+
+  end
+
+  it "should support direct transitions into an atomic state of a parallel state set" do
+    @sm = Statemachine.build do
+      trans :start,:go, :unlocked
+      state :maintenance
+      superstate :s do
+        parallel :p do
+          statemachine :s1 do
+            superstate :operative do
+              trans :locked, :coin, :unlocked, Proc.new {  @cooked = true }
+              trans :unlocked, :coin, :locked
+              event :maintain, :maintenance, Proc.new { @out_of_order = true }
+            end
+          end
+          statemachine :s2 do
+            superstate :onoff do
+              trans :on, :toggle, :off
+              trans :off, :toggle, :on
+            end
+          end
+        end
+      end
+    end
+
+    @sm.go
+    @sm.state.should eql :p
+    @sm.states_id.should == [:unlocked,:on]
+    @sm.maintain
+    @sm.state.should eql :maintenance
+    @sm.states_id.should == [:maintenance]
+  end
+
+  it "should support leaving a parallel state by an event from a super state of the parallel state" do
+    pending ("superstates have problems with late defined events ")
+    @sm = Statemachine.build do
+      trans :start,:go, :unlocked
+      state :maintenance
+      superstate :test do
+        superstate :s do
+          event :m, :maintenance
+          parallel :p do
+            statemachine :s1 do
+                trans :locked, :coin, :unlocked, Proc.new {  @cooked = true }
+                trans :unlocked, :coin, :locked
+            end
+            statemachine :s2 do
+              superstate :onoff do
+                trans :on, :toggle, :off
+                trans :off, :toggle, :on
+              end
+            end
+          end
+        end
+        event :repair, :maintenance # this one does not work, event has to be defined directly after superstate definition!
+      end
+    end
+
+    @sm.go
+    @sm.state.should eql :p
+    @sm.states_id.should == [:unlocked,:on]
+    @sm.toggle
+    @sm.repair
+    @sm.state.should eql :maintenance
+    @sm.states_id.should == [:maintenance]
+  end
+
+  it "should fail for undefined events if actual state is inside a parallel state" do
+    @sm.go
+    lambda {@sm.unknown}.should raise_error
+  end
+
+
+
+end