aasm 2.1.1 → 5.2.0

data/spec/unit/guard_spec.rb

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

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

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

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

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

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

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

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