statesman 1.1.0 → 1.2.0

data/spec/statesman/adapters/active_record_spec.rb

@@ -2,18 +2,14 @@ require "spec_helper"
 require "statesman/adapters/shared_examples"
 require "statesman/exceptions"
 
-describe Statesman::Adapters::ActiveRecord do
+describe Statesman::Adapters::ActiveRecord, active_record: true do
   before do
     prepare_model_table
     prepare_transitions_table
   end
 
   before { MyActiveRecordModelTransition.serialize(:metadata, JSON) }
-  let(:observer) do
-    result = double(Statesman::Machine)
-    allow(result).to receive(:execute)
-    result
-  end
+  let(:observer) { double(Statesman::Machine, execute: nil) }
   let(:model) { MyActiveRecordModel.create(current_state: :pending) }
   it_behaves_like "an adapter", described_class, MyActiveRecordModelTransition
 
@@ -24,11 +20,12 @@ describe Statesman::Adapters::ActiveRecord do
         allow(metadata_column).to receive_messages(sql_type: '')
         allow(MyActiveRecordModelTransition).to receive_messages(columns_hash:
                                            { 'metadata' => metadata_column })
-        if ::ActiveRecord.gem_version >= Gem::Version.new('4.2.0.a')
+        if ::ActiveRecord.respond_to?(:gem_version) &&
+           ::ActiveRecord.gem_version >= Gem::Version.new('4.2.0.a')
           allow(metadata_column).to receive_messages(cast_type: '')
         else
-          allow(MyActiveRecordModelTransition)
-            .to receive_messages(serialized_attributes: {})
+          allow(MyActiveRecordModelTransition).
+            to receive_messages(serialized_attributes: {})
         end
       end
 
@@ -46,16 +43,17 @@ describe Statesman::Adapters::ActiveRecord do
         allow(metadata_column).to receive_messages(sql_type: 'json')
         allow(MyActiveRecordModelTransition).to receive_messages(columns_hash:
                                            { 'metadata' => metadata_column })
-        if ::ActiveRecord.gem_version >= Gem::Version.new('4.2.0.a')
+        if ::ActiveRecord.respond_to?(:gem_version) &&
+           ::ActiveRecord.gem_version >= Gem::Version.new('4.2.0.a')
           serialized_type = ::ActiveRecord::Type::Serialized.new(
             '', ::ActiveRecord::Coders::JSON
           )
-          expect(metadata_column)
-            .to receive(:cast_type)
-            .and_return(serialized_type)
+          expect(metadata_column).
+            to receive(:cast_type).
+            and_return(serialized_type)
         else
-          expect(MyActiveRecordModelTransition)
-            .to receive_messages(serialized_attributes: { 'metadata' => '' })
+          expect(MyActiveRecordModelTransition).
+            to receive_messages(serialized_attributes: { 'metadata' => '' })
         end
       end
 
@@ -83,15 +81,15 @@ describe Statesman::Adapters::ActiveRecord do
         adapter2.create(:x, :y)
         adapter.last
         adapter2.create(:y, :z)
-        expect { adapter.create(:y, :z) }
-          .to raise_exception(Statesman::TransitionConflictError)
+        expect { adapter.create(:y, :z) }.
+          to raise_exception(Statesman::TransitionConflictError)
       end
     end
 
     context "when other exceptions occur" do
       before do
-        allow_any_instance_of(MyActiveRecordModelTransition)
-          .to receive(:save!).and_raise(error)
+        allow_any_instance_of(MyActiveRecordModelTransition).
+          to receive(:save!).and_raise(error)
       end
 
       context "ActiveRecord::RecordNotUnique unrelated to this transition" do
@@ -104,6 +102,44 @@ describe Statesman::Adapters::ActiveRecord do
         it { is_expected.to raise_exception(StandardError) }
       end
     end
