end_state 0.12.0 → 1.0.0

data/spec/end_state/transition_spec.rb

@@ -3,66 +3,43 @@ require 'ostruct'
 
 module EndState
   describe Transition do
-    subject(:transition) { Transition.new(state) }
-    let(:state) { :a }
-
-    describe '#custom_action' do
-      let(:custom) { double :custom }
-
-      it 'sets the action' do
-        transition.custom_action custom
-        expect(transition.action).to eq custom
-      end
-    end
-
-    describe '#blocked' do
-      it 'sets the blocked event message' do
-        transition.blocked 'This is blocked.'
-        expect(transition.blocked_event_message).to eq 'This is blocked.'
-      end
-    end
-
-    describe '#guard' do
-      let(:guard) { double :guard }
-      let(:another_guard) { double :another_guard }
-
-      it 'adds a guard' do
-        expect { transition.guard guard }.to change(transition.guards, :count).by(1)
-      end
-
-      it 'adds multiple guards' do
-        expect { transition.guard guard, another_guard }.to change(transition.guards, :count).by(2)
-      end
-    end
+    subject(:transition) { Transition.new(object, previous_state, state, configuration, mode) }
+    let(:object) { double :object, failure_messages: [] }
+    let(:previous_state) { :a }
+    let(:state) { :b }
+    let(:configuration) { OpenStruct.new(action: action, concluders: [], guards: [], required_params: []) }
+    let(:action) { double :action, new: action_instance }
+    let(:action_instance) { double :action_instance, call: action_return_value, rollback: nil }
+    let(:action_return_value) { true }
+    let(:mode) { :soft }
 
     describe '#allowed?' do
       let(:guard) { double :guard, new: guard_instance }
       let(:guard_instance) { double :guard_instance, allowed?: nil }
-      let(:object) { double :object }
-      before { transition.guards << guard }
+      before { configuration.guards << guard }
 
       context 'when all guards pass' do
         before { allow(guard_instance).to receive(:allowed?).and_return(true) }
 
-        specify { expect(transition.allowed? object).to be true }
+        specify { expect(transition.allowed?).to be true }
 
         context 'when params are provided' do
           it 'creates the guard with the params' do
-            transition.allowed? object, { foo: 'bar' }
+            transition.allowed?({ foo: 'bar' })
             expect(guard).to have_received(:new).with(object, state, { foo: 'bar' })
           end
 
           context 'and some params are required' do
-            before { transition.require_params :foo, :bar }
+            before { configuration.required_params = [:foo, :bar] }
 
             context 'and not all required are provided' do
               it 'throws an exception' do
-                expect { transition.allowed? object, foo: 'something' }.to raise_error('Missing params: bar')
+                expect { transition.allowed? foo: 'something' }.to raise_error('Missing params: bar')
               end
             end
 
             context 'and all required are provided' do
-              specify { expect(transition.allowed? object, foo: 1, bar: 2).to be true }
+              specify { expect(transition.allowed? foo: 1, bar: 2).to be true }
             end
           end
         end
@@ -71,36 +48,35 @@ module EndState
       context 'when not all guards pass' do
         before { allow(guard_instance).to receive(:allowed?).and_return(false) }
 
-        specify { expect(transition.allowed? object).to be false }
+        specify { expect(transition.allowed?).to be false }
       end
     end
 
     describe '#will_allow?' do
       let(:guard) { double :guard, new: guard_instance }
       let(:guard_instance) { double :guard_instance, will_allow?: nil }
-      let(:object) { double :object }
-      before { transition.guards << guard }
+      before { configuration.guards << guard }
 
       context 'when all guards pass' do
         before { allow(guard_instance).to receive(:will_allow?).and_return(true) }
 
-        specify { expect(transition.will_allow? object).to be true }
+        specify { expect(transition.will_allow?).to be true }
 
         context 'when params are provided' do
           it 'creates the guard with the params' do
