statesman 0.7.0 → 0.8.0

data/spec/statesman/adapters/active_record_transition_spec.rb

@@ -2,11 +2,11 @@ require "spec_helper"
 require "json"
 
 describe Statesman::Adapters::ActiveRecordTransition do
-  let(:transition_class) { Class.new }
+  let(:transition_class) { Class.new { def self.serialize(*_args); end } }
 
   describe "including behaviour" do
     it "calls Class.serialize" do
-      transition_class.should_receive(:serialize).with(:metadata, JSON).once
+      expect(transition_class).to receive(:serialize).with(:metadata, JSON).once
       transition_class.send(:include, described_class)
     end
   end

data/spec/statesman/adapters/mongoid_spec.rb

@@ -11,7 +11,7 @@ describe Statesman::Adapters::Mongoid, mongo: true do
   end
   let(:observer) do
     result = double(Statesman::Machine)
-    result.stub(:execute)
+    allow(result).to receive(:execute)
     result
   end
   let(:model) { MyMongoidModel.create(current_state: :pending) }
@@ -20,7 +20,8 @@ describe Statesman::Adapters::Mongoid, mongo: true do
   describe "#initialize" do
     context "with unserialized metadata" do
       before do
-        described_class.any_instance.stub(transition_class_hash_fields: [])
+        allow_any_instance_of(described_class)
+          .to receive_messages(transition_class_hash_fields: [])
       end
 
       it "raises an exception if metadata is not serialized" do
@@ -44,8 +45,8 @@ describe Statesman::Adapters::Mongoid, mongo: true do
       end
 
       it "caches the transition" do
-        MyMongoidModel.any_instance
-          .should_receive(:my_mongoid_model_transitions).never
+        expect_any_instance_of(MyMongoidModel)
+          .to receive(:my_mongoid_model_transitions).never
         adapter.last
       end
 

data/spec/statesman/adapters/shared_examples.rb

@@ -14,16 +14,16 @@ require "spec_helper"
 shared_examples_for "an adapter" do |adapter_class, transition_class|
   let(:observer) do
     result = double(Statesman::Machine)
-    result.stub(:execute)
+    allow(result).to receive(:execute)
     result
   end
   let(:adapter) { adapter_class.new(transition_class, model, observer) }
 
   describe "#initialize" do
     subject { adapter }
-    its(:transition_class) { should be(transition_class) }
-    its(:parent_model) { should be(model) }
-    its(:history) { should eq([]) }
+    its(:transition_class) { is_expected.to be(transition_class) }
+    its(:parent_model) { is_expected.to be(model) }
+    its(:history) { is_expected.to eq([]) }
   end
 
   describe "#create" do
@@ -33,32 +33,32 @@ shared_examples_for "an adapter" do |adapter_class, transition_class|
     let(:create) { adapter.create(from, to) }
     subject { -> { create } }
 
-    it { should change(adapter.history, :count).by(1) }
+    it { is_expected.to change(adapter.history, :count).by(1) }
 
     context "the new transition" do
       subject { create }
-      it { should be_a(transition_class) }
+      it { is_expected.to be_a(transition_class) }
 
       it "should have the initial state" do
         expect(subject.to_state.to_sym).to eq(to)
       end
 
       context "with no previous transition" do
-        its(:sort_key) { should be(0) }
+        its(:sort_key) { is_expected.to be(0) }
       end
 
       context "with a previous transition" do
         before { adapter.create(from, to) }
-        its(:sort_key) { should be(10) }
+        its(:sort_key) { is_expected.to be(10) }
       end
     end
 
     context "with before callbacks" do
       it "is called before the state transition" do
-        observer.should_receive(:execute).with do
-            |phase, from_state, to_state, transition|
-          expect(adapter.history.length).to eq(0) if phase == :before
-        end.once
+        expect(observer).to receive(:execute)
+          .with(:before, anything, anything, anything) {
+            expect(adapter.history.length).to eq(0)
+          }.once
         adapter.create(from, to)
         expect(adapter.history.length).to eq(1)
       end
