aasm 2.1.1 → 2.1.3

data/spec/unit/state_spec.rb

@@ -0,0 +1,74 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+# TODO These are specs ported from original aasm
+describe AASM::SupportingClasses::State do
+  before(:each) do
+    @name    = :astate
+    @options = { :crazy_custom_key => 'key' }
+  end
+
+  def new_state(options={})
+    AASM::SupportingClasses::State.new(@name, @options.merge(options))
+  end
+
+  it 'should set the name' do
+    state = new_state
+
+    state.name.should == :astate
+  end
+
+  it 'should set the options and expose them as options' do
+    state = new_state
+
+    state.options.should == @options
+  end
+
+  it 'should be equal to a symbol of the same name' do
+    state = new_state
+
+    state.should == :astate
+  end
+
+  it 'should be equal to a State of the same name' do
+    new_state.should == new_state
+  end
+
+  it 'should send a message to the record for an action if the action is present as a symbol' do
+    state = new_state(:entering => :foo)
+
+    record = mock('record')
+    record.should_receive(:foo)
+
+    state.call_action(:entering, record)
+  end
+
+  it 'should send a message to the record for an action if the action is present as a string' do
+    state = new_state(:entering => 'foo')
+
+    record = mock('record')
+    record.should_receive(:foo)
+
+    state.call_action(:entering, record)
+  end
+  
+  it 'should send a message to the record for each action' do
+    state = new_state(:entering => [:a, :b, "c", lambda {|r| r.foobar }])
+    
+    record = mock('record')
+    record.should_receive(:a)
+    record.should_receive(:b)
+    record.should_receive(:c)
+    record.should_receive(:foobar)
+    
+    state.call_action(:entering, record)
+  end
+
+  it 'should call a proc, passing in the record for an action if the action is present' do
+    state = new_state(:entering => Proc.new {|r| r.foobar})
+
+    record = mock('record')
+    record.should_receive(:foobar)
+
+    state.call_action(:entering, record)
+  end
+end

data/spec/unit/state_transition_spec.rb

@@ -0,0 +1,84 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+
+describe AASM::SupportingClasses::StateTransition do
+  it 'should set from, to, and opts attr readers' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+    st = AASM::SupportingClasses::StateTransition.new(opts)
+
+    st.from.should == opts[:from]
+    st.to.should == opts[:to]
+    st.opts.should == opts
+  end
+
+  it 'should pass equality check if from and to are the same' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+    st = AASM::SupportingClasses::StateTransition.new(opts)
+
+    obj = mock('object')
+    obj.stub!(:from).and_return(opts[:from])
+    obj.stub!(:to).and_return(opts[:to])
+
+    st.should == obj
+  end
+
+  it 'should fail equality check if from are not the same' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+    st = AASM::SupportingClasses::StateTransition.new(opts)
+
+    obj = mock('object')
+    obj.stub!(:from).and_return('blah')
+    obj.stub!(:to).and_return(opts[:to])
+
+    st.should_not == obj
+  end
+
+  it 'should fail equality check if to are not the same' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+    st = AASM::SupportingClasses::StateTransition.new(opts)
+
+    obj = mock('object')
+    obj.stub!(:from).and_return(opts[:from])
+    obj.stub!(:to).and_return('blah')
+
+    st.should_not == obj
+  end
+end
+
+describe AASM::SupportingClasses::StateTransition, '- when performing guard checks' do
+  it 'should return true of there is no guard' do
+    opts = {:from => 'foo', :to => 'bar'}
+    st = AASM::SupportingClasses::StateTransition.new(opts)
+
+    st.perform(nil).should be_true
+  end
+
+  it 'should call the method on the object if guard is a symbol' do
+    opts = {:from => 'foo', :to => 'bar', :guard => :test}
+    st = AASM::SupportingClasses::StateTransition.new(opts)
+
+    obj = mock('object')
+    obj.should_receive(:test)
+
+    st.perform(obj)
+  end
+
+  it 'should call the method on the object if guard is a string' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'test'}
+    st = AASM::SupportingClasses::StateTransition.new(opts)
+
+    obj = mock('object')
+    obj.should_receive(:test)
+
+    st.perform(obj)
+  end
+
+  it 'should call the proc passing the object if the guard is a proc' do
+    opts = {:from => 'foo', :to => 'bar', :guard => Proc.new {|o| o.test}}
+    st = AASM::SupportingClasses::StateTransition.new(opts)
+
+    obj = mock('object')
+    obj.should_receive(:test)
+
+    st.perform(obj)
+  end
+end

data/test/functional/auth_machine_test.rb

