end_state 0.12.0 → 1.0.0

data/spec/end_state/state_machine_spec.rb

@@ -6,185 +6,13 @@ module EndState
     subject(:machine) { StateMachine.new(object) }
     let(:object) { OpenStruct.new(state: nil) }
     before do
-      StateMachine.instance_variable_set '@transitions'.to_sym, nil
+      StateMachine.instance_variable_set '@transition_configurations'.to_sym, nil
       StateMachine.instance_variable_set '@events'.to_sym, nil
       StateMachine.instance_variable_set '@store_states_as_strings'.to_sym, nil
       StateMachine.instance_variable_set '@initial_state'.to_sym, :__nil__
       StateMachine.instance_variable_set '@mode'.to_sym, :soft
     end
 
-    describe '.transition' do
-      let(:options) { { a: :b } }
-
-      before do
-        @transitions = []
-        StateMachine.transition(options) { |transition| @transitions << transition }
-      end
-
-      it 'does not require a block' do
-        expect { StateMachine.transition(options) }.not_to raise_error
-      end
-
-      context 'single transition' do
-        it 'yields a transition for the supplied end state' do
-          expect(@transitions.count).to eq 1
-          expect(@transitions[0].state).to eq :b
-        end
-
-        it 'adds the transition to the state machine' do
-          expect(StateMachine.transitions[a: :b]).to eq @transitions[0]
-        end
-
-        context 'with as' do
-          let(:options) { { a: :b, as: :go } }
-
-          it 'creates an alias' do
-            expect(StateMachine.events[:go]).to eq [{ a: :b }]
-          end
-
-          context 'another single transition with as' do
-            before { StateMachine.transition({c: :d, as: :go}) }
-
-            it 'appends to the event' do
-              expect(StateMachine.events[:go]).to eq [{ a: :b }, { c: :d }]
-            end
-          end
-
-          context 'another single transition with as that conflicts' do
-            it 'raises an error' do
-              expect{ StateMachine.transition({a: :c, as: :go}) }.to raise_error EventConflict,
-                'Attempting to define :go as transitioning from :a => :c when :a => :b already exists. ' \
-                'You cannot define multiple transitions from a single state with the same event name.'
-            end
-          end
-
-          context 'another single transition with as that conflicts' do
-            it 'raises an error' do
-              expect{ StateMachine.transition({any_state: :c, as: :go}) }.to raise_error EventConflict,
-                'Attempting to define :go as transitioning from :any_state => :c when :a => :b already exists. ' \
-                'You cannot define multiple transitions from a single state with the same event name.'
-            end
-          end
-        end
-      end
-
-      context 'multiple start states' do
-        let(:options) { { [:a, :b] => :c } }
-
-        it 'yields each transition for the supplied end state' do
-          expect(@transitions.count).to eq 1
-          expect(@transitions[0].state).to eq :c
-        end
-
-        it 'adds the transitions to the state machine' do
-          expect(StateMachine.transitions[a: :c]).to eq @transitions[0]
-          expect(StateMachine.transitions[b: :c]).to eq @transitions[0]
-        end
-
-        context 'with as' do
-          let(:options) { { [:a, :b] => :c, as: :go } }
-
-          it 'creates an alias' do
-            expect(StateMachine.events[:go]).to eq [{ a: :c }, { b: :c }]
-          end
-        end
-      end
-
-      context 'multiple transitions' do
-        let(:options) { { a: :b, c: :d } }
-
-        it 'yields each transition for the supplied end state' do
-          expect(@transitions.count).to eq 2
-          expect(@transitions[0].state).to eq :b
-          expect(@transitions[1].state).to eq :d
-        end
-
-        it 'adds the transitions to the state machine' do
-          expect(StateMachine.transitions[a: :b]).to eq @transitions[0]
-          expect(StateMachine.transitions[c: :d]).to eq @transitions[1]
-        end
-
-        context 'with as' do
-          let(:options) { { a: :b, c: :d, as: :go } }
-
-          it 'creates an alias' do
-            expect(StateMachine.events[:go]).to eq [{ a: :b }, { c: :d }]
-          end
-        end
-      end
-    end
-
-    describe '.state_attribute' do
-      context 'when set to :foobar' do
-        let(:object) { OpenStruct.new(foobar: :a) }
-        before { StateMachine.state_attribute :foobar }
-
-        it 'answers state with foobar' do
-          expect(machine.state).to eq object.foobar
-        end
-
-        it 'answers state= with foobar=' do
-          machine.state = :b
-          expect(object.foobar).to eq :b
-        end
-
-        after do
-          StateMachine.send(:remove_method, :state)
-          StateMachine.send(:remove_method, :state=)
-        end
-      end
-    end
-
-    describe '.states' do
-      before do
-        StateMachine.transition(a: :b)
-        StateMachine.transition(b: :c)
-      end
-
-      specify { expect(StateMachine.states).to eq [:a, :b, :c] }
-    end
-
-    describe '.start_states' do
-      before do
-        StateMachine.transition(a: :b)
-        StateMachine.transition(b: :c)
-      end
-
-      specify { expect(StateMachine.start_states).to eq [:a, :b] }
-    end
-
-    describe '.end_states' do
-      before do
-        StateMachine.transition(a: :b)
-        StateMachine.transition(b: :c)
-      end
-
-      specify { expect(StateMachine.end_states).to eq [:b, :c] }
-    end
-
-    describe '.store_states_as_strings!' do
-      it 'sets the flag' do
-        StateMachine.store_states_as_strings!
-        expect(StateMachine.store_states_as_strings).to be true
-      end
-    end
-
-    describe '#store_states_as_strings' do
-      it 'is false by default' do
-        expect(StateMachine.store_states_as_strings).to be false
-      end
-    end
-
-    describe '.initial_state' do
-      context 'when set to :first' do
-        before { StateMachine.set_initial_state :first }
-
-        it 'has that initial state' do
-          expect(machine.state).to eq :first
-        end
-      end
-    end
-
     describe '#state' do
       context 'when there is no state set' do
         specify { expect(machine.state).to eq :__nil__ }
