aasm 3.0.24 → 3.4.0

data/spec/unit/guard_spec.rb

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

data/spec/unit/initial_state_spec.rb

@@ -5,8 +5,8 @@ class Banker
   aasm do
     state :retired
     state :selling_bad_mortgages
+    initial_state Proc.new { |banker| banker.rich? ? :retired : :selling_bad_mortgages }
   end
-  aasm_initial_state  Proc.new { |banker| banker.rich? ? :retired : :selling_bad_mortgages }
   RICH = 1_000_000
   attr_accessor :balance
   def initialize(balance = 0); self.balance = balance; end
@@ -17,12 +17,11 @@ describe 'initial states' do
   let(:bar) {Bar.new}
 
   it 'should use the first state defined if no initial state is given' do
-    bar.aasm_current_state.should == :read
-    # bar.aasm.current_state.should == :read # not yet supported
+    expect(bar.aasm.current_state).to eq(:read)
   end
 
   it 'should determine initial state from the Proc results' do
-    Banker.new(Banker::RICH - 1).aasm_current_state.should == :selling_bad_mortgages
-    Banker.new(Banker::RICH + 1).aasm_current_state.should == :retired
+    expect(Banker.new(Banker::RICH - 1).aasm.current_state).to eq(:selling_bad_mortgages)
+    expect(Banker.new(Banker::RICH + 1).aasm.current_state).to eq(:retired)
   end
 end

data/spec/unit/inspection_spec.rb

@@ -1,30 +1,17 @@
 require 'spec_helper'
 
 describe 'inspection for common cases' do
-  it 'should support the old DSL' do
-    Foo.should respond_to(:aasm_states)
-    Foo.aasm_states.should include(:open)
-    Foo.aasm_states.should include(:closed)
-
-    Foo.should respond_to(:aasm_initial_state)
-    Foo.aasm_initial_state.should == :open
-
-    Foo.should respond_to(:aasm_events)
-    Foo.aasm_events.should include(:close)
-    Foo.aasm_events.should include(:null)
-  end
-
   it 'should support the new DSL' do
-    Foo.aasm.should respond_to(:states)
-    Foo.aasm.states.should include(:open)
-    Foo.aasm.states.should include(:closed)
+    expect(Foo.aasm).to respond_to(:states)
+    expect(Foo.aasm.states).to include(:open)
+    expect(Foo.aasm.states).to include(:closed)
 
-    Foo.aasm.should respond_to(:initial_state)
-    Foo.aasm.initial_state.should == :open
+    expect(Foo.aasm).to respond_to(:initial_state)
+    expect(Foo.aasm.initial_state).to eq(:open)
 
-    Foo.aasm.should respond_to(:events)
-    Foo.aasm.events.should include(:close)
-    Foo.aasm.events.should include(:null)
+    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
@@ -33,77 +20,79 @@ describe 'inspection for common cases' do
 
     it "delivers all states" do
       states = foo.aasm.states
-      states.should include(:open)
-      states.should include(:closed)
+      expect(states).to include(:open)
+      expect(states).to include(:closed)
+      expect(states).to include(:final)
 
       states = foo.aasm.states(:permissible => true)
-      states.should include(:closed)
-      states.should_not include(:open)
+      expect(states).to include(:closed)
+      expect(states).not_to include(:open)
+      expect(states).not_to include(:final)
 
       foo.close
-      foo.aasm.states(:permissible => true).should be_empty
+      expect(foo.aasm.states(:permissible => true)).to be_empty
     end
 
     it "delivers all states for subclasses" do
       states = two.aasm.states
-      states.should include(:open)
-      states.should include(:closed)
-      states.should include(:foo)
+      expect(states).to include(:open)
+      expect(states).to include(:closed)
+      expect(states).to include(:foo)
 
       states = two.aasm.states(:permissible => true)
-      states.should include(:closed)
-      states.should_not include(:open)
+      expect(states).to include(:closed)
+      expect(states).not_to include(:open)
 
       two.close
-      two.aasm.states(:permissible => true).should be_empty
+      expect(two.aasm.states(:permissible => true)).to be_empty
     end
 
     it "delivers all events" do
       events = foo.aasm.events
-      events.should include(:close)
-      events.should include(:null)
+      expect(events).to include(:close)
+      expect(events).to include(:null)
       foo.close
-      foo.aasm.events.should be_empty
+      expect(foo.aasm.events).to be_empty
     end
   end
 
   it 'should list states in the order they have been defined' do
-    Conversation.aasm.states.should == [:needs_attention, :read, :closed, :awaiting_response, :junk]
+    expect(Conversation.aasm.states).to eq([:needs_attention, :read, :closed, :awaiting_response, :junk])
   end
 end
 
 describe "special cases" do
   it "should support valid a state name" do
-    Argument.aasm_states.should include(:invalid)
-    Argument.aasm_states.should include(:valid)
+    expect(Argument.aasm.states).to include(:invalid)
+    expect(Argument.aasm.states).to include(:valid)
 
     argument = Argument.new
-    argument.invalid?.should be_true
-    argument.aasm_current_state.should == :invalid
+    expect(argument.invalid?).to be_true
+    expect(argument.aasm.current_state).to eq(:invalid)
 
     argument.valid!
-    argument.valid?.should be_true
-    argument.aasm_current_state.should == :valid
+    expect(argument.valid?).to be_true
+    expect(argument.aasm.current_state).to eq(:valid)
   end
 end
 