@@ -66,20 +66,22 @@ shared_examples_for "an adapter" do |adapter_class, transition_class|
 
     context "with after callbacks" do
       it "is called after the state transition" do
-        observer.should_receive(:execute).with do
-            |phase, from_state, to_state, transition|
-          expect(adapter.last).to eq(transition) if phase == :after
-        end.once
+        expect(observer).to receive(:execute)
+          .with(:after, anything, anything, anything) {
+            |_phase, _from_state, _to_state, transition|
+            expect(adapter.last).to eq(transition)
+          }.once
         adapter.create(from, to)
       end
 
       it "exposes the new transition for subsequent transitions" do
         adapter.create(from, to)
 
-        observer.should_receive(:execute).with do
-            |phase, from_state, to_state, transition|
-          expect(adapter.last).to eq(transition) if phase == :after
-        end.once
+        expect(observer).to receive(:execute)
+          .with(:after, anything, anything, anything) {
+            |_phase, _from_state, _to_state, transition|
+            expect(adapter.last).to eq(transition)
+          }.once
         adapter.create(to, there)
       end
     end
@@ -87,22 +89,22 @@ shared_examples_for "an adapter" do |adapter_class, transition_class|
     context "with metadata" do
       let(:metadata) { { "some" => "hash" } }
       subject { adapter.create(from, to, metadata) }
-      its(:metadata) { should eq(metadata) }
+      its(:metadata) { is_expected.to eq(metadata) }
     end
   end
 
   describe "#history" do
     subject { adapter.history }
-    it { should eq([]) }
+    it { is_expected.to eq([]) }
 
     context "with transitions" do
       let!(:transition) { adapter.create(:x, :y) }
-      it { should eq([transition]) }
+      it { is_expected.to eq([transition]) }
 
       context "sorting" do
         let!(:transition2) { adapter.create(:x, :y) }
         subject { adapter.history }
-        it { should eq(adapter.history.sort_by(&:sort_key)) }
+        it { is_expected.to eq(adapter.history.sort_by(&:sort_key)) }
       end
     end
   end
@@ -114,7 +116,7 @@ shared_examples_for "an adapter" do |adapter_class, transition_class|
     end
     subject { adapter.last }
 
-    it { should be_a(transition_class) }
+    it { is_expected.to be_a(transition_class) }
     specify { expect(adapter.last.to_state.to_sym).to eq(:z) }
   end
 end

data/spec/statesman/callback_spec.rb

@@ -37,12 +37,12 @@ describe Statesman::Callback do
 
       context "and an allowed to value" do
         let(:to) { :y }
-        it { should be_true }
+        it { is_expected.to be_truthy }
       end
 
       context "and a disallowed to value" do
         let(:to) { :a }
-        it { should be_false }
+        it { is_expected.to be_falsey }
       end
     end
 
@@ -51,12 +51,12 @@ describe Statesman::Callback do
 
       context "and an allowed 'from' value" do
         let(:from) { :x }
-        it { should be_true }
+        it { is_expected.to be_truthy }
       end
 
       context "and a disallowed 'from' value" do
         let(:from) { :a }
-        it { should be_false }
+        it { is_expected.to be_falsey }
       end
     end
 
@@ -67,7 +67,7 @@ describe Statesman::Callback do
       let(:from) { :x }
       let(:to) { :y }
 
-      it { should be_true }
+      it { is_expected.to be_truthy }
     end
 
     context "with any from value on the callback" do
@@ -78,12 +78,12 @@ describe Statesman::Callback do
 
       context "and an allowed to value" do
         let(:to) { :y }
-        it { should be_true }
+        it { is_expected.to be_truthy }
       end
 
       context "and a disallowed to value" do
         let(:to) { :a }
-        it { should be_false }
+        it { is_expected.to be_falsey }
       end
     end
 
@@ -95,25 +95,25 @@ describe Statesman::Callback do
 
       context "and an allowed to value" do
         let(:from) { :x }
-        it { should be_true }
+        it { is_expected.to be_truthy }
       end
 
       context "and a disallowed to value" do
         let(:from) { :a }