@@ -251,9 +79,7 @@ module EndState
 
       context 'single transition' do
         before do
-          StateMachine.transition a: :b, as: :go do |t|
-            t.blocked 'Invalid event!'
-          end
+          StateMachine.transition a: :b, as: :go
         end
 
         it 'transitions the state' do
@@ -281,11 +107,6 @@ module EndState
             expect(machine.state).to eq :c
           end
 
-          it 'adds a failure message specified by blocked' do
-            machine.go
-            expect(machine.failure_messages).to eq ['Invalid event!']
-          end
-
           context 'and all transitions are forced to run in :hard mode' do
             before { machine.class.treat_all_transitions_as_hard! }
 
@@ -309,9 +130,7 @@ module EndState
 
       context 'multiple start states' do
         before do
-          StateMachine.transition [:a, :b] => :c, as: :go do |t|
-            t.blocked 'Invalid event!'
-          end
+          StateMachine.transition [:a, :b] => :c, as: :go
         end
 
         context 'initial state is :a' do
@@ -344,9 +163,7 @@ module EndState
 
       context 'multiple transitions' do
         before do
-          StateMachine.transition a: :b, c: :d, as: :go do |t|
-            t.blocked 'Invalid event!'
-          end
+          StateMachine.transition a: :b, c: :d, as: :go
         end
 
         context 'initial state is :a' do
@@ -372,9 +189,7 @@ module EndState
     describe '#{event}!' do
       let(:object) { OpenStruct.new(state: :a) }
       before do
-        StateMachine.transition a: :b, as: :go do |t|
-          t.blocked 'Invalid event!'
-        end
+        StateMachine.transition a: :b, as: :go
       end
 
       it 'transitions the state' do
@@ -612,8 +427,9 @@ module EndState
           let(:guard) { double :guard, new: guard_instance }
           let(:guard_instance) { double :guard_instance, allowed?: nil }
           before do
-            StateMachine.transition a: :b
-            StateMachine.transitions[{ a: :b }].guards << guard
+            StateMachine.transition a: :b do |t|
+              t.guard guard
+            end
           end
 
           context 'and the object satisfies the guard' do

