statesman 1.3.1 → 2.0.0.rc1

data/lib/statesman/version.rb

@@ -1,3 +1,3 @@
 module Statesman
-  VERSION = "1.3.1"
+  VERSION = "2.0.0.rc1"
 end

data/spec/spec_helper.rb

@@ -1,5 +1,8 @@
 require "statesman"
 require "sqlite3"
+require "mysql2"
+require "pg"
+require "mongoid"
 require "active_record"
 # We have to include all of Rails to make rspec-rails work
 require "rails"
@@ -8,7 +11,6 @@ require "action_dispatch"
 require "action_controller"
 require "rspec/rails"
 require "support/active_record"
-require "mongoid"
 require "rspec/its"
 
 RSpec.configure do |config|
@@ -17,16 +19,28 @@ RSpec.configure do |config|
 
   config.order = "random"
 
+  def connection_failure
+    if defined?(Moped)
+      Moped::Errors::ConnectionFailure
+    else
+      Mongo::Error::NoServerAvailable
+    end
+  end
+
   # Try a mongo connection at the start of the suite and raise if it fails
   begin
     Mongoid.configure do |mongo_config|
-      mongo_config.connect_to("statesman_test")
-      mongo_config.sessions["default"]["options"]["max_retries"] = 2
+      if defined?(Moped)
+        mongo_config.connect_to("statesman_test")
+        mongo_config.sessions["default"]["options"]["max_retries"] = 2
+      else
+        mongo_config.connect_to("statesman_test", server_selection_timeout: 2)
+      end
     end
     # Attempting a mongo operation will trigger 2 retries then throw an
     # exception if mongo is not running.
     Mongoid.purge! unless config.exclusion_filter[:mongo]
-  rescue Moped::Errors::ConnectionFailure => error
+  rescue connection_failure => error
     puts "The spec suite requires MongoDB to be installed and running locally"
     puts "Mongo dependent specs can be filtered with rspec --tag '~mongo'"
     raise(error)
@@ -71,13 +85,6 @@ RSpec.configure do |config|
       end
     end
 
-    def drop_most_recent_column
-      silence_stream(STDOUT) do
-        DropMostRecentColumn.migrate(:up)
-        MyActiveRecordModelTransition.reset_column_information
-      end
-    end
-
     def prepare_other_model_table
       silence_stream(STDOUT) do
         CreateOtherActiveRecordModelMigration.migrate(:up)

data/spec/statesman/adapters/active_record_queries_spec.rb

@@ -61,129 +61,66 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
     model
   end
 
-  context "with a most_recent column" do
-    describe ".in_state" do
-      context "given a single state" do
-        subject { MyActiveRecordModel.in_state(:succeeded) }
-
-        it { is_expected.to include model }
-        it { is_expected.not_to include other_model }
-        its(:to_sql) { is_expected.to include('.most_recent ') }
-      end
+  describe ".in_state" do
+    context "given a single state" do
+      subject { MyActiveRecordModel.in_state(:succeeded) }
 
-      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
+      it { is_expected.to include model }
+      it { is_expected.not_to 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([: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))
-        end
+    context "given an array of states" do
+      subject { MyActiveRecordModel.in_state([:succeeded, :failed]) }
 
-        it { is_expected.to be_empty }
-      end
+      it { is_expected.to include model }
+      it { is_expected.to include other_model }
     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.not_to include other_model }
-        its(:to_sql) { is_expected.to include('.most_recent ') }
+    context "merging two queries" do
+      subject do
+        MyActiveRecordModel.in_state(:succeeded).
+          joins(:other_active_record_model).
+          merge(OtherActiveRecordModel.in_state(:initial))
       end
 
-      context "given multiple states" do
-        subject { MyActiveRecordModel.not_in_state(:succeeded, :failed) }
-        it do
-          is_expected.to match_array([initial_state_model,
-                                      returned_to_initial_model])
-        end
-      end
-
-      context "given an array of states" do
-        subject { MyActiveRecordModel.not_in_state([:succeeded, :failed]) }
-        it do
-          is_expected.to match_array([initial_state_model,
-                                      returned_to_initial_model])
-        end
-      end
+      it { is_expected.to be_empty }
     end
   end
 
-  context "without a most_recent column" do
-    before { drop_most_recent_column }
-
-    describe ".in_state" do
-      context "given a single state" do
-        subject { MyActiveRecordModel.in_state(:succeeded) }
-
-        it { is_expected.to include model }
-        its(:to_sql) { is_expected.not_to include('.most_recent ') }
-      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([:succeeded, :failed]) }
-
-        it { is_expected.to include model }
-        it { is_expected.to include other_model }
-      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.not_to include other_model }
     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.not_to include other_model }