-        it { should be_false }
+        it { is_expected.to be_falsey }
       end
     end
 
     context "with allowed 'from' and 'to' values" do
       let(:from) { :x }
       let(:to) { :y }
-      it { should be_true }
+      it { is_expected.to be_truthy }
     end
 
     context "with disallowed 'from' and 'to' values" do
       let(:from) { :a }
       let(:to) { :b }
-      it { should be_false }
+      it { is_expected.to be_falsey }
     end
   end
 end

data/spec/statesman/config_spec.rb

@@ -12,7 +12,7 @@ describe Statesman::Config do
     let(:adapter) { Class.new }
     before  { instance.storage_adapter(adapter) }
     subject { instance.adapter_class }
-    it { should be(adapter) }
+    it { is_expected.to be(adapter) }
 
     it "is DSL configurable" do
       new_adapter = adapter

data/spec/statesman/machine_spec.rb

@@ -23,6 +23,80 @@ describe Statesman::Machine do
     end
   end
 
+  describe ".retry_conflicts" do
+    before do
+      machine.class_eval do
+        state :x, initial: true
+        state :y
+        state :z
+        transition from: :x, to: :y
+        transition from: :y, to: :z
+      end
+    end
+    let(:instance) { machine.new(my_model) }
+    let(:retry_attempts) { 2 }
+
+    subject(:transition_state) do
+      Statesman::Machine.retry_conflicts(retry_attempts) do
+        instance.transition_to(:y)
+      end
+    end
+
+    context "when no exception occurs" do
+      it "runs the transition once" do
+        expect(instance).to receive(:transition_to).once
+        transition_state
+      end
+    end
+
+    context "when an irrelevant exception occurs" do
+      it "runs the transition once" do
+        expect(instance)
+          .to receive(:transition_to).once
+          .and_raise(StandardError)
+        transition_state rescue nil # rubocop:disable RescueModifier
+      end
+
+      it "re-raises the exception" do
+        allow(instance).to receive(:transition_to).once
+          .and_raise(StandardError)
+        expect { transition_state }.to raise_error(StandardError)
+      end
+    end
+
+    context "when a TransitionConflictError occurs" do
+      context "and is resolved on the second attempt" do
+        it "runs the transition twice" do
+          expect(instance)
+            .to receive(:transition_to).once
+            .and_raise(Statesman::TransitionConflictError)
+            .ordered
+          expect(instance)
+            .to receive(:transition_to).once.ordered.and_call_original
+          transition_state
+        end
+      end
+
+      context "and keeps occurring" do
+        it "runs the transition `retry_attempts + 1` times" do
+          expect(instance)
+            .to receive(:transition_to)
+            .exactly(retry_attempts + 1).times
+            .and_raise(Statesman::TransitionConflictError)
+          transition_state rescue nil # rubocop:disable RescueModifier
+        end
+
+        it "re-raises the conflict" do
+          allow(instance)
+            .to receive(:transition_to)
+            .and_raise(Statesman::TransitionConflictError)
+          expect { transition_state }
+            .to raise_error(Statesman::TransitionConflictError)
+        end
+      end
+    end
+  end
+
   describe ".transition" do
     before do
       machine.class_eval do
@@ -192,21 +266,21 @@ describe Statesman::Machine do
 
     context "transition class" do
       it "sets a default" do
-        Statesman.storage_adapter.should_receive(:new).once
+        expect(Statesman.storage_adapter).to receive(:new).once
           .with(Statesman::Adapters::MemoryTransition, my_model, anything)
         machine.new(my_model)
       end
 
       it "sets the passed class" do
         my_transition_class = Class.new
-        Statesman.storage_adapter.should_receive(:new).once
+        expect(Statesman.storage_adapter).to receive(:new).once
           .with(my_transition_class, my_model, anything)
         machine.new(my_model, transition_class: my_transition_class)
       end
 
       it "falls back to Memory without transaction_class" do