+
+    context "when the transition_class has a most_recent column" do
+      subject { create }
+
+      context "with no previous transition" do
+        its(:most_recent) { is_expected.to eq(true) }
+      end
+
+      context "with a previous transition" do
+        let!(:previous_transition) { adapter.create(from, to) }
+        its(:most_recent) { is_expected.to eq(true) }
+
+        it "updates the previous transition's most_recent flag" do
+          expect { create }.
+            to change { previous_transition.reload.most_recent }.
+            from(true).to(false)
+        end
+
+        context "and the parent model is updated in a callback" do
+          before do
+            allow(observer).to receive(:execute) do |phase|
+              if phase == :before
+                model.update_attributes!(current_state: :ready)
+              end
+            end
+          end
+
+          it "doesn't save the transition too early" do
+            expect { create }.to_not raise_exception
+          end
+        end
+      end
+    end
+
+    context "when the transition_class doesn't have a most_recent column" do
+      before { drop_most_recent_column }
+      it { is_expected.to_not raise_exception }
+    end
   end
 
   describe "#last" do
@@ -111,18 +147,14 @@ describe Statesman::Adapters::ActiveRecord do
       described_class.new(MyActiveRecordModelTransition, model, observer)
     end
 
-    before do
-      adapter.create(:x, :y)
-    end
+    before { adapter.create(:x, :y) }
 
     context "with a previously looked up transition" do
-      before do
-        adapter.last
-      end
+      before { adapter.last }
 
       it "caches the transition" do
-        expect_any_instance_of(MyActiveRecordModel)
-          .to receive(:my_active_record_model_transitions).never
+        expect_any_instance_of(MyActiveRecordModel).
+          to receive(:my_active_record_model_transitions).never
         adapter.last
       end
 
@@ -135,10 +167,8 @@ describe Statesman::Adapters::ActiveRecord do
     end
 
     context "with a pre-fetched transition history" do
-      before do
-        adapter.create(:x, :y)
-        model.my_active_record_model_transitions.load_target
-      end
+      before { adapter.create(:x, :y) }
+      before { model.my_active_record_model_transitions.load_target }
 
       it "doesn't query the database" do
         expect(MyActiveRecordModelTransition).not_to receive(:connection)

data/spec/statesman/adapters/mongoid_spec.rb

@@ -5,23 +5,16 @@ require "support/mongoid"
 require "mongoid"
 
 describe Statesman::Adapters::Mongoid, mongo: true do
-
-  after do
-    Mongoid.purge!
-  end
-  let(:observer) do
-    result = double(Statesman::Machine)
-    allow(result).to receive(:execute)
-    result
-  end
+  after { Mongoid.purge! }
+  let(:observer) { double(Statesman::Machine, execute: nil) }
   let(:model) { MyMongoidModel.create(current_state: :pending) }
   it_behaves_like "an adapter", described_class, MyMongoidModelTransition
 
   describe "#initialize" do
     context "with unserialized metadata" do
       before do
