aasm 2.1.1 → 5.2.0

data/spec/unit/persistence/sequel_persistence_spec.rb

@@ -0,0 +1,368 @@
+require 'spec_helper'
+if defined?(Sequel)
+  describe 'sequel' do
+
+    Dir[File.dirname(__FILE__) + "/../../models/sequel/*.rb"].sort.each do |f|
+      require File.expand_path(f)
+    end
+
+    before(:all) do
+      @model = Sequel::Simple
+    end
+
+    describe "instance methods" do
+      let(:model) {@model.new}
+
+      it "should respond to aasm persistence methods" do
+        expect(model).to respond_to(:aasm_read_state)
+        expect(model).to respond_to(:aasm_write_state)
+        expect(model).to respond_to(:aasm_write_state_without_persistence)
+      end
+
+      it "should return the initial state when new and the aasm field is nil" do
+        expect(model.aasm.current_state).to eq(:alpha)
+      end
+
+      it "should save the initial state" do
+        model.save
+        expect(model.status).to eq("alpha")
+      end
+
+      it "should return the aasm column when new and the aasm field is not nil" do
+        model.status = "beta"
+        expect(model.aasm.current_state).to eq(:beta)
+      end
+
+      it "should return the aasm column when not new and the aasm_column is not nil" do
+        allow(model).to receive(:new?).and_return(false)
+        model.status = "gamma"
+        expect(model.aasm.current_state).to eq(:gamma)
+      end
+
+      it "should allow a nil state" do
+        allow(model).to receive(:new?).and_return(false)
+        model.status = nil
+        expect(model.aasm.current_state).to be_nil
+      end
+
+      it "should not change the state if state is not loaded" do
+        model.release
+        model.save
+        model.class.select(:id).first.save
+        model.reload
+        expect(model.aasm.current_state).to eq(:beta)
+      end
+
+      it "should call aasm_ensure_initial_state on validation before create" do
+        expect(model).to receive(:aasm_ensure_initial_state).and_return(true)
+        model.valid?
+      end
+
+      it "should call aasm_ensure_initial_state before create, even if skipping validations" do
+        expect(model).to receive(:aasm_ensure_initial_state).and_return(true)
+        model.save(:validate => false)
+      end
+    end
+
+    describe 'subclasses' do
+      it "should have the same states as its parent class" do
+        expect(Class.new(@model).aasm.states).to eq(@model.aasm.states)
+      end
+
+      it "should have the same events as its parent class" do
+        expect(Class.new(@model).aasm.events).to eq(@model.aasm.events)
+      end
+
+      it "should have the same column as its parent even for the new dsl" do
+        expect(@model.aasm.attribute_name).to eq(:status)
+        expect(Class.new(@model).aasm.attribute_name).to eq(:status)
+      end
+    end
+
+    describe 'initial states' do
+      it 'should support conditions' do
+        @model.aasm do
+          initial_state lambda{ |m| m.default }
+        end
+
+        expect(@model.new(:default => :beta).aasm.current_state).to eq(:beta)
+        expect(@model.new(:default => :gamma).aasm.current_state).to eq(:gamma)
+      end
+    end
+
+    describe 'transitions with persistence' do
+
+      it "should work for valid models" do
+        valid_object = Sequel::Validator.create(:name => 'name')
+        expect(valid_object).to be_sleeping
+        valid_object.status = :running
+        expect(valid_object).to be_running
+      end
+
+      it 'should not store states for invalid models' do
+        validator = Sequel::Validator.create(:name => 'name')
+        expect(validator).to be_valid
+        expect(validator).to be_sleeping
+
+        validator.name = nil
+        expect(validator).not_to be_valid
+        expect { validator.run! }.to raise_error(Sequel::ValidationFailed)
+        expect(validator).to be_sleeping
+
+        validator.reload
+        expect(validator).not_to be_running
+        expect(validator).to be_sleeping
+
+        validator.name = 'another name'
+        expect(validator).to be_valid
+        expect(validator.run!).to be_truthy
+        expect(validator).to be_running
+
+        validator.reload
+        expect(validator).to be_running
+        expect(validator).not_to be_sleeping
+      end
+
+      it 'should not store states for invalid models silently if configured' do
+        validator = Sequel::SilentPersistor.create(:name => 'name')
+        expect(validator).to be_valid
+        expect(validator).to be_sleeping
+
+        validator.name = nil
+        expect(validator).not_to be_valid
+        expect(validator.run!).to be_falsey
+        expect(validator).to be_sleeping
+
+        validator.reload
+        expect(validator).not_to be_running
+        expect(validator).to be_sleeping
+
+        validator.name = 'another name'
+        expect(validator).to be_valid
+        expect(validator.run!).to be_truthy
+        expect(validator).to be_running
+
+        validator.reload
+        expect(validator).to be_running
+        expect(validator).not_to be_sleeping
+      end
+
+      it 'should store states for invalid models if configured' do
+        persistor = Sequel::InvalidPersistor.create(:name => 'name')
+        expect(persistor).to be_valid
+        expect(persistor).to be_sleeping
+
+        persistor.name = nil
+        expect(persistor).not_to be_valid
+        expect(persistor.run!).to be_truthy
+        expect(persistor).to be_running
+
+        persistor = Sequel::InvalidPersistor[persistor.id]
+        persistor.valid?
+        expect(persistor).to be_valid
+        expect(persistor).to be_running
+        expect(persistor).not_to be_sleeping
+
+        persistor.reload
+        expect(persistor).to be_running
+        expect(persistor).not_to be_sleeping
+      end
+
+      describe 'pessimistic locking' do
+        let(:worker) { Sequel::Worker.create(:name => 'worker', :status => 'sleeping') }
+
+        subject { transactor.run! }
+
+        context 'no lock' do
+          let(:transactor) { Sequel::NoLockTransactor.create(:name => 'no_lock_transactor', :worker => worker) }
+
+          it 'should not invoke lock!' do
+            expect(transactor).to_not receive(:lock!)
+            subject
+          end
+        end
+
+        context 'a default lock' do
+          let(:transactor) { Sequel::LockTransactor.create(:name => 'lock_transactor', :worker => worker) }
+
+          it 'should invoke lock!' do
+            expect(transactor).to receive(:lock!).and_call_original
+            subject
+          end
+        end
+
+        context 'a FOR UPDATE NOWAIT lock' do
+          let(:transactor) { Sequel::LockNoWaitTransactor.create(:name => 'lock_no_wait_transactor', :worker => worker) }
+
+          it 'should invoke lock! with FOR UPDATE NOWAIT' do
+            # TODO: With and_call_original, get an error with syntax, should look into it.
+            expect(transactor).to receive(:lock!).with('FOR UPDATE NOWAIT')# .and_call_original
+            subject
+          end
+        end
+      end
+
+      describe 'transactions' do
+        let(:worker) { Sequel::Worker.create(:name => 'worker', :status => 'sleeping') }
+        let(:transactor) { Sequel::Transactor.create(:name => 'transactor', :worker => worker) }
+
+        it 'should rollback all changes' do
+          expect(transactor).to be_sleeping
+          expect(worker.status).to eq('sleeping')
+
+          expect {transactor.run!}.to raise_error(StandardError, 'failed on purpose')
+          expect(transactor).to be_running
+          expect(worker.reload.status).to eq('sleeping')
+        end
+
+        context "nested transactions" do
+          it "should rollback all changes in nested transaction" do
+            expect(transactor).to be_sleeping
+            expect(worker.status).to eq('sleeping')
+
+            Sequel::Worker.db.transaction do
+              expect { transactor.run! }.to raise_error(StandardError, 'failed on purpose')
+            end
+
+            expect(transactor).to be_running
+            expect(worker.reload.status).to eq('sleeping')
+          end
+
+          it "should only rollback changes in the main transaction not the nested one" do
+            # change configuration to not require new transaction
+            AASM::StateMachineStore[Sequel::Transactor][:default].config.requires_new_transaction = false
+
+            expect(transactor).to be_sleeping
+            expect(worker.status).to eq('sleeping')
+            Sequel::Worker.db.transaction do
+              expect { transactor.run! }.to raise_error(StandardError, 'failed on purpose')
+            end
+            expect(transactor).to be_running
+            expect(worker.reload.status).to eq('running')
+          end
+        end
+
+        describe "after_commit callback" do
+          it "should fire :after_commit if transaction was successful" do
+            validator = Sequel::Validator.create(:name => 'name')
+            expect(validator).to be_sleeping
+
+            validator.run!
+            expect(validator).to be_running
+            expect(validator.name).to eq("name changed")
+
+            validator.sleep!("sleeper")
+            expect(validator).to be_sleeping
+            expect(validator.name).to eq("sleeper")
+          end
+
+          it "should not fire :after_commit if transaction failed" do
+            validator = Sequel::Validator.create(:name => 'name')
+            expect { validator.fail! }.to raise_error(StandardError, 'failed on purpose')
+            expect(validator.name).to eq("name")
+          end
+
+          it "should not fire :after_commit if validation failed when saving object" do
+            validator = Sequel::Validator.create(:name => 'name')
+            validator.invalid = true
+            expect { validator.run! }.to raise_error(Sequel::ValidationFailed, 'validator invalid')
+            expect(validator).to be_sleeping
+            expect(validator.name).to eq("name")
+          end
+
+          it "should not fire if not saving" do
+            validator = Sequel::Validator.create(:name => 'name')
+            expect(validator).to be_sleeping
+            validator.run
+            expect(validator).to be_running
+            expect(validator.name).to eq("name")
+          end
+        end
+
+        describe 'before and after transaction callbacks' do
+          [:after, :before].each do |event_type|
+            describe "#{event_type}_transaction callback" do
+              it "should fire :#{event_type}_transaction if transaction was successful" do
+                validator = Sequel::Validator.create(:name => 'name')
+                expect(validator).to be_sleeping
+
+                expect { validator.run! }.to change { validator.send("#{event_type}_transaction_performed_on_run") }.from(nil).to(true)
+                expect(validator).to be_running
+              end
+
+              it "should fire :#{event_type}_transaction if transaction failed" do
+                validator = Sequel::Validator.create(:name => 'name')
+                expect do
+                  begin
+                    validator.fail!
+                  rescue => ignored
+                  end
+                end.to change { validator.send("#{event_type}_transaction_performed_on_fail") }.from(nil).to(true)
+                expect(validator).to_not be_running
+              end
+
+              it "should not fire :#{event_type}_transaction if not saving" do
+                validator = Sequel::Validator.create(:name => 'name')
+                expect(validator).to be_sleeping
+                expect { validator.run }.to_not change { validator.send("#{event_type}_transaction_performed_on_run") }
+                expect(validator).to be_running
+                expect(validator.name).to eq("name")
+              end
+            end
+          end
+        end
+
+        describe 'before and after all transactions callbacks' do
+          [:after, :before].each do |event_type|
+            describe "#{event_type}_all_transactions callback" do
+              it "should fire :#{event_type}_all_transactions if transaction was successful" do
+                validator = Sequel::Validator.create(:name => 'name')
+                expect(validator).to be_sleeping
+
+                expect { validator.run! }.to change { validator.send("#{event_type}_all_transactions_performed") }.from(nil).to(true)
+                expect(validator).to be_running
+              end
+
+              it "should fire :#{event_type}_all_transactions if transaction failed" do
+                validator = Sequel::Validator.create(:name => 'name')
+                expect do
+                  begin
+                    validator.fail!
+                  rescue => ignored
+                  end
+                end.to change { validator.send("#{event_type}_all_transactions_performed") }.from(nil).to(true)
+                expect(validator).to_not be_running
+              end
+
+              it "should not fire :#{event_type}_all_transactions if not saving" do
+                validator = Sequel::Validator.create(:name => 'name')
+                expect(validator).to be_sleeping
+                expect { validator.run }.to_not change { validator.send("#{event_type}_all_transactions_performed") }
+                expect(validator).to be_running
+                expect(validator.name).to eq("name")
+              end
+            end
+          end
+        end
+
+        context "when not persisting" do
+          it 'should not rollback all changes' do
+            expect(transactor).to be_sleeping
+            expect(worker.status).to eq('sleeping')
+
+            # Notice here we're calling "run" and not "run!" with a bang.
+            expect {transactor.run}.to raise_error(StandardError, 'failed on purpose')
+            expect(transactor).to be_running
+            expect(worker.reload.status).to eq('running')
+          end
+
+          it 'should not create a database transaction' do
+            expect(transactor.class).not_to receive(:transaction)
+            expect {transactor.run}.to raise_error(StandardError, 'failed on purpose')
+          end
+        end
+      end
+    end
+
+  end
+end

