simple_state_machine 0.4.3 → 0.5.0.beta

data/spec/decorator_spec.rb

@@ -1,44 +1,195 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-class WithoutEventMethods
-  extend SimpleStateMachine
+describe SimpleStateMachine::Decorator do
 
-  def initialize
-    self.state = 'unread'
-  end
-  event :view, :unread => :read
-  
-end
+  context "given a class" do
+    before do
+      klass = Class.new do
+        # TODO remove the need for defining this method
+        def self.state_machine_definition
+          @state_machine_definition ||= SimpleStateMachine::StateMachineDefinition.new
+        end
+      end
+      decorator = SimpleStateMachine::Decorator.new klass
+      decorator.decorate SimpleStateMachine::Transition.new(:event, :state1, :state2)
+      @instance = klass.new
+      @instance.state = 'state1'
+    end
 
-class WithPredefinedStateHelperMethods
-  extend SimpleStateMachine
+    describe "#initialize" do
+      it "defines a state_machine method" do
+        @instance.state_machine.should be_an(SimpleStateMachine::StateMachine)
+      end
 
-  def initialize
-    self.state = 'unread'
-  end
-  event :view, :unread => :read
+      it "defines a state getter method" do
+        @instance.should respond_to(:state)
+      end
+
+      it "defines a state setter method" do
+        @instance.should respond_to(:state=)
+      end
+    end
 
-  def unread?
-    raise "blah"
+    describe "#decorate" do
+      it "defines state_helper_methods for both states" do
+        @instance.state1?.should  == true
+        @instance.state2?.should  == false
+      end
+      
+      it "defines an event method" do
+        @instance.should respond_to(:event)
+      end
+    end
   end
-end
 
+  context "given a class with predefined public methods" do
+    before do
+      klass = Class.new do
+        # TODO remove the need for defining this method
+        def self.state_machine_definition
+          @state_machine_definition ||= SimpleStateMachine::StateMachineDefinition.new
+        end
+        # predefined methods
+        def state1?() "state1"            end
+        def state2?() "state2"            end
+        def event()   "predefined method" end
+      end
+      transition =  SimpleStateMachine::Transition.new(:event, :state1, :state2)
+      decorator = SimpleStateMachine::Decorator.new klass
+      decorator.decorate transition
+      klass.state_machine_definition.transitions << transition
+      @instance = klass.new
+      @instance.state = 'state1'
+    end
 
-describe SimpleStateMachine::Decorator do
+    describe "#initialize" do
+      it "defines a state_machine method" do
+        @instance.state_machine.should be_an(SimpleStateMachine::StateMachine)
+      end
+
+      it "defines a state getter method" do
+        @instance.should respond_to(:state)
+      end
+
+      it "defines a state setter method" do
+        @instance.should respond_to(:state=)
+      end
+    end
 
-  it "defines state_helper_methods for all states" do
-    TrafficLight.new.green?.should  == true
-    TrafficLight.new.orange?.should == false
-    TrafficLight.new.red?.should    == false
+    describe "#decorate" do
+      it "does not overwrite predefined state_helper_methods" do
+        @instance.state1?.should  == "state1"
+        @instance.state2?.should  == "state2"
+      end
+
+      it "does not overwrite predefined event method" do
+        @instance.event.should == "predefined method"
+      end
+    end
   end
   
-  it "does not define a state_helper_method if it already exists" do
-    l = lambda { WithPredefinedStateHelperMethods.new.unread? }
-    l.should raise_error(RuntimeError, 'blah')
+  context "given a class with predefined protected methods" do
+    before do
+      klass = Class.new do
+        # TODO remove the need for defining this method
+        def self.state_machine_definition
+          @state_machine_definition ||= SimpleStateMachine::StateMachineDefinition.new
+        end
+        # predefined methods
+        protected
+        def state1?() "state1"            end
+        def state2?() "state2"            end
+        def event()   "predefined method" end
+      end
+      transition =  SimpleStateMachine::Transition.new(:event, :state1, :state2)
+      decorator = SimpleStateMachine::Decorator.new klass
+      decorator.decorate transition
+      klass.state_machine_definition.transitions << transition
+      @instance = klass.new
+      @instance.state = 'state1'
+    end
+
+    describe "#initialize" do
+      it "defines a state_machine method" do
+        @instance.state_machine.should be_an(SimpleStateMachine::StateMachine)
+      end
+
+      it "defines a state getter method" do
+        @instance.should respond_to(:state)
+      end
+
+      it "defines a state setter method" do
+        @instance.should respond_to(:state=)
+      end
+    end
+
+    describe "#decorate" do
+      it "does not overwrite predefined protected state_helper_methods" do
+        @instance.send(:state1?).should  == "state1"
+        @instance.send(:state2?).should  == "state2"
+      end
+
+      it "keeps predefined protected state_helper_methods protected" do
+        expect { @instance.state1? }.to raise_error(NoMethodError)
+        expect { @instance.state2? }.to raise_error(NoMethodError)
+      end
+
+      it "does not overwrite predefined protected event method" do
+        @instance.event.should == "predefined method"
+      end
+    end
   end