-            transition.will_allow? object, { foo: 'bar' }
+            transition.will_allow?({ foo: 'bar' })
             expect(guard).to have_received(:new).with(object, state, { foo: 'bar' })
           end
 
           context 'and some params are required' do
-            before { transition.require_params :foo, :bar }
+            before { configuration.required_params = [:foo, :bar] }
 
             context 'and not all required are provided' do
-              specify { expect(transition.will_allow? object).to be false }
+              specify { expect(transition.will_allow?).to be false }
             end
 
             context 'and all required are provided' do
-              specify { expect(transition.will_allow? object, foo: 1, bar: 2).to be true }
+              specify { expect(transition.will_allow? foo: 1, bar: 2).to be true }
             end
           end
         end
@@ -109,82 +85,93 @@ module EndState
       context 'when not all guards pass' do
         before { allow(guard_instance).to receive(:will_allow?).and_return(false) }
 
-        specify { expect(transition.will_allow? object).to be false }
+        specify { expect(transition.will_allow?).to be false }
       end
 
       context 'when params are provided' do
         it 'creates the guard with the params' do
-          transition.will_allow? object, { foo: 'bar' }
+          transition.will_allow?({ foo: 'bar' })
           expect(guard).to have_received(:new).with(object, state, { foo: 'bar' })
         end
       end
     end
 
-    describe '#concluder' do
-      let(:concluder) { double :concluder }
-      let(:another_concluder) { double :another_concluder }
+    describe '#call' do
+      context 'when a guard returns false' do
+        let(:guard) { double :guard, new: guard_instance }
+        let(:guard_instance) { double :guard_instance, allowed?: false }
+        before do
+          configuration.guards << guard
+          object.failure_messages << 'not ready'
+        end
 
-      it 'adds a concluder' do
-        expect { transition.concluder concluder }.to change(transition.concluders, :count).by(1)
-      end
+        context 'soft mode' do
+          let(:mode) { :soft }
 
-      it 'adds multiple concluders' do
-        expect { transition.concluder concluder, another_concluder }.to change(transition.concluders, :count).by(2)
-      end
-    end
+          it 'returns false' do
+            expect(transition.call).to be false
+          end
+        end
 
-    describe '#persistence_on' do
-      it 'adds a Persistence concluder' do
-        expect { transition.persistence_on }.to change(transition.concluders, :count).by(1)
-      end
-    end
+        context 'hard mode' do
+          let(:mode) { :hard }
 
-    describe '#allow_params' do
-      it 'adds supplied keys to the allowed_params array' do
-        expect { transition.allow_params :foo, :bar }.to change(transition.allowed_params, :count).by(2)
+          it 'raises GuardFailed' do
+            expect{transition.call}.to raise_error(GuardFailed, 'The transition to b was blocked: not ready')
+          end
+        end
       end
-    end
 
-    describe '#require_params' do
-      it 'adds supplied keys to the required_params array' do
-        expect { transition.require_params :foo, :bar }.to change(transition.required_params, :count).by(2)
-      end
+      context 'when action returns false' do
+        let(:action_return_value) { false }
 
-      it 'adds supplied keys to the allowed_params array' do
-        expect { transition.allow_params :foo, :bar }.to change(transition.allowed_params, :count).by(2)
+        it 'returns false' do
+          expect(transition.call).to be false
+        end
       end
-    end
 
-    describe '#conclude' do
-      let(:concluder) { double :concluder, new: concluder_instance }
-      let(:concluder_instance) { double :concluder_instance, call: nil, rollback: nil }
-      let(:object) { OpenStruct.new(state: :b) }
-      before do
-        allow(object).to receive_message_chain(:class, store_states_as_strings: false)
-        transition.concluders << concluder
-      end
+      context 'when a concluder returns false' do
+        let(:concluder1) { double :concluder, new: concluder1_instance }
+        let(:concluder1_instance) { double :concluder_instance, call: true, rollback: nil }
+        let(:concluder2) { double :concluder, new: concluder2_instance }
+        let(:concluder2_instance) { double :concluder_instance, call: false, rollback: nil }
+        let(:concluder3) { double :concluder, new: concluder3_instance }
+        let(:concluder3_instance) { double :concluder_instance, call: true, rollback: nil }
+        before do
+          configuration.concluders = [concluder1, concluder2, concluder3]
+          object.failure_messages << 'service failure'
+        end
 
