aasm 4.12.0 → 4.12.1

data/spec/models/sequel/validator.rb

@@ -0,0 +1,93 @@
+db = Sequel::DATABASES.first || Sequel.connect(SEQUEL_DB)
+
+db.create_table(:validators) do
+  primary_key :id
+  String "name"
+  String "status"
+  Fixnum "worker_id"
+end
+
+module Sequel
+  class Validator < Sequel::Model(:validators)
+    plugin :validation_helpers
+
+    attr_accessor :after_all_transactions_performed,
+      :after_transaction_performed_on_fail,
+      :after_transaction_performed_on_run,
+      :before_all_transactions_performed,
+      :before_transaction_performed_on_fail,
+      :before_transaction_performed_on_run,
+      :invalid
+
+    def validate
+      super
+      errors.add(:validator, "invalid") if invalid
+      validates_presence :name
+    end
+
+    include AASM
+
+    aasm :column => :status, :whiny_persistence => true do
+      before_all_transactions :before_all_transactions
+      after_all_transactions  :after_all_transactions
+
+      state :sleeping, :initial => true
+      state :running
+      state :failed, :after_enter => :fail
+
+      event :run, :after_commit => :change_name! do
+        after_transaction do
+          @after_transaction_performed_on_run = true
+        end
+
+        before_transaction do
+          @before_transaction_performed_on_run = true
+        end
+
+        transitions :to => :running, :from => :sleeping
+      end
+
+      event :sleep do
+        after_commit do |name|
+          change_name_on_sleep name
+        end
+        transitions :to => :sleeping, :from => :running
+      end
+
+      event :fail do
+        after_transaction do
+          @after_transaction_performed_on_fail = true
+        end
+
+        before_transaction do
+          @before_transaction_performed_on_fail = true
+        end
+
+        transitions :to => :failed, :from => [:sleeping, :running]
+      end
+    end
+
+    def change_name!
+      self.name = "name changed"
+      save(raise_on_failure: true)
+    end
+
+    def change_name_on_sleep name
+      self.name = name
+      save(raise_on_failure: true)
+    end
+
+    def fail
+      raise StandardError.new('failed on purpose')
+    end
+
+    def after_all_transactions
+      @after_all_transactions_performed = true
+    end
+
+    def before_all_transactions
+      @before_all_transactions_performed = true
+    end
+  end
+
+end

data/spec/models/sequel/worker.rb

@@ -0,0 +1,12 @@
+db = Sequel::DATABASES.first || Sequel.connect(SEQUEL_DB)
+
+db.create_table(:workers) do
+  primary_key :id
+  String "name"
+  String "status"
+end
+
+module Sequel
+  class Worker < Sequel::Model(:workers)
+  end
+end

data/spec/spec_helpers/redis.rb

@@ -2,6 +2,14 @@
 begin
   require 'redis-objects'
   puts "redis-objects gem found, running Redis specs \e[32m#{'✔'}\e[0m"
+
+  Redis.current = Redis.new(host: '127.0.0.1', port: 6379)
+
+  RSpec.configure do |c|
+    c.before(:each) do
+      Redis.current.keys('redis_*').each { |k| Redis.current.del k }
+    end
+  end
 rescue LoadError
   puts "redis-objects gem not found, not running Redis specs \e[31m#{'✖'}\e[0m"
 end

data/spec/unit/guard_spec.rb

@@ -70,3 +70,20 @@ describe "event guards" do
   end
 
 end
+
+if defined?(ActiveRecord)
+
+  Dir[File.dirname(__FILE__) + "/../models/active_record/*.rb"].sort.each do |f|
+    require File.expand_path(f)
+  end
+
+  load_schema
+
+  describe "ActiveRecord per-transition guards" do
+    let(:example) { ComplexActiveRecordExample.new }
+
+    it "should be able to increment" do
+      expect(example.may_increment?).to be true
+    end
+  end
+end

data/spec/unit/guard_without_from_specified_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe "transitions without from specified" do
+  let(:guardian) { GuardianWithoutFromSpecified.new }
+
+  it "allows the transitions if guard succeeds" do
+    expect { guardian.use_guards_where_the_first_fails! }.to_not raise_error
+    expect(guardian).to be_gamma
+  end
+end

data/spec/unit/namespaced_multiple_example_spec.rb

@@ -11,6 +11,10 @@ describe 'state machine' do
     expect(namespaced.aasm(:review_status).current_state).to eq(:unapproved)
     expect(namespaced).to respond_to(:review_unapproved?)
     expect(namespaced).to be_review_unapproved
