state_machines-rspec 0.4.0

data/spec/integration/models/vehicle.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+class Vehicle
+  attr_accessor :seatbelt_on, :time_used, :auto_shop_busy
+
+  state_machine :state, :initial => :parked do
+    before_transition :parked => any - :parked, :do => :put_on_seatbelt
+
+    after_transition :on => :crash, :do => :tow
+    after_transition :on => :repair, :do => :fix
+    after_transition any => :parked do |vehicle, transition|
+      vehicle.seatbelt_on = false
+    end
+
+    after_failure :on => :ignite, :do => :log_start_failure
+
+    around_transition do |vehicle, transition, block|
+      start = Time.now
+      block.call
+      vehicle.time_used += Time.now - start
+    end
+
+    event :park do
+      transition [:idling, :first_gear] => :parked
+    end
+
+    event :ignite do
+      transition :stalled => same, :parked => :idling
+    end
+
+    event :idle do
+      transition :first_gear => :idling
+    end
+
+    event :shift_up do
+      transition :idling => :first_gear, :first_gear => :second_gear, :second_gear => :third_gear
+    end
+
+    event :shift_down do
+      transition :third_gear => :second_gear, :second_gear => :first_gear
+    end
+
+    event :crash do
+      transition all - [:parked, :stalled] => :stalled, :if => lambda {|vehicle| !vehicle.passed_inspection?}
+    end
+
+    event :repair do
+      # The first transition that matches the state and passes its conditions
+      # will be used
+      transition :stalled => :parked, :unless => :auto_shop_busy
+      transition :stalled => same
+    end
+
+    state :parked do
+      def speed
+        0
+      end
+    end
+
+    state :idling, :first_gear do
+      def speed
+        10
+      end
+    end
+
+    state all - [:parked, :stalled, :idling] do
+      def moving?
+        true
+      end
+    end
+
+    state :parked, :stalled, :idling do
+      def moving?
+        false
+      end
+    end
+  end
+
+  state_machine :alarm_state, :initial => :active, :namespace => 'alarm' do
+    event :enable do
+      transition all => :active
+    end
+
+    event :disable do
+      transition all => :off
+    end
+
+    state :active, :value => 1
+    state :off, :value => 0
+  end
+
+  def initialize
+    @seatbelt_on = false
+    @time_used = 0
+    @auto_shop_busy = true
+    super() # NOTE: This *must* be called, otherwise states won't get initialized
+  end
+
+  def put_on_seatbelt
+    @seatbelt_on = true
+  end
+
+  def passed_inspection?
+    false
+  end
+
+  def tow
+    # tow the vehicle
+  end
+
+  def fix
+    # get the vehicle fixed by a mechanic
+  end
+
+  def log_start_failure
+    # log a failed attempt to start the vehicle
+  end
+end
+

data/spec/matchers/events/handle_event_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe StateMachinesRspec::Matchers::HandleEventMatcher do
+  describe '#matches?' do
+    context 'when :when state is specified' do
+      context 'but the state doesn\'t exist' do
+        before do
+          matcher_class = Class.new do
+            state_machine :state, initial: :mathy
+          end
+          @matcher_subject = matcher_class.new
+          @matcher = described_class.new([when: :artsy])
+        end
+
+        it 'raises' do
+          expect { @matcher.matches? @matcher_subject }.
+            to raise_error StateMachinesIntrospectorError
+        end
+      end
+
+      context 'and that state exists' do
+        before do
+          matcher_class = Class.new do
+            state_machine :state, initial: :mathy do
+              state :artsy
+            end
+          end
+          @matcher_subject = matcher_class.new
+          @matcher = described_class.new([when: :artsy])
+        end
+
+        it 'sets the state' do
+          @matcher.matches? @matcher_subject
+          expect(@matcher_subject.state).to  eq 'artsy'
+        end
+      end
+    end
+
+    context 'when subject can perform events' do
+      before do
+        matcher_class = Class.new do
+          state_machine :mathiness, initial: :mathy do
+            event(:mathematize) { transition any => same }
+          end
+        end
+        @matcher_subject = matcher_class.new
+        @matcher = described_class.new([:mathematize, on: :mathiness])
+      end
+
+      it 'does not set a failure message' do
+        @matcher.matches? @matcher_subject
+        expect(@matcher.failure_message).to  be_nil
+      end
+      it 'returns true' do
+        expect(@matcher.matches?(@matcher_subject)).to be_truthy
+      end
+    end
+
+    context 'when subject cannot perform events' do
+      before do
+        matcher_class = Class.new do
+          state_machine :state, initial: :mathy do
+            state :polynomial
+
+            event(:mathematize) { transition any => same }
+            event(:algebraify) { transition :polynomial => same }
+            event(:trigonomalize) { transition :trigonomalize => same }
+          end
+        end
+        @matcher_subject = matcher_class.new
+      end
+
+      context 'because it cannot perform the transition' do
+        before do
+          @matcher = described_class.new([:mathematize, :algebraify, :trigonomalize])
+        end
+
+        it 'sets a failure message' do
+          @matcher.matches? @matcher_subject
+          expect(@matcher.failure_message).to eq('Expected to be able to handle events: algebraify, trigonomalize ' +
+                                                 'in state: mathy')
+        end
+        it 'returns false' do
+          expect(@matcher.matches?(@matcher_subject)).to be_falsey
+        end
+      end
+
+      context 'because no such events exist' do
+        before do
+          @matcher = described_class.new([:polynomialize, :eulerasterize])
+        end
+
+        it 'does not raise' do
+          expect { @matcher.matches?(@matcher_subject) }.not_to raise_error
+        end
+        it 'sets a failure message' do
+          @matcher.matches? @matcher_subject
+          expect(@matcher.failure_message).to eq('state_machine: state does not ' +
+                                                 'define events: polynomialize, eulerasterize')
+        end
+        it 'returns false' do
+          expect(@matcher.matches?(@matcher_subject)).to be_falsey
+        end
+      end
+    end
+  end
+
+  describe '#description' do
+    context 'with no options' do
+      let(:matcher) { described_class.new([:placate, :mollify]) }
+
+      it 'returns a string description' do
+        expect(matcher.description).to  eq('handle :placate, :mollify')
+      end
+    end
+
+    context 'when :when state is specified' do
+      let(:matcher) { described_class.new([:destroy_food, when: :hangry]) }
+
+      it 'mentions the requisite state' do
+        expect(matcher.description).to eq('handle :destroy_food when :hangry')
+      end
+    end
+
+    context 'when :on is specified' do
+      let(:matcher) { described_class.new([:ensmarmify, on: :tired_investors]) }
+
+      it 'mentions the state machines variable' do
+        expect(matcher.description).to eq('handle :ensmarmify on :tired_investors')
+      end
+    end
+  end
+end