-      context 'when all concluders succeed' do
-        before { allow(concluder_instance).to receive(:call).and_return(true) }
+        context 'soft mode' do
+          let(:mode) { :soft }
 
-        specify { expect(transition.conclude object, :a).to be true }
-      end
+          it 'returns false and rolls back the completed concluders and the action' do
+            expect(concluder3_instance).to_not receive(:rollback)
+            expect(concluder2_instance).to receive(:rollback).ordered
+            expect(concluder1_instance).to receive(:rollback).ordered
+            expect(action_instance).to receive(:rollback).ordered
+
+            expect(transition.call).to be false
+          end
+        end
 
-      context 'when not all concluders succeed' do
-        before { allow(concluder_instance).to receive(:call).and_return(false) }
+        context 'hard mode' do
+          let(:mode) { :hard }
 
-        specify { expect(transition.conclude object, :a).to be false }
+          it 'raises ConcluderFailed and rolls back the completed concluders and the action' do
+            expect(concluder3_instance).to_not receive(:rollback)
+            expect(concluder2_instance).to receive(:rollback).ordered
+            expect(concluder1_instance).to receive(:rollback).ordered
+            expect(action_instance).to receive(:rollback).ordered
 
-        it 'rolls them back' do
-          transition.conclude object, :a
-          expect(concluder_instance).to have_received(:rollback)
+            expect{transition.call}.to raise_error(ConcluderFailed, 'The transition to b was rolled back: service failure')
+          end
         end
       end
 
-      context 'when params are provided' do
-        it 'creates a concluder with the params' do
-          transition.conclude object, :b, { foo: 'bar' }
-          expect(concluder).to have_received(:new).twice.with(object, :a, { foo: 'bar'} )
+      context 'when guards, action, and concluders return true' do
+        it 'returns true' do
+          expect(transition.call).to be true
         end
       end
     end

data/spec/end_state_matchers_spec.rb

