aasm 4.12.3 → 5.1.1

data/spec/unit/complex_example_spec.rb

@@ -90,5 +90,4 @@ describe 'when being unsuspended' do
   it "should not be able to fire unknown events" do
     expect(auth.aasm.may_fire_event?(:unknown)).to be false
   end
-
 end

data/spec/unit/event_spec.rb

@@ -294,6 +294,19 @@ describe 'current event' do
     pe.wakeup!
     expect(pe.aasm.current_event).to eql :wakeup!
   end
+
+  describe "when calling events with fire/fire!" do
+    it "fire should populate aasm.current_event and transition (sleeping to showering)" do
+      pe.aasm.fire(:wakeup)
+      expect(pe.aasm.current_event).to eq :wakeup
+      expect(pe.aasm.current_state).to eq :showering
+    end
+    it "fire! should populate aasm.current_event and transition (sleeping to showering)" do
+      pe.aasm.fire!(:wakeup)
+      expect(pe.aasm.current_event).to eq :wakeup!
+      expect(pe.aasm.current_state).to eq :showering
+    end
+  end
 end
 
 describe 'parametrised events' do

data/spec/unit/exception_spec.rb

@@ -5,7 +5,7 @@ describe AASM::InvalidTransition do
     process = ProcessWithNewDsl.new
     expect { process.stop! }.to raise_error do |err|
       process.start
-      expect(err.message).to eql("Event 'stop' cannot transition from 'sleeping'. ")
+      expect(err.message).to eql("Event 'stop' cannot transition from 'sleeping'.")
     end
   end
 end

data/spec/unit/inspection_multiple_spec.rb

@@ -166,11 +166,15 @@ describe "special cases" do
 end
 
 describe 'aasm.states_for_select' do
-  it "should return a select friendly array of states" do
-    expect(FooMultiple.aasm(:left)).to respond_to(:states_for_select)
-    expect(FooMultiple.aasm(:left).states_for_select).to eq(
-      [['Open', 'open'], ['Closed', 'closed'], ['Final', 'final']]
-    )
+  context 'without I18n' do
+    before { allow(Module).to receive(:const_defined?).with(:I18n).and_return(nil) }
+
+    it "should return a select friendly array of states" do
+      expect(FooMultiple.aasm(:left)).to respond_to(:states_for_select)
+      expect(FooMultiple.aasm(:left).states_for_select).to eq(
+        [['Open', 'open'], ['Closed', 'closed'], ['Final', 'final']]
+      )
+    end
   end
 end
 

data/spec/unit/inspection_spec.rb

@@ -102,9 +102,13 @@ describe "special cases" do
 end
 
 describe 'aasm.states_for_select' do
-  it "should return a select friendly array of states" do
-    expect(Foo.aasm).to respond_to(:states_for_select)
-    expect(Foo.aasm.states_for_select).to eq([['Open', 'open'], ['Closed', 'closed'], ['Final', 'final']])
+  context 'without I18n' do
+    before { allow(Module).to receive(:const_defined?).with(:I18n).and_return(nil) }
+
+    it "should return a select friendly array of states" do
+      expect(Foo.aasm).to respond_to(:states_for_select)
+      expect(Foo.aasm.states_for_select).to eq([['Open', 'open'], ['Closed', 'closed'], ['Final', 'final']])
+    end
   end
 end
 

data/spec/unit/invoker_spec.rb