-describe :aasm_states_for_select do
+describe 'aasm.states_for_select' do
   it "should return a select friendly array of states" do
-    Foo.should respond_to(:aasm_states_for_select)
-    Foo.aasm_states_for_select.should == [['Open', 'open'], ['Closed', 'closed']]
+    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
+describe 'aasm.from_states_for_state' do
   it "should return all from states for a state" do
-    AuthMachine.should respond_to(:aasm_from_states_for_state)
-    froms = AuthMachine.aasm_from_states_for_state(:active)
-    [:pending, :passive, :suspended].each {|from| froms.should include(from)}
+    expect(AuthMachine.aasm).to respond_to(:from_states_for_state)
+    froms = AuthMachine.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 = AuthMachine.aasm_from_states_for_state(:active, :transition => :unsuspend)
-    [:suspended].each {|from| froms.should include(from)}
+    froms = AuthMachine.aasm.from_states_for_state(:active, :transition => :unsuspend)
+    [:suspended].each {|from| expect(froms).to include(from)}
   end
 end
 
@@ -111,7 +100,7 @@ describe 'permissible events' do
   let(:foo) {Foo.new}
 
   it 'work' do
-    foo.aasm.permissible_events.should include(:close)
-    foo.aasm.permissible_events.should_not include(:null)
+    expect(foo.aasm.permissible_events).to include(:close)
+    expect(foo.aasm.permissible_events).not_to include(:null)
   end
 end

data/spec/unit/localizer_spec.rb

@@ -10,12 +10,12 @@ class LocalizerTestModel < ActiveRecord::Base
 
   attr_accessor :aasm_state
 
-  aasm_initial_state :opened
-  aasm_state :opened
-  aasm_state :closed
-
-  aasm_event :close
-  aasm_event :open
+  aasm do
+    state :opened, :initial => true
+    state :closed
+    event :close
+    event :open
+  end
 end
 
 describe 'localized state names' do
@@ -30,11 +30,15 @@ describe 'localized state names' do
   end
 
   it 'should localize' do
-    LocalizerTestModel.aasm.states.detect {|s| s == :opened}.localized_name.should == "It's open now!"
+    state = LocalizerTestModel.aasm.states.detect {|s| s == :opened}
+    expect(state.localized_name).to eq("It's open now!")
+    expect(state.human_name).to eq("It's open now!")
   end
 
   it 'should use fallback' do
-    LocalizerTestModel.aasm.states.detect {|s| s == :closed}.localized_name.should == 'Closed'
+    state = LocalizerTestModel.aasm.states.detect {|s| s == :closed}
+    expect(state.localized_name).to eq('Closed')
+    expect(state.human_name).to eq('Closed')
   end
 end
 
@@ -52,23 +56,23 @@ describe AASM::Localizer, "new style" do
   let (:foo_opened) { LocalizerTestModel.new }
   let (:foo_closed) { LocalizerTestModel.new.tap { |x| x.aasm_state = :closed  } }
 
-  context 'aasm_human_state' do
+  context 'aasm.human_state' do
     it 'should return translated state value' do
-      foo_opened.aasm_human_state.should == "It's open now!"
+      expect(foo_opened.aasm.human_state).to eq("It's open now!")
     end
 
     it 'should return humanized value if not localized' do
-      foo_closed.aasm_human_state.should == "Closed"
+      expect(foo_closed.aasm.human_state).to eq("Closed")
     end
   end
 
   context 'aasm_human_event_name' do
     it 'should return translated event name' do
-      LocalizerTestModel.aasm_human_event_name(:close).should == "Let's close it!"
+      expect(LocalizerTestModel.aasm_human_event_name(:close)).to eq("Let's close it!")
     end
 
     it 'should return humanized event name' do
-      LocalizerTestModel.aasm_human_event_name(:open).should == "Open"
+      expect(LocalizerTestModel.aasm_human_event_name(:open)).to eq("Open")
     end
   end
 end
@@ -87,23 +91,23 @@ describe AASM::Localizer, "deprecated style" do
   let (:foo_opened) { LocalizerTestModel.new }
   let (:foo_closed) { LocalizerTestModel.new.tap { |x| x.aasm_state = :closed  } }
 
-  context 'aasm_human_state' do
+  context 'aasm.human_state' do
     it 'should return translated state value' do
-      foo_opened.aasm_human_state.should == "It's open now!"
+      expect(foo_opened.aasm.human_state).to eq("It's open now!")
     end
 
     it 'should return humanized value if not localized' do
-      foo_closed.aasm_human_state.should == "Closed"
+      expect(foo_closed.aasm.human_state).to eq("Closed")
     end
   end
 
   context 'aasm_human_event_name' do
     it 'should return translated event name' do
-      LocalizerTestModel.aasm_human_event_name(:close).should == "Let's close it!"
+      expect(LocalizerTestModel.aasm_human_event_name(:close)).to eq("Let's close it!")
     end
 
     it 'should return humanized event name' do
-      LocalizerTestModel.aasm_human_event_name(:open).should == "Open"
+      expect(LocalizerTestModel.aasm_human_event_name(:open)).to eq("Open")
     end
   end
 end

data/spec/unit/memory_leak_spec.rb

@@ -2,8 +2,8 @@
 
 # describe "state machines" do
 
-#   def number_of_objects(clazz)
-#     ObjectSpace.each_object(clazz) {}
+#   def number_of_objects(klass)
+#     ObjectSpace.each_object(klass) {}
 #   end
 
 #   def machines

data/spec/unit/new_dsl_spec.rb

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