-        allow_any_instance_of(described_class)
-          .to receive_messages(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
@@ -39,14 +32,12 @@ describe Statesman::Adapters::Mongoid, mongo: true do
     end
 
     context "with a previously looked up transition" do
-      before do
-        adapter.create(:x, :y)
-        adapter.last
-      end
+      before { adapter.create(:x, :y) }
+      before { adapter.last }
 
       it "caches the transition" do
-        expect_any_instance_of(MyMongoidModel)
-          .to 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

@@ -12,11 +12,7 @@ require "spec_helper"
 #   last:             Returns the latest transition history item
 #
 shared_examples_for "an adapter" do |adapter_class, transition_class|
-  let(:observer) do
-    result = double(Statesman::Machine)
-    allow(result).to receive(:execute)
-    result
-  end
+  let(:observer) { double(Statesman::Machine, execute: nil) }
   let(:adapter) { adapter_class.new(transition_class, model, observer) }
 
   describe "#initialize" do
@@ -55,8 +51,8 @@ shared_examples_for "an adapter" do |adapter_class, transition_class|
 
     context "with before callbacks" do
       it "is called before the state transition" do
-        expect(observer).to receive(:execute)
-          .with(:before, anything, anything, anything) {
+        expect(observer).to receive(:execute).
+          with(:before, anything, anything, anything) {
             expect(adapter.history.length).to eq(0)
           }.once
         adapter.create(from, to)
@@ -66,9 +62,8 @@ shared_examples_for "an adapter" do |adapter_class, transition_class|
 
     context "with after callbacks" do
       it "is called after the state transition" do
-        expect(observer).to receive(:execute)
-          .with(:after, anything, anything, anything) {
-            |_phase, _from_state, _to_state, transition|
+        expect(observer).to receive(:execute).
+          with(:after, anything, anything, anything) { |_, _, _, transition|
             expect(adapter.last).to eq(transition)
           }.once
         adapter.create(from, to)
@@ -77,9 +72,8 @@ shared_examples_for "an adapter" do |adapter_class, transition_class|
       it "exposes the new transition for subsequent transitions" do
         adapter.create(from, to)
 
-        expect(observer).to receive(:execute)
-          .with(:after, anything, anything, anything) {
-            |_phase, _from_state, _to_state, transition|
+        expect(observer).to receive(:execute).
+          with(:after, anything, anything, anything) { |_, _, _, transition|
             expect(adapter.last).to eq(transition)
           }.once
         adapter.create(to, there)
@@ -104,16 +98,15 @@ shared_examples_for "an adapter" do |adapter_class, transition_class|
       context "sorting" do
         let!(:transition2) { adapter.create(:x, :y) }
         subject { adapter.history }
+
         it { is_expected.to eq(adapter.history.sort_by(&:sort_key)) }
       end
     end
   end
 
   describe "#last" do
-    before do
-      adapter.create(:x, :y)
-      adapter.create(:y, :z)
-    end
+    before { adapter.create(:x, :y) }
+    before { adapter.create(:y, :z) }
     subject { adapter.last }
 
     it { is_expected.to be_a(transition_class) }

data/spec/statesman/callback_spec.rb

@@ -61,9 +61,7 @@ describe Statesman::Callback do
     end
 
     context "with any to and any from value on the callback" do
-      let(:callback) do
-        Statesman::Callback.new(callback: cb_lambda)
-      end
+      let(:callback) { Statesman::Callback.new(callback: cb_lambda) }
       let(:from) { :x }
       let(:to) { :y }
 
@@ -93,9 +91,7 @@ describe Statesman::Callback do
     end
 
     context "with any to value on the callback" do
-      let(:callback) do
-        Statesman::Callback.new(from: :x, callback: cb_lambda)
-      end
+      let(:callback) { Statesman::Callback.new(from: :x, callback: cb_lambda) }
       let(:to) { :y }
 
       context "and an allowed to value" do

data/spec/statesman/config_spec.rb

@@ -2,16 +2,13 @@ require "spec_helper"
 
 describe Statesman::Config do
   let(:instance) { Statesman::Config.new }
-
-  after do
-    # Don't leak global config changes into other specs
-    Statesman.configure { storage_adapter(Statesman::Adapters::Memory) }
-  end
+  after { Statesman.configure { storage_adapter(Statesman::Adapters::Memory) } }
 
   describe "#storage_adapter" do
     let(:adapter) { Class.new }
     before  { instance.storage_adapter(adapter) }
     subject { instance.adapter_class }
+
     it { is_expected.to be(adapter) }
 
     it "is DSL configurable" do

data/spec/statesman/guard_spec.rb

@@ -7,22 +7,16 @@ describe Statesman::Guard do
   specify { expect(guard).to be_a(Statesman::Callback) }
 
   describe "#call" do
-    subject { guard.call }
+    subject(:call) { guard.call }
 
     context "success" do
       let(:callback) { -> { true } }
-
-      it "does not raise an error" do
-        expect { guard.call }.to_not raise_error
-      end
+      specify { expect { call }.to_not raise_error }
     end
 
     context "error" do
       let(:callback) { -> { false } }
-
-      it "raises an error" do
-        expect { guard.call }.to raise_error(Statesman::GuardFailedError)
-      end
+      specify { expect { call }.to raise_error(Statesman::GuardFailedError) }
     end
   end
 end

data/spec/statesman/machine_spec.rb

@@ -15,9 +15,8 @@ describe Statesman::Machine do
 
       context "when an initial state is already defined" do
         it "raises an error" do
-          expect do
-            machine.state(:y, initial: true)
-          end.to raise_error(Statesman::InvalidStateError)
+          expect { machine.state(:y, initial: true) }.
+            to raise_error(Statesman::InvalidStateError)
         end
       end
     end
@@ -51,15 +50,15 @@ describe Statesman::Machine do
 
     context "when an irrelevant exception occurs" do
       it "runs the transition once" do
-        expect(instance)
-          .to receive(:transition_to).once
-          .and_raise(StandardError)
+        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)
+        allow(instance).to receive(:transition_to).once.
+          and_raise(StandardError)
         expect { transition_state }.to raise_error(StandardError)
       end
     end
@@ -67,31 +66,31 @@ describe Statesman::Machine do
     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
+          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)
+          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)
+          allow(instance).
+            to receive(:transition_to).
+            and_raise(Statesman::TransitionConflictError)
+          expect { transition_state }.
+            to raise_error(Statesman::TransitionConflictError)
         end
       end
     end
@@ -108,49 +107,43 @@ describe Statesman::Machine do
 
     context "given neither a 'from' nor a 'to' state" do
       it "raises an error" do
-        expect do
-          machine.transition
-        end.to raise_error(Statesman::InvalidStateError)
+        expect { machine.transition }.
+          to raise_error(Statesman::InvalidStateError)
       end
     end
 
     context "given no 'from' state and a valid 'to' state" do
       it "raises an error" do
-        expect do
-          machine.transition from: nil, to: :x
-        end.to raise_error(Statesman::InvalidStateError)
+        expect { machine.transition from: nil, to: :x }.
+          to raise_error(Statesman::InvalidStateError)
       end
     end
 
     context "given a valid 'from' state and a no 'to' state" do
       it "raises an error" do
-        expect do
-          machine.transition from: :x, to: nil
-        end.to raise_error(Statesman::InvalidStateError)
+        expect { machine.transition from: :x, to: nil }.
+          to raise_error(Statesman::InvalidStateError)
       end
     end
 
     context "given a valid 'from' state and an empty 'to' state array" do
       it "raises an error" do
-        expect do
-          machine.transition from: :x, to: []
-        end.to raise_error(Statesman::InvalidStateError)
+        expect { machine.transition from: :x, to: [] }.
+          to raise_error(Statesman::InvalidStateError)
       end
     end
 
     context "given an invalid 'from' state" do
       it "raises an error" do
-        expect do
-          machine.transition(from: :a, to: :x)
-        end.to raise_error(Statesman::InvalidStateError)
+        expect { machine.transition(from: :a, to: :x) }.
+          to raise_error(Statesman::InvalidStateError)
       end
     end
 
     context "given an invalid 'to' state" do
       it "raises an error" do
-        expect do
-          machine.transition(from: :x, to: :a)
-        end.to raise_error(Statesman::InvalidStateError)
+        expect { machine.transition(from: :x, to: :a) }.
+          to raise_error(Statesman::InvalidStateError)
       end
     end
 
@@ -176,25 +169,22 @@ describe Statesman::Machine do
 
     context "with a terminal 'from' state" do
       it "raises an exception" do
-        expect do
-          machine.validate_callback_condition(from: :z, to: :y)
-        end.to raise_error(Statesman::InvalidTransitionError)
+        expect { machine.validate_callback_condition(from: :z, to: :y) }.
+          to raise_error(Statesman::InvalidTransitionError)
       end
     end
 
     context "with an initial 'to' state" do
       it "raises an exception" do
-        expect do
-          machine.validate_callback_condition(from: :y, to: :x)
-        end.to raise_error(Statesman::InvalidTransitionError)
+        expect { machine.validate_callback_condition(from: :y, to: :x) }.
+          to raise_error(Statesman::InvalidTransitionError)
       end
     end
 
     context "with an invalid transition" do
       it "raises an exception" do
-        expect do
-          machine.validate_callback_condition(from: :x, to: :z)
-        end.to raise_error(Statesman::InvalidTransitionError)
+        expect { machine.validate_callback_condition(from: :x, to: :z) }.
+          to raise_error(Statesman::InvalidTransitionError)
       end
     end
 
@@ -206,9 +196,8 @@ describe Statesman::Machine do
 
     context "with a valid transition" do
       it "does not raise an exception" do
-        expect do
-          machine.validate_callback_condition(from: :x, to: :y)
-        end.to_not raise_error
+        expect { machine.validate_callback_condition(from: :x, to: :y) }.
+          to_not raise_error
       end
     end
   end
@@ -227,9 +216,7 @@ describe Statesman::Machine do
     let(:set_callback) { machine.send(assignment_method, options) {} }
 
     shared_examples "fails" do |error_type|
-      it "raises an exception" do
-        expect { set_callback }.to raise_error(error_type)
-      end
+      specify { expect { set_callback }.to raise_error(error_type) }
 
       it "does not add a callback" do
         expect do
@@ -243,13 +230,11 @@ describe Statesman::Machine do
     end
 
     shared_examples "adds callback" do
-      it "does not raise" do
-        expect { set_callback }.to_not raise_error
-      end
+      specify { expect { set_callback }.to_not raise_error }
 
       it "stores callbacks" do
-        expect { set_callback }.to change(
-          machine.callbacks[callback_store], :count).by(1)
+        expect { set_callback }.
+          to change(machine.callbacks[callback_store], :count).by(1)
       end
 
       it "stores callback instances" do
@@ -330,22 +315,22 @@ describe Statesman::Machine do
 
     context "transition class" do
       it "sets a default" do
-        expect(Statesman.storage_adapter).to receive(:new).once
-          .with(Statesman::Adapters::MemoryTransition, my_model, anything)
+        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
-        expect(Statesman.storage_adapter).to receive(:new).once
-          .with(my_transition_class, my_model, anything)
+        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
         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)
