simple_state_machine 0.6.0 → 0.6.1

data/spec/examples_spec.rb

@@ -4,54 +4,54 @@ describe "Examples" do
   describe "TrafficLight" do
     it "changes to the next state" do
       tl = TrafficLight.new
-      tl.should be_green
+      expect(tl).to be_green
       tl.change_state
-      tl.should be_orange
+      expect(tl).to be_orange
       tl.change_state
-      tl.should be_red
+      expect(tl).to be_red
       tl.change_state
-      tl.should be_green
+      expect(tl).to be_green
     end
   end
 
   describe "Lamp" do
     it "changes between :on and :off" do
       lamp = Lamp.new
-      lamp.should be_off
+      expect(lamp).to be_off
       lamp.push_button1
-      lamp.should be_on
+      expect(lamp).to be_on
       lamp.push_button2
-      lamp.should be_off
+      expect(lamp).to be_off
       lamp.push_button2
-      lamp.should be_on
+      expect(lamp).to be_on
       lamp.push_button1
-      lamp.should be_off
+      expect(lamp).to be_off
     end
   end
 
   describe "Conversation" do
     it "is :unread by default" do
       conversation = Conversation.new
-      conversation.should be_unread
+      expect(conversation).to be_unread
     end
 
     it "changes to read on view" do
       conversation = Conversation.new
       conversation.view
-      conversation.should be_read
+      expect(conversation).to be_read
     end
 
     it "changes to closed on close" do
       conversation = Conversation.new
       conversation.close
-      conversation.should be_closed
+      expect(conversation).to be_closed
     end
 
     it "changes to closed on close if :read" do
       conversation = Conversation.new
       conversation.view
       conversation.close
-      conversation.should be_closed
+      expect(conversation).to be_closed
     end
 
   end

data/spec/mountable_spec.rb

@@ -1,34 +1,36 @@
 require 'spec_helper'
 
-describe "Mountable" do
-  before do
-    mountable_class = Class.new(SimpleStateMachine::StateMachineDefinition) do
-      event(:event, :state1 => :state2)
+describe SimpleStateMachine::Mountable do
+  class MountableExample < SimpleStateMachine::StateMachineDefinition
+    event(:event, :state1 => :state2)
 
-      def decorator_class
-        SimpleStateMachine::Decorator::Default
-      end
+    def decorator_class
+      SimpleStateMachine::Decorator::Default
     end
-    klass = Class.new do
+  end
+
+  let(:klass) do
+    Class.new do
       attr_accessor :event_called
       extend SimpleStateMachine::Mountable
-      mount_state_machine mountable_class
+      mount_state_machine MountableExample
       def event_without_managed_state
         @event_called = true
       end
     end
-    @instance = klass.new
-    @instance.state = 'state1'
+  end
+  subject do
+    klass.new.tap{|i| i.state = 'state1' }
   end
 
   it "has state_helper methods" do
-    @instance.should be_state1
-    @instance.should_not be_state2
+    expect(subject).to be_state1
+    expect(subject).not_to be_state2
   end
 
   it "calls existing methods" do
-    @instance.event
-    @instance.should be_state2
-    @instance.event_called.should == true
+    subject.event
+    expect(subject).to be_state2
+    expect(subject.event_called).to eq(true)
   end
 end

data/spec/simple_state_machine_spec.rb

@@ -3,22 +3,21 @@ require 'spec_helper'
 describe SimpleStateMachine do
 
   it "has an error that extends RuntimeError" do
-    SimpleStateMachine::IllegalStateTransitionError.superclass.should == RuntimeError
+    expect(SimpleStateMachine::IllegalStateTransitionError.superclass).to eq(RuntimeError)
   end
 
-  describe ".event" do
-
-    before do
-      @klass = Class.new do
-        extend SimpleStateMachine
-        def initialize(state = 'state1')
-          @state = state
-        end
+  let(:klass) do
+    Class.new do
+      extend SimpleStateMachine
+      def initialize(state = 'state1')
+        @state = state
       end
     end