@@ -0,0 +1,189 @@
+require 'spec_helper'
+
+describe AASM::Core::Invoker do
+  let(:target) { nil }
+  let(:record) { double }
+  let(:args) { [] }
+
+  subject { described_class.new(target, record, args) }
+
+  describe '#with_options' do
+    context 'when passing array as a subject' do
+      context 'and "guard" option is set to true' do
+        let(:target) { [subject_1, subject_2] }
+
+        before { subject.with_options(guard: true) }
+
+        context 'and all the subjects are truthy' do
+          let(:subject_1) { Proc.new { true } }
+          let(:subject_2) { Proc.new { true } }
+
+          it 'then returns "true" while invoking' do
+            expect(subject.invoke).to eq(true)
+          end
+        end
+
+        context 'and any subject is falsely' do
+          let(:subject_1) { Proc.new { false } }
+          let(:subject_2) { Proc.new { true } }
+
+          it 'then returns "false" while invoking' do
+            expect(subject.invoke).to eq(false)
+          end
+        end
+      end
+
+      context 'and "unless" option is set to true' do
+        let(:target) { [subject_1, subject_2] }
+
+        before { subject.with_options(unless: true) }
+
+        context 'and all the subjects are falsely' do
+          let(:subject_1) { Proc.new { false } }
+          let(:subject_2) { Proc.new { false } }
+
+          it 'then returns "true" while invoking' do
+            expect(subject.invoke).to eq(true)
+          end
+        end
+
+        context 'and any subject is truthy' do
+          let(:subject_1) { Proc.new { false } }
+          let(:subject_2) { Proc.new { true } }
+
+          it 'then returns "false" while invoking' do
+            expect(subject.invoke).to eq(false)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#with_failures' do
+    let(:concrete_invoker) { AASM::Core::Invokers::ProcInvoker }
+    let(:target) { Proc.new {} }
+
+    it 'then sets failures buffer for concrete invokers' do
+      expect_any_instance_of(concrete_invoker)
+        .to receive(:with_failures)
+        .and_call_original
+
+      subject.invoke
+    end
+  end
+
+  describe '#with_default_return_value' do
+    context 'when return value is "true"' do
+      before { subject.with_default_return_value(true) }
+
+      it 'then returns "true" when was not picked up by any invoker' do
+        expect(subject.invoke).to eq(true)
+      end
+    end
+
+    context 'when return value is "false"' do
+      before { subject.with_default_return_value(false) }
+
+      it 'then returns "false" when was not picked up by any invoker' do
+        expect(subject.invoke).to eq(false)
+      end
+    end
+  end
+
+  describe '#invoke' do
+    context 'when subject is a proc' do
+      let(:concrete_invoker) { AASM::Core::Invokers::ProcInvoker }
+      let(:target) { Proc.new {} }
+
+      it 'then calls proc invoker' do
+        expect_any_instance_of(concrete_invoker)
+          .to receive(:invoke)
+          .and_call_original
+
+        expect(record).to receive(:instance_exec)
+
+        subject.invoke
+      end
+    end
+
+    context 'when subject is a class' do
+      let(:concrete_invoker) { AASM::Core::Invokers::ClassInvoker }
+      let(:target) { Class.new { def call; end } }
+
+      it 'then calls proc invoker' do
+        expect_any_instance_of(concrete_invoker)
+          .to receive(:invoke)
+          .and_call_original
+
+        expect_any_instance_of(target).to receive(:call)
+
+        subject.invoke
+      end
+    end
+
+    context 'when subject is a literal' do
+      let(:concrete_invoker) { AASM::Core::Invokers::LiteralInvoker }
+      let(:record) { double(invoke_me: nil) }
+      let(:target) { :invoke_me }
+
+      it 'then calls literal invoker' do
+        expect_any_instance_of(concrete_invoker)
+          .to receive(:invoke)
+          .and_call_original
+
+        expect(record).to receive(:invoke_me)
+
+        subject.invoke
+      end
+    end
+
+    context 'when subject is an array of procs' do
+      let(:subject_1) { Proc.new {} }
+      let(:subject_2) { Proc.new {} }
+      let(:target) { [subject_1, subject_2] }
+
+      it 'then calls each proc' do
+        expect(record).to receive(:instance_exec).twice
+
+        subject.invoke
+      end
+    end
+
+    context 'when subject is an array of classes' do
+      let(:subject_1) { Class.new { def call; end } }
+      let(:subject_2) { Class.new { def call; end } }
+      let(:target) { [subject_1, subject_2] }
+
+      it 'then calls each class' do
+        expect_any_instance_of(subject_1).to receive(:call)
+
+        expect_any_instance_of(subject_2).to receive(:call)
+
+        subject.invoke
+      end
+    end
+
+    context 'when subject is an array of literals' do
+      let(:subject_1) { :method_one }
+      let(:subject_2) { :method_two }
+      let(:record) { double(method_one: nil, method_two: nil) }
+      let(:target) { [subject_1, subject_2] }
+
+      it 'then calls each class' do
+        expect(record).to receive(:method_one)
+
+        expect(record).to receive(:method_two)
+
+        subject.invoke
+      end
+    end
+
+    context 'when subject is not supported' do
+      let(:target) { nil }
+
+      it 'then just returns default value' do
+        expect(subject.invoke).to eq(described_class::DEFAULT_RETURN_VALUE)
+      end
+    end
+  end
+end

