aasm 4.12.3 → 5.1.1

data/spec/unit/invokers/proc_invoker_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe AASM::Core::Invokers::ProcInvoker do
+  let(:target) { Proc.new {} }
+  let(:record) { double }
+  let(:args) { [] }
+
+  subject { described_class.new(target, record, args) }
+
+  describe '#may_invoke?' do
+    context 'when subject is a Proc' do
+      it 'then returns "true"' do
+        expect(subject.may_invoke?).to eq(true)
+      end
+    end
+
+    context 'when subject is not a Proc' do
+      let(:target) { nil }
+
+      it 'then returns "false"' do
+        expect(subject.may_invoke?).to eq(false)
+      end
+    end
+  end
+
+  describe '#log_failure' do
+    context 'when subject respond to #source_location' do
+      it 'then adds "source_location" to a failures buffer' do
+        subject.log_failure
+
+        expect(subject.failures)
+          .to eq([target.source_location.join('#')])
+      end
+    end
+
+    context 'when subject does not respond to #source_location' do
+      before do
+        Method.__send__(:alias_method, :original_source_location, :source_location)
+        Method.__send__(:undef_method, :source_location)
+      end
+
+      after do
+        Method.__send__(
+          :define_method,
+          :source_location,
+          Method.instance_method(:original_source_location)
+        )
+      end
+
+      it 'then adds the subject to a failures buffer' do
+        subject.log_failure
+
+        expect(subject.failures).to eq([target])
+      end
+    end
+  end
+
+  describe '#invoke_subject' do
+    context 'when passing no arguments' do
+      let(:args) { [1, 2 ,3] }
+      let(:target) { ->() {} }
+
+      it 'then correctly uses passed arguments' do
+        expect { subject.invoke_subject }.not_to raise_error
+      end
+    end
+
+    context 'when passing variable number arguments' do
+      let(:args) { [1, 2 ,3, 4, 5, 6] }
+      let(:target) { ->(_a, _b, *_c) {} }
+
+      it 'then correctly uses passed arguments' do
+        expect { subject.invoke_subject }.not_to raise_error
+      end
+    end
+
+    context 'when passing one or more arguments' do
+      let(:args) { [1, 2 ,3, 4, 5, 6] }
+      let(:target) { ->(_a, _b, _c) {} }
+
+      it 'then correctly uses passed arguments' do
+        expect { subject.invoke_subject }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/unit/localizer_spec.rb

@@ -1,20 +1,18 @@
 require 'spec_helper'
 
-if defined?(ActiceRecord)
-  require 'i18n'
-
-  I18n.enforce_available_locales = false
+if defined?(ActiveRecord)
+  require 'models/active_record/localizer_test_model'
   load_schema
 
   describe AASM::Localizer, "new style" do
     before(:all) do
-      I18n.load_path << 'spec/en.yml'
-      I18n.default_locale = :en
+      I18n.load_path << 'spec/localizer_test_model_new_style.yml'
       I18n.reload!
     end
 
     after(:all) do
-      I18n.load_path.clear
+      I18n.load_path.delete('spec/localizer_test_model_new_style.yml')
+      I18n.backend.load_translations
     end
 
     let (:foo_opened) { LocalizerTestModel.new }
@@ -43,13 +41,14 @@ if defined?(ActiceRecord)
 
   describe AASM::Localizer, "deprecated style" do
     before(:all) do
-      I18n.load_path << 'spec/en_deprecated_style.yml'
-      I18n.default_locale = :en
+      I18n.load_path << 'spec/localizer_test_model_deprecated_style.yml'
       I18n.reload!
+      I18n.backend.load_translations
     end
 
     after(:all) do
-      I18n.load_path.clear
+      I18n.load_path.delete('spec/localizer_test_model_deprecated_style.yml')
+      I18n.backend.load_translations
     end
 
     let (:foo_opened) { LocalizerTestModel.new }

data/spec/unit/persistence/active_record_persistence_multiple_spec.rb

@@ -359,13 +359,13 @@ if defined?(ActiveRecord)
 
       # allow it temporarily
       MultipleNoDirectAssignment.aasm(:left).state_machine.config.no_direct_assignment = false
-      obj.aasm_state = :pending
-      expect(obj.aasm_state.to_sym).to eql :pending
+      obj.aasm_state = :running
+      expect(obj.aasm_state.to_sym).to eql :running
 
       # and forbid it again
       MultipleNoDirectAssignment.aasm(:left).state_machine.config.no_direct_assignment = true
-      expect {obj.aasm_state = :running}.to raise_error(AASM::NoDirectAssignmentError)
-      expect(obj.aasm_state.to_sym).to eql :pending
+      expect {obj.aasm_state = :pending}.to raise_error(AASM::NoDirectAssignmentError)
+      expect(obj.aasm_state.to_sym).to eql :running
     end
   end # direct assignment
 

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -333,6 +333,22 @@ if defined?(ActiveRecord)
       end
     end
 
