aasm 2.2.0 → 2.3.1

data/spec/unit/active_record_persistence_spec.rb

@@ -2,20 +2,18 @@ begin
   require 'rubygems'
   require 'active_record'
   require 'logger'
-  
-  ActiveRecord::Base.logger = Logger.new(STDERR)
 
-  # A dummy class for mocking the activerecord connection class
-  class Connection
-  end
+  load_schema
 
-  class FooBar < ActiveRecord::Base
+  ActiveRecord::Base.logger = Logger.new(STDERR)
+
+  class Gate < ActiveRecord::Base
     include AASM
 
     # Fake this column for testing purposes
     attr_accessor :aasm_state
 
-    aasm_state :open
+    aasm_state :opened
     aasm_state :closed
 
     aasm_event :view do
@@ -23,36 +21,37 @@ begin
     end
   end
 
-  class Fi < ActiveRecord::Base
+  class Reader < ActiveRecord::Base
     def aasm_read_state
       "fi"
     end
     include AASM
   end
 
-  class Fo < ActiveRecord::Base
+  class Writer < ActiveRecord::Base
     def aasm_write_state(state)
       "fo"
     end
     include AASM
   end
 
-  class Fum < ActiveRecord::Base
+  class Transient < ActiveRecord::Base
     def aasm_write_state_without_persistence(state)
       "fum"
     end
     include AASM
   end
 
-  class June < ActiveRecord::Base
+  class Simple < ActiveRecord::Base
     include AASM
     aasm_column :status
   end
 
-  class Beaver < June
+  class Derivate < Simple
   end
 
   class Thief < ActiveRecord::Base
+    set_table_name "thieves"
     include AASM
     aasm_initial_state  Proc.new { |thief| thief.skilled ? :rich : :jailed }
     aasm_state          :rich
@@ -60,7 +59,7 @@ begin
     attr_accessor :skilled, :aasm_state
   end
 
-  describe "aasm model", :shared => true do
+  shared_examples_for "aasm model" do
     it "should include AASM::Persistence::ActiveRecordPersistence" do
       @klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence)
     end
@@ -69,9 +68,9 @@ begin
     end
   end
 
-  describe FooBar, "class methods" do
+  describe Gate, "class methods" do
     before(:each) do
-      @klass = FooBar
+      @klass = Gate
     end
     it_should_behave_like "aasm model"
     it "should include AASM::Persistence::ActiveRecordPersistence::ReadState" do
@@ -85,9 +84,9 @@ begin
     end
   end
 
-  describe Fi, "class methods" do
+  describe Reader, "class methods" do
     before(:each) do
-      @klass = Fi
+      @klass = Reader
     end
     it_should_behave_like "aasm model"
     it "should not include AASM::Persistence::ActiveRecordPersistence::ReadState" do
@@ -101,9 +100,9 @@ begin
     end
   end
 
-  describe Fo, "class methods" do
+  describe Writer, "class methods" do
     before(:each) do
-      @klass = Fo
+      @klass = Writer
     end
     it_should_behave_like "aasm model"
     it "should include AASM::Persistence::ActiveRecordPersistence::ReadState" do
@@ -117,9 +116,9 @@ begin
     end
   end
 
-  describe Fum, "class methods" do
+  describe Transient, "class methods" do
     before(:each) do
-      @klass = Fum
+      @klass = Transient
     end
     it_should_behave_like "aasm model"
     it "should include AASM::Persistence::ActiveRecordPersistence::ReadState" do
@@ -133,61 +132,57 @@ begin
     end
   end
 
-  describe FooBar, "instance methods" do
-    before(:each) do
-      connection = mock(Connection, :columns => [])
-      FooBar.stub!(:connection).and_return(connection)
-    end
+  describe Gate, "instance methods" do
 
     it "should respond to aasm read state when not previously defined" do
-      FooBar.new.should respond_to(:aasm_read_state)
+      Gate.new.should respond_to(:aasm_read_state)
     end
 
     it "should respond to aasm write state when not previously defined" do
-      FooBar.new.should respond_to(:aasm_write_state)
+      Gate.new.should respond_to(:aasm_write_state)
     end
 
     it "should respond to aasm write state without persistence when not previously defined" do
-      FooBar.new.should respond_to(:aasm_write_state_without_persistence)
+      Gate.new.should respond_to(:aasm_write_state_without_persistence)
     end
 
     it "should return the initial state when new and the aasm field is nil" do
-      FooBar.new.aasm_current_state.should == :open
+      Gate.new.aasm_current_state.should == :opened
     end
 
     it "should return the aasm column when new and the aasm field is not nil" do
-      foo = FooBar.new
+      foo = Gate.new
       foo.aasm_state = "closed"
       foo.aasm_current_state.should == :closed
     end
 
     it "should return the aasm column when not new and the aasm_column is not nil" do
