aasm 3.0.14 → 3.0.15

data/spec/unit/complex_example_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'AuthMachine on initialization' do
+describe 'on initialization' do
   let(:auth) {AuthMachine.new}
 
   it 'should be in the pending state' do
@@ -13,7 +13,7 @@ describe 'AuthMachine on initialization' do
   end
 end
 
-describe 'AuthMachine when being unsuspended' do
+describe 'when being unsuspended' do
   let(:auth) {AuthMachine.new}
 
   it 'should be able to be unsuspended' do

data/spec/unit/initial_state_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+class Banker
+  include AASM
+  aasm do
+    state :retired
+    state :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
+  def rich?; self.balance >= RICH; end
+end
+
+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
+  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
+  end
+end

data/spec/unit/inspection_spec.rb

@@ -1,7 +1,79 @@
 require 'spec_helper'
 
-describe 'inspecting AASM' do
-  it 'should support listing all states in the order they have been defined' do
-    Conversation.aasm_states.should == [:needs_attention, :read, :closed, :awaiting_response, :junk]
+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)
+
+    Foo.aasm.should respond_to(:initial_state)
+    Foo.aasm.initial_state.should == :open
+
+    Foo.aasm.should respond_to(:events)
+    Foo.aasm.events.should include(:close)
+    Foo.aasm.events.should include(:null)
+  end
+
+  it 'should list states in the order they have been defined' do
+    Conversation.aasm.states.should == [: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)
+
+    argument = Argument.new
+    argument.invalid?.should be_true
+    argument.aasm_current_state.should == :invalid
+
+    argument.valid!
+    argument.valid?.should be_true
+    argument.aasm_current_state.should == :valid
+  end
+end
+
+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']]
+  end
+end
+
+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)}
+  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)}
+  end
+end
+
+describe :aasm_events_for_current_state do
+  let(:foo) {Foo.new}
+
+  it 'work' do
+    foo.aasm_events_for_current_state.should include(:close)
+    foo.aasm_events_for_current_state.should include(:null)
+    foo.close
+    foo.aasm_events_for_current_state.should be_empty
   end
 end

data/spec/unit/memory_leak_spec.rb

@@ -1,34 +1,38 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+# require 'spec_helper'
 
-describe "state machines" do
+# describe "state machines" do
 
-  def number_of_objects(clazz)
-    ObjectSpace.each_object(clazz) {}
-  end
-  
-  def machines
-    AASM::StateMachine.instance_variable_get("@machines")
-  end
+#   def number_of_objects(clazz)
+#     ObjectSpace.each_object(clazz) {}
+#   end
 
-  it "should be created without memory leak" do
-    machines_count = machines.size
-    state_count = number_of_objects(AASM::SupportingClasses::State)
-    event_count = number_of_objects(AASM::SupportingClasses::Event)
-    transition_count = number_of_objects(AASM::SupportingClasses::StateTransition)
+#   def machines
+#     AASM::StateMachine.instance_variable_get("@machines")
+#   end
 
-    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::SupportingClasses::State).should == state_count + 3                 # + Process
-    number_of_objects(AASM::SupportingClasses::Event).should == event_count + 2                 # + Process
-    number_of_objects(AASM::SupportingClasses::StateTransition).should == transition_count + 2  # + Process
+#   it "should be created without memory leak" do
+#     machines_count = machines.size
+#     state_count = number_of_objects(AASM::SupportingClasses::State)
+#     event_count = number_of_objects(AASM::SupportingClasses::Event)
+#     puts "event_count = #{event_count}"
+#     transition_count = number_of_objects(AASM::SupportingClasses::StateTransition)
 
-    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::SupportingClasses::State).should == state_count + 3                 # + Process
-    number_of_objects(AASM::SupportingClasses::Event).should == event_count + 2                 # + Process
-    number_of_objects(AASM::SupportingClasses::StateTransition).should == transition_count + 2  # + Process
-  end
+#     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::SupportingClasses::State).should == state_count + 3                 # + Process
+#     puts "event_count = #{number_of_objects(AASM::SupportingClasses::Event)}"
+#     number_of_objects(AASM::SupportingClasses::Event).should == event_count + 2                 # + Process
+#     number_of_objects(AASM::SupportingClasses::StateTransition).should == transition_count + 2  # + Process
 
