state_machines_activerecord_rspec 0.1.0

data/spec/integration/integration_spec.rb

@@ -0,0 +1,327 @@
+require 'spec_helper'
+require 'integration/models/vehicle'
+
+describe Vehicle do
+  let(:vehicle) { Vehicle.new }
+  subject { vehicle }
+
+  its(:passed_inspection?) { is_expected.to be_falsey }
+
+  shared_examples 'crashable' do
+    describe 'crash' do
+      context 'having passed inspection' do
+        before { allow(vehicle).to receive_messages(:passed_inspection => true) }
+        pending 'keeps running' do
+          initial_state = vehicle.state
+          vehicle.crash!
+
+          expect(vehicle.state).to eq initial_state
+        end
+      end
+
+      context 'not having passed inspection' do
+        before { allow(vehicle).to receive_messages(:passed_inspection => false) }
+        it 'stalls' do
+          vehicle.crash!
+          expect(vehicle.state).to eq :stalled.to_s
+        end
+      end
+    end
+  end
+
+  shared_examples 'speedless' do
+    it 'does not respond to speed' do
+      expect { vehicle.speed }.to raise_error StateMachines::InvalidContext
+    end
+  end
+
+  describe '#initialize' do
+    its(:seatbelt_on) { is_expected.to be_falsey }
+    its(:time_used) { is_expected.to eq 0 }
+    its(:auto_shop_busy) { is_expected.to be_truthy }
+  end
+
+  describe '#put_on_seatbelt' do
+    it 'sets seatbelt_on to true' do
+      vehicle.seatbelt_on = false
+      vehicle.put_on_seatbelt
+
+      expect(vehicle.seatbelt_on).to be_truthy
+    end
+  end
+
+  describe 'state machine' do
+    it { is_expected.to have_states :parked, :idling, :stalled, :first_gear,
+                            :second_gear, :third_gear }
+    it { is_expected.to reject_state :flying }
+
+    it { is_expected.to handle_event :ignite, when: :parked }
+    it { is_expected.to reject_events :park, :idle, :shift_up,
+                              :shift_down, :crash, :repair,
+                              when: :parked }
+
+    it { is_expected.to handle_events :park, :shift_up, :crash, when: :idling }
+    it { is_expected.to reject_events :ignite, :idle, :shift_down, :repair,
+                              when: :idling }
+
+    it { is_expected.to handle_events :ignite, :repair, when: :stalled }
+    it { is_expected.to reject_events :park, :idle, :shift_up, :shift_down, :crash,
+                              when: :stalled }
+
+    it { is_expected.to handle_events :park, :idle, :shift_up, :crash,
+                              when: :first_gear }
+    it { is_expected.to reject_events :ignite, :shift_down, :repair,
+                              when: :first_gear }
+
+    it { is_expected.to handle_events :shift_up, :shift_down, :crash,
+                              when: :second_gear }
+    it { is_expected.to reject_events :park, :ignite, :idle, :repair,
+                              when: :second_gear }
+
+    it { is_expected.to handle_events :shift_down, :crash, when: :third_gear }
+    it { is_expected.to reject_events :park, :ignite, :idle, :shift_up, :repair,
+                              when: :third_gear }
+
+    it 'has an initial state of "parked"' do
+      expect(vehicle).to be_parked
+    end
+
+    it 'has an initial alarm state of "active"' do
+      expect(vehicle.alarm_active?).to be_truthy
+    end
+
+    describe 'around transitions' do
+      it 'updates the time used' do
+        expect(vehicle).to receive(:time_used=).with(0)
+        Timecop.freeze { vehicle.ignite! }
+      end
+    end
+
+    context 'when parked' do
+      before { vehicle.state = :parked.to_s }
+
+      its(:speed) { is_expected.to be_zero }
+      it { is_expected.not_to be_moving }
+
+      describe 'before transitions' do
+        it 'puts on a seatbelt' do
+          expect(vehicle).to receive :put_on_seatbelt
+          vehicle.ignite!
+        end
+      end
+
+      describe 'ignite' do
+        it 'should transition to idling' do
+          vehicle.ignite!
+          expect(vehicle).to be_idling
+        end
+      end
+    end
+
+    context 'when transitioning to parked' do
+      before { vehicle.state = :idling.to_s }
+      it 'removes seatbelts' do
+        expect(vehicle).to receive(:seatbelt_on=).with(false)
+        vehicle.park!
+      end
+    end
+
+    context 'when idling' do
+      before { vehicle.state = :idling.to_s }
+
+      its(:speed) { is_expected.to eq 10 }
+      it { is_expected.not_to be_moving }
+
+      describe 'park' do
+        it 'should transition to a parked state' do
+          vehicle.park!
+          expect(vehicle).to be_parked
+        end
+      end
+
+      describe 'shift up' do
+        it 'should shift into first gear' do
+          vehicle.shift_up!
+          expect(vehicle).to be_first_gear
+        end
+      end
+
+      it_behaves_like 'crashable'
+    end
+
+    context 'when stalled' do
+      before { vehicle.state = :stalled.to_s }
+
+      it { is_expected.not_to be_moving }
+      it_behaves_like 'speedless'
+
+      describe 'ignite' do
+        it 'remains stalled' do
+          vehicle.ignite!
+          expect(vehicle).to be_stalled
+        end
+      end
+
+      describe 'repair' do
+        context 'the auto shop is busy' do
+          before { allow(vehicle).to receive_messages(:auto_shop_busy => true) }
+          it 'remains stalled' do
+            vehicle.repair!
+            expect(vehicle).to be_stalled
+          end
+        end
+
+        context 'the auto shop is not busy' do
+          before { allow(vehicle).to receive_messages(:auto_shop_busy => false) }
+          it 'is parked' do
+            vehicle.repair!
+            expect(vehicle).to be_parked
+          end
+        end
+      end
+    end
+
+    context 'when in first gear' do
+      before { vehicle.state = :first_gear.to_s }
+
+      its(:speed) { is_expected.to eq 10 }
+      it { is_expected.to be_moving }
+
+      describe 'park' do
+        it 'parks' do
+          vehicle.park!
+          expect(vehicle).to be_parked
+        end
+      end
+
+      describe 'idle' do
+        it 'idles' do
+          vehicle.idle!
+          expect(vehicle).to be_idling
+        end
+      end
+
+      describe 'shift up' do
+        it 'shift into second gear' do
+          vehicle.shift_up!
+          expect(vehicle).to be_second_gear
+        end
+      end
+
+      it_behaves_like 'crashable'
+    end
+
+    context 'when in second gear' do
+      before { vehicle.state = :second_gear.to_s }
+
+      it { is_expected.to be_moving }
+      it_behaves_like 'speedless'
+
+      describe 'shift up' do
+        it 'shifts into third gear' do
+          vehicle.shift_up!
+          expect(vehicle).to be_third_gear
+        end
+      end
+
+      describe 'shift down' do
+        it 'shifts back into first gear' do
+          vehicle.shift_down!
+          expect(vehicle).to be_first_gear
+        end
+      end
+
+      it_behaves_like 'crashable'
+    end
+
+    context 'when in third gear' do
+      before { vehicle.state = :third_gear.to_s }
+
+      it { is_expected.to be_moving }
+      it_behaves_like 'speedless'
+
+      describe 'shift down' do
+        it 'shifts back into second gear' do
+          vehicle.shift_down!
+          expect(vehicle).to be_second_gear
+        end
+      end
+
+      it_behaves_like 'crashable'
+    end
+
+    context 'on ignition' do
+      context 'when it fails' do
+        before { allow(vehicle).to receive_messages(:ignite => false) }
+        pending 'logs the failure' do
+          expect(vehicle).to receive(:log_start_failure)
+          vehicle.ignite
+        end
+      end
+    end
+
+    context 'on a crash' do
+      before { vehicle.state = :third_gear.to_s }
+      it 'gets towed' do
+        expect(vehicle).to receive(:tow)
+        vehicle.crash!
+      end
+    end
+
+    context 'upon being repaired' do
+      before { vehicle.state = :stalled.to_s }
+      it 'gets fixed' do
+        expect(vehicle).to receive(:fix)
+        vehicle.repair!
+      end
+    end
+  end
+
+  describe 'alarm state machine' do
+    it { is_expected.to have_state :active, on: :alarm_state, value: 1 }
+    it { is_expected.to have_state :off, on: :alarm_state, value: 0 }
+    it { is_expected.to reject_states :broken, :ringing, on: :alarm_state }
+
+    it { is_expected.to handle_events :enable_alarm, :disable_alarm,
+                              when: :active, on: :alarm_state }
+    it { is_expected.to handle_events :enable_alarm, :disable_alarm,
+                              when: :off, on: :alarm_state }
+
+    it 'has an initial state of activated' do
+      expect(vehicle.alarm_active?).to be_truthy
+    end
+
+    context 'when active' do
+      describe 'enable' do
+        it 'becomes active' do
+          vehicle.enable_alarm!
+          expect(vehicle.alarm_active?).to be_truthy
+        end
+      end
+
+      describe 'disable' do
+        it 'turns the alarm off' do
+          vehicle.disable_alarm!
+          expect(vehicle.alarm_off?).to be_truthy
+        end
+      end
+    end
+
+    context 'when off' do
+      before { vehicle.alarm_state = 0 }
+      describe 'enable' do
+        it 'becomes active' do
+          vehicle.enable_alarm!
+          expect(vehicle.alarm_active?).to be_truthy
+        end
+      end
+
+      describe 'disable' do
+        it 'turns the alarm off' do
+          vehicle.disable_alarm!
+          expect(vehicle.alarm_off?).to be_truthy
+        end
+      end
+    end
+  end
+end

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 StateMachinesActiverecordRspec::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 StateMachineIntrospectorError
+        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 machine 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 StateMachinesActiverecordRspec::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 StateMachineIntrospectorError
+        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 machine variable' do
+        expect(matcher.description).to  eq('reject :harrangue on :suspicious_crowd')
+      end
+    end
+  end
+end