aasm 5.1.1 → 5.5.0

data/spec/unit/guard_spec.rb

@@ -1,89 +0,0 @@
-require 'spec_helper'
-
-describe "per-transition guards" do
-  let(:guardian) { Guardian.new }
-
-  it "allows the transition if the guard succeeds" do
-    expect { guardian.use_one_guard_that_succeeds! }.to_not raise_error
-    expect(guardian).to be_beta
-  end
-
-  it "stops the transition if the guard fails" do
-    expect { guardian.use_one_guard_that_fails! }.to raise_error(AASM::InvalidTransition)
-    expect(guardian).to be_alpha
-  end
-
-  it "allows the transition if all guards succeeds" do
-    expect { guardian.use_guards_that_succeed! }.to_not raise_error
-    expect(guardian).to be_beta
-  end
-
-  it "stops the transition if the first guard fails" do
-    expect { guardian.use_guards_where_the_first_fails! }.to raise_error(AASM::InvalidTransition)
-    expect(guardian).to be_alpha
-  end
-
-  it "stops the transition if the second guard fails" do
-    expect { guardian.use_guards_where_the_second_fails! }.to raise_error(AASM::InvalidTransition)
-    expect(guardian).to be_alpha
-  end
-
-  describe "with params" do
-    it "using a Proc" do
-      expect(guardian).to receive(:inner_guard).with({:flag => true}).and_return(true)
-      guardian.use_proc_guard_with_params(:flag => true)
-    end
-
-    it "using a lambda" do
-      expect(guardian).to receive(:inner_guard).with({:flag => true}).and_return(true)
-      guardian.use_lambda_guard_with_params(:flag => true)
-    end
-  end
-end
-
-describe "event guards" do
-  let(:guardian) { Guardian.new }
-
-  it "allows the transition if the event guards succeed" do
-    expect { guardian.use_event_guards_that_succeed! }.to_not raise_error
-    expect(guardian).to be_beta
-  end
-
-  it "allows the transition if the event and transition guards succeed" do
-    expect { guardian.use_event_and_transition_guards_that_succeed! }.to_not raise_error
-    expect(guardian).to be_beta
-  end
-
-  it "stops the transition if the first event guard fails" do
-    expect { guardian.use_event_guards_where_the_first_fails! }.to raise_error(AASM::InvalidTransition)
-    expect(guardian).to be_alpha
-  end
-
-  it "stops the transition if the second event guard fails" do
-    expect { guardian.use_event_guards_where_the_second_fails! }.to raise_error(AASM::InvalidTransition)
-    expect(guardian).to be_alpha
-  end
-
-  it "stops the transition if the transition guard fails" do
-    expect { guardian.use_event_and_transition_guards_where_third_fails! }.to raise_error(AASM::InvalidTransition)
-    expect(guardian).to be_alpha
-  end
-
-end
-
-if defined?(ActiveRecord)
-
-  Dir[File.dirname(__FILE__) + "/../models/active_record/*.rb"].sort.each do |f|
-    require File.expand_path(f)
-  end
-
-  load_schema
-
-  describe "ActiveRecord per-transition guards" do
-    let(:example) { ComplexActiveRecordExample.new }
-
-    it "should be able to increment" do
-      expect(example.may_increment?).to be true
-    end
-  end
-end

data/spec/unit/guard_with_params_multiple_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-describe "guards with params" do
-  let(:guard) { GuardWithParamsMultiple.new }
-  let(:user) {GuardParamsClass.new}
-
-  it "list permitted states" do
-    expect(guard.aasm(:left).states({:permitted => true}, user).map(&:name)).to eql [:reviewed]
-  end
-end

data/spec/unit/guard_with_params_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe "guards with params" do
-  let(:guard) { GuardWithParams.new }
-  let(:user) {GuardParamsClass.new}
-
-  it "list permitted states" do
-    expect(guard.aasm.states({:permitted => true}, user).map(&:name)).to eql [:reviewed]
-  end
-
-  it "list no states if user is blank" do
-    expect(guard.aasm.states({:permitted => true}, nil).map(&:name)).to eql []
-  end
-end

data/spec/unit/guard_without_from_specified_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-describe "transitions without from specified" do
-  let(:guardian) { GuardianWithoutFromSpecified.new }
-
-  it "allows the transitions if guard succeeds" do
-    expect { guardian.use_guards_where_the_first_fails! }.to_not raise_error
-    expect(guardian).to be_gamma
-  end
-end

data/spec/unit/initial_state_multiple_spec.rb

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

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,205 +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
-  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
-
-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,153 +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
-  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
-
-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