-        its(:to_sql) { is_expected.not_to include('.most_recent ') }
-      end
-
-      context "given multiple states" do
-        subject { MyActiveRecordModel.not_in_state(:succeeded, :failed) }
-        it do
-          is_expected.to match_array([initial_state_model,
-                                      returned_to_initial_model])
-        end
+    context "given multiple states" do
+      subject { MyActiveRecordModel.not_in_state(:succeeded, :failed) }
+      it do
+        is_expected.to match_array([initial_state_model,
+                                    returned_to_initial_model])
       end
+    end
 
-      context "given an array of states" do
-        subject { MyActiveRecordModel.not_in_state([:succeeded, :failed]) }
-        it do
-          is_expected.to match_array([initial_state_model,
-                                      returned_to_initial_model])
-        end
+    context "given an array of states" do
+      subject { MyActiveRecordModel.not_in_state([:succeeded, :failed]) }
+      it do
+        is_expected.to match_array([initial_state_model,
+                                    returned_to_initial_model])
       end
     end
   end
@@ -200,20 +137,9 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
       end
     end
 
-    context "with a most_recent column" do
-      describe ".in_state" do
-        subject(:query) { MyActiveRecordModel.in_state(:succeeded) }
-        specify { expect { query }.to_not raise_error }
-      end
-    end
-
-    context "without a most_recent column" do
-      before { drop_most_recent_column }
-
-      describe ".in_state" do
-        subject(:query) { MyActiveRecordModel.in_state(:succeeded) }
-        specify { expect { query }.to_not raise_error }
-      end
+    describe ".in_state" do
+      subject(:query) { MyActiveRecordModel.in_state(:succeeded) }
+      specify { expect { query }.to_not raise_error }
     end
   end
 end

data/spec/statesman/adapters/active_record_spec.rb

@@ -131,7 +131,7 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
       end
     end
 
-    context "when the transition_class has a most_recent column" do
+    describe "updating the most_recent column" do
       subject { create }
 
       context "with no previous transition" do
@@ -148,17 +148,31 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
             from(true).to be_falsey
         end
 
-        context "and the parent model is updated in a callback" do
-          before do
-            allow(observer).to receive(:execute) do |phase|
-              if phase == :before
-                model.update_attributes!(current_state: :ready)
+        context "and a query on the parent model's state is made" do
+          context "in a before action" 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")
               end
+
+              adapter.create(:y, :z)
             end
           end
 
-          it "doesn't save the transition too early" do
-            expect { create }.to_not raise_exception
+          context "in an after action" 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")
+              end
+
+              adapter.create(:y, :z)
+            end
           end
         end
       end
@@ -175,11 +189,6 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
         end
       end
     end
-
-    context "when the transition_class doesn't have a most_recent column" do
-      before { drop_most_recent_column }
-      it { is_expected.to_not raise_exception }
-    end
   end
 
   describe "#last" do
@@ -198,12 +207,32 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
         adapter.last
       end
 
-      context "and a new transition" do
+      context "after then creating a new transition" do
         before { adapter.create(:y, :z, []) }
         it "retrieves the new transition from the database" do
           expect(adapter.last.to_state).to eq("z")
         end
       end
+
+      context "when a new transition has been created elsewhere" do
+        let(:alternate_adapter) do
+          described_class.new(MyActiveRecordModelTransition, model, observer)
+        end
+
+        before { alternate_adapter.create(:y, :z, []) }
+
+        it "still returns the cached value" do
+          expect_any_instance_of(MyActiveRecordModel).
+            to receive(:my_active_record_model_transitions).never
+          expect(adapter.last.to_state).to eq("y")
+        end
+
+        context "when explitly not using the cache" do
+          it "still returns the cached value" do
+            expect(adapter.last(force_reload: true).to_state).to eq("z")
+          end
+        end
+      end
     end
 
     context "with a pre-fetched transition history" do

data/spec/statesman/adapters/shared_examples.rb

@@ -47,12 +47,12 @@ shared_examples_for "an adapter" do |adapter_class, transition_class, options =
       end
 
       context "with no previous transition" do
-        its(:sort_key) { is_expected.to be(0) }
+        its(:sort_key) { is_expected.to be(10) }
       end
 
       context "with a previous transition" do
         before { adapter.create(from, to) }
-        its(:sort_key) { is_expected.to be(10) }
+        its(:sort_key) { is_expected.to be(20) }
       end
     end
 
@@ -118,5 +118,8 @@ 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
   end
 end

data/spec/statesman/machine_spec.rb

@@ -374,6 +374,61 @@ describe Statesman::Machine do
     end
   end
 