+    # Scopes on abstract classes didn't work until Rails 5.
+    #
+    # Reference:
+    # https://github.com/rails/rails/issues/10658
+    if ActiveRecord::VERSION::MAJOR >= 5
+      context "For a descendant of an abstract model" do
+        it "should add the scope without the table_name" do
+          expect(ImplementedAbstractClassDsl).to respond_to(:unknown_scope)
+          expect(ImplementedAbstractClassDsl).to respond_to(:another_unknown_scope)
+
+          expect(ImplementedAbstractClassDsl.unknown_scope.is_a?(ActiveRecord::Relation)).to be_truthy
+          expect(ImplementedAbstractClassDsl.another_unknown_scope.is_a?(ActiveRecord::Relation)).to be_truthy
+        end
+      end
+    end
+
     it "does not create scopes if requested" do
       expect(NoScope).not_to respond_to(:pending)
     end
@@ -377,13 +393,13 @@ if defined?(ActiveRecord)
 
       # allow it temporarily
       NoDirectAssignment.aasm.state_machine.config.no_direct_assignment = false
-      obj.aasm_state = :pending
-      expect(obj.aasm_state.to_sym).to eql :pending
+      obj.aasm_state = :running
+      expect(obj.aasm_state.to_sym).to eql :running
 
       # and forbid it again
       NoDirectAssignment.aasm.state_machine.config.no_direct_assignment = true
-      expect {obj.aasm_state = :running}.to raise_error(AASM::NoDirectAssignmentError)
-      expect(obj.aasm_state.to_sym).to eql :pending
+      expect {obj.aasm_state = :pending}.to raise_error(AASM::NoDirectAssignmentError)
+      expect(obj.aasm_state.to_sym).to eql :running
     end
   end # direct assignment
 
@@ -597,6 +613,73 @@ if defined?(ActiveRecord)
           expect(validator).to be_running
           expect(validator.name).to eq("name")
         end
+
+        context "nested transaction" do
+          it "should fire :after_commit if root transaction was successful" do
+            validator = Validator.create(:name => 'name')
+            expect(validator).to be_sleeping
+
+            validator.transaction do
+              validator.run!
+              expect(validator.name).to eq("name")
+              expect(validator).to be_running
+            end
+
+            expect(validator.name).to eq("name changed")
+            expect(validator.reload).to be_running
+          end
+
+          it "should not fire :after_commit if root transaction failed" do
+            validator = Validator.create(:name => 'name')
+            expect(validator).to be_sleeping
+
+            validator.transaction do
+              validator.run!
+              expect(validator.name).to eq("name")
+              expect(validator).to be_running
+
+              raise ActiveRecord::Rollback, "failed on purpose"
+            end
+
+            expect(validator.name).to eq("name")
+            expect(validator.reload).to be_sleeping
+          end
+        end
+      end
+
+      describe 'callbacks for the new DSL' do
+
+        it "be called in order" do
+          show_debug_log = false
+
+          callback = ActiveRecordCallback.create
+          callback.aasm.current_state
+
+          unless show_debug_log
+            expect(callback).to receive(:before_all_events).once.ordered
+            expect(callback).to receive(:before_event).once.ordered
+            expect(callback).to receive(:event_guard).once.ordered.and_return(true)
+            expect(callback).to receive(:transition_guard).once.ordered.and_return(true)
+            expect(callback).to receive(:before_exit_open).once.ordered                   # these should be before the state changes
+            expect(callback).to receive(:exit_open).once.ordered
+            # expect(callback).to receive(:event_guard).once.ordered.and_return(true)
+            # expect(callback).to receive(:transition_guard).once.ordered.and_return(true)
+            expect(callback).to receive(:after_all_transitions).once.ordered
+            expect(callback).to receive(:after_transition).once.ordered
+            expect(callback).to receive(:before_enter_closed).once.ordered
+            expect(callback).to receive(:enter_closed).once.ordered
+            expect(callback).to receive(:aasm_write_state).once.ordered.and_return(true)  # this is when the state changes
+            expect(callback).to receive(:after_exit_open).once.ordered                    # these should be after the state changes
+            expect(callback).to receive(:after_enter_closed).once.ordered
+            expect(callback).to receive(:after_event).once.ordered
+            expect(callback).to receive(:after_all_events).once.ordered
+            expect(callback).to receive(:ensure_event).once.ordered
+            expect(callback).to receive(:ensure_on_all_events).once.ordered
+            expect(callback).to receive(:event_after_commit).once.ordered
+          end
+
+          callback.close!
+        end
       end
 
       describe 'before and after transaction callbacks' do
@@ -732,4 +815,26 @@ if defined?(ActiveRecord)
       expect { job.run }.to raise_error(AASM::InvalidTransition)
     end
   end
