aasm 5.3.1 → 5.4.0

data/spec/unit/invoker_spec.rb

@@ -1,189 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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,109 +0,0 @@
-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

@@ -1,38 +0,0 @@
-# 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

@@ -1,14 +0,0 @@
-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