data/spec/unit/readme_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe 'testing the README examples' do
+
+  it 'Usage' do
+    class Job
+      include AASM
+
+      aasm do
+        state :sleeping, :initial => true
+        state :running, :cleaning
+
+        event :run do
+          transitions :from => :sleeping, :to => :running
+        end
+
+        event :clean do
+          transitions :from => :running, :to => :cleaning
+        end
+
+        event :sleep do
+          transitions :from => [:running, :cleaning], :to => :sleeping
+        end
+      end
+    end
+
+    job = Job.new
+
+    expect(job.sleeping?).to eql true
+    expect(job.may_run?).to eql true
+
+    job.run
+
+    expect(job.running?).to eql true
+    expect(job.sleeping?).to eql false
+    expect(job.may_run?).to eql false
+
+    expect { job.run }.to raise_error(AASM::InvalidTransition)
+  end
+
+end

data/spec/unit/reloading_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe 'when redefining states' do
+  let(:definer) { DoubleDefiner.new }
+
+  it "allows extending states" do
+    expect(definer).to receive(:do_enter)
+    definer.finish
+  end
+
+  it "allows extending events" do
+    expect(definer).to receive(:do_on_transition)
+    definer.finish
+  end
+end

data/spec/unit/rspec_matcher_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe 'state machine' do
+  let(:simple) { SimpleExample.new }
+  let(:multiple) { SimpleMultipleExample.new }
+
+  describe 'transition_from' do
+    it "works for simple state machines" do
+      expect(simple).to transition_from(:initialised).to(:filled_out).on_event(:fill_out)
+      expect(simple).to_not transition_from(:initialised).to(:authorised).on_event(:fill_out)
+      expect(simple).to_not transition_from(:authorised).to(:filled_out).on_event(:fill_out)
+    end
+
+    it "works for multiple state machines" do
+      expect(multiple).to transition_from(:standing).to(:walking).on_event(:walk).on(:move)
+      expect(multiple).to_not transition_from(:standing).to(:running).on_event(:walk).on(:move)
+      expect(multiple).to_not transition_from(:running).to(:walking).on_event(:walk).on(:move)
+
+      expect(multiple).to transition_from(:sleeping).to(:processing).on_event(:start).on(:work)
+      expect(multiple).to_not transition_from(:sleeping).to(:sleeping).on_event(:start).on(:work)
+      expect(multiple).to_not transition_from(:processing).to(:sleeping).on_event(:start).on(:work)
+    end
+  end
+
+  describe 'allow_transition_to' do
+    it "works for simple state machines" do
+      expect(simple).to allow_transition_to(:filled_out)
+      expect(simple).to_not allow_transition_to(:authorised)
+    end
+
+    it "works for multiple state machines" do
+      expect(multiple).to allow_transition_to(:walking).on(:move)
+      expect(multiple).to_not allow_transition_to(:standing).on(:move)
+
+      expect(multiple).to allow_transition_to(:processing).on(:work)
+      expect(multiple).to_not allow_transition_to(:sleeping).on(:work)
+    end
+  end
+
+  describe "have_state" do
+    it "works for simple state machines" do
+      expect(simple).to have_state :initialised
+      expect(simple).to_not have_state :filled_out
+      simple.fill_out
+      expect(simple).to have_state :filled_out
+    end
+
+    it "works for multiple state machines" do
+      expect(multiple).to have_state(:standing).on(:move)
+      expect(multiple).to_not have_state(:walking).on(:move)
+      multiple.walk
+      expect(multiple).to have_state(:walking).on(:move)
+
+      expect(multiple).to have_state(:sleeping).on(:work)
+      expect(multiple).to_not have_state(:processing).on(:work)
+      multiple.start
+      expect(multiple).to have_state(:processing).on(:work)
+    end
+  end
+
+  describe "allow_event" do
+    it "works for simple state machines" do
+      expect(simple).to allow_event :fill_out
+      expect(simple).to_not allow_event :authorise
+      simple.fill_out
+      expect(simple).to allow_event :authorise
+    end
+
+    it "works with custom arguments" do
+      example = SimpleExampleWithGuardArgs.new
+      expect(example).to allow_event(:fill_out_with_args).with(true)
+      expect(example).to_not allow_event(:fill_out_with_args).with(false)
+    end
+
+    it "works for multiple state machines" do
+      expect(multiple).to allow_event(:walk).on(:move)
+      expect(multiple).to_not allow_event(:hold).on(:move)
+      multiple.walk
+      expect(multiple).to allow_event(:hold).on(:move)
+
+      expect(multiple).to allow_event(:start).on(:work)
+      expect(multiple).to_not allow_event(:stop).on(:work)
+      multiple.start
+      expect(multiple).to allow_event(:stop).on(:work)
+    end
+  end
+
+end