+
+  describe 'testing the instance_level skip validation with _without_validation method' do
+    let(:example) do
+      obj = InstanceLevelSkipValidationExample.new(state: 'new')
+      obj.save(validate: false)
+      obj
+    end
+
+    it 'should be able to change the state with invalid record' do
+      expect(example.valid?).to be_falsey
+      expect(example.complete!).to be_falsey
+      expect(example.complete_without_validation!).to be_truthy
+      expect(example.state).to eq('complete')
+    end
+
+    it 'shouldn\'t affect the behaviour of existing method after calling _without_validation! method' do
+      expect(example.set_draft!).to be_falsey
+      expect(example.set_draft_without_validation!).to be_truthy
+      expect(example.state).to eq('draft')
+      expect(example.complete!).to be_falsey
+    end
+  end
 end

data/spec/unit/persistence/mongoid_persistence_multiple_spec.rb

@@ -10,10 +10,6 @@ if defined?(Mongoid::Document)
     before(:all) do
       # if you want to see the statements while running the spec enable the following line
       # Mongoid.logger = Logger.new(STDERR)
-
-      Mongoid.configure do |config|
-        config.connect_to "mongoid_#{Process.pid}"
-      end
     end
 
     after do

data/spec/unit/persistence/mongoid_persistence_spec.rb

@@ -10,10 +10,6 @@ if defined?(Mongoid::Document)
     before(:all) do
       # if you want to see the statements while running the spec enable the following line
       # Mongoid.logger = Logger.new(STDERR)
-
-      Mongoid.configure do |config|
-        config.connect_to "mongoid_#{Process.pid}"
-      end
     end
 
     after do

data/spec/unit/persistence/no_brainer_persistence_multiple_spec.rb

@@ -0,0 +1,198 @@
+require 'spec_helper'
+
+if defined?(NoBrainer::Document)
+  describe 'nobrainer' do
+    Dir[File.dirname(__FILE__) + '/../../models/nobrainer/*.rb'].sort.each do |f|
+      require File.expand_path(f)
+    end
+
+    before(:all) do
+      # if you want to see the statements while running the spec enable the
+      # following line
+      # NoBrainer.configure do |config|
+      #   config.logger = Logger.new(STDERR)
+      # end
+    end
+
+    after do
+      NoBrainer.purge!
+    end
+
+    describe 'named scopes with the old DSL' do
+      context 'Does not already respond_to? the scope name' do
+        it 'should add a scope for each state' do
+          expect(SimpleNoBrainerMultiple).to respond_to(:unknown_scope)
+          expect(SimpleNoBrainerMultiple).to respond_to(:another_unknown_scope)
+
+          expect(SimpleNoBrainerMultiple.unknown_scope.class).to eq(NoBrainer::Criteria)
+          expect(SimpleNoBrainerMultiple.another_unknown_scope.class).to eq(NoBrainer::Criteria)
+        end
+      end
+
+      context 'Already respond_to? the scope name' do
+        it 'should not add a scope' do
+          expect(SimpleNoBrainerMultiple).to respond_to(:new)
+          expect(SimpleNoBrainerMultiple.new.class).to eq(SimpleNoBrainerMultiple)
+        end
+      end
+
+    end
+
+    describe 'named scopes with the new DSL' do
+      context 'Does not already respond_to? the scope name' do
+        it 'should add a scope' do
+          expect(SimpleNewDslNoBrainerMultiple).to respond_to(:unknown_scope)
+          expect(SimpleNewDslNoBrainerMultiple.unknown_scope.class).to eq(NoBrainer::Criteria)
+        end
+      end
+
+      context 'Already respond_to? the scope name' do
+        it 'should not add a scope' do
+          expect(SimpleNewDslNoBrainerMultiple).to respond_to(:new)
+          expect(SimpleNewDslNoBrainerMultiple.new.class).to eq(SimpleNewDslNoBrainerMultiple)
+        end
+      end
+
+      it 'does not create scopes if requested' do
+        expect(NoScopeNoBrainerMultiple).not_to respond_to(:ignored_scope)
+      end
+    end
+
+    describe 'instance methods' do
+      let(:simple) { SimpleNewDslNoBrainerMultiple.new }
+
+      it 'should initialize the aasm state on instantiation' do
+        expect(SimpleNewDslNoBrainerMultiple.new.status).to eql 'unknown_scope'
+        expect(SimpleNewDslNoBrainerMultiple.new.aasm(:left).current_state).to eql :unknown_scope
+      end
+    end
+
+    describe 'transitions with persistence' do
+      it 'should work for valid models' do
+        valid_object = MultipleValidatorNoBrainer.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 = MultipleValidatorNoBrainer.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(NoBrainer::Error::DocumentInvalid)
+        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 = MultipleSilentPersistorNoBrainer.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 = MultipleInvalidPersistorNoBrainer.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 = MultipleInvalidPersistorNoBrainer.find(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
+    end
+
+    describe 'complex example' do
+      it 'works' do
+        record = ComplexNoBrainerExample.new
+        expect_aasm_states record, :one, :alpha
+
+        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