aasm 5.0.8 → 5.5.0

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,78 +0,0 @@
-require 'spec_helper'
-
-if defined?(ActiceRecord)
-  require 'i18n'
-
-  I18n.enforce_available_locales = false
-  load_schema
-
-  describe AASM::Localizer, "new style" do
-    before(:all) do
-      I18n.load_path << 'spec/en.yml'
-      I18n.default_locale = :en
-      I18n.reload!
-    end
-
-    after(:all) do
-      I18n.load_path.clear
-    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
-      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
-  end
-
-  describe AASM::Localizer, "deprecated style" do
-    before(:all) do
-      I18n.load_path << 'spec/en_deprecated_style.yml'
-      I18n.default_locale = :en
-      I18n.reload!
-    end
-
-    after(:all) do
-      I18n.load_path.clear
-    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
-      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
-  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

data/spec/unit/namespaced_multiple_example_spec.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-
-describe 'state machine' do
-  let(:namespaced) { NamespacedMultipleExample.new }
-
-  it 'starts with an initial state' do
-    expect(namespaced.aasm(:status).current_state).to eq(:unapproved)
-    expect(namespaced).to respond_to(:unapproved?)
-    expect(namespaced).to be_unapproved
-
-    expect(namespaced.aasm(:review_status).current_state).to eq(:unapproved)
-    expect(namespaced).to respond_to(:review_unapproved?)
-    expect(namespaced).to be_review_unapproved
-
-    expect(namespaced.aasm(:car).current_state).to eq(:unsold)
-    expect(namespaced).to respond_to(:car_unsold?)
-    expect(namespaced).to be_car_unsold
-  end
-
-  it 'allows transitions to other states' do
-    expect(namespaced).to respond_to(:approve)
-    expect(namespaced).to respond_to(:approve!)
-    namespaced.approve!
-    expect(namespaced).to respond_to(:approved?)
-    expect(namespaced).to be_approved
-
-    expect(namespaced).to respond_to(:approve_review)
-    expect(namespaced).to respond_to(:approve_review!)
-    namespaced.approve_review!
-    expect(namespaced).to respond_to(:review_approved?)
-    expect(namespaced).to be_review_approved
-
-    expect(namespaced).to respond_to(:sell_car)
-    expect(namespaced).to respond_to(:sell_car!)
-    namespaced.sell_car!
-    expect(namespaced).to respond_to(:car_sold?)
-    expect(namespaced).to be_car_sold
-  end
-
-  it 'denies transitions to other states' do
-    expect {namespaced.unapprove}.to raise_error(AASM::InvalidTransition)
-    expect {namespaced.unapprove!}.to raise_error(AASM::InvalidTransition)
-    namespaced.approve
-    expect {namespaced.approve}.to raise_error(AASM::InvalidTransition)
-    expect {namespaced.approve!}.to raise_error(AASM::InvalidTransition)
-    namespaced.unapprove
-
-    expect {namespaced.unapprove_review}.to raise_error(AASM::InvalidTransition)
-    expect {namespaced.unapprove_review!}.to raise_error(AASM::InvalidTransition)
-    namespaced.approve_review
-    expect {namespaced.approve_review}.to raise_error(AASM::InvalidTransition)
-    expect {namespaced.approve_review!}.to raise_error(AASM::InvalidTransition)
-    namespaced.unapprove_review
-
-    expect {namespaced.return_car}.to raise_error(AASM::InvalidTransition)
-    expect {namespaced.return_car!}.to raise_error(AASM::InvalidTransition)
-    namespaced.sell_car
-    expect {namespaced.sell_car}.to raise_error(AASM::InvalidTransition)
-    expect {namespaced.sell_car!}.to raise_error(AASM::InvalidTransition)
-    namespaced.return_car
-  end
-
-  it 'defines constants for each state name' do
-    expect(NamespacedMultipleExample::STATE_UNAPPROVED).to eq(:unapproved)
-    expect(NamespacedMultipleExample::STATE_APPROVED).to eq(:approved)
-
-    expect(NamespacedMultipleExample::STATE_REVIEW_UNAPPROVED).to eq(:unapproved)
-    expect(NamespacedMultipleExample::STATE_REVIEW_APPROVED).to eq(:approved)
-
-    expect(NamespacedMultipleExample::STATE_CAR_UNSOLD).to eq(:unsold)
-    expect(NamespacedMultipleExample::STATE_CAR_SOLD).to eq(:sold)
-  end
-
-
-end

data/spec/unit/new_dsl_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe "the new dsl" do
-
-  let(:process) {ProcessWithNewDsl.new}
-
-  it 'should not conflict with other event or state methods' do
-    expect {ProcessWithNewDsl.state}.to raise_error(RuntimeError, "wrong state method")
-    expect {ProcessWithNewDsl.event}.to raise_error(RuntimeError, "wrong event method")
-  end
-
-end

data/spec/unit/override_warning_spec.rb

@@ -1,94 +0,0 @@
-require 'spec_helper'
-
-describe 'warns when overrides a method' do
-  before do
-    AASM::Configuration.hide_warnings = false
-  end
-
-  after do
-    AASM::Configuration.hide_warnings = true
-  end
-
-  module Clumsy
-    def self.included base
-      base.send :include, AASM
-
-      base.aasm do
-        state :valid
-        event(:save) { }
-      end
-    end
-  end
-
-  module WithEnumBase
-    def self.included base
-      base.send :include, AASM
-      base.instance_eval do
-        def defined_enums
-          { 'state' => { 'valid' => 0, 'invalid' => 1 } }
-        end
-      end
-      base.aasm enum: true do
-        state :valid
-        event(:save) { }
-      end
-    end
-  end
-
-  describe 'state' do
-    let(:base_klass) do
-      Class.new do
-        def valid?; end
-      end
-    end
-
-    subject { base_klass.send :include, Clumsy }
-
-    it 'should log to warn' do
-      expect_any_instance_of(Logger).to receive(:warn).with(": overriding method 'valid?'!")
-      subject
-    end
-  end
-
-  describe 'enum' do
-    let(:enum_base_klass) do
-      Class.new do
-        def valid?; end
-      end
-    end
-
-    subject { enum_base_klass.send :include, WithEnumBase }
-
-    it 'should not log to warn' do
-      expect_any_instance_of(Logger).to receive(:warn).never
-      subject
-    end
-  end
-
-  describe 'event' do
-    context 'may?' do
-      let(:base_klass) do
-        Class.new do
-          def may_save?; end
-          def save!; end
-          def save; end
-        end
-      end
-
-      subject { base_klass.send :include, Clumsy }
-
-      it 'should log to warn' do
-        expect_any_instance_of(Logger).to receive(:warn).exactly(3).times do |logger, message|
-          expect(
-            [
-              ": overriding method 'may_save?'!",
-              ": overriding method 'save!'!",
-              ": overriding method 'save'!"
-            ]
-          ).to include(message)
-        end
-        subject
-      end
-    end
-  end
-end