-  
-  it "defines an event method if it doesn't exist" do
-    WithoutEventMethods.new.view
+
+  context "given a class with predefined private methods" do
+    before do
+      klass = Class.new do
+        # TODO the need for defining this method
+        def self.state_machine_definition
+          @state_machine_definition ||= SimpleStateMachine::StateMachineDefinition.new
+        end
+        # predefined methods
+        private
+        def state1?() "state1"            end
+        def state2?() "state2"            end
+        def event()   "predefined method" end
+      end
+      transition =  SimpleStateMachine::Transition.new(:event, :state1, :state2)
+      decorator = SimpleStateMachine::Decorator.new klass
+      decorator.decorate transition
+      klass.state_machine_definition.transitions << transition
+      @instance = klass.new
+      @instance.state = 'state1'
+    end
+
+    describe "#initialize" do
+      it "defines a state_machine method" do
+        @instance.state_machine.should be_an(SimpleStateMachine::StateMachine)
+      end
+
+      it "defines a state getter method" do
+        @instance.should respond_to(:state)
+      end
+
+      it "defines a state setter method" do
+        @instance.should respond_to(:state=)
+      end
+    end
+
+    describe "#decorate" do
+      it "does not overwrite predefined private state_helper_methods" do
+        @instance.send(:state1?).should  == "state1"
+        @instance.send(:state2?).should  == "state2"
+      end
+
+      it "keeps predefined private state_helper_methods private" do
+        expect { @instance.state1? }.to raise_error(NoMethodError)
+        expect { @instance.state2? }.to raise_error(NoMethodError)
+      end
+
+      it "does not overwrite predefined protected event method" do
+        @instance.event.should == "predefined method"
+      end
+    end
   end
 
 end

data/spec/examples_spec.rb

@@ -53,6 +53,7 @@ describe "Examples" do
       conversation.close
       conversation.should be_closed
     end
+
   end
 
 end

data/spec/mountable_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Mountable" do
+  before do
+    mountable_class = Class.new(SimpleStateMachine::StateMachineDefinition) do
+      def initialize(subject)
+        self.lazy_decorator = lambda { SimpleStateMachine::Decorator.new(subject) }
+        add_transition(:event, :state1, :state2)
+      end
+    end
+    klass = Class.new do
+      extend SimpleStateMachine::Mountable
+      self.state_machine_definition = mountable_class.new self
+    end
+    @instance = klass.new
+    @instance.state = 'state1'
+  end
+
+  it "has state_helper methods" do
+    @instance.should be_state1
+    @instance.should_not be_state2
+  end
+
+end

data/spec/simple_state_machine_spec.rb

@@ -1,85 +1,81 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-class SimpleExample
-  extend SimpleStateMachine
-  attr_reader :event2_called
-  def initialize(state = 'state1')
-    @state = state
-  end
-  event :event1, :state1 => :state2, :state2 => :state3
-  def event2
-    @event2_called = true
-    'event2'
-  end
-  event :event2, :state2 => :state3
-  event :event_with_multiple_from, [:state1, :state2] => :state3
-  event :event_from_all, :all => :state3
-end
-
-class SimpleExampleWithCustomStateMethod
-  extend SimpleStateMachine
-  state_machine_definition.state_method = :ssm_state
-
-  def initialize(state = 'state1')
-    @ssm_state = state
-  end
-  event :event1, :state1 => :state2
-  event :event2, :state2 => :state3
-end
+require 'cgi'
 
 describe SimpleStateMachine do
  
   it "has an error that extends RuntimeError" do
-    SimpleStateMachine::Error.superclass.should == RuntimeError
+    SimpleStateMachine::IllegalStateTransitionError.superclass.should == RuntimeError
   end
 
