aasm 4.12.2 → 5.5.0

data/spec/unit/initial_state_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe 'initial states' do
-  it 'should use the first state defined if no initial state is given' do
-    expect(NoInitialState.new.aasm.current_state).to eq(:read)
-  end
-
-  it 'should determine initial state from the Proc results' do
-    expect(InitialStateProc.new(InitialStateProc::RICH - 1).aasm.current_state).to eq(:selling_bad_mortgages)
-    expect(InitialStateProc.new(InitialStateProc::RICH + 1).aasm.current_state).to eq(:retired)
-  end
-end

data/spec/unit/inspection_multiple_spec.rb

@@ -1,201 +0,0 @@
-require 'spec_helper'
-
-describe 'inspection for common cases' do
-  it 'should support the new DSL' do
-    # 1st state machine
-    expect(FooMultiple.aasm(:left)).to respond_to(:states)
-    expect(FooMultiple.aasm(:left).states.size).to eql 3
-    expect(FooMultiple.aasm(:left).states).to include(:open)
-    expect(FooMultiple.aasm(:left).states).to include(:closed)
-    expect(FooMultiple.aasm(:left).states).to include(:final)
-
-    expect(FooMultiple.aasm(:left)).to respond_to(:initial_state)
-    expect(FooMultiple.aasm(:left).initial_state).to eq(:open)
-
-    expect(FooMultiple.aasm(:left)).to respond_to(:events)
-    expect(FooMultiple.aasm(:left).events.size).to eql 2
-    expect(FooMultiple.aasm(:left).events).to include(:close)
-    expect(FooMultiple.aasm(:left).events).to include(:null)
-
-    # 2nd state machine
-    expect(FooMultiple.aasm(:right)).to respond_to(:states)
-    expect(FooMultiple.aasm(:right).states.size).to eql 3
-    expect(FooMultiple.aasm(:right).states).to include(:green)
-    expect(FooMultiple.aasm(:right).states).to include(:yellow)
-    expect(FooMultiple.aasm(:right).states).to include(:red)
-
-    expect(FooMultiple.aasm(:right)).to respond_to(:initial_state)
-    expect(FooMultiple.aasm(:right).initial_state).to eq(:green)
-
-    expect(FooMultiple.aasm(:right)).to respond_to(:events)
-    expect(FooMultiple.aasm(:right).events.size).to eql 3
-    expect(FooMultiple.aasm(:right).events).to include(:green)
-    expect(FooMultiple.aasm(:right).events).to include(:yellow)
-    expect(FooMultiple.aasm(:right).events).to include(:red)
-  end
-
-  context "instance level inspection" do
-    let(:foo) { FooMultiple.new }
-    let(:two) { FooTwoMultiple.new }
-
-    it "delivers all states" do
-      # 1st state machine
-      states = foo.aasm(:left).states
-      expect(states.size).to eql 3
-      expect(states).to include(:open)
-      expect(states).to include(:closed)
-      expect(states).to include(:final)
-
-      states = foo.aasm(:left).states(:permitted => true)
-      expect(states.size).to eql 1
-      expect(states).to include(:closed)
-      expect(states).not_to include(:open)
-      expect(states).not_to include(:final)
-
-      foo.close
-      expect(foo.aasm(:left).states(:permitted => true)).to be_empty
-
-      # 2nd state machine
-      states = foo.aasm(:right).states
-      expect(states.size).to eql 3
-      expect(states).to include(:green)
-      expect(states).to include(:yellow)
-      expect(states).to include(:red)
-
-      states = foo.aasm(:right).states(:permitted => true)
-      expect(states.size).to eql 1
-      expect(states).to include(:yellow)
-      expect(states).not_to include(:green)
-      expect(states).not_to include(:red)
-
-      foo.yellow
-      states = foo.aasm(:right).states(:permitted => true)
-      expect(states.size).to eql 2
-      expect(states).to include(:red)
-      expect(states).to include(:green)
-      expect(states).not_to include(:yellow)
-    end
-
-    it "delivers all states for subclasses" do
-      # 1st state machine
-      states = two.aasm(:left).states
-      expect(states.size).to eql 4
-      expect(states).to include(:open)
-      expect(states).to include(:closed)
-      expect(states).to include(:final)
-      expect(states).to include(:foo)
-
-      states = two.aasm(:left).states(:permitted => true)
-      expect(states.size).to eql 1
-      expect(states).to include(:closed)
-      expect(states).not_to include(:open)
-
-      two.close
-      expect(two.aasm(:left).states(:permitted => true)).to be_empty
-
-      # 2nd state machine
-      states = two.aasm(:right).states
-      expect(states.size).to eql 4
-      expect(states).to include(:green)
-      expect(states).to include(:yellow)
-      expect(states).to include(:red)
-      expect(states).to include(:bar)
-
-      states = two.aasm(:right).states(:permitted => true)
-      expect(states.size).to eql 1
-      expect(states).to include(:yellow)
-      expect(states).not_to include(:red)
-      expect(states).not_to include(:green)
-      expect(states).not_to include(:bar)
-
-      two.yellow
-      states = two.aasm(:right).states(:permitted => true)
-      expect(states.size).to eql 2
-      expect(states).to include(:green)
-      expect(states).to include(:red)
-      expect(states).not_to include(:yellow)
-      expect(states).not_to include(:bar)
-    end
-
-    it "delivers all events" do
-      # 1st state machine
-      events = foo.aasm(:left).events
-      expect(events.size).to eql 2
-      expect(events).to include(:close)
-      expect(events).to include(:null)
-
-      foo.close
-      expect(foo.aasm(:left).events).to be_empty
-
-      # 2nd state machine
-      events = foo.aasm(:right).events
-      expect(events.size).to eql 1
-      expect(events).to include(:yellow)
-      expect(events).not_to include(:green)
-      expect(events).not_to include(:red)
-
-      foo.yellow
-      events = foo.aasm(:right).events
-      expect(events.size).to eql 2
-      expect(events).to include(:green)
-      expect(events).to include(:red)
-      expect(events).not_to include(:yellow)
-    end
-  end
-
-  it 'should list states in the order they have been defined' do
-    expect(ConversationMultiple.aasm(:left).states).to eq([
-      :needs_attention, :read, :closed, :awaiting_response, :junk
-    ])
-  end
-end
-
-describe "special cases" do
-  it "should support valid as state name" do
-    expect(ValidStateNameMultiple.aasm(:left).states).to include(:invalid)
-    expect(ValidStateNameMultiple.aasm(:left).states).to include(:valid)
-
-    argument = ValidStateNameMultiple.new
-    expect(argument.invalid?).to be_truthy
-    expect(argument.aasm(:left).current_state).to eq(:invalid)
-
-    argument.valid!
-    expect(argument.valid?).to be_truthy
-    expect(argument.aasm(:left).current_state).to eq(:valid)
-  end
-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']]
-    )
-  end
-end
-
-describe 'aasm.from_states_for_state' do
-  it "should return all from states for a state" do
-    expect(ComplexExampleMultiple.aasm(:left)).to respond_to(:from_states_for_state)
-    froms = ComplexExampleMultiple.aasm(:left).from_states_for_state(:active)
-    [:pending, :passive, :suspended].each {|from| expect(froms).to include(from)}
-  end
-
-  it "should return from states for a state for a particular transition only" do
-    froms = ComplexExampleMultiple.aasm(:left).from_states_for_state(:active, :transition => :left_unsuspend)
-    [:suspended].each {|from| expect(froms).to include(from)}
-  end
-end
-
-describe 'permitted events' do
-  let(:foo) {FooMultiple.new}
-
-  it 'work' do
-    expect(foo.aasm(:left).events(:permitted => true)).to include(:close)
-    expect(foo.aasm(:left).events(:permitted => true)).not_to include(:null)
-
-    expect(foo.aasm(:right).events(:permitted => true)).to include(:yellow)
-    expect(foo.aasm(:right).events(:permitted => true)).not_to include(:green)
-    expect(foo.aasm(:right).events(:permitted => true)).not_to include(:red)
-  end
-end