data/spec/matchers/events/reject_event_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe StateMachinesRspec::Matchers::RejectEventMatcher do
+  describe '#matches?' do
+    context 'when :when state is specified' do
+      context 'but that state doesn\'t exist' do
+        before do
+          matcher_class = Class.new do
+            state_machine :state, initial: :sleazy
+          end
+          @matcher_subject = matcher_class.new
+          @matcher = described_class.new([when: :sneezy])
+        end
+
+        it 'raises' do
+          expect { @matcher.matches? @matcher_subject }.
+            to raise_error StateMachinesIntrospectorError
+        end
+      end
+
+      context 'and that state exists' do
+        before do
+          matcher_class = Class.new do
+            state_machine :state, initial: :sleazy do
+              state :sneezy
+            end
+          end
+          @matcher_subject = matcher_class.new
+          @matcher = described_class.new([when: :sneezy])
+        end
+
+        it 'sets the state' do
+          @matcher.matches? @matcher_subject
+          expect(@matcher_subject.state).to eq('sneezy')
+        end
+      end
+    end
+
+    context 'when an expectation is made on an event that is undefined' do
+      before do
+        matcher_class = Class.new do
+          state_machine :state, initial: :snarky do
+            event(:primmadonnalize) { transition any => same }
+          end
+        end
+        @matcher_subject = matcher_class.new
+        @matcher = described_class.new([:primmadonnalize, :martinilunchitize])
+      end
+
+      it 'does not raise' do
+        expect { @matcher.matches?(@matcher_subject) }.not_to raise_error
+      end
+      it 'sets a failure message' do
+        @matcher.matches? @matcher_subject
+        expect(@matcher.failure_message).to eq('state_machine: state does not ' +
+                                               'define events: martinilunchitize')
+      end
+      it 'returns false' do
+        expect(@matcher.matches?(@matcher_subject)).to be_falsey
+      end
+    end
+
+    context 'when subject cannot perform any of the specified events' do
+      before do
+        matcher_class = Class.new do
+          state_machine :state, initial: :snarky do
+            state :haughty
+            event(:primmadonnalize) { transition :haughty => same }
+          end
+        end
+        @matcher_subject = matcher_class.new
+        @matcher = described_class.new([:primmadonnalize])
+      end
+
+      it 'does not set a failure message' do
+        @matcher.matches? @matcher_subject
+        expect(@matcher.failure_message).to  be_nil
+      end
+      it 'returns true' do
+        expect(@matcher.matches?(@matcher_subject)).to be_truthy
+      end
+    end
+
+    context 'when subject can perform any one of the specified events' do
+      before do
+        matcher_class = Class.new do
+          state_machine :state, initial: :snarky do
+            state :haughty
+            event(:primmadonnalize) { transition :haughty => same }
+            event(:defer_to_management) { transition any => same }
+          end
+        end
+        @matcher_subject = matcher_class.new
+        @matcher = described_class.new([:primmadonnalize, :defer_to_management])
+      end
+
+      it 'sets a failure message' do
+        @matcher.matches? @matcher_subject
+        expect(@matcher.failure_message).to eq('Did not expect to be able to handle events: defer_to_management ' +
+                                               'in state: snarky')
+      end
+      it 'returns false' do
+        expect(@matcher.matches?(@matcher_subject)).to be_falsey
+      end
+    end
+  end
+
+  describe '#description' do
+    context 'with no options' do
+      let(:matcher) { described_class.new([:makeadealify, :hustlinate]) }
+
+      it 'returns a string description' do
+        expect(matcher.description).to  eq('reject :makeadealify, :hustlinate')
+      end
+    end
+
+    context 'when :when state is specified' do
+      let(:matcher) { described_class.new([:begargle, when: :sleep_encrusted]) }
+
+      it 'mentions the requisite state' do
+        expect(matcher.description).to  eq('reject :begargle when :sleep_encrusted')
+      end
+    end
+
+    context 'when :on is specified' do
+      let(:matcher) { described_class.new([:harrangue, on: :suspicious_crowd]) }
+
+      it 'mentions the state machines variable' do
+        expect(matcher.description).to  eq('reject :harrangue on :suspicious_crowd')
+      end
+    end
+  end
+end

