statesman 7.4.0 → 12.1.0

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
@@ -21,8 +21,8 @@ namespace :statesman do
     batch_size = 500
 
     parent_class.find_in_batches(batch_size: batch_size) do |models|
-      ActiveRecord::Base.transaction(requires_new: true) do
-        if Statesman::Adapters::ActiveRecord.database_supports_partial_indexes?
+      transition_class.transaction(requires_new: true) do
+        if Statesman::Adapters::ActiveRecord.database_supports_partial_indexes?(transition_class)
           # Set all transitions' most_recent to FALSE
           transition_class.where(parent_fk => models.map(&:id)).
             update_all(most_recent: false, updated_at: updated_at)
@@ -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/generators/statesman/active_record_transition_generator_spec.rb

@@ -1,10 +1,16 @@
 # frozen_string_literal: true
 
-require "spec_helper"
 require "support/generators_shared_examples"
 require "generators/statesman/active_record_transition_generator"
 
 describe Statesman::ActiveRecordTransitionGenerator, type: :generator do
+  before do
+    stub_const("Bacon", Class.new(ActiveRecord::Base))
+    stub_const("BaconTransition", Class.new(ActiveRecord::Base))
+    stub_const("Yummy::Bacon", Class.new(ActiveRecord::Base))
+    stub_const("Yummy::BaconTransition", Class.new(ActiveRecord::Base))
+  end
+
   it_behaves_like "a generator" do
     let(:migration_name) { "db/migrate/create_bacon_transitions.rb" }
   end

data/spec/generators/statesman/migration_generator_spec.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
-require "spec_helper"
 require "support/generators_shared_examples"
 require "generators/statesman/migration_generator"
 
 describe Statesman::MigrationGenerator, type: :generator do
+  before do
+    stub_const("Yummy::Bacon", Class.new(ActiveRecord::Base))
+    stub_const("Yummy::BaconTransition", Class.new(ActiveRecord::Base))
+  end
+
   it_behaves_like "a generator" do
     let(:migration_name) { "db/migrate/add_statesman_to_bacon_transitions.rb" }
   end

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 }
@@ -50,10 +48,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 +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
 
@@ -125,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
@@ -154,6 +153,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 +200,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 +208,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 +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,33 @@ 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
+        # 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
 
@@ -140,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
@@ -277,17 +293,90 @@ 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.create(:x, :y) }
+
       before { adapter.last }
 
       it "caches the transition" do
@@ -300,8 +389,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
@@ -353,6 +453,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
@@ -361,10 +490,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 }
@@ -128,6 +126,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