statesman 3.5.0 → 7.4.0

data/spec/statesman/adapters/active_record_queries_spec.rb

@@ -1,39 +1,28 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
+  def configure_old(klass, transition_class)
+    klass.define_singleton_method(:transition_class) { transition_class }
+    klass.define_singleton_method(:initial_state) { :initial }
+    klass.send(:include, described_class)
+  end
+
+  def configure_new(klass, transition_class)
+    klass.send(:include, described_class[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 { storage_adapter(Statesman::Adapters::ActiveRecord) }
-
-    MyActiveRecordModel.send(:include, Statesman::Adapters::ActiveRecordQueries)
-    MyActiveRecordModel.class_eval do
-      def self.transition_class
-        MyActiveRecordModelTransition
-      end
-
-      def self.initial_state
-        :initial
-      end
+    Statesman.configure do
+      storage_adapter(Statesman::Adapters::ActiveRecord)
     end
-
-    OtherActiveRecordModel.send(:include,
-                                Statesman::Adapters::ActiveRecordQueries)
-    OtherActiveRecordModel.class_eval do
-      def self.transition_class
-        OtherActiveRecordModelTransition
-      end
-
-      def self.initial_state
-        :initial
-      end
-    end
-
-    MyActiveRecordModel.send(:has_one, :other_active_record_model)
-    OtherActiveRecordModel.send(:belongs_to, :my_active_record_model)
   end
 
   after { Statesman.configure { storage_adapter(Statesman::Adapters::Memory) } }
@@ -59,105 +48,164 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
     model
   end
 
-  describe ".in_state" do
-    context "given a single state" do
-      subject { MyActiveRecordModel.in_state(:succeeded) }
+  shared_examples "testing methods" do
+    before do
+      if config_type == :old
+        configure_old(MyActiveRecordModel, MyActiveRecordModelTransition)
+        configure_old(OtherActiveRecordModel, OtherActiveRecordModelTransition)
+      elsif config_type == :new
+        configure_new(MyActiveRecordModel, MyActiveRecordModelTransition)
+        configure_new(OtherActiveRecordModel, OtherActiveRecordModelTransition)
+      else
+        raise "Unknown config type #{config_type}"
+      end
 
-      it { is_expected.to include model }
-      it { is_expected.to_not include other_model }
+      MyActiveRecordModel.send(:has_one, :other_active_record_model)
+      OtherActiveRecordModel.send(:belongs_to, :my_active_record_model)
     end
 
-    context "given multiple states" do
-      subject { MyActiveRecordModel.in_state(:succeeded, :failed) }
+    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 include other_model }
-    end
+        it { is_expected.to include model }
+        it { is_expected.to_not include other_model }
+      end
 
-    context "given the initial state" do
-      subject { MyActiveRecordModel.in_state(:initial) }
+      context "given multiple states" do
+        subject { MyActiveRecordModel.in_state(:succeeded, :failed) }
 
-      it { is_expected.to include initial_state_model }
-      it { is_expected.to include returned_to_initial_model }
-    end
+        it { is_expected.to include model }
+        it { is_expected.to include other_model }
+      end
 
-    context "given an array of states" do
-      subject { MyActiveRecordModel.in_state(%i[succeeded failed]) }
+      context "given the initial state" do
+        subject { MyActiveRecordModel.in_state(:initial) }
 
-      it { is_expected.to include model }
-      it { is_expected.to include other_model }
-    end
+        it { is_expected.to include initial_state_model }
+        it { is_expected.to include returned_to_initial_model }
+      end
 
-    context "merging two queries" do
-      subject do
-        MyActiveRecordModel.in_state(:succeeded).
-          joins(:other_active_record_model).
-          merge(OtherActiveRecordModel.in_state(:initial))
+      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
 
-      it { is_expected.to be_empty }
+      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
-  end
 
-  describe ".not_in_state" do
-    context "given a single state" do
-      subject { MyActiveRecordModel.not_in_state(:failed) }
+    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
+        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) }
+      context "given multiple states" 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])
+        it do
+          expect(not_in_state).to match_array([initial_state_model,
+                                               returned_to_initial_model])
+        end
       end
-    end
 
-    context "given an array of states" do
-      subject(:not_in_state) { MyActiveRecordModel.not_in_state(%i[succeeded failed]) }
+      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 match_array([initial_state_model,
-                                             returned_to_initial_model])
+        it do
+          expect(not_in_state).to match_array([initial_state_model,
+                                               returned_to_initial_model])
+        end
       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
