statesman 10.0.0 → 10.2.3

data/spec/statesman/adapters/active_record_spec.rb

@@ -12,6 +12,9 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
 
     MyActiveRecordModelTransition.serialize(:metadata, JSON)
 
+    prepare_sti_model_table
+    prepare_sti_transitions_table
+
     Statesman.configure do
       # Rubocop requires described_class to be used, but this block
       # is instance_eval'd and described_class won't be defined
@@ -35,8 +38,8 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
         allow(metadata_column).to receive_messages(sql_type: "")
         allow(MyActiveRecordModelTransition).to receive_messages(columns_hash:
                                            { "metadata" => metadata_column })
-        if ::ActiveRecord.respond_to?(:gem_version) &&
-            ::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")
           expect(MyActiveRecordModelTransition).
             to receive(:type_for_attribute).with("metadata").
             and_return(ActiveRecord::Type::Value.new)
@@ -60,10 +63,10 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
         allow(metadata_column).to receive_messages(sql_type: "json")
         allow(MyActiveRecordModelTransition).to receive_messages(columns_hash:
                                            { "metadata" => metadata_column })
-        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
+        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(MyActiveRecordModelTransition).
             to receive(:type_for_attribute).with("metadata").
@@ -88,10 +91,10 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
         allow(metadata_column).to receive_messages(sql_type: "jsonb")
         allow(MyActiveRecordModelTransition).to receive_messages(columns_hash:
                                            { "metadata" => metadata_column })
-        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
+        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(MyActiveRecordModelTransition).
             to receive(:type_for_attribute).with("metadata").
@@ -112,7 +115,7 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
   end
 
   describe "#create" do
-    subject { -> { create } }
+    subject(:transition) { create }
 
     let!(:adapter) do
       described_class.new(MyActiveRecordModelTransition, model, observer)
@@ -165,27 +168,25 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
 
       context "ActiveRecord::RecordNotUnique unrelated to this transition" do
         let(:error) do
-          if ::ActiveRecord.respond_to?(:gem_version) &&
-              ::ActiveRecord.gem_version >= Gem::Version.new("4.0.0")
+          if ActiveRecord.respond_to?(:gem_version) &&
+              ActiveRecord.gem_version >= Gem::Version.new("4.0.0")
             ActiveRecord::RecordNotUnique.new("unrelated")
           else
             ActiveRecord::RecordNotUnique.new("unrelated", nil)
           end
         end
 
-        it { is_expected.to raise_exception(ActiveRecord::RecordNotUnique) }
+        it { expect { transition }.to raise_exception(ActiveRecord::RecordNotUnique) }
       end
 
       context "other errors" do
         let(:error) { StandardError }
 
-        it { is_expected.to raise_exception(StandardError) }
+        it { expect { transition }.to raise_exception(StandardError) }
       end
     end
 
     describe "updating the most_recent column" do
-      subject { create }
-
       context "with no previous transition" do
         its(:most_recent) { is_expected.to eq(true) }
       end
@@ -302,6 +303,57 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
             from(true).to be_falsey
         end
       end