-  it "has a default state" do
-    SimpleExample.new.state.should == 'state1'
-  end
+  describe ".event" do
 
-  describe "events" do
+    before do
+      @klass = Class.new do
+        extend SimpleStateMachine
+        def initialize(state = 'state1')
+          @state = state
+        end
+      end
+    end
 
     it "changes state if event has multiple transitions" do
-      example = SimpleExample.new
+      klass = Class.new(@klass)
+      klass.instance_eval do
+        event :event, :state1 => :state2, :state2 => :state3
+      end
+      example = klass.new
       example.should be_state1
-      example.event1
+      example.event
       example.should be_state2
-      example.event1
+      example.event
       example.should be_state3
     end
 
     it "changes state if event has multiple froms" do
-      example = SimpleExample.new
-      example.event_with_multiple_from
+      klass = Class.new(@klass)
+      klass.instance_eval do
+        event :event, [:state1, :state2] => :state3
+      end
+      example = klass.new
+      example.event
       example.should be_state3
-      example = SimpleExample.new 'state2'
+      example = klass.new 'state2'
       example.should be_state2
-      example.event_with_multiple_from
+      example.event
       example.should be_state3
     end
 
     it "changes state if event has all as from" do
-      example = SimpleExample.new
-      example.event_from_all
+      klass = Class.new(@klass)
+      klass.instance_eval do
+        event :other_event, :state1 => :state2
+        event :event, :all => :state3
+      end
+      example = klass.new
+      example.event
       example.should be_state3
-      example = SimpleExample.new 'state2'
+      example = klass.new 'state2'
       example.should be_state2
-      example.event_from_all
+      example.event
       example.should be_state3
     end
 
     it "changes state when state is a symbol instead of a string" do
-      example = SimpleExample.new :state1
+      klass = Class.new(@klass)
+      klass.instance_eval do
+        event :event, :state1 => :state2
+      end  
+      example = klass.new :state1
       example.state.should == :state1
-      example.send(:event1)
+      example.send(:event)
       example.should be_state2
     end
 
-    it "changes state to error_state when error should be caught" do
-      class_with_error = Class.new(SimpleExample)
+    it "changes state to error_state when error can be caught" do
+      class_with_error = Class.new(@klass)
       class_with_error.instance_eval do
         define_method :raise_error do
-          raise
+          raise RuntimeError.new
         end
         event :raise_error, :state1 => :state2, RuntimeError => :failed
       end
@@ -89,61 +85,45 @@ describe SimpleStateMachine do
       example.should be_failed
     end
     
-    it "raise an error if an invalid state_transition is called" do
-      example = SimpleExample.new
-      lambda { example.event2 }.should raise_error(SimpleStateMachine::Error, "You cannot 'event2' when state is 'state1'")
+    it "raises an error if an invalid state_transition is called" do
+      klass = Class.new(@klass)
+      klass.instance_eval do
+        event :event,  :state1 => :state2
+        event :event2, :state2 => :state3
+      end  
+      example = klass.new
+      lambda { example.event2 }.should raise_error(SimpleStateMachine::IllegalStateTransitionError, "You cannot 'event2' when state is 'state1'")
     end
 
     it "returns what the decorated method returns" do
-      example = SimpleExample.new
+      klass = Class.new(@klass)
+      klass.instance_eval do
+        event :event1,  :state1 => :state2
+        define_method :event2 do
+          'event2'
+        end
+        event :event2, :state2 => :state3
+      end  
+      example = klass.new
       example.event1.should == nil
       example.event2.should == 'event2'
     end
 
     it "calls existing methods" do
-      example = SimpleExample.new
-      example.event1
-      example.event2
-      example.event2_called.should == true
-    end
-
-  end
-
-  describe 'custom state method' do
-    
-    it "changes state when calling events" do
-      example = SimpleExampleWithCustomStateMethod.new
-      example.should be_state1
-      example.event1
-      example.should be_state2
-      example.event2
-      example.should be_state3
-    end    
-    
-    it "raise an error if an invalid state_transition is called" do
-      example = SimpleExampleWithCustomStateMethod.new
-      lambda { example.event2 }.should raise_error(SimpleStateMachine::Error, "You cannot 'event2' when state is 'state1'")
-    end
-
-  end
-
-  describe "state_machine_definition" do
-    it "is inherited by subclasses" do
-      example = Class.new(SimpleExample).new
-      example.should be_state1
-      example.event1
-      example.should be_state2
-      example.event1
-      example.should be_state3
+      klass = Class.new(@klass)
+      klass.instance_eval do
+        attr_accessor :event_called
+        define_method :event do
+          @event_called = true
+        end
+        event :event, :state1 => :state2
+      end  
+      example = klass.new
+      example.event
+      example.event_called.should == true
     end