+    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
 
-    describe ".in_state" do
-      subject(:query) { MyActiveRecordModel.in_state(:succeeded) }
+    context "after_commit transactional integrity" do
+      before do
+        MyStateMachine.class_eval do
+          cattr_accessor(:after_commit_callback_executed) { false }
 
-      specify { expect { query }.to_not raise_error }
+          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
+
+      # rubocop:disable RSpec/ExampleLength
+      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
+      # rubocop:enable RSpec/ExampleLength
     end
   end
 
+  context "using old configuration method" do
+    let(:config_type) { :old }
+
+    include_examples "testing methods"
+  end
+
+  context "using new configuration method" do
+    let(:config_type) { :new }
+
+    include_examples "testing methods"
+  end
+
   context "with no association with the transition class" do
     before do
       class UnknownModelTransition < OtherActiveRecordModelTransition; end
 
-      MyActiveRecordModel.class_eval do
-        def self.transition_class
-          UnknownModelTransition
-        end
-      end
+      configure_old(MyActiveRecordModel, UnknownModelTransition)
     end
 
     describe ".in_state" do
@@ -168,4 +216,32 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
       end
     end
   end
+
+  describe "check_missing_methods!" do
+    subject(:check_missing_methods!) { described_class.check_missing_methods!(base) }
+
+    context "when base has no missing methods" do
+      let(:base) do
+        Class.new do
+          def self.transition_class; end
+
+          def self.initial_state; end
+        end
+      end
+
+      it "does not raise an error" do
+        expect { check_missing_methods! }.to_not raise_exception(NotImplementedError)
+      end
+    end
+
+    context "when base has missing methods" do
+      let(:base) do
+        Class.new
+      end
+
+      it "raises an error" do
+        expect { check_missing_methods! }.to raise_exception(NotImplementedError)
+      end
+    end
+  end
 end

data/spec/statesman/adapters/active_record_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 require "timecop"
 require "statesman/adapters/shared_examples"
@@ -7,9 +9,19 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
   before do
     prepare_model_table
     prepare_transitions_table
+
+    MyActiveRecordModelTransition.serialize(:metadata, JSON)
+
+    Statesman.configure do
+      # Rubocop requires described_class to be used, but this block
+      # is instance_eval'd and described_class won't be defined
+      # rubocop:disable RSpec/DescribedClass
+      storage_adapter(Statesman::Adapters::ActiveRecord)
+      # rubocop:enable RSpec/DescribedClass
+    end
   end
 
-  before { MyActiveRecordModelTransition.serialize(:metadata, JSON) }
+  after { Statesman.configure { storage_adapter(Statesman::Adapters::Memory) } }
 
   let(:observer) { double(Statesman::Machine, execute: nil) }
   let(:model) { MyActiveRecordModel.create(current_state: :pending) }
@@ -227,6 +239,7 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
             it "still has the old state" do
               allow(observer).to receive(:execute) do |phase|
                 next unless phase == :before
+
                 expect(
                   model.transitions.where(most_recent: true).first.to_state,
                 ).to eq("y")
@@ -240,6 +253,7 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
             it "still has the old state" do
               allow(observer).to receive(:execute) do |phase|
                 next unless phase == :after
+
                 expect(
                   model.transitions.where(most_recent: true).first.to_state,
                 ).to eq("z")

data/spec/statesman/adapters/active_record_transition_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 require "json"
 

data/spec/statesman/adapters/memory_spec.rb

@@ -1,3 +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,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 require "statesman/adapters/memory_transition"
 

data/spec/statesman/adapters/shared_examples.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 # All adpators must define seven methods:

data/spec/statesman/callback_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Statesman::Callback do

data/spec/statesman/config_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Statesman::Config do

data/spec/statesman/exceptions_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe Statesman do
+  describe "InvalidStateError" 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
+  end
+
+  describe "InvalidTransitionError" 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
+  end
+
+  describe "InvalidCallbackError" 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
+  end
+
+  describe "TransitionConflictError" 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
+  end
+
+  describe "MissingTransitionAssociation" 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
+  end
+
+  describe "TransitionFailedError" 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") }
+
+    its(:message) do
+      is_expected.to eq("Guard on transition from: 'from' to 'to' returned false")
+    end
+    its "string matches its message" do
+      expect(error.to_s).to eq(error.message)
+    end
+  end
+
+  describe "UnserializedMetadataError" 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
+  end
+
+  describe "IncompatibleSerializationError" 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
+  end
+end