-end
+#     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::SupportingClasses::State).should == state_count + 3                 # + Process
+#     # ObjectSpace.each_object(AASM::SupportingClasses::Event) {|o| puts o.inspect}
+#     puts "event_count = #{number_of_objects(AASM::SupportingClasses::Event)}"
+#     number_of_objects(AASM::SupportingClasses::Event).should == event_count + 2                 # + Process
+#     number_of_objects(AASM::SupportingClasses::StateTransition).should == transition_count + 2  # + Process
+#   end
+
+# end

data/spec/unit/new_dsl_spec.rb

@@ -1,24 +1,8 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+require 'spec_helper'
 
 describe "the new dsl" do
 
-  before(:each) do
-    @process = ProcessWithNewDsl.new
-  end
-  
-  it 'should use an initial event' do
-    @process.aasm_current_state.should == :sleeping
-    @process.should be_sleeping
-  end
-  
-  it 'should have states and transitions' do
-    @process.flagged.should be_nil
-    @process.start!
-    @process.should be_running
-    @process.flagged.should be_true
-    @process.stop!
-    @process.should be_suspended
-  end
+  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")

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'active_record'
 require 'logger'
 require 'spec_helper'
@@ -58,7 +57,7 @@ end
 describe "instance methods" do
   let(:gate) {Gate.new}
 
-  it "should respond to aasm states" do
+  it "should respond to aasm persistence methods" do
     gate.should respond_to(:aasm_read_state)
     gate.should respond_to(:aasm_write_state)
     gate.should respond_to(:aasm_write_state_without_persistence)
@@ -85,16 +84,12 @@ describe "instance methods" do
     gate.aasm_current_state.should be_nil
   end
 
-  it "should have aasm_ensure_initial_state" do
-    gate.send :aasm_ensure_initial_state
-  end
-
   it "should call aasm_ensure_initial_state on validation before create" do
     gate.should_receive(:aasm_ensure_initial_state).and_return(true)
     gate.valid?
   end
 
-  it "should call aasm_ensure_initial_state on validation before create" do
+  it "should not call aasm_ensure_initial_state on validation before update" do
     gate.stub!(:new_record?).and_return(false)
     gate.should_not_receive(:aasm_ensure_initial_state)
     gate.valid?

data/spec/unit/simple_example_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+class Payment
+  include AASM
+  aasm do
+    state :initialised, :initial => true
+    state :filled_out
+    state :authorised
+
+    event :fill_out do
+      transitions :from => :initialised, :to => :filled_out
+    end
+    event :authorise do
+      transitions :from => :filled_out, :to => :authorised
+    end
+  end
+end
+
+describe 'state machine' do
+  let(:payment) {Payment.new}
+
+  it 'starts with an initial state' do
+    payment.aasm_current_state.should == :initialised
+    # payment.aasm.current_state.should == :initialised # not yet supported
+    payment.should respond_to(:initialised?)
+    payment.should be_initialised
+  end
+
+  it 'allows transitions to other states' do
+    payment.should respond_to(:fill_out)
+    payment.should respond_to(:fill_out!)
+    payment.fill_out!
+    payment.should respond_to(:filled_out?)
+    payment.should be_filled_out
+
+    payment.should respond_to(:authorise)
+    payment.should respond_to(:authorise!)
+    payment.authorise
+    payment.should respond_to(:authorised?)
+    payment.should be_authorised
+  end
+
+  it 'denies transitions to other states' do
+    lambda {payment.authorise}.should raise_error(AASM::InvalidTransition)
+    lambda {payment.authorise!}.should raise_error(AASM::InvalidTransition)
+    payment.fill_out
+    lambda {payment.fill_out}.should raise_error(AASM::InvalidTransition)
+    lambda {payment.fill_out!}.should raise_error(AASM::InvalidTransition)
+    payment.authorise
+    lambda {payment.fill_out}.should raise_error(AASM::InvalidTransition)
+    lambda {payment.fill_out!}.should raise_error(AASM::InvalidTransition)
+  end
+end

data/spec/unit/subclassing_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe 'subclassing' do
+  it 'should have the parent states' do
+    Foo.aasm_states.each do |state|
+      FooTwo.aasm_states.should include(state)
+    end
+    Baz.aasm_states.should == Bar.aasm_states
+  end
+
+  it 'should not add the child states to the parent machine' do
+    Foo.aasm_states.should_not include(:foo)
+  end
+
+  it "should have the same events as its parent" do
+    Baz.aasm_events.should == Bar.aasm_events
+  end
+end
+

data/spec/unit/{event_spec.rb → supporting_classes/event_spec.rb}

@@ -1,51 +1,50 @@
 require 'spec_helper'
 
 describe 'adding an event' do