@@ -0,0 +1,105 @@
+require "spec_helper"
+
+module EndState
+  class TestGuard1 < EndState::Guard; end
+  class TestGuard2 < EndState::Guard; end
+  class TestGuard3 < EndState::Guard; end
+
+  class TestConcluder1 < EndState::Concluder; end
+  class TestConcluder2 < EndState::Concluder; end
+  class TestConcluder3 < EndState::Concluder; end
+
+  class TestMachine < EndState::StateMachine
+    transition a: :b, as: :go do |t|
+      t.guard TestGuard1, TestGuard2
+      t.concluder TestConcluder1, TestConcluder2
+      t.require_params :a, :b
+    end
+  end
+
+  describe 'matchers' do
+    describe 'have_transition' do
+      it 'passes when the transition is present' do
+        expect(TestMachine).to have_transition(a: :b)
+      end
+
+      it 'fails when the guard is not present' do
+        expect {
+          expect(TestMachine).to have_transition(b: :c)
+        }.to fail_with('expected transition b => c to be defined')
+      end
+
+      describe 'with_event' do
+        it 'passes when the guard is present' do
+          expect(TestMachine).to have_transition(a: :b).with_event(:go)
+        end
+
+        it 'fails when the guard is not present' do
+          expect {
+            expect(TestMachine).to have_transition(a: :b).with_event(:reset)
+          }.to fail_with('expected transition a => b to have event name: reset')
+        end
+      end
+
+      describe 'with_guard' do
+        it 'passes when the guard is present' do
+          expect(TestMachine).to have_transition(a: :b).with_guard(TestGuard1)
+        end
+
+        it 'fails when the guard is not present' do
+          expect {
+            expect(TestMachine).to have_transition(a: :b).with_guard(TestGuard3)
+          }.to fail_with('expected transition a => b to have guard EndState::TestGuard3')
+        end
+      end
+
+      describe 'with_guards' do
+        it 'passes when the guards are present' do
+          expect(TestMachine).to have_transition(a: :b).with_guards(TestGuard1, TestGuard2)
+        end
+
+        it 'fails when the guards are not present' do
+          expect {
+            expect(TestMachine).to have_transition(a: :b).with_guards(TestGuard2, TestGuard3)
+          }.to fail_with('expected transition a => b to have guard EndState::TestGuard3')
+        end
+      end
+
+      describe 'with_concluder' do
+        it 'passes when the concluder is present' do
+          expect(TestMachine).to have_transition(a: :b).with_concluder(TestConcluder1)
+        end
+
+        it 'fails when the concluder is not present' do
+          expect {
+            expect(TestMachine).to have_transition(a: :b).with_concluder(TestConcluder3)
+          }.to fail_with('expected transition a => b to have concluder EndState::TestConcluder3')
+        end
+      end
+
+      describe 'with_concluders' do
+        it 'passes when the concluders are present' do
+          expect(TestMachine).to have_transition(a: :b).with_concluders(TestConcluder1, TestConcluder2)
+        end
+
+        it 'fails when the concluders are not present' do
+          expect {
+            expect(TestMachine).to have_transition(a: :b).with_concluders(TestConcluder2, TestConcluder3)
+          }.to fail_with('expected transition a => b to have concluder EndState::TestConcluder3')
+        end
+      end
+
+      describe 'with_required_params' do
+        it 'passes when the required_params match' do
+          expect(TestMachine).to have_transition(a: :b).with_required_params(:a, :b)
+        end
+
+        it 'fails when the required_params do not match' do
+          expect {
+            expect(TestMachine).to have_transition(a: :b).with_required_params(:b, :c)
+          }.to fail_with('expected transition a => b to have required param c')
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,2 +1,19 @@
+if ENV['TRAVIS']
+  require 'coveralls'
+  Coveralls.wear!
+else
+  require 'simplecov'
+  SimpleCov.start
+end
+
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'end_state'
+require 'end_state_matchers'
+
+module RSpec
+  module Matchers
+    def fail_with(message)
+      raise_error(RSpec::Expectations::ExpectationNotMetError, message)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: end_state
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 1.0.0
 platform: ruby
 authors:
 - alexpeachey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-05 00:00:00.000000000 Z
+date: 2016-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A modular state machine with single responsibilities.
 email:
 - alex.peachey@gmail.com
@@ -94,20 +108,26 @@ files:
 - lib/end_state/graph.rb
 - lib/end_state/guard.rb
 - lib/end_state/messages.rb
+- lib/end_state/no_graph.rb
 - lib/end_state/state_machine.rb
-- lib/end_state/state_mapping.rb
+- lib/end_state/state_machine_configuration.rb
 - lib/end_state/transition.rb
+- lib/end_state/transition_configuration.rb
+- lib/end_state/transition_configuration_set.rb
 - lib/end_state/version.rb
 - lib/end_state_matchers.rb
 - lib/tasks/end_state.rake
 - spec/end_state/action_spec.rb
 - spec/end_state/concluder_spec.rb
 - spec/end_state/concluders/persistence_spec.rb
+- spec/end_state/graph_spec.rb
 - spec/end_state/guard_spec.rb
+- spec/end_state/state_machine_configuration_spec.rb
 - spec/end_state/state_machine_spec.rb
-- spec/end_state/state_mapping_spec.rb
+- spec/end_state/transition_configuration_set_spec.rb
+- spec/end_state/transition_configuration_spec.rb
 - spec/end_state/transition_spec.rb
-- spec/end_state_spec.rb
+- spec/end_state_matchers_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/Originate/end_state
 licenses:
@@ -129,7 +149,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: A State Machine implementation
@@ -137,9 +157,12 @@ test_files:
 - spec/end_state/action_spec.rb
 - spec/end_state/concluder_spec.rb
 - spec/end_state/concluders/persistence_spec.rb
+- spec/end_state/graph_spec.rb
 - spec/end_state/guard_spec.rb
+- spec/end_state/state_machine_configuration_spec.rb
 - spec/end_state/state_machine_spec.rb
-- spec/end_state/state_mapping_spec.rb
+- spec/end_state/transition_configuration_set_spec.rb
+- spec/end_state/transition_configuration_spec.rb
 - spec/end_state/transition_spec.rb
-- spec/end_state_spec.rb
+- spec/end_state_matchers_spec.rb
 - spec/spec_helper.rb

data/lib/end_state/state_mapping.rb

@@ -1,25 +0,0 @@
-module EndState
-  class StateMapping < Hash
-    def start_state
-      keys.first
-    end
-
-    def end_state
-      values.first
-    end
-
-    def any_start_state?
-      start_state == :any_state
-    end
-
-    def matches_start_state?(state)
-      start_state == state || any_start_state?
-    end
-
-    def conflicts?(state_mapping)
-      start_state == state_mapping.start_state ||
-      any_start_state? ||
-      state_mapping.any_start_state?
-    end
-  end
-end

data/spec/end_state/state_mapping_spec.rb

@@ -1,94 +0,0 @@
-require 'spec_helper'
-require 'ostruct'
-
-module EndState
-  describe StateMapping do
-    describe 'simple example' do
-      let(:subject) { StateMapping[a: :b] }
-
-      context '#start_state' do
-        it 'returns the first key' do
-          expect(subject.start_state).to eq :a
-        end
-      end
-
-      context '#end_state' do
-        it 'returns the first value' do
-          expect(subject.end_state).to eq :b
-        end
-      end
-
-      context '#any_start_state?' do
-        context 'start_state is :any_state' do
-          let(:subject) { StateMapping[any_state: :b] }
-          it 'returns true' do
-            expect(subject.any_start_state?).to eq true
-          end
-        end
-
-        context 'start_state is anything else' do
-          it 'returns false' do
-            expect(subject.any_start_state?).to eq false
-          end
-        end
-      end
-
-      context '#matches_start_state?' do
-        context 'same start_state' do
-          it 'returns true' do
-            expect(subject.matches_start_state?(:a)).to eq true
-          end
-        end
-
-        context 'different start_state' do
-          it 'returns false' do
-            expect(subject.matches_start_state?(:b)).to eq false
-          end
-        end
-
-        context 'object has a start_state of :any_state' do
-          let(:subject) { StateMapping[any_state: :c] }
-
-          it 'returns true' do
-            expect(subject.matches_start_state?(:b)).to eq true
-          end
-        end
-      end
-
-      context '#conflicts?' do
-        context 'same start_state' do
-          let(:other) { StateMapping[a: :c] }
-
-          it 'returns true' do
-            expect(subject.conflicts?(other)).to eq true
-          end
-        end
-
-        context 'different start_state' do
-          let(:other) { StateMapping[c: :d] }
-
-          it 'returns false' do
-            expect(subject.conflicts?(other)).to eq false
-          end
-        end
-
-        context 'argument has a start_state of :any_state' do
-          let(:other) { StateMapping[any_state: :c] }
-
-          it 'returns true' do
-            expect(subject.conflicts?(other)).to eq true
-          end
-        end
-
-        context 'object has a start_state of :any_state' do
-          let(:subject) { StateMapping[any_state: :c] }
-          let(:other) { StateMapping[a: :c] }
-
-          it 'returns true' do
-            expect(subject.conflicts?(other)).to eq true
-          end
-        end
-      end
-    end
-  end
-end

data/spec/end_state_spec.rb

@@ -1,4 +0,0 @@
-require 'spec_helper'
-
-describe EndState do
-end