+
+      context "when transition uses STI" do
+        let(:sti_model) { StiActiveRecordModel.create }
+
+        let(:adapter_a) do
+          described_class.new(
+            StiAActiveRecordModelTransition,
+            sti_model,
+            observer,
+            { association_name: :sti_a_active_record_model_transitions },
+          )
+        end
+        let(:adapter_b) do
+          described_class.new(
+            StiBActiveRecordModelTransition,
+            sti_model,
+            observer,
+            { association_name: :sti_b_active_record_model_transitions },
+          )
+        end
+        let(:create) { adapter_a.create(from, to) }
+
+        context "with a previous unrelated transition" do
+          let!(:transition_b) { adapter_b.create(from, to) }
+
+          its(:most_recent) { is_expected.to eq(true) }
+
+          it "doesn't update the previous transition's most_recent flag" do
+            expect { create }.
+              to_not(change { transition_b.reload.most_recent })
+          end
+        end
+
+        context "with previous related and unrelated transitions" do
+          let!(:transition_a) { adapter_a.create(from, to) }
+          let!(:transition_b) { adapter_b.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 { transition_a.reload.most_recent }.
+              from(true).to be_falsey
+          end
+
+          it "doesn't update the previous unrelated transition's most_recent flag" do
+            expect { create }.
+              to_not(change { transition_b.reload.most_recent })
+          end
+        end
+      end
     end
   end
 
@@ -310,9 +362,9 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
       described_class.new(MyActiveRecordModelTransition, model, observer)
     end
 
-    before { adapter.create(:x, :y) }
-
     context "with a previously looked up transition" do
+      before { adapter.create(:x, :y) }
+
       before { adapter.last }
 
       it "caches the transition" do
@@ -378,6 +430,22 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
         expect(adapter.last.to_state).to eq("y")
       end
     end
+
+    context "without previous transitions" do
+      it "does query the database only once" do
+        expect(model.my_active_record_model_transitions).
+          to receive(:order).once.and_call_original
+
+        expect(adapter.last).to eq(nil)
+        expect(adapter.last).to eq(nil)
+      end
+    end
+  end
+
+  describe "#reset" do
+    it "works with empty cache" do
+      expect { model.state_machine.reset }.to_not raise_error
+    end
   end
 
   it "resets last with #reload" do

data/spec/statesman/adapters/shared_examples.rb

@@ -30,14 +30,14 @@ shared_examples_for "an adapter" do |adapter_class, transition_class, options =
   end
 
   describe "#create" do
-    subject { -> { create } }
+    subject(:transition) { create }
 
     let(:from) { :x }
     let(:to) { :y }
     let(:there) { :z }
     let(:create) { adapter.create(from, to) }
 
-    it { is_expected.to change(adapter.history, :count).by(1) }
+    it { expect { transition }.to change(adapter.history, :count).by(1) }
 
     context "the new transition" do
       subject(:instance) { create }

data/spec/statesman/adapters/type_safe_active_record_queries_spec.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Statesman::Adapters::TypeSafeActiveRecordQueries, active_record: true do
+  def configure(klass, transition_class)
+    klass.send(:extend, described_class)
+    klass.configure_state_machine(
+      transition_class: transition_class,
+      initial_state: :initial,
+    )
+  end
+
+  before do
+    prepare_model_table
+    prepare_transitions_table
+    prepare_other_model_table
+    prepare_other_transitions_table
+
+    Statesman.configure do
+      storage_adapter(Statesman::Adapters::ActiveRecord)
+    end
+  end
+
+  after { Statesman.configure { storage_adapter(Statesman::Adapters::Memory) } }
+
+  let!(:model) do
+    model = MyActiveRecordModel.create
+    model.state_machine.transition_to(:succeeded)
+    model
+  end
+
+  let!(:other_model) do
+    model = MyActiveRecordModel.create
+    model.state_machine.transition_to(:failed)
+    model
+  end
+
+  let!(:initial_state_model) { MyActiveRecordModel.create }
+
+  let!(:returned_to_initial_model) do
+    model = MyActiveRecordModel.create
+    model.state_machine.transition_to(:failed)
+    model.state_machine.transition_to(:initial)
+    model
+  end
+
+  shared_examples "testing methods" do
+    before do
+      configure(MyActiveRecordModel, MyActiveRecordModelTransition)
+      configure(OtherActiveRecordModel, OtherActiveRecordModelTransition)
+
+      MyActiveRecordModel.send(:has_one, :other_active_record_model)
+      OtherActiveRecordModel.send(:belongs_to, :my_active_record_model)
+    end
+
+    describe ".in_state" do
+      context "given a single state" do
+        subject { MyActiveRecordModel.in_state(:succeeded) }
+
+        it { is_expected.to include model }
+        it { is_expected.to_not include other_model }
+      end
+
+      context "given multiple states" do
+        subject { MyActiveRecordModel.in_state(:succeeded, :failed) }
+
+        it { is_expected.to include model }
+        it { is_expected.to include other_model }
+      end
+
+      context "given the initial state" do
+        subject { MyActiveRecordModel.in_state(:initial) }
+
+        it { is_expected.to include initial_state_model }
+        it { is_expected.to include returned_to_initial_model }
+      end
+
+      context "given an array of states" do
+        subject { MyActiveRecordModel.in_state(%i[succeeded failed]) }
+
+        it { is_expected.to include model }
+        it { is_expected.to include other_model }
+      end
+
+      context "merging two queries" do
+        subject do
+          MyActiveRecordModel.in_state(:succeeded).
+            joins(:other_active_record_model).
+            merge(OtherActiveRecordModel.in_state(:initial))
+        end
+
+        it { is_expected.to be_empty }
+      end
+    end
+
+    describe ".not_in_state" do
+      context "given a single state" do
+        subject { MyActiveRecordModel.not_in_state(:failed) }
+
+        it { is_expected.to include model }
+        it { is_expected.to_not include other_model }
+      end
+
+      context "given multiple states" do
+        subject(:not_in_state) { MyActiveRecordModel.not_in_state(:succeeded, :failed) }
+
+        it do
+          expect(not_in_state).to contain_exactly(initial_state_model,
+                                                  returned_to_initial_model)
+        end
+      end
+
+      context "given an array of states" do
+        subject(:not_in_state) { MyActiveRecordModel.not_in_state(%i[succeeded failed]) }
+
+        it do
+          expect(not_in_state).to contain_exactly(initial_state_model,
+                                                  returned_to_initial_model)
+        end
+      end
+    end
+
+    context "with a custom name for the transition association" do
+      before do
+        # Switch to using OtherActiveRecordModelTransition, so the existing
+        # relation with MyActiveRecordModelTransition doesn't interfere with
+        # this spec.
+        MyActiveRecordModel.send(:has_many,
+                                 :custom_name,
+                                 class_name: "OtherActiveRecordModelTransition")
+
+        MyActiveRecordModel.class_eval do
+          def self.transition_class
+            OtherActiveRecordModelTransition
+          end
+        end
+      end
+
+      describe ".in_state" do
+        subject(:query) { MyActiveRecordModel.in_state(:succeeded) }
+
+        specify { expect { query }.to_not raise_error }
+      end
+    end
+
+    context "with a custom primary key for the model" do
+      before do
+        # Switch to using OtherActiveRecordModelTransition, so the existing
+        # relation with MyActiveRecordModelTransition doesn't interfere with
+        # this spec.
+        # Configure the relationship to use a different primary key,
+        MyActiveRecordModel.send(:has_many,
+                                 :custom_name,
+                                 class_name: "OtherActiveRecordModelTransition",
+                                 primary_key: :external_id)
+
+        MyActiveRecordModel.class_eval do
+          def self.transition_class
+            OtherActiveRecordModelTransition
+          end
+        end
+      end
+
+      describe ".in_state" do
+        subject(:query) { MyActiveRecordModel.in_state(:succeeded) }
+
+        specify { expect { query }.to_not raise_error }
+      end
+    end
+
+    context "after_commit transactional integrity" do
+      before do
+        MyStateMachine.class_eval do
+          cattr_accessor(:after_commit_callback_executed) { false }
+
+          after_transition(from: :initial, to: :succeeded, after_commit: true) do
+            # This leaks state in a testable way if transactional integrity is broken.
+            MyStateMachine.after_commit_callback_executed = true
+          end
+        end
+      end
+
+      after do
+        MyStateMachine.class_eval do
+          callbacks[:after_commit] = []
+        end
+      end
+
+      let!(:model) do
+        MyActiveRecordModel.create
+      end
+
+      it do
+        expect do
+          ActiveRecord::Base.transaction do
+            model.state_machine.transition_to!(:succeeded)
+            raise ActiveRecord::Rollback
+          end
+        end.to_not change(MyStateMachine, :after_commit_callback_executed)
+      end
+    end
+  end
+
+  context "using configuration method" do
+    include_examples "testing methods"
+  end
+end

data/spec/statesman/exceptions_spec.rb

@@ -64,12 +64,18 @@ describe Statesman do
   end
 
   describe "GuardFailedError" do
-    subject(:error) { Statesman::GuardFailedError.new("from", "to") }
+    subject(:error) { Statesman::GuardFailedError.new("from", "to", callback) }
+
+    let(:callback) { -> { "hello" } }
 
     its(:message) do
       is_expected.to eq("Guard on transition from: 'from' to 'to' returned false")
     end
 
+    its(:backtrace) do
+      is_expected.to eq([callback.source_location.join(":")])
+    end
+
     its "string matches its message" do
       expect(error.to_s).to eq(error.message)
     end

data/spec/statesman/machine_spec.rb

@@ -28,7 +28,7 @@ describe Statesman::Machine do
   end
 
   describe ".remove_state" do
-    subject(:remove_state) { -> { machine.remove_state(:x) } }
+    subject(:remove_state) { machine.remove_state(:x) }
 
     before do
       machine.class_eval do
@@ -39,7 +39,7 @@ describe Statesman::Machine do
     end
 
     it "removes the state" do
-      expect(remove_state).
+      expect { remove_state }.
         to change(machine, :states).
         from(match_array(%w[x y z])).
         to(%w[y z])
@@ -49,7 +49,7 @@ describe Statesman::Machine do
       before { machine.transition from: :x, to: :y }
 
       it "removes the transition" do
-        expect(remove_state).
+        expect { remove_state }.
           to change(machine, :successors).
           from({ "x" => ["y"] }).
           to({})
@@ -59,7 +59,7 @@ describe Statesman::Machine do
         before { machine.transition from: :x, to: :z }
 
         it "removes all transitions" do
-          expect(remove_state).
+          expect { remove_state }.
             to change(machine, :successors).
             from({ "x" => %w[y z] }).
             to({})
@@ -71,7 +71,7 @@ describe Statesman::Machine do
       before { machine.transition from: :y, to: :x }
 
       it "removes the transition" do
-        expect(remove_state).
+        expect { remove_state }.
           to change(machine, :successors).
           from({ "y" => ["x"] }).
           to({})
@@ -81,7 +81,7 @@ describe Statesman::Machine do
         before { machine.transition from: :z, to: :x }
 
         it "removes all transitions" do
-          expect(remove_state).
+          expect { remove_state }.
             to change(machine, :successors).
             from({ "y" => ["x"], "z" => ["x"] }).
             to({})
@@ -104,7 +104,7 @@ describe Statesman::Machine do
       end
 
       it "removes the guard" do
-        expect(remove_state).
+        expect { remove_state }.
           to change(machine, :callbacks).
           from(a_hash_including(guards: match_array(guards))).
           to(a_hash_including(guards: []))
@@ -125,7 +125,7 @@ describe Statesman::Machine do
       end
 
       it "removes the guard" do
-        expect(remove_state).
+        expect { remove_state }.
           to change(machine, :callbacks).
           from(a_hash_including(guards: match_array(guards))).
           to(a_hash_including(guards: []))
@@ -935,10 +935,10 @@ describe Statesman::Machine do
       it { is_expected.to be(:some_state) }
     end
 
-    context "when it is unsuccesful" do
+    context "when it is unsuccessful" do
       before do
         allow(instance).to receive(:transition_to!).
-          and_raise(Statesman::GuardFailedError.new(:x, :some_state))
+          and_raise(Statesman::GuardFailedError.new(:x, :some_state, nil))
       end
 
       it { is_expected.to be_falsey }
@@ -976,20 +976,20 @@ describe Statesman::Machine do
     end
 
     context "with defined callbacks" do
-      let(:callback_1) { -> { "Hi" } }
-      let(:callback_2) { -> { "Bye" } }
+      let(:callback_one) { -> { "Hi" } }
+      let(:callback_two) { -> { "Bye" } }
 
       before do
-        machine.send(definer, from: :x, to: :y, &callback_1)
-        machine.send(definer, from: :y, to: :z, &callback_2)
+        machine.send(definer, from: :x, to: :y, &callback_one)
+        machine.send(definer, from: :y, to: :z, &callback_two)
       end
 
       it "contains the relevant callback" do
-        expect(callbacks.map(&:callback)).to include(callback_1)
+        expect(callbacks.map(&:callback)).to include(callback_one)
       end
 
       it "does not contain the irrelevant callback" do
-        expect(callbacks.map(&:callback)).to_not include(callback_2)
+        expect(callbacks.map(&:callback)).to_not include(callback_two)
       end
     end
   end