data/spec/end_state/transition_configuration_set_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+require 'ostruct'
+
+module EndState
+  describe TransitionConfigurationSet do
+    subject(:set) { TransitionConfigurationSet.new }
+    let(:config1) { double :config }
+    let(:config2) { double :config }
+    let(:config3) { double :config }
+    let(:config4) { double :config }
+
+    describe 'without any configurations added' do
+      context '#get_configuration' do
+        it 'returns nil' do
+          expect(set.get_configuration(:a, :b)).to be_nil
+        end
+      end
+
+      context '#get_end_state' do
+        it 'returns nil' do
+          expect(set.get_end_state(:a, :advance)).to be_nil
+        end
+      end
+
+      context '#each' do
+        it 'iterates over []' do
+          expect{ |b| set.each(&b) }.to_not yield_control
+        end
+      end
+
+      context '#start_states' do
+        it 'returns []' do
+          expect(set.start_states).to eql []
+        end
+      end
+
+      context '#end_states' do
+        it 'returns []' do
+          expect(set.end_states).to eql []
+        end
+      end
+
+      context '#events' do
+        it 'returns []' do
+          expect(set.events).to eql []
+        end
+      end
+    end
+
+    describe 'with direct transitions set' do
+      before do
+        set.add(:a, :b, config1)
+        set.add(:b, :c, config2, :advance)
+        set.add(:c, :a, config3, :reset)
+      end
+
+      context '#get_configuration' do
+        it 'returns nil if the configuration does not exist' do
+          expect(set.get_configuration(:b, :a)).to be_nil
+          expect(set.get_configuration(:c, :b)).to be_nil
+        end
+
+        it 'returns the configuration if it exists' do
+          expect(set.get_configuration(:a, :b)).to eql config1
+          expect(set.get_configuration(:b, :c)).to eql config2
+          expect(set.get_configuration(:c, :a)).to eql config3
+        end
+      end
+
+      context '#get_end_state' do
+        it 'returns nil if the configuration does not exist' do
+          expect(set.get_end_state(:b, :reset)).to be_nil
+          expect(set.get_end_state(:c, :advance)).to be_nil
+        end
+
+        it 'returns the configuration if it exists' do
+          expect(set.get_end_state(:b, :advance)).to eql :c
+          expect(set.get_end_state(:c, :reset)).to eql :a
+        end
+      end
+
+      context '#each' do
+        it 'iterates over all transitions' do
+          expect{ |b| set.each(&b) }.to yield_control.exactly(3)
+          expect(set.each).to match_array [
+            [:a, :b, config1, nil], [:b, :c, config2, :advance], [:c, :a, config3, :reset]
+          ]
+        end
+      end
+
+      context '#start_states' do
+        it 'returns all the start_states' do
+          expect(set.start_states).to match_array [:a, :b, :c]
+        end
+      end
+
+      context '#end_states' do
+        it 'returns all the end_states' do
+          expect(set.end_states).to match_array [:a, :b, :c]
+        end
+      end
+
+      context '#events' do
+        it 'returns all the events' do
+          expect(set.events).to match_array [:advance, :reset]
+        end
+      end
+
+      context "#event_conflicts?" do
+        it 'returns false if the event would not conflict with an existing event' do
+          expect(set.event_conflicts?(:a, :advance)).to eql false
+          expect(set.event_conflicts?(:b, :reset)).to eql false
+          expect(set.event_conflicts?(:c, :other)).to eql false
+          expect(set.event_conflicts?(:any_state, :other)).to eql false
+        end
+
+        it 'returns true if the event would conflict with an existing event' do
+          expect(set.event_conflicts?(:b, :advance)).to eql true
+          expect(set.event_conflicts?(:c, :reset)).to eql true
+          expect(set.event_conflicts?(:any_state, :advance)).to eql true
+          expect(set.event_conflicts?(:any_state, :reset)).to eql true
+        end
+      end
+    end
+
+    describe 'with direct and :any_state transitions set' do
+      before do
+        set.add(:a, :b, config1)
+        set.add(:b, :c, config2)
+        set.add(:any_state, :d, config3, :done)
+        set.add(:any_state, :e, config4)
+      end
+
+      context '#get_configuration' do
+        it 'returns nil if the configuration does not exist' do
+          expect(set.get_configuration(:d, :a)).to be_nil
+          expect(set.get_configuration(:d, :b)).to be_nil
+        end
+
+        it 'returns the configuration if it exists' do
+          expect(set.get_configuration(:a, :d)).to eql config3
+          expect(set.get_configuration(:b, :d)).to eql config3
+          expect(set.get_configuration(:c, :d)).to eql config3
+          expect(set.get_configuration(:d, :d)).to eql config3
+          expect(set.get_configuration(:e, :d)).to eql config3
+
+          expect(set.get_configuration(:a, :e)).to eql config4
+          expect(set.get_configuration(:b, :e)).to eql config4
+          expect(set.get_configuration(:c, :e)).to eql config4
+          expect(set.get_configuration(:d, :e)).to eql config4
+          expect(set.get_configuration(:e, :e)).to eql config4
+        end
+      end
+
+      context '#get_end_state' do
+        it 'returns nil if the end_state does not exist' do
+          expect(set.get_end_state(:a, :invalid)).to be_nil
+          expect(set.get_end_state(:e, :go)).to be_nil
+        end
+
+        it 'returns the end state if it exists' do
+          expect(set.get_end_state(:a, :done)).to eql :d
+          expect(set.get_end_state(:b, :done)).to eql :d
+          expect(set.get_end_state(:c, :done)).to eql :d
+          expect(set.get_end_state(:d, :done)).to eql :d
+          expect(set.get_end_state(:e, :done)).to eql :d
+        end
+      end
+
+      context '#each' do
+        it 'iterates over all transitions' do
+          expect{ |b| set.each(&b) }.to yield_control.exactly(12)
+          expect(set.each).to match_array [
+            [:a, :b, config1, nil], [:b, :c, config2, nil],
+            [:a, :d, config3, :done], [:b, :d, config3, :done], [:c, :d, config3, :done], [:d, :d, config3, :done], [:e, :d, config3, :done],
+            [:a, :e, config4, nil], [:b, :e, config4, nil], [:c, :e, config4, nil], [:d, :e, config4, nil], [:e, :e, config4, nil]
+          ]
+        end
+      end
+
+      context '#start_states' do
+        it 'returns all the start_states' do
+          expect(set.start_states).to match_array [:a, :b, :c, :d, :e]
+        end
+      end
+
+      context '#end_states' do
+        it 'returns all the end_states' do
+          expect(set.end_states).to match_array [:b, :c, :d, :e]
+        end
+      end
+
+      context '#events' do
+        it 'returns all the events' do
+          expect(set.events).to match_array [:done]
+        end
+      end
+
+      context "#event_conflicts?" do
+        it 'returns false if the event would not conflict with an existing event' do
+          expect(set.event_conflicts?(:a, :other)).to eql false
+          expect(set.event_conflicts?(:b, :other)).to eql false
+          expect(set.event_conflicts?(:c, :other)).to eql false
+          expect(set.event_conflicts?(:any_state, :other)).to eql false
+        end
+
+        it 'returns true if the event would conflict with an existing event' do
+          expect(set.event_conflicts?(:a, :done)).to eql true
+          expect(set.event_conflicts?(:b, :done)).to eql true
+          expect(set.event_conflicts?(:c, :done)).to eql true
+          expect(set.event_conflicts?(:d, :done)).to eql true
+          expect(set.event_conflicts?(:e, :done)).to eql true
+        end
+      end
+    end
+  end
+end