+        expect(Statesman::Adapters::Memory).to receive(:new).once.
+          with(Statesman::Adapters::MemoryTransition, my_model, anything)
         machine.new(my_model)
       end
     end
@@ -380,10 +365,8 @@ describe Statesman::Machine do
     end
 
     context "with multiple transitions" do
-      before do
-        instance.transition_to!(:y)
-        instance.transition_to!(:z)
-      end
+      before { instance.transition_to!(:y) }
+      before { instance.transition_to!(:z) }
 
       it { is_expected.to eq("z") }
     end
@@ -408,18 +391,12 @@ describe Statesman::Machine do
     end
 
     context "with one possible state" do
-      before do
-        instance.transition_to!(:y)
-      end
-
+      before { instance.transition_to!(:y) }
       it { is_expected.to eq(['z']) }
     end
 
     context "with no possible transitions" do
-      before do
-        instance.transition_to!(:z)
-      end
-
+      before { instance.transition_to!(:z) }
       it { is_expected.to eq([]) }
     end
   end
@@ -429,8 +406,8 @@ describe Statesman::Machine do
     let(:last_action) { "Whatever" }
 
     it "delegates to the storage adapter" do
-      expect_any_instance_of(Statesman.storage_adapter).to receive(:last).once
-        .and_return(last_action)
+      expect_any_instance_of(Statesman.storage_adapter).to receive(:last).once.
+        and_return(last_action)
       expect(instance.last_transition).to be(last_action)
     end
   end