data/spec/unit/simple_custom_example_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe 'Custom AASM::Base' do
+  context 'when aasm_with invoked with SimpleCustomExample' do
+    let(:simple_custom) { SimpleCustomExample.new }
+
+    subject do
+      simple_custom.fill_out!
+      simple_custom.authorise
+    end
+
+    it 'has invoked authorizable?' do
+      expect { subject }.to change { simple_custom.authorizable_called }.from(nil).to(true)
+    end
+
+    it 'has invoked fillable?' do
+      expect { subject }.to change { simple_custom.fillable_called }.from(nil).to(true)
+    end
+
+    it 'has two transition counts' do
+      expect { subject }.to change { simple_custom.transition_count }.from(nil).to(2)
+    end
+  end
+
+  context 'when aasm_with invoked with non AASM::Base' do
+    subject do
+      Class.new do
+        include AASM
+
+        aasm :with_klass => String do
+        end
+      end
+    end
+
+    it 'should raise an ArgumentError' do
+      expect { subject }.to raise_error(ArgumentError, 'The class String must inherit from AASM::Base!')
+    end
+  end
+end

data/spec/unit/simple_example_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe 'state machine' do
+  let(:simple) { SimpleExample.new }
+
+  it 'starts with an initial state' do
+    expect(simple.aasm.current_state).to eq(:initialised)
+    expect(simple).to respond_to(:initialised?)
+    expect(simple).to be_initialised
+  end
+
+  it 'allows transitions to other states' do
+    expect(simple).to respond_to(:fill_out)
+    expect(simple).to respond_to(:fill_out!)
+    simple.fill_out!
+    expect(simple).to respond_to(:filled_out?)
+    expect(simple).to be_filled_out
+
+    expect(simple).to respond_to(:authorise)
+    expect(simple).to respond_to(:authorise!)
+    simple.authorise
+    expect(simple).to respond_to(:authorised?)
+    expect(simple).to be_authorised
+  end
+
+  it 'shows the permitted transitions' do
+    expect(simple.aasm.permitted_transitions).to eq(
+      [
+        { event: :fill_out, state: :filled_out },
+        { event: :deny, state: :denied }
+      ]
+    )
+
+    simple.fill_out!
+    expect(simple.aasm.permitted_transitions).to eq([{ event: :authorise, state: :authorised }])
+
+    simple.authorise
+    expect(simple.aasm.permitted_transitions).to eq([])
+  end
+
+  it 'denies transitions to other states' do
+    expect {simple.authorise}.to raise_error(AASM::InvalidTransition)
+    expect {simple.authorise!}.to raise_error(AASM::InvalidTransition)
+    simple.fill_out
+    expect {simple.fill_out}.to raise_error(AASM::InvalidTransition)
+    expect {simple.fill_out!}.to raise_error(AASM::InvalidTransition)
+    simple.authorise
+    expect {simple.fill_out}.to raise_error(AASM::InvalidTransition)
+    expect {simple.fill_out!}.to raise_error(AASM::InvalidTransition)
+  end
+
+  it 'defines constants for each state name' do
+    expect(SimpleExample::STATE_INITIALISED).to eq(:initialised)
+    expect(SimpleExample::STATE_FILLED_OUT).to eq(:filled_out)
+    expect(SimpleExample::STATE_AUTHORISED).to eq(:authorised)
+  end
+end