statesman 9.0.0 → 13.0.0

data/spec/statesman/adapters/type_safe_active_record_queries_spec.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+describe Statesman::Adapters::TypeSafeActiveRecordQueries, :active_record 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
+    it_behaves_like "testing methods"
+  end
+end

data/spec/statesman/callback_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "spec_helper"
-
 describe Statesman::Callback do
   let(:cb_lambda) { -> {} }
   let(:callback) do

data/spec/statesman/config_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "spec_helper"
-
 describe Statesman::Config do
   let(:instance) { described_class.new }
 

data/spec/statesman/exceptions_spec.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require "spec_helper"
-
-describe Statesman do
+describe "Exceptions" do
   describe "InvalidStateError" do
     subject(:error) { Statesman::InvalidStateError.new }
 
@@ -64,12 +62,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/guard_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "spec_helper"
-
 describe Statesman::Guard do
   let(:callback) { -> {} }
   let(:guard) { described_class.new(from: nil, to: nil, callback: callback) }

data/spec/statesman/machine_spec.rb

@@ -1,15 +1,14 @@
 # frozen_string_literal: true
 
-require "spec_helper"
-
 describe Statesman::Machine do
   let(:machine) { Class.new { include Statesman::Machine } }
   let(:my_model) { Class.new { attr_accessor :current_state }.new }
 
   describe ".state" do
-    before { machine.state(:x) }
-
-    before { machine.state(:y) }
+    before do
+      machine.state(:x)
+      machine.state(:y)
+    end
 
     specify { expect(machine.states).to eq(%w[x y]) }
 
@@ -27,6 +26,112 @@ describe Statesman::Machine do
     end
   end
 
+  describe ".remove_state" do
+    subject(:remove_state) { machine.remove_state(:x) }
+
+    before do
+      machine.class_eval do
+        state :x
+        state :y
+        state :z
+      end
+    end
+
+    it "removes the state" do
+      expect { remove_state }.
+        to change(machine, :states).
+        from(match_array(%w[x y z])).
+        to(%w[y z])
+    end
+
+    context "with a transition from the removed state" do
+      before { machine.transition from: :x, to: :y }
+
+      it "removes the transition" do
+        expect { remove_state }.
+          to change(machine, :successors).
+          from({ "x" => ["y"] }).
+          to({})
+      end
+
+      context "with multiple transitions" do
+        before { machine.transition from: :x, to: :z }
+
+        it "removes all transitions" do
+          expect { remove_state }.
+            to change(machine, :successors).
+            from({ "x" => %w[y z] }).
+            to({})
+        end
+      end
+    end
+
+    context "with a transition to the removed state" do
+      before { machine.transition from: :y, to: :x }
+
+      it "removes the transition" do
+        expect { remove_state }.
+          to change(machine, :successors).
+          from({ "y" => ["x"] }).
+          to({})
+      end
+
+      context "with multiple transitions" do
+        before { machine.transition from: :z, to: :x }
+
+        it "removes all transitions" do
+          expect { remove_state }.
+            to change(machine, :successors).
+            from({ "y" => ["x"], "z" => ["x"] }).
+            to({})
+        end
+      end
+    end
+
+    context "with a callback from the removed state" do
+      before do
+        machine.class_eval do
+          transition from: :x, to: :y
+          transition from: :x, to: :z
+          guard_transition(from: :x) { return false }
+          guard_transition(from: :x, to: :z) { return true }
+        end
+      end
+
+      let(:guards) do
+        [having_attributes(from: "x", to: []), having_attributes(from: "x", to: ["z"])]
+      end
+
+      it "removes the guard" do
+        expect { remove_state }.
+          to change(machine, :callbacks).
+          from(a_hash_including(guards: match_array(guards))).
+          to(a_hash_including(guards: []))
+      end
+    end
+
+    context "with a callback to the removed state" do
+      before do
+        machine.class_eval do
+          transition from: :y, to: :x
+          guard_transition(to: :x) { return false }
+          guard_transition(from: :y, to: :x) { return true }
+        end
+      end
+
+      let(:guards) do
+        [having_attributes(from: nil, to: ["x"]), having_attributes(from: "y", to: ["x"])]
+      end
+
+      it "removes the guard" do
+        expect { remove_state }.
+          to change(machine, :callbacks).
+          from(a_hash_including(guards: match_array(guards))).
+          to(a_hash_including(guards: []))
+      end
+    end
+  end
+
   describe ".retry_conflicts" do
     subject(:transition_state) do
       described_class.retry_conflicts(retry_attempts) do
@@ -170,6 +275,42 @@ describe Statesman::Machine do
     end
   end
 