@@ -499,9 +476,8 @@ describe Statesman::Machine do
 
     context "when the state cannot be transitioned to" do
       it "raises an error" do
-        expect do
-          instance.transition_to!(:z)
-        end.to raise_error(Statesman::TransitionFailedError)
+        expect { instance.transition_to!(:z) }.
+          to raise_error(Statesman::TransitionFailedError)
       end
     end
 
@@ -512,12 +488,11 @@ describe Statesman::Machine do
       end
 
       it "creates a new transition object" do
-        expect do
-          instance.transition_to!(:y)
-        end.to change(instance.history, :count).by(1)
+        expect { instance.transition_to!(:y) }.
+          to change(instance.history, :count).by(1)
 
-        expect(instance.history.first)
-          .to be_a(Statesman::Adapters::MemoryTransition)
+        expect(instance.history.first).
+          to be_a(Statesman::Adapters::MemoryTransition)
         expect(instance.history.first.to_state).to eq("y")
       end
 
@@ -532,9 +507,7 @@ describe Statesman::Machine do
         expect(instance.history.first.metadata).to eq({})
       end
 
-      it "returns true" do
-        expect(instance.transition_to!(:y)).to be_truthy
-      end
+      specify { expect(instance.transition_to!(:y)).to be_truthy }
 
       context "with a guard" do
         let(:result) { true }