+
+    expect(namespaced.aasm(:car).current_state).to eq(:unsold)
+    expect(namespaced).to respond_to(:car_unsold?)
+    expect(namespaced).to be_car_unsold
   end
 
   it 'allows transitions to other states' do
@@ -25,6 +29,12 @@ describe 'state machine' do
     namespaced.approve_review!
     expect(namespaced).to respond_to(:review_approved?)
     expect(namespaced).to be_review_approved
+
+    expect(namespaced).to respond_to(:sell_car)
+    expect(namespaced).to respond_to(:sell_car!)
+    namespaced.sell_car!
+    expect(namespaced).to respond_to(:car_sold?)
+    expect(namespaced).to be_car_sold
   end
 
   it 'denies transitions to other states' do
@@ -41,6 +51,13 @@ describe 'state machine' do
     expect {namespaced.approve_review}.to raise_error(AASM::InvalidTransition)
     expect {namespaced.approve_review!}.to raise_error(AASM::InvalidTransition)
     namespaced.unapprove_review
+
+    expect {namespaced.return_car}.to raise_error(AASM::InvalidTransition)
+    expect {namespaced.return_car!}.to raise_error(AASM::InvalidTransition)
+    namespaced.sell_car
+    expect {namespaced.sell_car}.to raise_error(AASM::InvalidTransition)
+    expect {namespaced.sell_car!}.to raise_error(AASM::InvalidTransition)
+    namespaced.return_car
   end
 
   it 'defines constants for each state name' do
@@ -49,5 +66,10 @@ describe 'state machine' do
 
     expect(NamespacedMultipleExample::STATE_REVIEW_UNAPPROVED).to eq(:unapproved)
     expect(NamespacedMultipleExample::STATE_REVIEW_APPROVED).to eq(:approved)
+
+    expect(NamespacedMultipleExample::STATE_CAR_UNSOLD).to eq(:unsold)
+    expect(NamespacedMultipleExample::STATE_CAR_SOLD).to eq(:sold)
   end
+
+
 end

data/spec/unit/persistence/active_record_persistence_multiple_spec.rb

@@ -139,7 +139,7 @@ if defined?(ActiveRecord)
 
       before :each do
         allow(gate).to receive(:aasm_enum).and_return(enum_name)
-        allow(gate).to receive(:aasm_write_attribute)
+        allow(gate).to receive(:aasm_write_state_attribute)
         allow(gate).to receive(:write_attribute)
 
         allow(MultipleGate).to receive(enum_name).and_return(enum)
@@ -173,7 +173,7 @@ if defined?(ActiveRecord)
 
             gate.aasm_write_state state_sym, :left
 
-            expect(gate).to have_received(:aasm_write_attribute).with(state_sym, :left)
+            expect(gate).to have_received(:aasm_write_state_attribute).with(state_sym, :left)
             expect(gate).to_not have_received :write_attribute
           end
         end
@@ -183,7 +183,7 @@ if defined?(ActiveRecord)
         it "delegates state update to the helper method" do
           gate.aasm_write_state_without_persistence state_sym, :left
 
-          expect(gate).to have_received(:aasm_write_attribute).with(state_sym, :left)
+          expect(gate).to have_received(:aasm_write_state_attribute).with(state_sym, :left)
           expect(gate).to_not have_received :write_attribute
         end
       end
@@ -219,7 +219,7 @@ if defined?(ActiveRecord)
         allow(gate).to receive(:write_attribute)
         allow(gate).to receive(:aasm_raw_attribute_value).and_return(value)
 
-        gate.send(:aasm_write_attribute, sym, :left)
+        gate.send(:aasm_write_state_attribute, sym, :left)
       end
 
       it "generates attribute value using a helper method" do

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -139,7 +139,7 @@ if defined?(ActiveRecord)
 
       before :each do
         allow(gate).to receive(:aasm_enum).and_return(enum_name)
-        allow(gate).to receive(:aasm_write_attribute)
+        allow(gate).to receive(:aasm_write_state_attribute)
         allow(gate).to receive(:write_attribute)
 
         allow(Gate).to receive(enum_name).and_return(enum)
@@ -191,7 +191,7 @@ if defined?(ActiveRecord)
 
             gate.aasm_write_state state_sym
 
-            expect(gate).to have_received(:aasm_write_attribute).with(state_sym, :default)
+            expect(gate).to have_received(:aasm_write_state_attribute).with(state_sym, :default)
             expect(gate).to_not have_received :write_attribute
           end
         end