@@ -0,0 +1,120 @@
+require 'test_helper'
+
+class AuthMachine
+  include AASM
+
+  attr_accessor :activation_code, :activated_at, :deleted_at
+
+  aasm_initial_state :pending
+
+  aasm_state :passive
+  aasm_state :pending, :enter => :make_activation_code
+  aasm_state :active,  :enter => :do_activate
+  aasm_state :suspended
+  aasm_state :deleted, :enter => :do_delete, :exit => :do_undelete
+
+  aasm_event :register do
+    transitions :from => :passive, :to => :pending, :guard => Proc.new {|u| u.can_register? }
+  end
+
+  aasm_event :activate do
+    transitions :from => :pending, :to => :active
+  end
+
+  aasm_event :suspend do
+    transitions :from => [:passive, :pending, :active], :to => :suspended
+  end
+
+  aasm_event :delete do
+    transitions :from => [:passive, :pending, :active, :suspended], :to => :deleted
+  end
+
+  aasm_event :unsuspend do
+    transitions :from => :suspended, :to => :active,  :guard => Proc.new {|u| u.has_activated? }
+    transitions :from => :suspended, :to => :pending, :guard => Proc.new {|u| u.has_activation_code? }
+    transitions :from => :suspended, :to => :passive
+  end
+
+  def initialize
+    # the AR backend uses a before_validate_on_create :aasm_ensure_initial_state
+    # lets do something similar here for testing purposes.
+    aasm_enter_initial_state
+  end
+
+  def make_activation_code
+    @activation_code = 'moo'
+  end
+
+  def do_activate
+    @activated_at = Time.now
+    @activation_code = nil
+  end
+
+  def do_delete
+    @deleted_at = Time.now
+  end
+
+  def do_undelete
+    @deleted_at = false
+  end
+
+  def can_register?
+    true
+  end
+
+  def has_activated?
+    !!@activated_at
+  end
+
+  def has_activation_code?
+    !!@activation_code
+  end
+end
+
+class AuthMachineTest < Test::Unit::TestCase
+  context 'authentication state machine' do
+    context 'on initialization' do
+      setup do
+        @auth = AuthMachine.new
+      end
+
+      should 'be in the pending state' do
+        assert_equal :pending, @auth.aasm_current_state
+      end
+
+      should 'have an activation code' do
+        assert @auth.has_activation_code?
+        assert_not_nil @auth.activation_code
+      end
+    end
+
+    context 'when being unsuspended' do
+      should 'be active if previously activated' do
+        @auth = AuthMachine.new
+        @auth.activate!
+        @auth.suspend!
+        @auth.unsuspend!
+
+        assert_equal :active, @auth.aasm_current_state
+      end
+
+      should 'be pending if not previously activated, but an activation code is present' do
+        @auth = AuthMachine.new
+        @auth.suspend!
+        @auth.unsuspend!
+
+        assert_equal :pending, @auth.aasm_current_state
+      end
+
+      should 'be passive if not previously activated and there is no activation code' do
+        @auth = AuthMachine.new
+        @auth.activation_code = nil
+        @auth.suspend!
+        @auth.unsuspend!
+
+        assert_equal :passive, @auth.aasm_current_state
+      end
+    end
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,33 @@
+require 'ostruct'
+require 'rubygems'
+
+begin
+  gem 'minitest'
+rescue Gem::LoadError
+  puts 'minitest gem not found'
+end
+
+begin
+  require 'minitest/autorun'
+  puts 'using minitest'
+rescue LoadError
+  require 'test/unit'
+  puts 'using test/unit'
+end
+
+require 'rr'
+require 'shoulda'
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit
+end
+
+begin
+  require 'ruby-debug'
+  Debugger.start
+rescue LoadError
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'aasm'

data/test/unit/event_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+class EventTest < Test::Unit::TestCase
+  def new_event
+    @event = AASM::SupportingClasses::Event.new(@name, {:success => @success}) do
+      transitions :to => :closed, :from => [:open, :received]
+    end
+  end
+  
+  context 'event' do
+    setup do
+      @name = :close_order
+      @success = :success_callback
+    end
+    
+    should 'set the name' do
+      assert_equal @name, new_event.name
+    end
+    
+    should 'set the success option' do
+      assert_equal @success, new_event.success
+    end
+    
+    should 'create StateTransitions' do
+      mock(AASM::SupportingClasses::StateTransition).new({:to => :closed, :from => :open})
+      mock(AASM::SupportingClasses::StateTransition).new({:to => :closed, :from => :received})
+      new_event
+    end
+    
+    context 'when firing' do
+      should 'raise an AASM::InvalidTransition error if the transitions are empty' do
+        event = AASM::SupportingClasses::Event.new(:event)
+        
+        obj = OpenStruct.new
+        obj.aasm_current_state = :open
+        
+        assert_raise AASM::InvalidTransition do
+          event.fire(obj)
+        end
+      end
+      
+      should 'return the state of the first matching transition it finds' do
+        event = AASM::SupportingClasses::Event.new(:event) do
+          transitions :to => :closed, :from => [:open, :received]
+        end
+
+        obj = OpenStruct.new
+        obj.aasm_current_state = :open
+
+        assert_equal :closed, event.fire(obj)
+      end
+    end
+  end
+end