data/spec/unit/invokers/base_invoker_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe AASM::Core::Invokers::BaseInvoker do
+  let(:target) { double }
+  let(:record) { double }
+  let(:args) { [] }
+
+  subject { described_class.new(target, record, args) }
+
+  describe '#may_invoke?' do
+    it 'then raises NoMethodError' do
+      expect { subject.may_invoke? }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#log_failure' do
+    it 'then raises NoMethodError' do
+      expect { subject.log_failure }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#invoke_subject' do
+    it 'then raises NoMethodError' do
+      expect { subject.log_failure }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#with_failures' do
+    it 'then sets failures buffer' do
+      buffer = [1, 2, 3]
+      subject.with_failures(buffer)
+
+      expect(subject.failures).to eq(buffer)
+    end
+  end
+
+  describe '#invoke' do
+    context 'when #may_invoke? respond with "false"' do
+      before { allow(subject).to receive(:may_invoke?).and_return(false) }
+
+      it 'then returns "nil"' do
+        expect(subject.invoke).to eq(nil)
+      end
+    end
+
+    context 'when #invoke_subject respond with "false"' do
+      before do
+        allow(subject).to receive(:may_invoke?).and_return(true)
+        allow(subject).to receive(:invoke_subject).and_return(false)
+      end
+
+      it 'then calls #log_failure' do
+        expect(subject).to receive(:log_failure)
+
+        subject.invoke
+      end
+    end
+
+    context 'when #invoke_subject succeed' do
+      before do
+        allow(subject).to receive(:may_invoke?).and_return(true)
+        allow(subject).to receive(:invoke_subject).and_return(true)
+      end
+
+      it 'then returns result' do
+        expect(subject).to receive(:result)
+
+        subject.invoke
+      end
+    end
+  end
+end

data/spec/unit/invokers/class_invoker_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe AASM::Core::Invokers::ClassInvoker do
+  let(:target) { Class.new { def call; end } }
+  let(:record) { double }
+  let(:args) { [] }
+
+  subject { described_class.new(target, record, args) }
+
+  describe '#may_invoke?' do
+    context 'when subject is a Class and responds to #call' do
+      it 'then returns "true"' do
+        expect(subject.may_invoke?).to eq(true)
+      end
+    end
+
+    context 'when subject is not a class or not respond to #call' do
+      let(:target) { Class.new {} }
+
+      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.instance_method(:call).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.first).to be_a(Method)
+      end
+    end
+  end
+
+  describe '#invoke_subject' do
+    context 'when passing no arguments' do
+      let(:args) { [1, 2 ,3] }
+      let(:target) { Class.new { def call; end } }
+
+      it 'then correctly uses passed arguments' do
+        expect { subject.invoke_subject }.not_to raise_error
+      end
+    end
+
+    context 'when passing single argument' do
+      let(:args) { [1, 2 ,3, 4, 5, 6] }
+      let(:target) { Class.new { def initialize(_a); end; def call; end } }
+
+      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) { Class.new { def initialize(_a, _b, *_c); end; def call; end } }
+
+      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) { Class.new { def initialize(_a, _b, _c); end; def call; end } }
+
+      it 'then correctly uses passed arguments' do
+        expect { subject.invoke_subject }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/unit/invokers/literal_invoker_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe AASM::Core::Invokers::LiteralInvoker do
+  let(:target) { nil }
+  let(:record) { double }
+  let(:args) { [] }
+
+  subject { described_class.new(target, record, args) }
+
+  describe '#may_invoke?' do
+    context 'when subject is a Symbol' do
+      let(:target) { :i_am_symbol }
+
+      it 'then returns "true"' do
+        expect(subject.may_invoke?).to eq(true)
+      end
+    end
+
+    context 'when subject is a String' do
+      let(:target) { 'i_am_string' }
+
+      it 'then returns "true"' do
+        expect(subject.may_invoke?).to eq(true)
+      end
+    end
+
+    context 'when subject is neither a String nor Symbol' do
+      let(:target) { double }
+
+      it 'then returns "false"' do
+        expect(subject.may_invoke?).to eq(false)
+      end
+    end
+  end
+
+  describe '#log_failure' do
+    let(:target) { Proc.new { false } }
+
+    it 'then adds the subject to a failures buffer' do
+      subject.log_failure
+
+      expect(subject.failures).to eq([target])
+    end
+  end
+
+  describe '#invoke_subject' do
+    context 'when passing no arguments' do
+      let(:record) { Class.new { def my_method; end }.new }
+      let(:args) { [1, 2 ,3] }
+      let(:target) { :my_method }
+
+      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(:record) { Class.new { def my_method(_a, _b, *_c); end }.new }
+      let(:args) { [1, 2 ,3, 4, 5, 6] }
+      let(:target) { :my_method }
+
+      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(:record) { Class.new { def my_method(_a, _b, _c); end }.new }
+      let(:args) { [1, 2 ,3, 4, 5, 6] }
+      let(:target) { :my_method }
+
+      it 'then correctly uses passed arguments' do
+        expect { subject.invoke_subject }.not_to raise_error
+      end
+    end
+
+    context 'when record does not respond to subject' do
+      let(:record) { Class.new { }.new }
+      let(:target) { :my_method }
+
+      it 'then raises uses passed arguments' do
+        expect { subject.invoke_subject }.to raise_error(NoMethodError)
+      end
+    end
+  end
+end