statesman 7.4.0 → 10.2.3

data/lib/tasks/statesman.rake

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 namespace :statesman do
-  desc "Set most_recent to false for old transitions and to true for the "\
+  desc "Set most_recent to false for old transitions and to true for the " \
        "latest one. Safe to re-run"
   task :backfill_most_recent, [:parent_model_name] => :environment do |_, args|
     parent_model_name = args.parent_model_name
@@ -56,8 +56,8 @@ namespace :statesman do
       end
 
       done_models += batch_size
-      puts "Updated #{transition_class.name.pluralize} for "\
-           "#{[done_models, total_models].min}/#{total_models} "\
+      puts "Updated #{transition_class.name.pluralize} for " \
+           "#{[done_models, total_models].min}/#{total_models} " \
            "#{parent_model_name.pluralize}"
     end
   end

data/spec/spec_helper.rb

@@ -48,6 +48,8 @@ RSpec.configure do |config|
       my_namespace_my_active_record_model_transitions
       other_active_record_models
       other_active_record_model_transitions
+      sti_active_record_models
+      sti_active_record_model_transitions
     ]
     tables.each do |table_name|
       sql = "DROP TABLE IF EXISTS #{table_name};"
@@ -72,6 +74,15 @@ RSpec.configure do |config|
       OtherActiveRecordModelTransition.reset_column_information
     end
 
+    def prepare_sti_model_table
+      CreateStiActiveRecordModelMigration.migrate(:up)
+    end
+
+    def prepare_sti_transitions_table
+      CreateStiActiveRecordModelTransitionMigration.migrate(:up)
+      StiActiveRecordModelTransition.reset_column_information
+    end
+
     MyNamespace::MyActiveRecordModelTransition.serialize(:metadata, JSON)
   end
 end

data/spec/statesman/adapters/active_record_queries_spec.rb

@@ -50,10 +50,11 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
 
   shared_examples "testing methods" do
     before do
-      if config_type == :old
+      case config_type
+      when :old
         configure_old(MyActiveRecordModel, MyActiveRecordModelTransition)
         configure_old(OtherActiveRecordModel, OtherActiveRecordModelTransition)
-      elsif config_type == :new
+      when :new
         configure_new(MyActiveRecordModel, MyActiveRecordModelTransition)
         configure_new(OtherActiveRecordModel, OtherActiveRecordModelTransition)
       else
@@ -116,8 +117,8 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
         subject(:not_in_state) { MyActiveRecordModel.not_in_state(:succeeded, :failed) }
 
         it do
-          expect(not_in_state).to match_array([initial_state_model,
-                                               returned_to_initial_model])
+          expect(not_in_state).to contain_exactly(initial_state_model,
+                                                  returned_to_initial_model)
         end
       end
 
@@ -125,8 +126,8 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
         subject(:not_in_state) { MyActiveRecordModel.not_in_state(%i[succeeded failed]) }
 
         it do
-          expect(not_in_state).to match_array([initial_state_model,
-                                               returned_to_initial_model])
+          expect(not_in_state).to contain_exactly(initial_state_model,
+                                                  returned_to_initial_model)
         end
       end
     end
@@ -154,6 +155,31 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
       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
@@ -176,7 +202,6 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
         MyActiveRecordModel.create
       end
 
-      # rubocop:disable RSpec/ExampleLength
       it do
         expect do
           ActiveRecord::Base.transaction do
@@ -185,7 +210,6 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
           end
         end.to_not change(MyStateMachine, :after_commit_callback_executed)
       end
-      # rubocop:enable RSpec/ExampleLength
     end
   end
 
@@ -230,7 +254,7 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
       end
 
       it "does not raise an error" do
-        expect { check_missing_methods! }.to_not raise_exception(NotImplementedError)
+        expect { check_missing_methods! }.to_not raise_exception
       end
     end
 

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)
@@ -130,6 +133,31 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
         expect { adapter.create(:y, :z) }.
           to raise_exception(Statesman::TransitionConflictError)
       end
