aasm 4.11.1 → 4.12.1

data/spec/unit/persistence/sequel_persistence_spec.rb

@@ -1,15 +1,13 @@
-describe 'sequel' do
-  begin
-    require 'sequel'
-    require 'logger'
-    require 'spec_helper'
+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 = SequelSimple
+      @model = Sequel::Simple
     end
 
     describe "instance methods" do
@@ -92,9 +90,279 @@ describe 'sequel' do
       end
     end
 
-  rescue LoadError
-    puts "------------------------------------------------------------------------"
-    puts "Not running Sequel specs because sequel gem is not installed!!!"
-    puts "------------------------------------------------------------------------"
+    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/simple_multiple_example_spec.rb

@@ -60,4 +60,32 @@ describe 'state machine' do
     expect(SimpleMultipleExample::STATE_PROCESSING).to eq(:processing)
     expect(SimpleMultipleExample::STATE_RUNNING).to eq(:running)
   end
+
+  context 'triggers binding_events in bindind_state_machine' do
+    it 'does persist' do
+      expect(simple).to be_sleeping
+      expect(simple).to be_answered
+      expect(simple).to receive(:start!).and_call_original
+      simple.ask!
+      expect(simple).to be_asked
+      expect(simple).to be_processing
+      expect(simple).to receive(:stop!).and_call_original
+      simple.answer!
+      expect(simple).to be_sleeping
+      expect(simple).to be_answered
+    end
+
+    it 'does not persist' do
+      expect(simple).to be_sleeping
+      expect(simple).to be_answered
+      expect(simple).to receive(:start).and_call_original
+      simple.ask
+      expect(simple).to be_asked
+      expect(simple).to be_processing
+      expect(simple).to receive(:stop).and_call_original
+      simple.answer
+      expect(simple).to be_sleeping
+      expect(simple).to be_answered
+    end
+  end
 end

data/spec/unit/subclassing_multiple_spec.rb

@@ -19,7 +19,7 @@ describe 'subclassing with multiple state machines' do
     expect(SuperClassMultiple.aasm(:right).states).not_to include(:archived)
   end
 
-  it "should have the same events as its parent" do
+  it 'should have the same events as its parent' do
     expect(SubClassMultiple.aasm(:left).events).to eq(SuperClassMultiple.aasm(:left).events)
     expect(SubClassMultiple.aasm(:right).events).to eq(SuperClassMultiple.aasm(:right).events)
   end
@@ -35,5 +35,40 @@ describe 'subclassing with multiple state machines' do
     expect(son.aasm(:left).current_state).to eq(:ended)
   end
 
-end
+  it 'should allow the child to modify its left state machine' do
+    son = SubClassMultiple.new
+    expect(son.left_called_after).to eq(nil)
+    expect(son.right_called_after).to eq(nil)
+    son.foo
+    expect(son.left_called_after).to eq(true)
+    expect(son.right_called_after).to eq(nil)
+    global_callbacks = SubClassMultiple.aasm(:left).state_machine.global_callbacks
+    expect(global_callbacks).to_not be_empty
+    expect(global_callbacks[:after_all_transitions]).to eq :left_after_all_event
+  end
+
+  it 'should allow the child to modify its right state machine' do
+    son = SubClassMultiple.new
+    expect(son.right_called_after).to eq(nil)
+    expect(son.left_called_after).to eq(nil)
+    son.close
+    expect(son.right_called_after).to eq(true)
+    expect(son.left_called_after).to eq(nil)
+    global_callbacks = SubClassMultiple.aasm(:right).state_machine.global_callbacks
+    expect(global_callbacks).to_not be_empty
+    expect(global_callbacks[:after_all_transitions]).to eq :right_after_all_event
+  end
 
+  it 'should not modify the parent left state machine' do
+    super_class_event = SuperClassMultiple.aasm(:left).events.select { |event| event.name == :foo }.first
+    expect(super_class_event.options).to be_empty
+    expect(SuperClassMultiple.aasm(:left).state_machine.global_callbacks).to be_empty
+  end
+
+  it 'should not modify the parent right state machine' do
+    super_class_event = SuperClassMultiple.aasm(:right).events.select { |event| event.name == :close }.first
+    expect(super_class_event.options).to be_empty
+    expect(SuperClassMultiple.aasm(:right).state_machine.global_callbacks).to be_empty
+  end
+
+end

data/spec/unit/subclassing_spec.rb

@@ -13,7 +13,7 @@ describe 'subclassing' do
     expect(SuperClass.aasm.states).not_to include(:foo)
   end
 
-  it "should have the same events as its parent" do
+  it 'should have the same events as its parent' do
     expect(SubClass.aasm.events).to eq(SuperClass.aasm.events)
   end
 
@@ -27,5 +27,20 @@ describe 'subclassing' do
     expect(son.aasm.current_state).to eq(:ended)
   end
 
-end
+  it 'should allow the child to modify its state machine' do
+    son = SubClass.new
+    expect(son.called_after).to eq(nil)
+    son.foo
+    expect(son.called_after).to eq(true)
+    global_callbacks = SubClass.aasm.state_machine.global_callbacks
+    expect(global_callbacks).to_not be_empty
+    expect(global_callbacks[:after_all_transitions]).to eq :after_all_event
+  end
 
