state_machines_rspec 0.3.0

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

data/spec/matchers/states/reject_state_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe StateMachinesRspec::Matchers::RejectStateMatcher do
+  describe '#matches?' do
+    context 'when :on state machines attribute is specified' do
+      before { @matcher = described_class.new([:supportive, on: :environment]) }
+      context 'but that state machines doesn\'t exist' do
+        before { @class = Class.new }
+        it 'raises' do
+          expect { @matcher.matches? @class.new }.to raise_error
+        end
+      end
+
+      context 'and that state machines exists' do
+        context 'but it defines states which match one of the specified states' do
+          before do
+            @class = Class.new do
+              state_machine :environment, initial: :supportive
+            end
+          end
+
+          it 'sets a failure message' do
+            @matcher.matches? @class.new
+            expect(@matcher.failure_message).to eq('Did not expect environment to allow states: supportive')
+          end
+          it 'returns false' do
+            expect(@matcher.matches?(@class.new)).to be_falsey
+          end
+        end
+
+        context 'and it does not define any of the states specified' do
+          before do
+            @class = Class.new do
+              state_machine :environment, initial: :conducive
+            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
+      end
+    end
+
+    context 'when :on state machines is not specified' do
+      before { @matcher = described_class.new([:ever_changing]) }
+      context 'but the default state machines defines states which match one of the specified states' do
+        before do
+          @class = Class.new do
+            state_machine initial: :ever_changing
+          end
+        end
+
+          it 'sets a failure message' do
+            @matcher.matches? @class.new
+            expect(@matcher.failure_message).to eq('Did not expect state to allow states: ever_changing')
+          end
+          it 'returns false' do
+            expect(@matcher.matches?(@class.new)).to be_falsey
+          end
+      end
+
+      context 'and the default state machines does not define any of the states specified' do
+        before { @class = Class.new }
+        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
+    end
+  end
+
+  describe '#description' do
+    context 'with no options' do
+      let(:matcher) { described_class.new([:mustard, :tomatoes]) }
+
+      it 'returns a string description' do
+        expect(matcher.description).to eq('not have :mustard, :tomatoes')
+      end
+    end
+
+    context 'when :on state machines is specified' do
+      let(:matcher) { described_class.new([:peanut_butter, on: :toast]) }
+
+      it 'mentions the state machines variable' do
+        expect(matcher.description).to eq('not have :peanut_butter on :toast')
+      end
+    end
+  end
+end