aasm 4.12.3 → 5.5.0

data/spec/unit/persistence/redis_persistence_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-if defined?(Redis::Objects)
-  describe 'redis' do
-
-    Dir[File.dirname(__FILE__) + "/../../models/redis/*.rb"].sort.each do |f|
-      require File.expand_path(f)
-    end
-
-    before(:all) do
-      @model = RedisSimple
-    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 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 allow a nil state" do
-        model.status = nil
-        expect(model.aasm.current_state).to be_nil
-        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
-  end
-end

data/spec/unit/persistence/sequel_persistence_multiple_spec.rb

@@ -1,148 +0,0 @@
-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::Multiple
-    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(:left).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(:left).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(:left).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(:left).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(:left).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(:left).states).to eq(@model.aasm(:left).states)
-      end
-
-      it "should have the same events as its parent class" do
-        expect(Class.new(@model).aasm(:left).events).to eq(@model.aasm(:left).events)
-      end
-
-      it "should have the same column as its parent even for the new dsl" do
-        expect(@model.aasm(:left).attribute_name).to eq(:status)
-        expect(Class.new(@model).aasm(:left).attribute_name).to eq(:status)
-      end
-    end
-
-    describe 'initial states' do
-      it 'should support conditions' do
-        @model.aasm(:left) do
-          initial_state lambda{ |m| m.default }
-        end
-
-        expect(@model.new(:default => :beta).aasm(:left).current_state).to eq(:beta)
-        expect(@model.new(:default => :gamma).aasm(:left).current_state).to eq(:gamma)
-      end
-    end
-
-    describe "complex example" do
-      it "works" do
-        record = Sequel::ComplexExample.new
-        expect(record.aasm(:left).current_state).to eql :one
-        expect(record.left).to be_nil
-        expect(record.aasm(:right).current_state).to eql :alpha
-        expect(record.right).to be_nil
-
-        record.save
-        expect_aasm_states record, :one, :alpha
-        record.reload
-        expect_aasm_states record, :one, :alpha
-
-        record.increment!
-        expect_aasm_states record, :two, :alpha
-        record.reload
-        expect_aasm_states record, :two, :alpha
-
-        record.level_up!
-        expect_aasm_states record, :two, :beta
-        record.reload
-        expect_aasm_states record, :two, :beta
-
-        record.increment!
-        expect { record.increment! }.to raise_error(AASM::InvalidTransition)
-        expect_aasm_states record, :three, :beta
-        record.reload
-        expect_aasm_states record, :three, :beta
-
-        record.level_up!
-        expect_aasm_states record, :three, :gamma
-        record.reload
-        expect_aasm_states record, :three, :gamma
-
-        record.level_down # without saving
-        expect_aasm_states record, :three, :beta
-        record.reload
-        expect_aasm_states record, :three, :gamma
-
-        record.level_down # without saving
-        expect_aasm_states record, :three, :beta
-        record.reset!
-        expect_aasm_states record, :one, :beta
-      end
-
-      def expect_aasm_states(record, left_state, right_state)
-        expect(record.aasm(:left).current_state).to eql left_state.to_sym
-        expect(record.left).to eql left_state.to_s
-        expect(record.aasm(:right).current_state).to eql right_state.to_sym
-        expect(record.right).to eql right_state.to_s
-      end
-    end
-
-  end
-end

data/spec/unit/persistence/sequel_persistence_spec.rb

@@ -1,368 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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