@@ -545,8 +518,8 @@ describe Statesman::Machine 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, {}).and_return(true)
+            expect(guard_cb).to receive(:call).once.
+              with(my_model, instance.last_transition, {}).and_return(true)
             instance.transition_to!(:y)
           end
         end
@@ -562,9 +535,8 @@ describe Statesman::Machine do
           let(:result) { false }
 
           it "raises an exception" do
-            expect do
-              instance.transition_to!(:y)
-            end.to raise_error(Statesman::GuardFailedError)
+            expect { instance.transition_to!(:y) }.
+              to raise_error(Statesman::GuardFailedError)
           end
         end
       end
@@ -578,32 +550,29 @@ describe Statesman::Machine do
 
     context "when it is succesful" do
       before do
-        expect(instance).to receive(:transition_to!).once
-          .with(:some_state, metadata).and_return(:some_state)
+        expect(instance).to receive(:transition_to!).once.
+          with(:some_state, metadata).and_return(:some_state)
       end
       it { is_expected.to be(:some_state) }
     end
 
     context "when it is unsuccesful" do
       before do
-        allow(instance).to receive(:transition_to!)
-          .and_raise(Statesman::GuardFailedError)
+        allow(instance).to receive(:transition_to!).
+          and_raise(Statesman::GuardFailedError)
       end
       it { is_expected.to be_falsey }
     end
 
     context "when a non statesman exception is raised" do
       before do
-        allow(instance).to receive(: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
-        expectation = expect do
-          instance.transition_to(:some_state, metadata)
-        end
-
-        expectation.to raise_error(RuntimeError, 'user defined exception')
+        expect { instance.transition_to(:some_state, metadata) }.
+          to raise_error(RuntimeError, 'user defined exception')
       end
     end
   end
@@ -650,13 +619,11 @@ describe Statesman::Machine do
   end
 
   describe "#before_callbacks_for" do
-    it_behaves_like "a callback filter", :before_transition,
-                    :before
+    it_behaves_like "a callback filter", :before_transition, :before
   end
 
   describe "#after_callbacks_for" do
-    it_behaves_like "a callback filter", :after_transition,
-                    :after
+    it_behaves_like "a callback filter", :after_transition, :after
   end
 
   describe "#event" do
@@ -680,9 +647,8 @@ describe Statesman::Machine do
 
     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)
+        expect { instance.trigger!(:event_2) }.
+          to raise_error(Statesman::TransitionFailedError)
       end
     end
 
@@ -693,12 +659,11 @@ describe Statesman::Machine do
       end
 
       it "creates a new transition object" do
-        expect do
-          instance.trigger!(:event_1)
-        end.to change(instance.history, :count).by(1)
+        expect { instance.trigger!(:event_1) }.
+          to change(instance.history, :count).by(1)
 
-        expect(instance.history.first)
-          .to be_a(Statesman::Adapters::MemoryTransition)
+        expect(instance.history.first).
+          to be_a(Statesman::Adapters::MemoryTransition)
         expect(instance.history.first.to_state).to eq("y")
       end
 
@@ -728,16 +693,16 @@ describe Statesman::Machine 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, {}).and_return(true)
+            expect(guard_cb).to receive(:call).once.
+              with(my_model, instance.last_transition, {}).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")
+            expect { instance.trigger!(:event_1) }.
+              to change { instance.current_state }.to("y")
           end
         end
 
@@ -745,14 +710,12 @@ describe Statesman::Machine do
           let(:result) { false }
 
           it "raises an exception" do
-            expect do
-              instance.trigger!(:event_1)
-            end.to raise_error(Statesman::GuardFailedError)
+            expect { instance.trigger!(:event_1) }.
+              to raise_error(Statesman::GuardFailedError)
           end
         end
       end
     end
-
   end
 
   describe "#available_events" do
@@ -784,5 +747,4 @@ describe Statesman::Machine do
       expect(instance.available_events).to eq([:event_2, :event_3])
     end
   end
-
 end