alexrevin-aasm_numerical 2.3.1

data/spec/unit/localizer_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'active_record'
+require 'logger'
+require 'i18n'
+
+ActiveRecord::Base.logger = Logger.new(STDERR)
+
+class LocalizerTestModel < ActiveRecord::Base
+  include AASM
+
+  attr_accessor :aasm_state
+
+  aasm_initial_state :open
+  aasm_state :opened
+  aasm_state :closed
+
+  aasm_event :close
+  aasm_event :open
+end
+
+describe AASM::Localizer do
+  before(:all) do
+    I18n.load_path << 'spec/en.yml'
+    I18n.default_locale = :en
+  end
+
+  after(:all) { I18n.load_path.clear }
+
+  let (:foo_opened) { LocalizerTestModel.new }
+  let (:foo_closed) { LocalizerTestModel.new.tap { |x| x.aasm_state = :closed  } }
+
+  context '.human_state' do
+    it 'should return translated state value' do
+       foo_opened.human_state.should == "It's opened now!"
+    end
+
+    it 'should return humanized value if not localized' do
+      foo_closed.human_state.should == "Closed"
+    end
+  end
+
+  context '.human_event_name' do
+    it 'should return translated event name' do
+      LocalizerTestModel.human_event_name(:close).should == "Let's close it!"
+    end
+
+    it 'should return humanized event name' do
+      LocalizerTestModel.human_event_name(:open).should == "Open"
+    end
+  end
+end

data/spec/unit/state_spec.rb

@@ -0,0 +1,85 @@
+require File.expand_path(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 stop calling actions if one of them raises :halt_aasm_chain" do
+    state = new_state(:entering => [:a, :b, :c])
+
+    record = mock('record')
+    record.should_receive(:a)
+    record.should_receive(:b).and_throw(:halt_aasm_chain)
+    record.should_not_receive(:c)
+
+    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,163 @@
+require File.expand_path(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
+
+describe AASM::SupportingClasses::StateTransition, '- when executing the transition with a Proc' do
+  it 'should call a Proc on the object with args' do
+    opts = {:from => 'foo', :to => 'bar', :on_transition => Proc.new {|o| o.test}}
+    st = AASM::SupportingClasses::StateTransition.new(opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = mock('object')
+
+    opts[:on_transition].should_receive(:call).with(any_args)
+
+    st.execute(obj, args)
+  end
+
+  it 'should call a Proc on the object without args' do
+    opts = {:from => 'foo', :to => 'bar', :on_transition => Proc.new {||}}
+    st = AASM::SupportingClasses::StateTransition.new(opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = mock('object')
+
+    opts[:on_transition].should_receive(:call).with(no_args)
+
+    st.execute(obj, args)
+  end
+end
+
+describe AASM::SupportingClasses::StateTransition, '- when executing the transition with an :on_transtion method call' do
+  it 'should accept a String for the method name' do
+    opts = {:from => 'foo', :to => 'bar', :on_transition => 'test'}
+    st = AASM::SupportingClasses::StateTransition.new(opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = mock('object')
+
+    obj.should_receive(:test)
+
+    st.execute(obj, args)    
+  end
+  
+  it 'should accept a Symbol for the method name' do
+    opts = {:from => 'foo', :to => 'bar', :on_transition => :test}
+    st = AASM::SupportingClasses::StateTransition.new(opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = mock('object')
+
+    obj.should_receive(:test)
+
+    st.execute(obj, args)    
+  end
+  
+  it 'should pass args if the target method accepts them' do
+    opts = {:from => 'foo', :to => 'bar', :on_transition => :test}
+    st = AASM::SupportingClasses::StateTransition.new(opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = mock('object')
+
+    obj.class.class_eval do
+      define_method(:test) {|*args| 'success'}
+    end
+
+    return_value = st.execute(obj, args)
+
+    return_value.should == 'success'
+  end
+  
+  it 'should NOT pass args if the target method does NOT accept them' do
+    opts = {:from => 'foo', :to => 'bar', :on_transition => :test}
+    st = AASM::SupportingClasses::StateTransition.new(opts)
+    args = {:arg1 => '1', :arg2 => '2'}
+    obj = mock('object')
+
+    obj.class.class_eval do
+      define_method(:test) {|*args| 'success'}
+    end
+
+    return_value = st.execute(obj, args)
+
+    return_value.should == 'success'
+  end
+    
+end

data/test/functional/auth_machine_test.rb

@@ -0,0 +1,148 @@
+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
+
+  # a dummy event that can never happen
+  aasm_event :unpassify do
+    transitions :from => :passive, :to => :active, :guard => Proc.new {|u| false }
+  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 able to be unsuspended' do
+        @auth = AuthMachine.new
+        @auth.activate!
+        @auth.suspend!
+        assert @auth.may_unsuspend?
+      end
+      
+      should 'not be able to be unsuspended into active' do
+        @auth = AuthMachine.new
+        @auth.suspend!
+        assert_equal false, @auth.may_unsuspend?(:active)
+      end
+      
+      should 'not be able to be unpassified' do
+        @auth = AuthMachine.new
+        @auth.activate!
+        @auth.suspend!
+        @auth.unsuspend!
+        
+        assert_equal false, @auth.may_unpassify?
+      end
+      
+      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