data/spec/end_state/transition_configuration_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'ostruct'
+
+module EndState
+  describe TransitionConfiguration do
+    subject(:config) { TransitionConfiguration.new }
+
+    describe '#custom_action' do
+      let(:custom) { double :custom }
+
+      it 'sets the action' do
+        config.custom_action custom
+        expect(config.action).to eq custom
+      end
+    end
+
+    describe '#guard' do
+      let(:guard) { double :guard }
+      let(:another_guard) { double :another_guard }
+
+      it 'adds a guard' do
+        expect { config.guard guard }.to change(config.guards, :count).by(1)
+      end
+
+      it 'adds multiple guards' do
+        expect { config.guard guard, another_guard }.to change(config.guards, :count).by(2)
+      end
+    end
+
+    describe '#concluder' do
+      let(:concluder) { double :concluder }
+      let(:another_concluder) { double :another_concluder }
+
+      it 'adds a concluder' do
+        expect { config.concluder concluder }.to change(config.concluders, :count).by(1)
+      end
+
+      it 'adds multiple concluders' do
+        expect { config.concluder concluder, another_concluder }.to change(config.concluders, :count).by(2)
+      end
+    end
+
+    describe '#persistence_on' do
+      it 'adds a Persistence concluder' do
+        expect { config.persistence_on }.to change(config.concluders, :count).by(1)
+      end
+    end
+
+    describe '#allow_params' do
+      it 'adds supplied keys to the allowed_params array' do
+        expect { config.allow_params :foo, :bar }.to change(config.allowed_params, :count).by(2)
+      end
+    end
+
+    describe '#require_params' do
+      it 'adds supplied keys to the required_params array' do
+        expect { config.require_params :foo, :bar }.to change(config.required_params, :count).by(2)
+      end
+
+      it 'adds supplied keys to the allowed_params array' do
+        expect { config.allow_params :foo, :bar }.to change(config.allowed_params, :count).by(2)
+      end
+    end
+  end
+end