statesman 9.0.0 → 13.0.0

data/spec/spec_helper.rb

@@ -5,13 +5,14 @@ require "sqlite3"
 require "mysql2"
 require "pg"
 require "active_record"
+require "active_record/database_configurations"
 # We have to include all of Rails to make rspec-rails work
 require "rails"
 require "action_view"
 require "action_dispatch"
 require "action_controller"
 require "rspec/rails"
-require "support/active_record"
+require "support/exactly_query_databases"
 require "rspec/its"
 require "pry"
 
@@ -28,10 +29,31 @@ RSpec.configure do |config|
   if config.exclusion_filter[:active_record]
     puts "Skipping ActiveRecord tests"
   else
-    # Connect to the database for activerecord tests
-    db_conn_spec = ENV["DATABASE_URL"]
-    db_conn_spec ||= { adapter: "sqlite3", database: ":memory:" }
-    ActiveRecord::Base.establish_connection(db_conn_spec)
+    current_env = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+
+    # We have to parse this to a hash since ActiveRecord::Base.configurations
+    # will only consider a single URL config.
+    url_config = if ENV["DATABASE_URL"]
+                   ActiveRecord::DatabaseConfigurations::ConnectionUrlResolver.
+                     new(ENV["DATABASE_URL"]).to_hash.merge({ sslmode: "disable" })
+                 end
+
+    db_config = {
+      current_env => {
+        primary: url_config || {
+          adapter: "sqlite3",
+          database: "/tmp/statesman.db",
+        },
+        secondary: url_config || {
+          adapter: "sqlite3",
+          database: "/tmp/statesman.db",
+        },
+      },
+    }
+
+    # Connect to the primary database for activerecord tests.
+    ActiveRecord::Base.configurations = db_config
+    ActiveRecord::Base.establish_connection(:primary)
 
     db_adapter = ActiveRecord::Base.connection.adapter_name
     puts "Running with database adapter '#{db_adapter}'"
@@ -40,7 +62,9 @@ RSpec.configure do |config|
     ActiveRecord::Migration.verbose = false
   end
 
-  config.before(:each, active_record: true) do
+  # Since our primary and secondary connections point to the same database, we don't
+  # need to worry about applying these actions to both.
+  config.before(:each, :active_record) do
     tables = %w[
       my_active_record_models
       my_active_record_model_transitions
@@ -48,9 +72,12 @@ 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};"
+
       ActiveRecord::Base.connection.execute(sql)
     end
 
@@ -72,6 +99,16 @@ RSpec.configure do |config|
       OtherActiveRecordModelTransition.reset_column_information
     end
 
-    MyNamespace::MyActiveRecordModelTransition.serialize(:metadata, JSON)
+    def prepare_sti_model_table
+      CreateStiActiveRecordModelMigration.migrate(:up)
+    end
+
+    def prepare_sti_transitions_table
+      CreateStiActiveRecordModelTransitionMigration.migrate(:up)
+      StiActiveRecordModelTransition.reset_column_information
+    end
   end
 end
+
+# We have to require this after the databases are configured.
+require "support/active_record"

data/spec/statesman/adapters/active_record_queries_spec.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require "spec_helper"
-
-describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
+describe Statesman::Adapters::ActiveRecordQueries, :active_record do
   def configure_old(klass, transition_class)
     klass.define_singleton_method(:transition_class) { transition_class }
     klass.define_singleton_method(:initial_state) { :initial }
@@ -117,8 +115,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
 
@@ -126,8 +124,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
@@ -216,13 +214,13 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
   context "using old configuration method" do
     let(:config_type) { :old }
 
-    include_examples "testing methods"
+    it_behaves_like "testing methods"
   end
 
   context "using new configuration method" do
     let(:config_type) { :new }
 
-    include_examples "testing methods"
+    it_behaves_like "testing methods"
   end
 
   context "with no association with the transition class" do
@@ -254,7 +252,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

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require "spec_helper"
 require "timecop"
 require "statesman/adapters/shared_examples"
 require "statesman/exceptions"
 