+  end
+
+  describe ".event" do
 
     it "returns what the decorated method returns" do
-      klass = Class.new(@klass)
       klass.instance_eval do
         event :event1,  :state1 => :state2
         define_method :event2 do
@@ -26,13 +25,12 @@ describe SimpleStateMachine do
         end
         event :event2, :state2 => :state3
       end
-      example = klass.new
-      example.event1.should == nil
-      example.event2.should == 'event2'
+      subject = klass.new
+      expect(subject.event1).to eq(nil)
+      expect(subject.event2).to eq('event2')
     end
 
     it "calls existing methods" do
-      klass = Class.new(@klass)
       klass.instance_eval do
         attr_accessor :event_called
         define_method :event do
@@ -40,112 +38,122 @@ describe SimpleStateMachine do
         end
         event :event, :state1 => :state2
       end
-      example = klass.new
-      example.event
-      example.event_called.should == true
+      subject = klass.new
+      subject.event
+      expect(subject.event_called).to eq(true)
     end
 
     context "given an event has multiple transitions" do
-      it "changes state for all transitions" do
-        klass = Class.new(@klass)
+      before do
         klass.instance_eval do
           event :event, :state1 => :state2, :state2 => :state3
         end
-        example = klass.new
-        example.should be_state1
-        example.event
-        example.should be_state2
-        example.event
-        example.should be_state3
+      end
+
+      it "changes state for all transitions" do
+        subject = klass.new
+        expect(subject).to be_state1
+        subject.event
+        expect(subject).to be_state2
+        subject.event
+        expect(subject).to be_state3
       end
     end
 
     context "given an event has multiple from states" do
-      it "changes state for all from states" do
-        klass = Class.new(@klass)
+      before do
         klass.instance_eval do
           event :event, [:state1, :state2] => :state3
         end
-        example = klass.new
-        example.event
-        example.should be_state3
-        example = klass.new 'state2'
-        example.should be_state2
-        example.event
-        example.should be_state3
+      end
+
+      it "changes state for all from states" do
+        subject = klass.new
+        subject.event
+        expect(subject).to be_state3
+        subject = klass.new 'state2'
+        expect(subject).to be_state2
+        subject.event
+        expect(subject).to be_state3
       end
     end
 
     context "given an event has :all as from state" do
-      it "changes state from all states" do
-        klass = Class.new(@klass)
+      before do
         klass.instance_eval do
           event :other_event, :state1 => :state2
           event :event, :all => :state3
         end
-        example = klass.new
-        example.event
-        example.should be_state3
-        example = klass.new 'state2'
-        example.should be_state2
-        example.event
-        example.should be_state3
+      end
+
+      it "changes state from all states" do
+        subject = klass.new
+        subject.event
+        expect(subject).to be_state3
+        subject = klass.new 'state2'
+        expect(subject).to be_state2
+        subject.event
+        expect(subject).to be_state3
       end
     end
 
     context "given state is a symbol instead of a string" do
-      it "changes state" do
-        klass = Class.new(@klass)
+      before do
         klass.instance_eval do
           event :event, :state1 => :state2
         end
-        example = klass.new :state1
-        example.state.should == :state1
-        example.send(:event)
-        example.should be_state2
+      end
+
+      it "changes state" do
+        subject = klass.new :state1
+        expect(subject.state).to eq(:state1)
+        subject.send(:event)
+        expect(subject).to be_state2
       end
     end
 
     context "given an RuntimeError begin state" do
       it "changes state to error_state when error can be caught" do
-        class_with_error = Class.new(@klass)
+        class_with_error = Class.new(klass)
         class_with_error.instance_eval do
           define_method :raise_error do
             raise RuntimeError.new
           end
           event :raise_error, :state1 => :state2, RuntimeError => :failed
         end
-        example = class_with_error.new
-        example.should be_state1
-        example.raise_error
-        example.should be_failed
+        subject = class_with_error.new
+        expect(subject).to be_state1
+        subject.raise_error
+        expect(subject).to be_failed
       end
 
       it "changes state to error_state when error superclass can be caught" do
         error_subclass   = Class.new(RuntimeError)