-        Statesman.stub(:storage_adapter).and_return(Class.new)
-        Statesman::Adapters::Memory.should_receive(:new).once
+        allow(Statesman).to receive(:storage_adapter).and_return(Class.new)
+        expect(Statesman::Adapters::Memory).to receive(:new).once
           .with(Statesman::Adapters::MemoryTransition, my_model, anything)
         machine.new(my_model)
       end
@@ -238,7 +312,7 @@ describe Statesman::Machine do
     subject { instance.current_state }
 
     context "with no transitions" do
-      it { should eq(machine.initial_state) }
+      it { is_expected.to eq(machine.initial_state) }
     end
 
     context "with multiple transitions" do
@@ -247,7 +321,7 @@ describe Statesman::Machine do
         instance.transition_to!(:z)
       end
 
-      it { should eq("z") }
+      it { is_expected.to eq("z") }
     end
   end
 
@@ -266,7 +340,7 @@ describe Statesman::Machine do
     subject { instance.allowed_transitions }
 
     context "with multiple possible states" do
-      it { should eq(%w(y z)) }
+      it { is_expected.to eq(%w(y z)) }
     end
 
     context "with one possible state" do
@@ -274,7 +348,7 @@ describe Statesman::Machine do
         instance.transition_to!(:y)
       end
 
-      it { should eq(['z']) }
+      it { is_expected.to eq(['z']) }
     end
 
     context "with no possible transitions" do
@@ -282,7 +356,7 @@ describe Statesman::Machine do
         instance.transition_to!(:z)
       end
 
-      it { should eq([]) }
+      it { is_expected.to eq([]) }
     end
   end
 
@@ -291,7 +365,7 @@ describe Statesman::Machine do
     let(:last_action) { "Whatever" }
 
     it "delegates to the storage adapter" do
-      Statesman.storage_adapter.any_instance.should_receive(:last).once
+      expect_any_instance_of(Statesman.storage_adapter).to receive(:last).once
         .and_return(last_action)
       expect(instance.last_transition).to be(last_action)
     end
@@ -314,13 +388,13 @@ describe Statesman::Machine do
     context "when the transition is invalid" do
       context "with an initial to state" do
         let(:new_state) { :x }
-        it { should be_false }
+        it { is_expected.to be_falsey }
       end
 
       context "with a terminal from state" do
         before { instance.transition_to!(:y) }
         let(:new_state) { :y }
-        it { should be_false }
+        it { is_expected.to be_falsey }
       end
 
       context "and is guarded" do
@@ -329,19 +403,19 @@ describe Statesman::Machine do
         before { machine.guard_transition(to: new_state, &guard_cb) }
 
         it "does not fire guard" do
-          guard_cb.should_not_receive(:call)
-          should be_false
+          expect(guard_cb).not_to receive(:call)
+          is_expected.to be_falsey
         end
       end
     end
 
     context "when the transition valid" do
       let(:new_state) { :y }
-      it { should be_true }
+      it { is_expected.to be_truthy }
 
       context "but it has a failing guard" do
         before { machine.guard_transition(to: :y) { false } }
-        it { should be_false }
+        it { is_expected.to be_falsey }
       end
     end
   end
@@ -390,19 +464,19 @@ describe Statesman::Machine do
       end
 
       it "returns true" do
-        expect(instance.transition_to!(:y)).to be_true
+        expect(instance.transition_to!(:y)).to be_truthy
       end
 
       context "with a guard" do
         let(:result) { true }
-        let(:guard_cb) { ->(*args) { result } }
+        let(:guard_cb) { ->(*_args) { result } }
         before { machine.guard_transition(from: :x, to: :y, &guard_cb) }
 
         context "and an object to act on" do
           let(:instance) { machine.new(my_model) }
 
           it "passes the object to the guard" do
-            guard_cb.should_receive(:call).once
+            expect(guard_cb).to receive(:call).once
               .with(my_model, instance.last_transition, nil).and_return(true)
             instance.transition_to!(:y)
           end
@@ -435,23 +509,24 @@ describe Statesman::Machine do
 
     context "when it is succesful" do
       before do
-        instance.should_receive(:transition_to!).once
+        expect(instance).to receive(:transition_to!).once
           .with(:some_state, metadata).and_return(:some_state)
       end