-describe Statesman::Adapters::ActiveRecord, active_record: true do
+describe Statesman::Adapters::ActiveRecord, :active_record do
   before do
     prepare_model_table
     prepare_transitions_table
 
-    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
@@ -23,8 +23,10 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
 
   after { Statesman.configure { storage_adapter(Statesman::Adapters::Memory) } }
 
+  let(:model_class) { MyActiveRecordModel }
+  let(:transition_class) { MyActiveRecordModelTransition }
   let(:observer) { double(Statesman::Machine, execute: nil) }
-  let(:model) { MyActiveRecordModel.create(current_state: :pending) }
+  let(:model) { model_class.create(current_state: :pending) }
 
   it_behaves_like "an adapter", described_class, MyActiveRecordModelTransition
 
@@ -33,17 +35,11 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
       before do
         metadata_column = double
         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")
-          expect(MyActiveRecordModelTransition).
-            to receive(:type_for_attribute).with("metadata").
-            and_return(ActiveRecord::Type::Value.new)
-        else
-          expect(MyActiveRecordModelTransition).
-            to receive_messages(serialized_attributes: {})
-        end
+        allow(MyActiveRecordModelTransition).
+          to receive_messages(columns_hash: { "metadata" => metadata_column })
+        expect(MyActiveRecordModelTransition).
+          to receive(:type_for_attribute).with("metadata").
+          and_return(ActiveRecord::Type::Value.new)
       end
 
       it "raises an exception" do
@@ -60,10 +56,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,18 +84,12 @@ 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
-          )
-          expect(MyActiveRecordModelTransition).
-            to receive(:type_for_attribute).with("metadata").
-            and_return(serialized_type)
-        else
-          expect(MyActiveRecordModelTransition).
-            to receive_messages(serialized_attributes: { "metadata" => "" })
-        end
+        serialized_type = ActiveRecord::Type::Serialized.new(
+          "", ActiveRecord::Coders::JSON
+        )
+        expect(MyActiveRecordModelTransition).
+          to receive(:type_for_attribute).with("metadata").
+          and_return(serialized_type)
       end
 
       it "raises an exception" do
@@ -112,15 +102,17 @@ 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)
-    end
+    let!(:adapter) { described_class.new(transition_class, model, observer) }
     let(:from) { :x }
     let(:to) { :y }
     let(:create) { adapter.create(from, to) }
 
+    it "only connects to the primary database" do
+      expect { create }.to exactly_query_databases({ primary: [:writing] })
+    end
+
     context "when there is a race" do
       it "raises a TransitionConflictError" do
         adapter2 = adapter.dup
@@ -128,7 +120,8 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
         adapter.last
         adapter2.create(:y, :z)
         expect { adapter.create(:y, :z) }.
-          to raise_exception(Statesman::TransitionConflictError)
+          to raise_exception(Statesman::TransitionConflictError).
+          and exactly_query_databases({ primary: [:writing] })
       end
 
       it "does not pollute the state when the transition fails" do
@@ -165,27 +158,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,18 +293,92 @@ 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
 
-  describe "#last" do
-    let(:adapter) do
-      described_class.new(MyActiveRecordModelTransition, model, observer)
+    context "when using the secondary database" do
+      let(:model_class) { SecondaryActiveRecordModel }
+      let(:transition_class) { SecondaryActiveRecordModelTransition }
+
+      it "doesn't connect to the primary database" do
+        expect { create }.to exactly_query_databases({ secondary: [:writing] })
+        expect(adapter.last.to_state).to eq("y")
+      end
+
+      context "when there is a race" do
+        it "raises a TransitionConflictError and uses the correct database" do
+          adapter2 = adapter.dup
+          adapter2.create(:x, :y)
+          adapter.last
+          adapter2.create(:y, :z)
+
+          expect { adapter.create(:y, :z) }.
+            to raise_exception(Statesman::TransitionConflictError).
+            and exactly_query_databases({ secondary: [:writing] })
+        end
+      end
     end