+
+      it "does not pollute the state when the transition fails" do
+        # this increments the sort_key in the database
+        adapter.create(:x, :y)
+
+        # we then pre-load the transitions for efficiency
+        preloaded_model = MyActiveRecordModel.
+          includes(:my_active_record_model_transitions).
+          find(model.id)
+
+        adapter2 = described_class.
+          new(MyActiveRecordModelTransition, preloaded_model, observer)
+
+        # Now we generate a race
+        adapter.create(:y, :z)
+        expect { adapter2.create(:y, :a) }.
+          to raise_error(Statesman::TransitionConflictError)
+
+        # The preloaded adapter should discard the preloaded info
+        expect(adapter2.last).to have_attributes(to_state: "z")
+        expect(adapter2.history).to contain_exactly(
+          have_attributes(to_state: "y"),
+          have_attributes(to_state: "z"),
+        )
+      end
     end
 
     context "when other exceptions occur" do
@@ -140,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
@@ -277,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
 
@@ -285,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
@@ -353,6 +430,35 @@ 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
+    model.save!
+    ActiveRecord::Base.transaction do
+      model.state_machine.transition_to!(:succeeded)
+      # force to cache value in last_transition instance variable
+      expect(model.state_machine.current_state).to eq("succeeded")
+      raise ActiveRecord::Rollback
+    end
+    expect(model.state_machine.current_state).to eq("succeeded")
+    model.reload
+    expect(model.state_machine.current_state).to eq("initial")
   end
 
   context "with a namespaced model" 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 }
@@ -128,6 +128,7 @@ shared_examples_for "an adapter" do |adapter_class, transition_class, options =
 
     it { is_expected.to be_a(transition_class) }
     specify { expect(adapter.last.to_state.to_sym).to eq(:z) }
+
     specify do
       expect(adapter.last(force_reload: true).to_state.to_sym).to eq(:z)
     end

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

@@ -7,6 +7,7 @@ describe Statesman do
     subject(:error) { Statesman::InvalidStateError.new }
 
     its(:message) { is_expected.to eq("Statesman::InvalidStateError") }
+
     its "string matches its message" do
       expect(error.to_s).to eq(error.message)
     end
@@ -16,6 +17,7 @@ describe Statesman do
     subject(:error) { Statesman::InvalidTransitionError.new }
 
     its(:message) { is_expected.to eq("Statesman::InvalidTransitionError") }
+
     its "string matches its message" do
       expect(error.to_s).to eq(error.message)
     end
@@ -25,6 +27,7 @@ describe Statesman do
     subject(:error) { Statesman::InvalidTransitionError.new }
 
     its(:message) { is_expected.to eq("Statesman::InvalidTransitionError") }
+
     its "string matches its message" do
       expect(error.to_s).to eq(error.message)
     end
@@ -34,6 +37,7 @@ describe Statesman do
     subject(:error) { Statesman::TransitionConflictError.new }
 
     its(:message) { is_expected.to eq("Statesman::TransitionConflictError") }
+
     its "string matches its message" do
       expect(error.to_s).to eq(error.message)
     end
@@ -43,6 +47,7 @@ describe Statesman do
     subject(:error) { Statesman::MissingTransitionAssociation.new }
 
     its(:message) { is_expected.to eq("Statesman::MissingTransitionAssociation") }
+
     its "string matches its message" do
       expect(error.to_s).to eq(error.message)
     end
@@ -52,17 +57,25 @@ describe Statesman do
     subject(:error) { Statesman::TransitionFailedError.new("from", "to") }
 
     its(:message) { is_expected.to eq("Cannot transition from 'from' to 'to'") }
+
     its "string matches its message" do
       expect(error.to_s).to eq(error.message)
     end
   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
@@ -72,6 +85,7 @@ describe Statesman do
     subject(:error) { Statesman::UnserializedMetadataError.new("foo") }
 
     its(:message) { is_expected.to match(/foo#metadata is not serialized/) }
+
     its "string matches its message" do
       expect(error.to_s).to eq(error.message)
     end
@@ -81,6 +95,7 @@ describe Statesman do
     subject(:error) { Statesman::IncompatibleSerializationError.new("foo") }
 
     its(:message) { is_expected.to match(/foo#metadata column type cannot be json/) }
+
     its "string matches its message" do
       expect(error.to_s).to eq(error.message)
     end