-      it { should be(:some_state) }
+      it { is_expected.to be(:some_state) }
     end
 
     context "when it is unsuccesful" do
       before do
-        instance.stub(:transition_to!).and_raise(Statesman::GuardFailedError)
+        allow(instance).to receive(:transition_to!)
+          .and_raise(Statesman::GuardFailedError)
       end
-      it { should be_false }
+      it { is_expected.to be_falsey }
     end
 
     context "when a non statesman exception is raised" do
       before do
-        instance.stub(:transition_to!).and_raise(RuntimeError,
-                                                 'user defined exception')
+        allow(instance).to receive(:transition_to!)
+          .and_raise(RuntimeError, 'user defined exception')
       end
 
       it "should not rescue the exception" do
@@ -514,4 +589,126 @@ describe Statesman::Machine do
     it_behaves_like "a callback filter", :after_transition,
                     :after
   end
+
+  describe "#event" do
+    before do
+      machine.class_eval do
+        state :x, initial: true
+        state :y
+        state :z
+
+        event :event_1 do
+          transition from: :x, to: :y
+        end
+
+        event :event_2 do
+          transition from: :y, to: :z
+        end
+      end
+    end
+
+    let(:instance) { machine.new(my_model) }
+
+    context "when the state cannot be transitioned to" do
+      it "raises an error" do
+        expect do
+          instance.trigger!(:event_2)
+        end.to raise_error(Statesman::TransitionFailedError)
+      end
+    end
+
+    context "when the state can be transitioned to" do
+      it "changes state" do
+        instance.trigger!(:event_1)
+        expect(instance.current_state).to eq("y")
+      end
+
+      it "creates a new transition object" do
+        expect do
+          instance.trigger!(:event_1)
+        end.to change(instance.history, :count).by(1)
+
+        expect(instance.history.first)
+          .to be_a(Statesman::Adapters::MemoryTransition)
+        expect(instance.history.first.to_state).to eq("y")
+      end
+
+      it "sends metadata to the transition object" do
+        meta = { "my" => "hash" }
+        instance.trigger!(:event_1, meta)
+        expect(instance.history.first.metadata).to eq(meta)
+      end
+
+      it "returns true" do
+        expect(instance.trigger!(:event_1)).to eq(true)
+      end
+
+      context "with a guard" do
+        let(:result) { true }
+        # rubocop:disable UnusedBlockArgument
+        let(:guard_cb) { ->(*args) { result } }
+        # rubocop:enable UnusedBlockArgument
+        before { machine.guard_transition(from: :x, to: :y, &guard_cb) }
+
+        context "and an object to act on" do
+          let(:instance) { machine.new(my_model) }
+
+          it "passes the object to the guard" do
+            expect(guard_cb).to receive(:call).once
+              .with(my_model, instance.last_transition, nil).and_return(true)
+            instance.trigger!(:event_1)
+          end
+        end
+
+        context "which passes" do
+          it "changes state" do
+            instance.trigger!(:event_1)
+            expect(instance.current_state).to eq("y")
+          end
+        end
+
+        context "which fails" do
+          let(:result) { false }
+
+          it "raises an exception" do
+            expect do
+              instance.trigger!(:event_1)
+            end.to raise_error(Statesman::GuardFailedError)
+          end
+        end
+      end
+    end
+
+  end
+
+  describe "#available_events" do
+    before do
+      machine.class_eval do
+        state :x, initial: true
+        state :y
+        state :z
+
+        event :event_1 do
+          transition from: :x, to: :y
+        end
+
+        event :event_2 do
+          transition from: :y, to: :z
+        end
+
+        event :event_3 do
+          transition from: :x, to: :y
+          transition from: :y, to: :x
+        end
+      end
+    end
+
+    let(:instance) { machine.new(my_model) }
+    it "should return list of available events for the current state" do
+      expect(instance.available_events).to eq([:event_1, :event_3])
+      instance.trigger!(:event_1)
+      expect(instance.available_events).to eq([:event_2, :event_3])
+    end
+  end
+
 end