data/test/unit/state_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class StateTest < Test::Unit::TestCase
+  def new_state(options={})
+    AASM::SupportingClasses::State.new(@name, @options.merge(options))
+  end
+  
+  context 'state' do
+    setup do
+      @name = :astate
+      @options = { :crazy_custom_key => 'key' }
+    end
+    
+    should 'set the name' do
+      assert_equal :astate, new_state.name
+    end
+    
+    should 'set the display_name from name' do
+      assert_equal "Astate", new_state.display_name
+    end
+    
+    should 'set the display_name from options' do
+      assert_equal "A State", new_state(:display => "A State").display_name
+    end
+    
+    should 'set the options and expose them as options' do
+      assert_equal @options, new_state.options
+    end
+    
+    should 'equal a symbol of the same name' do
+      assert_equal new_state, :astate
+    end
+    
+    should 'equal a state of the same name' do
+      assert_equal new_state, new_state
+    end
+    
+    should 'send a message to the record for an action if the action is present as a symbol' do
+      state = new_state(:entering => :foo)
+      mock(record = Object.new).foo
+      state.call_action(:entering, record)
+    end
+    
+    should 'send a message to the record for an action if the action is present as a string' do
+      state = new_state(:entering => 'foo')
+      mock(record = Object.new).foo
+      state.call_action(:entering, record)
+    end
+    
+    should 'call a proc with the record as its argument for an action if the action is present as a proc' do
+      state = new_state(:entering => Proc.new {|r| r.foobar})
+      mock(record = Object.new).foobar
+      state.call_action(:entering, record)
+    end
+    
+    should 'send a message to the record for each action if the action is present as an array' do
+      state = new_state(:entering => [:a, :b, 'c', lambda {|r| r.foobar}])
+      
+      record = Object.new
+      mock(record).a
+      mock(record).b
+      mock(record).c
+      mock(record).foobar
+      
+      state.call_action(:entering, record)
+    end
+    
+  end
+end

data/test/unit/state_transition_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+class StateTransitionTest < Test::Unit::TestCase
+  context 'state transition' do
+    setup do
+      @opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+      @st = AASM::SupportingClasses::StateTransition.new(@opts)
+    end
+    
+    should 'set from, to, and opts attr readers' do
+      assert_equal @opts[:from], @st.from
+      assert_equal @opts[:to], @st.to
+      assert_equal @opts, @st.options
+    end
+    
+    should 'pass equality check if from and to are the same' do
+      obj = OpenStruct.new
+      obj.from = @opts[:from]
+      obj.to = @opts[:to]
+      
+      assert_equal @st, obj
+    end
+    
+    should 'fail equality check if from is not the same' do
+      obj = OpenStruct.new
+      obj.from = 'blah'
+      obj.to = @opts[:to]
+      
+      assert_not_equal @st, obj
+    end
+    
+    should 'fail equality check if to is not the same' do
+      obj = OpenStruct.new
+      obj.from = @opts[:from]
+      obj.to = 'blah'
+      
+      assert_not_equal @st, obj
+    end
+    
+    context 'when performing guard checks' do
+      should 'return true if there is no guard' do
+        opts = {:from => 'foo', :to => 'bar'}
+        st = AASM::SupportingClasses::StateTransition.new(opts)
+        assert st.perform(nil)
+      end
+      
+      should 'call the method on the object if guard is a symbol' do
+        opts = {:from => 'foo', :to => 'bar', :guard => :test_guard}
+        st = AASM::SupportingClasses::StateTransition.new(opts)
+
+        mock(obj = Object.new).test_guard
+
+        st.perform(obj)
+      end
+      
+      should 'call the method on the object if guard is a string' do
+        opts = {:from => 'foo', :to => 'bar', :guard => 'test_guard'}
+        st = AASM::SupportingClasses::StateTransition.new(opts)
+
+        mock(obj = Object.new).test_guard
+
+        st.perform(obj)
+      end
+      
+      should 'call the proc passing the object if guard is a proc' do
+        opts = {:from => 'foo', :to => 'bar', :guard => Proc.new {|o| o.test_guard}}
+        st = AASM::SupportingClasses::StateTransition.new(opts)
+
+        mock(obj = Object.new).test_guard
+
+        st.perform(obj)
+      end 
+    end
+  end
+end