@@ -201,7 +201,7 @@ if defined?(ActiveRecord)
         it "delegates state update to the helper method" do
           gate.aasm_write_state_without_persistence state_sym
 
-          expect(gate).to have_received(:aasm_write_attribute).with(state_sym, :default)
+          expect(gate).to have_received(:aasm_write_state_attribute).with(state_sym, :default)
           expect(gate).to_not have_received :write_attribute
         end
       end
@@ -237,7 +237,7 @@ if defined?(ActiveRecord)
         allow(gate).to receive(:write_attribute)
         allow(gate).to receive(:aasm_raw_attribute_value).and_return(value)
 
-        gate.send(:aasm_write_attribute, sym)
+        gate.send(:aasm_write_state_attribute, sym)
       end
 
       it "generates attribute value using a helper method" do

data/spec/unit/persistence/redis_persistence_multiple_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+if defined?(Redis)
+  describe 'redis' do
+
+    Dir[File.dirname(__FILE__) + "/../../models/redis/*.rb"].sort.each do |f|
+      require File.expand_path(f)
+    end
+
+    before(:all) do
+      @model = RedisMultiple
+    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
+        expect(model.status).to eq("alpha")
+      end
+
+      it "should return the aasm column the aasm field is not nil" do
+        model.status = "beta"
+        expect(model.aasm(:left).current_state).to eq(:beta)
+      end
+
+      it "should allow a nil state" do
+        model.status = nil
+        expect(model.aasm(:left).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(: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 "complex example" do
+      it "works" do
+        record = RedisComplexExample.new
+
+        expect(record.aasm(:left).current_state).to eql :one
+        expect(record.aasm(:right).current_state).to eql :alpha
+
+        expect_aasm_states record, :one, :alpha
+
+        record.increment!
+        expect_aasm_states record, :two, :alpha
+
+        record.level_up!
+        expect_aasm_states record, :two, :beta
+
+        record.increment!
+        expect { record.increment! }.to raise_error(AASM::InvalidTransition)
+        expect_aasm_states record, :three, :beta
+
+        record.level_up!
+        expect_aasm_states record, :three, :gamma
+      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.value.to_s).to eql left_state.to_s
+        expect(record.aasm(:right).current_state).to eql right_state.to_sym
+        expect(record.right.value.to_s).to eql right_state.to_s
+      end
+    end
+  end
+end

data/spec/unit/persistence/redis_persistence_spec.rb

@@ -3,31 +3,12 @@ require 'spec_helper'
 if defined?(Redis::Objects)
   describe 'redis' do
 
-    before(:all) do
-      Redis.current = Redis.new(host: '127.0.0.1', port: 6379)
-
-      @model = Class.new do
-        attr_accessor :default
-
-        include Redis::Objects
-        include AASM
-
-        value :status
-
-        def id
-          1
-        end
+    Dir[File.dirname(__FILE__) + "/../../models/redis/*.rb"].sort.each do |f|
+      require File.expand_path(f)
+    end
 
-        aasm column: :status
-        aasm do
-          state :alpha, initial: true
-          state :beta
-          state :gamma
-          event :release do
-            transitions from: [:alpha, :beta, :gamma], to: :beta
-          end
-        end
-      end
+    before(:all) do
+      @model = RedisSimple
     end
 
     describe "instance methods" do
@@ -68,6 +49,5 @@ if defined?(Redis::Objects)
         expect(Class.new(@model).aasm.attribute_name).to eq(:status)
       end
     end
-
   end
 end

data/spec/unit/persistence/sequel_persistence_multiple_spec.rb

@@ -8,7 +8,7 @@ if defined?(Sequel)
     end
 
     before(:all) do
-      @model = SequelMultiple
+      @model = Sequel::Multiple
     end
 
     describe "instance methods" do
@@ -93,7 +93,7 @@ if defined?(Sequel)
 
     describe "complex example" do
       it "works" do
-        record = ComplexSequelExample.new
+        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

data/spec/unit/persistence/sequel_persistence_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-
 if defined?(Sequel)
   describe 'sequel' do
 
@@ -8,7 +7,7 @@ if defined?(Sequel)
     end
 
     before(:all) do
-      @model = SequelSimple
+      @model = Sequel::Simple
     end
 
     describe "instance methods" do
@@ -91,5 +90,279 @@ if defined?(Sequel)
       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