+  end
 
-    before { adapter.create(:x, :y) }
+  describe "#last" do
+    let(:transition_class) { MyActiveRecordModelTransition }
+    let(:adapter) { described_class.new(transition_class, model, observer) }
 
     context "with a previously looked up transition" do
-      before { adapter.last }
+      before do
+        adapter.create(:x, :y)
+        adapter.last
+      end
 
       it "caches the transition" do
         expect_any_instance_of(MyActiveRecordModel).
@@ -325,8 +390,19 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
         before { adapter.create(:y, :z, []) }
 
         it "retrieves the new transition from the database" do
+          expect { adapter.last.to_state }.to exactly_query_databases({ primary: [:writing] })
           expect(adapter.last.to_state).to eq("z")
         end
+
+        context "when using the secondary database" do
+          let(:model_class) { SecondaryActiveRecordModel }
+          let(:transition_class) { SecondaryActiveRecordModelTransition }
+
+          it "retrieves the new transition from the database" do
+            expect { adapter.last.to_state }.to exactly_query_databases({ secondary: [:writing] })
+            expect(adapter.last.to_state).to eq("z")
+          end
+        end
       end
 
       context "when a new transition has been created elsewhere" do
@@ -369,15 +445,32 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
     end
 
     context "with a pre-fetched transition history" do
-      before { adapter.create(:x, :y) }
-
-      before { model.my_active_record_model_transitions.load_target }
+      before do
+        adapter.create(:x, :y)
+        model.my_active_record_model_transitions.load_target
+      end
 
       it "doesn't query the database" do
         expect(MyActiveRecordModelTransition).to_not receive(:connection)
         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
@@ -399,10 +492,6 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
       CreateNamespacedARModelTransitionMigration.migrate(:up)
     end
 
-    before do
-      MyNamespace::MyActiveRecordModelTransition.serialize(:metadata, JSON)
-    end
-
     let(:observer) { double(Statesman::Machine, execute: nil) }
     let(:model) do
       MyNamespace::MyActiveRecordModel.create(current_state: :pending)

data/spec/statesman/adapters/active_record_transition_spec.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "spec_helper"
 require "json"
 
 describe Statesman::Adapters::ActiveRecordTransition do
@@ -8,7 +7,11 @@ describe Statesman::Adapters::ActiveRecordTransition do
 
   describe "including behaviour" do
     it "calls Class.serialize" do
-      expect(transition_class).to receive(:serialize).with(:metadata, JSON).once
+      if Gem::Version.new(ActiveRecord::VERSION::STRING) >= Gem::Version.new("7.1")
+        expect(transition_class).to receive(:serialize).with(:metadata, coder: JSON).once
+      else
+        expect(transition_class).to receive(:serialize).with(:metadata, JSON).once
+      end
       transition_class.send(:include, described_class)
     end
   end

data/spec/statesman/adapters/memory_spec.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "spec_helper"
 require "statesman/adapters/shared_examples"
 require "statesman/adapters/memory_transition"
 

data/spec/statesman/adapters/memory_transition_spec.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "spec_helper"
 require "statesman/adapters/memory_transition"
 
 describe Statesman::Adapters::MemoryTransition do

data/spec/statesman/adapters/shared_examples.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "spec_helper"
-
 # All adpators must define seven methods:
 #   initialize:       Accepts a transition class, parent model and state_attr.
 #   transition_class: Returns the transition class object passed to initialize.
@@ -30,14 +28,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 }
@@ -122,9 +120,10 @@ shared_examples_for "an adapter" do |adapter_class, transition_class, options =
   describe "#last" do
     subject { adapter.last }
 
-    before { adapter.create(:x, :y) }
-
-    before { adapter.create(:y, :z) }
+    before do
+      adapter.create(:x, :y)
+      adapter.create(:y, :z)
+    end
 
     it { is_expected.to be_a(transition_class) }
     specify { expect(adapter.last.to_state.to_sym).to eq(:z) }