+  describe ".remove_transitions" do
+    before do
+      machine.class_eval do
+        state :x
+        state :y
+        state :z
+        transition from: :x, to: :y
+        transition from: :x, to: :z
+        transition from: :y, to: :z
+      end
+    end
+
+    let(:initial_successors) { { "x" => %w[y z], "y" => ["z"] } }
+
+    it "removes the correct transitions when given a from state" do
+      expect { machine.remove_transitions(from: :x) }.
+        to change(machine, :successors).
+        from(initial_successors).
+        to({ "y" => ["z"] })
+    end
+
+    it "removes the correct transitions when given a to state" do
+      expect { machine.remove_transitions(to: :z) }.
+        to change(machine, :successors).
+        from(initial_successors).
+        to({ "x" => ["y"] })
+    end
+
+    it "removes the correct transitions when given a from and to state" do
+      expect { machine.remove_transitions(from: :x, to: :z) }.
+        to change(machine, :successors).
+        from(initial_successors).
+        to({ "x" => ["y"], "y" => ["z"] })
+    end
+  end
+
   describe ".validate_callback_condition" do
     before do
       machine.class_eval do
@@ -338,12 +479,83 @@ describe Statesman::Machine do
     it_behaves_like "a callback store", :after_guard_failure, :after_guard_failure
   end
 
+  shared_examples "initial transition is not created" do
+    it "doesn't call .create on storage adapter" do
+      expect_any_instance_of(Statesman.storage_adapter).to_not receive(:create)
+      machine.new(my_model, options)
+    end
+  end
+
+  shared_examples "initial transition is created" do
+    it "calls .create on storage adapter" do
+      expect_any_instance_of(Statesman.storage_adapter).to receive(:create).with(nil, "x")
+      machine.new(my_model, options)
+    end
+
+    it "creates a new transition object" do
+      instance = machine.new(my_model, options)
+
+      expect(instance.history.count).to eq(1)
+      expect(instance.history.first.to_state).to eq("x")
+    end
+  end
+
   describe "#initialize" do
     it "accepts an object to manipulate" do
       machine_instance = machine.new(my_model)
       expect(machine_instance.object).to be(my_model)
     end
 
+    context "initial_transition is not provided" do
+      let(:options) { {} }
+
+      it_behaves_like "initial transition is not created"
+    end
+
+    context "initial_transition is provided" do
+      context "initial_transition is true" do
+        let(:options) do
+          { initial_transition: true,
+            transition_class: Statesman::Adapters::MemoryTransition }
+        end
+
+        context "history is empty" do
+          context "initial state is defined" do
+            before { machine.state(:x, initial: true) }
+
+            it_behaves_like "initial transition is created"
+          end
+
+          context "initial state is not defined" do
+            it_behaves_like "initial transition is not created"
+          end
+        end
+
+        context "history is not empty" do
+          before do
+            allow_any_instance_of(Statesman.storage_adapter).to receive(:history).
+              and_return([{}])
+          end
+
+          context "initial state is defined" do
+            before { machine.state(:x, initial: true) }
+
+            it_behaves_like "initial transition is not created"
+          end
+
+          context "initial state is not defined" do
+            it_behaves_like "initial transition is not created"
+          end
+        end
+      end
+
+      context "initial_transition is false" do
+        let(:options) { { initial_transition: false } }
+
+        it_behaves_like "initial transition is not created"
+      end
+    end
+
     context "transition class" do
       it "sets a default" do
         expect(Statesman.storage_adapter).to receive(:new).once.
@@ -399,9 +611,10 @@ describe Statesman::Machine do
     end
 
     context "with multiple transitions" do
-      before { instance.transition_to!(:y) }
-
-      before { instance.transition_to!(:z) }
+      before do
+        instance.transition_to!(:y)
+        instance.transition_to!(:z)
+      end
 
       it { is_expected.to eq("z") }
     end
@@ -416,12 +629,11 @@ describe Statesman::Machine do
         state :y
         transition from: :x, to: :y
       end
+      instance.transition_to!(:y)
     end
 
     let(:instance) { machine.new(my_model) }
 
-    before { instance.transition_to!(:y) }
-
     context "when machine is in given state" do
       let(:state) { "y" }
 
@@ -784,7 +996,7 @@ describe Statesman::Machine do
     let(:instance) { machine.new(my_model) }
     let(:metadata) { { some: :metadata } }
 
-    context "when it is succesful" do
+    context "when it is successful" do
       before do
         expect(instance).to receive(:transition_to!).once.
           with(:some_state, metadata).and_return(:some_state)
@@ -793,10 +1005,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 }
@@ -834,20 +1046,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

data/spec/statesman/utils_spec.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "spec_helper"
-
 describe Statesman::Utils do
   describe ".rails_major_version" do
     subject { described_class.rails_major_version }