aasm 2.3.1 → 2.4.0

data/test/test_helper.rb

@@ -1,43 +0,0 @@
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-
-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.settings[:autoeval] = true; debugger; rubys_debugger = 'annoying'
-  require 'ruby-debug/completion'
-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

@@ -1,54 +0,0 @@
-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_machine_test.rb

@@ -1,37 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-
-class StateMachineTest < Test::Unit::TestCase
-  
-  context "state machines" do
-    
-    should "be created without memory leak" do
-      assert_equal 1, AASM::StateMachine.instance_variable_get("@machines").size  # AuthMachine      
-      assert_number_of_objects AASM::SupportingClasses::State, 5                  # AuthMachine
-      assert_number_of_objects AASM::SupportingClasses::Event, 11                 # AuthMachine
-      assert_number_of_objects AASM::SupportingClasses::StateTransition, 19       # AuthMachine
-      
-      load File.expand_path(File.dirname(__FILE__) + '/../models/process.rb')
-      assert_equal 2, AASM::StateMachine.instance_variable_get("@machines").size  # AuthMachine + Process
-      assert_number_of_objects Models::Process, 0
-      assert_number_of_objects AASM::SupportingClasses::State, 8                  # AuthMachine + Process
-      assert_number_of_objects AASM::SupportingClasses::Event, 13                 # AuthMachine + Process
-      assert_number_of_objects AASM::SupportingClasses::StateTransition, 21       # AuthMachine + Process
-      
-      Models.send(:remove_const, "Process") if Models.const_defined?("Process")
-      load File.expand_path(File.dirname(__FILE__) + '/../models/process.rb')
-      assert_equal 2, AASM::StateMachine.instance_variable_get("@machines").size  # AuthMachine + Process
-      assert_number_of_objects AASM::SupportingClasses::State, 8                  # AuthMachine + Process
-      assert_number_of_objects AASM::SupportingClasses::Event, 13                 # AuthMachine + Process
-      assert_number_of_objects AASM::SupportingClasses::StateTransition, 21       # AuthMachine + Process
-    end
-    
-  end
-  
-  private
-  
-    def assert_number_of_objects(clazz, num)
-      count = ObjectSpace.each_object(clazz) {}
-      assert_equal num, count, "#{num} expected, but we had #{count} #{clazz}"
-    end
-  
-end

data/test/unit/state_test.rb

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

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