+  describe "#in_state?" do
+    before do
+      machine.class_eval do
+        state :x, initial: true
+        state :y
+        transition from: :x, to: :y
+      end
+    end
+
+    let(:instance) { machine.new(my_model) }
+    subject { instance.in_state?(state) }
+    before { instance.transition_to!(:y) }
+
+    context "when machine is in given state" do
+      let(:state) { "y" }
+      it { is_expected.to eq(true) }
+    end
+
+    context "when machine is not in given state" do
+      let(:state) { "x" }
+      it { is_expected.to eq(false) }
+    end
+
+    context "when given a symbol" do
+      let(:state) { :y }
+      it { is_expected.to eq(true) }
+    end
+
+    context "when given multiple states" do
+      context "when given multiple arguments" do
+        context "when one of the states is the current state" do
+          subject { instance.in_state?(:x, :y) }
+          it { is_expected.to eq(true) }
+        end
+
+        context "when none of the states are the current state" do
+          subject { instance.in_state?(:x, :z) }
+          it { is_expected.to eq(false) }
+        end
+      end
+
+      context "when given an array" do
+        context "when one of the states is the current state" do
+          subject { instance.in_state?([:x, :y]) }
+          it { is_expected.to eq(true) }
+        end
+
+        context "when none of the states are the current state" do
+          subject { instance.in_state?([:x, :z]) }
+          it { is_expected.to eq(false) }
+        end
+      end
+    end
+  end
+
   describe "#allowed_transitions" do
     before do
       machine.class_eval do
@@ -627,126 +682,4 @@ describe Statesman::Machine do
   describe "#after_callbacks_for" do
     it_behaves_like "a callback filter", :after_transition, :after
   end
-
-  describe "#event" do
-    before do
-      machine.class_eval do
-        state :x, initial: true
-        state :y
-        state :z
-
-        event :event_1 do
-          transition from: :x, to: :y
-        end
-
-        event :event_2 do
-          transition from: :y, to: :z
-        end
-      end
-    end
-
-    let(:instance) { machine.new(my_model) }
-
-    context "when the state cannot be transitioned to" do
-      it "raises an error" do
-        expect { instance.trigger!(:event_2) }.
-          to raise_error(Statesman::TransitionFailedError)
-      end
-    end
-
-    context "when the state can be transitioned to" do
-      it "changes state" do
-        instance.trigger!(:event_1)
-        expect(instance.current_state).to eq("y")
-      end
-
-      it "creates a new transition object" do
-        expect { instance.trigger!(:event_1) }.
-          to change(instance.history, :count).by(1)
-
-        expect(instance.history.first).
-          to be_a(Statesman::Adapters::MemoryTransition)
-        expect(instance.history.first.to_state).to eq("y")
-      end
-
-      it "sends metadata to the transition object" do
-        meta = { "my" => "hash" }
-        instance.trigger!(:event_1, meta)
-        expect(instance.history.first.metadata).to eq(meta)
-      end
-
-      it "sets an empty hash as the metadata if not specified" do
-        instance.trigger!(:event_1)
-        expect(instance.history.first.metadata).to eq({})
-      end
-
-      it "returns true" do
-        expect(instance.trigger!(:event_1)).to eq(true)
-      end
-
-      context "with a guard" do
-        let(:result) { true }
-        # rubocop:disable UnusedBlockArgument
-        let(:guard_cb) { ->(*args) { result } }
-        # rubocop:enable UnusedBlockArgument
-        before { machine.guard_transition(from: :x, to: :y, &guard_cb) }
-
-        context "and an object to act on" do
-          let(:instance) { machine.new(my_model) }
-
-          it "passes the object to the guard" do
-            expect(guard_cb).to receive(:call).once.
-              with(my_model, instance.last_transition, {}).and_return(true)
-            instance.trigger!(:event_1)
-          end
-        end
-
-        context "which passes" do
-          it "changes state" do
-            expect { instance.trigger!(:event_1) }.
-              to change { instance.current_state }.to("y")
-          end
-        end
-
-        context "which fails" do
-          let(:result) { false }
-
-          it "raises an exception" do
-            expect { instance.trigger!(:event_1) }.
-              to raise_error(Statesman::GuardFailedError)
-          end
-        end
-      end
-    end
-  end
-
-  describe "#available_events" do
-    before do
-      machine.class_eval do
-        state :x, initial: true
-        state :y
-        state :z
-
-        event :event_1 do
-          transition from: :x, to: :y
-        end
-
-        event :event_2 do
-          transition from: :y, to: :z
-        end
-
-        event :event_3 do
-          transition from: :x, to: :y
-          transition from: :y, to: :x
-        end
-      end
-    end
-
-    let(:instance) { machine.new(my_model) }
-    it "should return list of available events for the current state" do
-      expect(instance.available_events).to eq([:event_1, :event_3])
-      instance.trigger!(:event_1)
-      expect(instance.available_events).to eq([:event_2, :event_3])
-    end
-  end
 end