aasm 5.0.8 → 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,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/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