-  end
 
-  describe "state_machine" do
-    it "has a next_state method" do
-      example = SimpleExample.new
-      example.state_machine.next_state('event1').should == 'state2'
-      example.state_machine.next_state('event2').should be_nil
-    end
   end
 
 end
+

data/spec/spec_helper.rb

@@ -1,13 +1,7 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'simple_state_machine'
-require 'spec'
-require 'spec/autorun'
-
 require 'examples/conversation'
 require 'examples/lamp'
 require 'examples/traffic_light'
 
-Spec::Runner.configure do |config|
-  
-end

data/spec/state_machine_definition_spec.rb

@@ -0,0 +1,89 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe SimpleStateMachine::StateMachineDefinition do
+
+  before do
+    @klass = Class.new do
+      extend SimpleStateMachine
+      def initialize(state = 'state1')
+        @state = state
+      end
+      event :event1, :state1 => :state2, :state2 => :state3      
+    end
+    @smd = @klass.state_machine_definition
+  end
+
+  it "is inherited by subclasses" do
+    example = Class.new(@klass).new
+    example.should be_state1
+    example.event1
+    example.should be_state2
+    example.event1
+    example.should be_state3
+  end
+
+  describe '#state_method' do
+    subject do
+      klass = Class.new do
+        attr_reader :ssm_state
+        extend SimpleStateMachine
+        state_machine_definition.state_method = :ssm_state
+
+        def initialize(state = 'state1')
+          @ssm_state = state
+        end
+        event :event1, :state1 => :state2
+        event :event2, :state2 => :state3
+      end
+      klass.new
+    end
+
+    it "is used when changing state" do
+      subject.ssm_state.should == 'state1'
+      subject.event1
+      subject.ssm_state.should == 'state2'
+      subject.event2
+      subject.ssm_state.should == 'state3'
+    end
+
+    it "works with state helper methods" do
+      subject.should be_state1
+      subject.event1
+      subject.should be_state2
+      subject.event2
+      subject.should be_state3
+    end
+    
+    it "raise an error if an invalid state_transition is called" do
+      lambda { subject.event2 }.should raise_error(SimpleStateMachine::IllegalStateTransitionError, "You cannot 'event2' when state is 'state1'")
+    end
+
+  end
+
+  describe "#transitions" do
+    it "has a list of transitions" do
+      @smd.transitions.should be_a(Array)
+      @smd.transitions.first.should be_a(SimpleStateMachine::Transition)
+    end
+  end
+
+  describe "#to_s" do
+    it "converts to readable string format" do
+      @smd.to_s.should =~ Regexp.new("state1.event1! => state2")
+    end
+  end
+
+  describe "#to_graphiz_dot" do
+    it "converts to graphiz dot format" do
+      @smd.to_graphiz_dot.should ==  %("state1"->"state2"[label=event1];"state2"->"state3"[label=event1])
+    end
+  end
+
+  describe "#google_chart_url" do
+    it "shows the state and event dependencies as a Google chart" do
+      puts "http://chart.googleapis.com/chart?cht=gv&chl=digraph{#{::CGI.escape @smd.to_graphiz_dot}}"
+      @smd.google_chart_url.should == "http://chart.googleapis.com/chart?cht=gv&chl=digraph{#{::CGI.escape @smd.to_graphiz_dot}}"
+    end
+  end
+end
+

data/spec/state_machine_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe SimpleStateMachine::StateMachine do
+
+  describe "#next_state" do
+    subject do
+      klass = Class.new do
+        extend SimpleStateMachine
+        def initialize() @state = 'state1' end
+        event :event1, :state1 => :state2
+        event :event2, :state2 => :state3
+      end
+      klass.new.state_machine
+    end
+
+    it "returns the next state for the event and current state" do
+      subject.next_state('event1').should == 'state2'
+    end
+
+    it "returns nil if no next state for the event and current state exists" do
+      subject.next_state('event2').should be_nil
+    end
+  end
+
+end
+