-        class_with_error = Class.new(@klass)
+        class_with_error = Class.new(klass)
         class_with_error.instance_eval do
           define_method :raise_error do
             raise error_subclass.new
           end
           event :raise_error, :state1 => :state2, RuntimeError => :failed
         end
-        example = class_with_error.new
-        example.should be_state1
-        example.raise_error
-        example.should be_failed
+        subject = class_with_error.new
+        expect(subject).to be_state1
+        subject.raise_error
+        expect(subject).to be_failed
       end
     end
 
     context "given an invalid state_transition is called" do
-      it "raises an IllegalStateTransitionError" do
-        klass = Class.new(@klass)
+      before do
         klass.instance_eval do
           event :event,  :state1 => :state2
           event :event2, :state2 => :state3
         end
-        example = klass.new
-        lambda { example.event2 }.should raise_error(
+      end
+
+      it "raises an IllegalStateTransitionError" do
+        subject = klass.new
+        expect { subject.event2 }.to raise_error(
             SimpleStateMachine::IllegalStateTransitionError,
             "You cannot 'event2' when state is 'state1'")
       end

data/spec/spec_helper.rb

@@ -1,13 +1,20 @@
 require "rubygems"
 require "bundler"
-Bundler.require
-#Bundler.setup(:test)#, :activerecord)
-require 'active_record'
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+Bundler.require :test
+begin
+  require 'active_record'
+rescue LoadError
+  puts "Skipping ActiveRecord specs"
+end
+
+ROOT = Pathname(File.expand_path(File.join(File.dirname(__FILE__), '..')))
+$LOAD_PATH << File.join(ROOT, 'lib')
+$LOAD_PATH << File.join(ROOT, 'spec')
+$LOAD_PATH << File.join(ROOT, 'examples')
+
 require 'simple_state_machine'
-require 'examples/conversation'
-require 'examples/lamp'
-require 'examples/traffic_light'
-require 'examples/user'
+require File.join(ROOT, 'examples', 'conversation.rb')
+require File.join(ROOT, 'examples', 'lamp.rb')
+require File.join(ROOT, 'examples', 'traffic_light.rb')
+require File.join(ROOT, 'examples', 'user.rb') if defined? ActiveRecord
 

data/spec/state_machine_definition_spec.rb

@@ -2,24 +2,24 @@ require 'spec_helper'
 
 describe SimpleStateMachine::StateMachineDefinition do
 
-  before do
-    @klass = Class.new do
+  let(:klass) do
+    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
+  let(:smd) { klass.state_machine_definition }
 
   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
+    subject = Class.new(klass).new
+    expect(subject).to be_state1
+    subject.event1
+    expect(subject).to be_state2
+    subject.event1
+    expect(subject).to be_state3
   end
 
   describe '#state_method' do
@@ -39,23 +39,23 @@ describe SimpleStateMachine::StateMachineDefinition do
     end
 
     it "is used when changing state" do
-      subject.ssm_state.should == 'state1'
+      expect(subject.ssm_state).to eq('state1')
       subject.event1
-      subject.ssm_state.should == 'state2'
+      expect(subject.ssm_state).to eq('state2')
       subject.event2
-      subject.ssm_state.should == 'state3'
+      expect(subject.ssm_state).to eq('state3')
     end
 
     it "works with state helper methods" do
-      subject.should be_state1
+      expect(subject).to be_state1
       subject.event1
-      subject.should be_state2
+      expect(subject).to be_state2
       subject.event2
-      subject.should be_state3
+      expect(subject).to 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'")
+      expect { subject.event2 }.to raise_error(SimpleStateMachine::IllegalStateTransitionError, "You cannot 'event2' when state is 'state1'")
     end
 
   end
@@ -80,22 +80,22 @@ describe SimpleStateMachine::StateMachineDefinition do
     end
 
     it "is set when an error occurs during an event" do
-      subject.state.should == 'state1'
+      expect(subject.state).to eq('state1')
       subject.event1
-      subject.state.should == 'failed'
+      expect(subject.state).to eq('failed')
     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)