+  it 'should not modify the parent state machine' do
+    super_class_event = SuperClass.aasm.events.select { |event| event.name == :foo }.first
+    expect(super_class_event.options).to be_empty
+    expect(SuperClass.aasm.state_machine.global_callbacks).to be_empty
+  end
+
+end

data/test/minitest_helper.rb

@@ -0,0 +1,57 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec', 'models')))
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+require 'aasm'
+require 'minitest/autorun'
+require 'aasm/minitest_spec'
+require 'pry'
+
+# require 'ruby-debug'; Debugger.settings[:autoeval] = true; debugger; rubys_debugger = 'annoying'
+# require 'ruby-debug/completion'
+# require 'pry'
+
+SEQUEL_DB = defined?(JRUBY_VERSION) ? 'jdbc:sqlite::memory:' : 'sqlite:/'
+
+def load_schema
+  require 'logger'
+  config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+  ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+  ActiveRecord::Base.establish_connection(config['sqlite3'])
+  require File.dirname(__FILE__) + "/database.rb"
+end
+
+# Dynamoid initialization
+begin
+  require 'dynamoid'
+  require 'aws-sdk-resources'
+
+  ENV['ACCESS_KEY'] ||= 'abcd'
+  ENV['SECRET_KEY'] ||= '1234'
+
+  Aws.config.update({
+    region: 'us-west-2',
+    credentials: Aws::Credentials.new(ENV['ACCESS_KEY'], ENV['SECRET_KEY'])
+  })
+
+  Dynamoid.configure do |config|
+    config.namespace = "dynamoid_tests"
+    config.endpoint = 'http://127.0.0.1:30180'
+    config.warn_on_scan = false
+  end
+
+  Dynamoid.logger.level = Logger::FATAL
+
+  class Minitest::Spec
+    before do
+      Dynamoid.adapter.list_tables.each do |table|
+        Dynamoid.adapter.delete_table(table) if table =~ /^#{Dynamoid::Config.namespace}/
+      end
+      Dynamoid.adapter.tables.clear
+    end
+  end
+rescue LoadError
+  # Without Dynamoid settings
+end
+
+# example model classes
+Dir[File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec', 'models')) + '/*.rb'].sort.each { |f| require File.expand_path(f) }

data/test/unit/minitest_matcher_test.rb

@@ -0,0 +1,80 @@
+require 'minitest_helper'
+
+class StateMachineTest < Minitest::Spec
+  
+  let(:simple) { SimpleExample.new }
+  let(:multiple) { SimpleMultipleExample.new }
+
+  describe 'transition_from' do
+    it "works for simple state machines" do
+      simple.must_transition_from :initialised, to: :filled_out, on_event: :fill_out
+      simple.wont_transition_from :initialised, to: :authorised, on_event: :fill_out
+    end
+
+    it "works for multiple state machines" do
+      multiple.must_transition_from :standing, to: :walking, on_event: :walk, on: :move
+      multiple.wont_transition_from :standing, to: :running, on_event: :walk, on: :move
+
+      multiple.must_transition_from :sleeping, to: :processing, on_event: :start, on: :work
+      multiple.wont_transition_from :sleeping, to: :sleeping, on_event: :start, on: :work
+    end
+  end
+
+  describe 'allow_transition_to' do
+    it "works for simple state machines" do
+      simple.must_allow_transition_to :filled_out
+      simple.wont_allow_transition_to :authorised
+    end
+
+    it "works for multiple state machines" do
+      multiple.must_allow_transition_to :walking, on: :move
+      multiple.wont_allow_transition_to :standing, on: :move
+
+      multiple.must_allow_transition_to :processing, on: :work
+      multiple.wont_allow_transition_to :sleeping, on: :work
+    end
+  end
+
+  describe "have_state" do
+    it "works for simple state machines" do
+      simple.must_have_state :initialised
+      simple.wont_have_state :filled_out
+      simple.fill_out
+      simple.must_have_state :filled_out
+    end
+
+    it "works for multiple state machines" do
+      multiple.must_have_state :standing, on: :move
+      multiple.wont_have_state :walking, on: :move
+      multiple.walk
+      multiple.must_have_state :walking, on: :move
+
+      multiple.must_have_state :sleeping, on: :work
+      multiple.wont_have_state :processing, on: :work
+      multiple.start
+      multiple.must_have_state :processing, on: :work
+    end
+  end
+
+  describe "allow_event" do
+    it "works for simple state machines" do
+      simple.must_allow_event :fill_out
+      simple.wont_allow_event :authorise
+      simple.fill_out
+      simple.must_allow_event :authorise
+    end
+
+    it "works for multiple state machines" do
+      multiple.must_allow_event :walk, on: :move
+      multiple.wont_allow_event :hold, on: :move
+      multiple.walk
+      multiple.must_allow_event :hold, on: :move
+
+      multiple.must_allow_event :start, on: :work
+      multiple.wont_allow_event :stop, on: :work
+      multiple.start
+      multiple.must_allow_event :stop, on: :work
+    end
+  end
+
+end