data/spec/matchers/states/have_state_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+describe StateMachinesRspec::Matchers::HaveStateMatcher do
+  describe '#matches?' do
+    before { @matcher = described_class.new([:rad, :not_so_rad, { on: :radical_state }]) }
+
+    context 'when values are asserted on multiple states' do
+      before do
+        @matcher = described_class.new([:rad, :not_so_rad, { value: 'rad' }])
+      end
+      it 'raises an ArgumentError' do
+        expect { @matcher.matches? nil }.to raise_error ArgumentError,
+          'cannot make value assertions on multiple states at once'
+      end
+    end
+
+    context 'when class does not have a matching state attribute' do
+      before do
+        @class = Class.new do
+          state_machine :bodacious_state, initial: :super_bodacious
+        end
+      end
+
+      it 'raises' do
+        expect { @matcher.matches? @class.new }.
+          to raise_error StateMachinesIntrospectorError,
+            /.+? does not have a state machine defined on radical_state/
+      end
+    end
+
+    context 'when class has a matching state attribute' do
+      context 'but is missing some of the specified states' do
+        before do
+          @class = Class.new do
+            state_machine :radical_state do
+              state :not_so_rad
+            end
+          end
+        end
+
+        it 'sets a failure message indicating a state is missing' do
+          @matcher.matches? @class.new
+          expect(@matcher.failure_message).to eq 'Expected radical_state to allow states: rad'
+        end
+        it 'returns false' do
+          expect(@matcher.matches?(@class.new)).to be_falsey
+        end
+      end
+
+      context 'and has all states specified' do
+        before do
+          @class = Class.new do
+            state_machine :radical_state do
+              state :rad, value: 'totes rad'
+              state :not_so_rad, value: 'meh'
+            end
+          end
+        end
+
+        context 'state values not specified' do
+          it 'does not set a failure message' do
+            @matcher.matches? @class.new
+            expect(@matcher.failure_message).to be_nil
+          end
+          it 'returns true' do
+            expect(@matcher.matches?(@class.new)).to be_truthy
+          end
+        end
+
+        context 'state value matches specified value' do
+          before do
+            @matcher = described_class.new([:rad, { on: :radical_state, value: 'uber-rad' }])
+            @class = Class.new do
+              state_machine :radical_state do
+                state :rad, value: 'uber-rad'
+              end
+            end
+          end
+
+          it 'does not set a failure message' do
+            @matcher.matches? @class.new
+            expect(@matcher.failure_message).to  be_nil
+          end
+          it 'returns true' do
+            expect(@matcher.matches?(@class.new)).to be_truthy
+          end
+        end
+
+        context 'state value does not match specified value' do
+          before do
+            @matcher = described_class.new([:rad, { on: :radical_state, value: 'uber-rad' }])
+            @class = Class.new do
+              state_machine :radical_state do
+                state :rad, value: 'kinda rad'
+              end
+            end
+          end
+
+          it 'does not set a failure message' do
+            @matcher.matches? @class.new
+            expect(@matcher.failure_message).to  eq 'Expected rad to have value uber-rad'
+          end
+          it 'returns true' do
+            expect(@matcher.matches?(@class.new)).to be_falsey
+          end
+        end
+      end
+    end
+  end
+
+  describe '#description' do
+    context 'with no options' do
+      let(:matcher) { described_class.new([:fancy_shirt, :cracked_toenail]) }
+
+      it 'returns a string description' do
+        expect(matcher.description).to  eq('have :fancy_shirt, :cracked_toenail')
+      end
+    end
+
+    context 'when :value is specified' do
+      let(:matcher) { described_class.new([:mustache, value: :really_shady]) }
+
+      it 'mentions the requisite state' do
+        expect(matcher.description).to  eq('have :mustache == :really_shady')
+      end
+    end
+
+    context 'when :on state machines is specified' do
+      let(:matcher) { described_class.new([:lunch, on: :tuesday]) }
+
+      it 'mentions the state machines variable' do
+        expect(matcher.description).to  eq('have :lunch on :tuesday')
+      end
+    end
+  end
+end