aasm 2.1.1 → 5.2.0

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

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

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+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/localizer_test_model_new_style.yml'
+      I18n.reload!
+    end
+
+    after(:all) do
+      I18n.load_path.delete('spec/localizer_test_model_new_style.yml')
+      I18n.backend.load_translations
+    end
+
+    let (:foo_opened) { LocalizerTestModel.new }
+    let (:foo_closed) { LocalizerTestModel.new.tap { |x| x.aasm_state = :closed  } }
+
+    context 'aasm.human_state' do
+      it 'should return translated state value' do
+        expect(foo_opened.aasm.human_state).to eq("It's open now!")
+      end
+
+      it 'should return humanized value if not localized' do
+        expect(foo_closed.aasm.human_state).to eq("Closed")
+      end
+    end
+
+    context 'aasm.human_event_name' do
+      context 'with event name' do
+        it 'should return translated event name' do
+          expect(LocalizerTestModel.aasm.human_event_name(:close)).to eq("Let's close it!")
+        end
+
+        it 'should return humanized event name' do
+          expect(LocalizerTestModel.aasm.human_event_name(:open)).to eq("Open")
+        end
+      end
+
+      context 'with event object' do
+        it 'should return translated event name' do
+          event = LocalizerTestModel.aasm.events.detect { |e| e.name == :close }
+
+          expect(LocalizerTestModel.aasm.human_event_name(event)).to eq("Let's close it!")
+        end
+
+        it 'should return humanized event name' do
+          event = LocalizerTestModel.aasm.events.detect { |e| e.name == :open }
+
+          expect(LocalizerTestModel.aasm.human_event_name(event)).to eq("Open")
+        end
+      end
+    end
+  end
+
+  describe AASM::Localizer, "deprecated style" do
+    before(:all) do
+      I18n.load_path << 'spec/localizer_test_model_deprecated_style.yml'
+      I18n.reload!
+      I18n.backend.load_translations
+    end
+
+    after(:all) do
+      I18n.load_path.delete('spec/localizer_test_model_deprecated_style.yml')
+      I18n.backend.load_translations
+    end
+
+    let (:foo_opened) { LocalizerTestModel.new }
+    let (:foo_closed) { LocalizerTestModel.new.tap { |x| x.aasm_state = :closed  } }
+
+    context 'aasm.human_state' do
+      it 'should return translated state value' do
+        expect(foo_opened.aasm.human_state).to eq("It's open now!")
+      end
+
+      it 'should return humanized value if not localized' do
+        expect(foo_closed.aasm.human_state).to eq("Closed")
+      end
+    end
+
+    context 'aasm.human_event_name' do
+      context 'with event name' do
+        it 'should return translated event name' do
+          expect(LocalizerTestModel.aasm.human_event_name(:close)).to eq("Let's close it!")
+        end
+
+        it 'should return humanized event name' do
+          expect(LocalizerTestModel.aasm.human_event_name(:open)).to eq("Open")
+        end
+      end
+
+      context 'with event object' do
+        it 'should return translated event name' do
+          event = LocalizerTestModel.aasm.events.detect { |e| e.name == :close }
+
+          expect(LocalizerTestModel.aasm.human_event_name(event)).to eq("Let's close it!")
+        end
+
+        it 'should return humanized event name' do
+          event = LocalizerTestModel.aasm.events.detect { |e| e.name == :open }
+
+          expect(LocalizerTestModel.aasm.human_event_name(event)).to eq("Open")
+        end
+      end
+    end
+  end
+end

data/spec/unit/memory_leak_spec.rb

@@ -0,0 +1,38 @@
+# require 'spec_helper'
+
+# describe "state machines" do
+
+#   def number_of_objects(klass)
+#     ObjectSpace.each_object(klass) {}
+#   end
+
+#   def machines
+#     AASM::StateMachineStore.instance_variable_get("@stores")
+#   end
+
+#   it "should be created without memory leak" do
+#     machines_count = machines.size
+#     state_count = number_of_objects(AASM::Core::State)
+#     event_count = number_of_objects(AASM::Core::Event)
+#     puts "event_count = #{event_count}"
+#     transition_count = number_of_objects(AASM::Core::Transition)
+
+#     load File.expand_path(File.dirname(__FILE__) + '/../models/not_auto_loaded/process.rb')
+#     machines.size.should == machines_count + 1                                                  # + Process
+#     number_of_objects(Models::Process).should == 0
+#     number_of_objects(AASM::Core::State).should == state_count + 3                 # + Process
+#     puts "event_count = #{number_of_objects(AASM::Core::Event)}"
+#     number_of_objects(AASM::Core::Event).should == event_count + 2                 # + Process
+#     number_of_objects(AASM::Core::Transition).should == transition_count + 2  # + Process
+
+#     Models.send(:remove_const, "Process") if Models.const_defined?("Process")
+#     load File.expand_path(File.dirname(__FILE__) + '/../models/not_auto_loaded/process.rb')
+#     machines.size.should == machines_count + 1                                                  # + Process
+#     number_of_objects(AASM::Core::State).should == state_count + 3                 # + Process
+#     # ObjectSpace.each_object(AASM::Core::Event) {|o| puts o.inspect}
+#     puts "event_count = #{number_of_objects(AASM::Core::Event)}"
+#     number_of_objects(AASM::Core::Event).should == event_count + 2                 # + Process
+#     number_of_objects(AASM::Core::Transition).should == transition_count + 2  # + Process
+#   end
+
+# end

data/spec/unit/multiple_transitions_that_differ_only_by_guard_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe "multiple transitions that differ only by guard" do
+  let(:job) { MultipleTransitionsThatDifferOnlyByGuard.new }
+
+  it 'does not follow the first transition if its guard fails' do
+    expect{job.go}.not_to raise_error
+  end
+
+  it 'executes the second transition\'s callbacks' do
+    job.go
+    expect(job.executed_second).to be_truthy
+  end
+end