+      expect(smd.transitions).to be_a(Array)
+      expect(smd.transitions.first).to 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")
+      expect(smd.to_s).to match(Regexp.new("state1.event1! => state2"))
     end
   end
 

data/spec/state_machine_spec.rb

@@ -14,11 +14,11 @@ describe SimpleStateMachine::StateMachine do
     end
 
     it "returns the next state for the event and current state" do
-      subject.next_state('event1').should == 'state2'
+      expect(subject.next_state('event1')).to eq('state2')
     end
 
     it "returns nil if no next state for the event and current state exists" do
-      subject.next_state('event2').should be_nil
+      expect(subject.next_state('event2')).to be_nil
     end
   end
 
@@ -37,20 +37,20 @@ describe SimpleStateMachine::StateMachine do
         end
       end
 
+      subject do
+        class_with_error.new.tap{|i| i.raise_error }
+      end
+
       it "the raised error is accessible" do
-        example = class_with_error.new
-        example.raise_error
-        raised_error = example.state_machine.raised_error
-        raised_error.should be_a(RuntimeError)
-        raised_error.message.should == "Something went wrong"
+        raised_error = subject.state_machine.raised_error
+        expect(raised_error).to be_a(RuntimeError)
+        expect(raised_error.message).to eq("Something went wrong")
       end
 
       it "the raised error is set to nil on the next transition" do
-        example = class_with_error.new
-        example.raise_error
-        example.state_machine.raised_error.should be
-        example.retry
-        example.state_machine.raised_error.should_not be
+        expect(subject.state_machine.raised_error).to be
+        subject.retry
+        expect(subject.state_machine.raised_error).not_to be
       end
 
     end

data/spec/tools/graphviz_spec.rb

@@ -15,13 +15,14 @@ describe SimpleStateMachine::Tools::Graphviz do
 
   describe "#to_graphviz_dot" do
     it "converts to graphviz dot format" do
-      @smd.to_graphviz_dot.should ==  %("state1"->"state2"[label=event1];"state2"->"state3"[label=event1])
+      expect(@smd.to_graphviz_dot).to eq(%(digraph G {\n"state1"->"state2"[label=event1];\n"state2"->"state3"[label=event1]\n}))
     end
   end
 
   describe "#google_chart_url" do
     it "shows the state and event dependencies as a Google chart" do
-      @smd.google_chart_url.should == "http://chart.googleapis.com/chart?cht=gv&chl=digraph{#{::CGI.escape @smd.to_graphviz_dot}}"
+      graph = @smd.transitions.map { |t| t.to_graphviz_dot }.sort.join(";")
+      expect(@smd.google_chart_url).to eq("http://chart.googleapis.com/chart?cht=gv&chl=digraph{#{::CGI.escape graph}}")
     end
   end
 end

data/spec/tools/inspector_spec.rb

@@ -19,7 +19,7 @@ describe SimpleStateMachine::Tools::Inspector do
     end
 
     it "returns all 'from' states that aren't 'to' states" do
-      @klass.new.begin_states.should == [:state1, RuntimeError]
+      expect(@klass.new.begin_states).to eq([:state1, RuntimeError])
     end
   end
 
@@ -40,7 +40,7 @@ describe SimpleStateMachine::Tools::Inspector do
     end
 
     it "returns all 'to' states that aren't 'from' states" do
-      @klass.new.end_states.should == [:state3]
+      expect(@klass.new.end_states).to eq([:state3])
     end
   end
 
@@ -61,7 +61,7 @@ describe SimpleStateMachine::Tools::Inspector do
     end
 
     it "returns all states" do
-      @klass.new.states.map(&:to_s).sort.should == %w{state1 state2 state3}
+      expect(@klass.new.states.map(&:to_s).sort).to eq(%w{state1 state2 state3})
     end
   end