-      foo = FooBar.new
+      foo = Gate.new
       foo.stub!(:new_record?).and_return(false)
       foo.aasm_state = "state"
       foo.aasm_current_state.should == :state
     end
 
     it "should allow a nil state" do
-      foo = FooBar.new
+      foo = Gate.new
       foo.stub!(:new_record?).and_return(false)
       foo.aasm_state = nil
       foo.aasm_current_state.should be_nil
     end
 
     it "should have aasm_ensure_initial_state" do
-      foo = FooBar.new
+      foo = Gate.new
       foo.send :aasm_ensure_initial_state
     end
 
     it "should call aasm_ensure_initial_state on validation before create" do
-      foo = FooBar.new
+      foo = Gate.new
       foo.should_receive(:aasm_ensure_initial_state).and_return(true)
       foo.valid?
     end
 
     it "should call aasm_ensure_initial_state on validation before create" do
-      foo = FooBar.new
+      foo = Gate.new
       foo.stub!(:new_record?).and_return(false)
       foo.should_not_receive(:aasm_ensure_initial_state)
       foo.valid?
@@ -195,45 +190,41 @@ begin
 
   end
 
-  describe 'Beavers' do
+  describe 'Derivates' do
     it "should have the same states as it's parent" do
-      Beaver.aasm_states.should == June.aasm_states
+      Derivate.aasm_states.should == Simple.aasm_states
     end
 
     it "should have the same events as it's parent" do
-      Beaver.aasm_events.should == June.aasm_events
+      Derivate.aasm_events.should == Simple.aasm_events
     end
 
     it "should have the same column as it's parent" do
-      Beaver.aasm_column.should == :status
+      Derivate.aasm_column.should == :status
     end
   end
 
   describe AASM::Persistence::ActiveRecordPersistence::NamedScopeMethods do
-    class NamedScopeExample < ActiveRecord::Base
-      include AASM
-    end
 
     context "Does not already respond_to? the scope name" do
       it "should add a scope" do
-        NamedScopeExample.aasm_state :unknown_scope
-        NamedScopeExample.scopes.keys.should include(:unknown_scope)
+        Simple.should_not respond_to(:unknown_scope)
+        Simple.aasm_state :unknown_scope
+        Simple.should respond_to(:unknown_scope)
+        Simple.unknown_scope.class.should == ActiveRecord::Relation
       end
     end
 
     context "Already respond_to? the scope name" do
       it "should not add a scope" do
-        NamedScopeExample.aasm_state :new
-        NamedScopeExample.scopes.keys.should_not include(:new)
+        Simple.aasm_state :new
+        Simple.should respond_to(:new)
+        Simple.new.class.should == Simple
       end
     end
   end
 
   describe 'Thieves' do
-    before(:each) do
-      connection = mock(Connection, :columns => [])
-      Thief.stub!(:connection).and_return(connection)
-    end
 
     it 'should be rich if they\'re skilled' do
       Thief.new(:skilled => true).aasm_current_state.should == :rich

data/spec/unit/event_spec.rb

@@ -48,6 +48,20 @@ describe AASM::SupportingClasses::Event, 'when firing an event' do
 
     event.fire(obj).should == :closed
   end
+
+
+  it 'should call the guard with the params passed in' do
+    event = AASM::SupportingClasses::Event.new(:event) do
+      transitions :to => :closed, :from => [:open, :received], :guard => :guard_fn
+    end
+
+    obj = mock('object')
+    obj.stub!(:aasm_current_state).and_return(:open)
+    obj.should_receive(:guard_fn).with('arg1', 'arg2').and_return(true)
+
+    event.fire(obj, nil, 'arg1', 'arg2').should == :closed
+  end
+
 end
 
 describe AASM::SupportingClasses::Event, 'when executing the success callback' do

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_transition_spec.rb

@@ -82,3 +82,82 @@ describe AASM::SupportingClasses::StateTransition, '- when performing guard chec
     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

@@ -29,6 +29,11 @@ class AuthMachine
     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? }
@@ -89,6 +94,29 @@ class AuthMachineTest < Test::Unit::TestCase
     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!

data/test/models/process.rb

@@ -0,0 +1,18 @@
+module Models
+  class Process
+    include AASM
+
+    aasm_state :sleeping
+    aasm_state :running
+    aasm_state :suspended
+
+    aasm_event :start do
+      transitions :from => :sleeping, :to => :running
+    end
+
+    aasm_event :stop do
+      transitions :from => :running, :to => :suspended
+    end
+
+  end
+end

data/test/test_helper.rb

@@ -1,3 +1,13 @@
+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'
 
@@ -23,8 +33,8 @@ class Test::Unit::TestCase
 end
 
 begin
-  require 'ruby-debug'
-  Debugger.start
+  require 'ruby-debug'; Debugger.settings[:autoeval] = true; debugger; rubys_debugger = 'annoying'
+  require 'ruby-debug/completion'
 rescue LoadError
 end
 

data/test/unit/state_machine_test.rb

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