-
-  def new_event
-    @event = AASM::SupportingClasses::Event.new(:close_order, {:success => :success_callback}) do
+  let(:event) do
+    AASM::SupportingClasses::Event.new(:close_order, {:success => :success_callback}) do
       transitions :to => :closed, :from => [:open, :received]
     end
   end
 
   it 'should set the name' do
-    new_event
-    @event.name.should == :close_order
+    event.name.should == :close_order
   end
 
-  it 'should set the success option' do
-    new_event
-    @event.success.should == :success_callback
+  it 'should set the success callback' do
+    event.success.should == :success_callback
   end
 
-  it 'should create StateTransitions' do
-    AASM::SupportingClasses::StateTransition.should_receive(:new).with({:to => :closed, :from => :open})
-    AASM::SupportingClasses::StateTransition.should_receive(:new).with({:to => :closed, :from => :received})
-    new_event
+  it 'should create transitions' do
+    transitions = event.all_transitions
+    transitions[0].from.should == :open
+    transitions[0].to.should == :closed
+    transitions[1].from.should == :received
+    transitions[1].to.should == :closed
   end
 end
 
 describe 'transition inspection' do
-  before do
-    @event = AASM::SupportingClasses::Event.new(:run) do
+  let(:event) do
+    AASM::SupportingClasses::Event.new(:run) do
       transitions :to => :running, :from => :sleeping
     end
   end
 
-  it 'should support inspecting transitions from states' do
-    @event.transitions_from_state(:sleeping).map(&:to).should == [:running]
-    @event.transitions_from_state?(:sleeping).should be_true
+  it 'should support inspecting transitions from other states' do
+    event.transitions_from_state(:sleeping).map(&:to).should == [:running]
+    event.transitions_from_state?(:sleeping).should be_true
 
-    @event.transitions_from_state(:cleaning).map(&:to).should == []
-    @event.transitions_from_state?(:cleaning).should be_false
+    event.transitions_from_state(:cleaning).map(&:to).should == []
+    event.transitions_from_state?(:cleaning).should be_false
   end
 
-  it 'should support inspecting transitions to states' do
-    @event.transitions_to_state(:running).map(&:from).should == [:sleeping]
-    @event.transitions_to_state?(:running).should be_true
+  it 'should support inspecting transitions to other states' do
+    event.transitions_to_state(:running).map(&:from).should == [:sleeping]
+    event.transitions_to_state?(:running).should be_true
 
-    @event.transitions_to_state(:cleaning).map(&:to).should == []
-    @event.transitions_to_state?(:cleaning).should be_false
+    event.transitions_to_state(:cleaning).map(&:to).should == []
+    event.transitions_to_state?(:cleaning).should be_false
   end
 end
 
@@ -148,3 +147,57 @@ describe 'executing the success callback' do
     model.with_proc!
   end
 end
+
+describe 'parametrised events' do
+  let(:pe) {ParametrisedEvent.new}
+
+  it 'should transition to specified next state (sleeping to showering)' do
+    pe.wakeup!(:showering)
+    pe.aasm_current_state.should == :showering
+  end
+
+  it 'should transition to specified next state (sleeping to working)' do
+    pe.wakeup!(:working)
+    pe.aasm_current_state.should == :working
+  end
+
+  it 'should transition to default (first or showering) state' do
+    pe.wakeup!
+    pe.aasm_current_state.should == :showering
+  end
+
+  it 'should transition to default state when on_transition invoked' do
+    pe.dress!(nil, 'purple', 'dressy')
+    pe.aasm_current_state.should == :working
+  end
+
+  it 'should call on_transition method with args' do
+    pe.wakeup!(:showering)
+    pe.should_receive(:wear_clothes).with('blue', 'jeans')
+    pe.dress!(:working, 'blue', 'jeans')
+  end
+
+  it 'should call on_transition proc' do
+    pe.wakeup!(:showering)
+    pe.should_receive(:wear_clothes).with('purple', 'slacks')
+    pe.dress!(:dating, 'purple', 'slacks')
+  end
+
+  it 'should call on_transition with an array of methods' do
+    pe.wakeup!(:showering)
+    pe.should_receive(:condition_hair)
+    pe.should_receive(:fix_hair)
+    pe.dress!(:prettying_up)
+  end
+end
+
+describe 'event firing without persistence' do
+  it 'should attempt to persist if aasm_write_state is defined' do
+    foo = Foo.new
+    def foo.aasm_write_state; end
+    foo.should be_open
+
+    foo.should_receive(:aasm_write_state_without_persistence)
+    foo.close
+  end
+end