data/spec/unit/inspection_spec.rb

@@ -1,149 +0,0 @@
-require 'spec_helper'
-
-describe 'inspection for common cases' do
-  it 'should support the new DSL' do
-    expect(Foo.aasm).to respond_to(:states)
-    expect(Foo.aasm.states).to include(:open)
-    expect(Foo.aasm.states).to include(:closed)
-
-    expect(Foo.aasm).to respond_to(:initial_state)
-    expect(Foo.aasm.initial_state).to eq(:open)
-
-    expect(Foo.aasm).to respond_to(:events)
-    expect(Foo.aasm.events).to include(:close)
-    expect(Foo.aasm.events).to include(:null)
-  end
-
-  context "instance level inspection" do
-    let(:foo) { Foo.new }
-    let(:two) { FooTwo.new }
-    let(:multi) { MultiTransitioner.new }
-
-    it "delivers all states" do
-      states = foo.aasm.states
-      expect(states).to include(:open)
-      expect(states).to include(:closed)
-      expect(states).to include(:final)
-
-      permitted_states = foo.aasm.states(:permitted => true)
-      expect(permitted_states).to include(:closed)
-      expect(permitted_states).not_to include(:open)
-      expect(permitted_states).not_to include(:final)
-
-      blocked_states = foo.aasm.states(:permitted => false)
-      expect(blocked_states).to include(:closed)
-      expect(blocked_states).not_to include(:open)
-      expect(blocked_states).to include(:final)
-
-      foo.close
-      expect(foo.aasm.states(:permitted => true)).to be_empty
-    end
-
-    it "delivers all states for subclasses" do
-      states = two.aasm.states
-      expect(states).to include(:open)
-      expect(states).to include(:closed)
-      expect(states).to include(:final)
-      expect(states).to include(:foo)
-
-      states = two.aasm.states(:permitted => true)
-      expect(states).to include(:closed)
-      expect(states).not_to include(:open)
-      expect(states).not_to include(:final)
-
-      two.close
-      expect(two.aasm.states(:permitted => true)).to be_empty
-    end
-
-    it "delivers all events" do
-      events = foo.aasm.events
-      expect(events).to include(:close)
-      expect(events).to include(:null)
-      foo.close
-      expect(foo.aasm.events).to be_empty
-    end
-
-    it "delivers permitted states when multiple transitions are defined" do
-      multi.can_run = false
-      states = multi.aasm.states(:permitted => true)
-      expect(states).to_not include(:running)
-      expect(states).to include(:dancing)
-
-      multi.can_run = true
-      states = multi.aasm.states(:permitted => true)
-      expect(states).to include(:running)
-      expect(states).to_not include(:dancing)
-    end
-
-    it "transitions to correct state if from state is missing from one transitions" do
-      multi.sleep
-      expect(multi.aasm.current_state).to eq(:sleeping)
-    end
-  end
-
-  it 'should list states in the order they have been defined' do
-    expect(Conversation.aasm.states).to eq([:needs_attention, :read, :closed, :awaiting_response, :junk])
-  end
-end
-
-describe "special cases" do
-  it "should support valid as state name" do
-    expect(ValidStateName.aasm.states).to include(:invalid)
-    expect(ValidStateName.aasm.states).to include(:valid)
-
-    argument = ValidStateName.new
-    expect(argument.invalid?).to be_truthy
-    expect(argument.aasm.current_state).to eq(:invalid)
-
-    argument.valid!
-    expect(argument.valid?).to be_truthy
-    expect(argument.aasm.current_state).to eq(:valid)
-  end
-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']])
-  end
-end
-
-describe 'aasm.from_states_for_state' do
-  it "should return all from states for a state" do
-    expect(ComplexExample.aasm).to respond_to(:from_states_for_state)
-    froms = ComplexExample.aasm.from_states_for_state(:active)
-    [:pending, :passive, :suspended].each {|from| expect(froms).to include(from)}
-  end
-
-  it "should return from states for a state for a particular transition only" do
-    froms = ComplexExample.aasm.from_states_for_state(:active, :transition => :unsuspend)
-    [:suspended].each {|from| expect(froms).to include(from)}
-  end
-end
-
-describe 'permitted events' do
-  let(:foo) {Foo.new}
-
-  it 'work' do
-    expect(foo.aasm.events(:permitted => true)).to include(:close)
-    expect(foo.aasm.events(:permitted => true)).not_to include(:null)
-  end
-
-  it 'should not include events in the reject option' do
-    expect(foo.aasm.events(:permitted => true, reject: :close)).not_to include(:close)
-    expect(foo.aasm.events(:permitted => true, reject: [:close])).not_to include(:close)
-  end
-end
-
-describe 'not permitted events' do
-  let(:foo) {Foo.new}
-
-  it 'work' do
-    expect(foo.aasm.events(:permitted => false)).to include(:null)
-    expect(foo.aasm.events(:permitted => false)).not_to include(:close)
-  end
-
-  it 'should not include events in the reject option' do
-    expect(foo.aasm.events(:permitted => false, reject: :null)).to eq([])
-  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