aasm 4.0.3 → 4.1.0

data/spec/models/persistence.rb

@@ -2,7 +2,29 @@ class Gate < ActiveRecord::Base
   include AASM
 
   # Fake this column for testing purposes
-  attr_accessor :aasm_state
+  # attr_accessor :aasm_state
+
+  def value
+    'value'
+  end
+
+  aasm do
+    state :opened
+    state :closed
+
+    event :view do
+      transitions :to => :read, :from => [:needs_attention]
+    end
+  end
+end
+
+class FalseState < ActiveRecord::Base
+  include AASM
+
+  def initialize(*args)
+    super
+    self.aasm_state = false
+  end
 
   aasm do
     state :opened
@@ -14,6 +36,62 @@ class Gate < ActiveRecord::Base
   end
 end
 
+class WithEnum < ActiveRecord::Base
+  include AASM
+
+  # Fake this column for testing purposes
+  attr_accessor :aasm_state
+
+  def self.test
+    {}
+  end
+
+  aasm :enum => :test do
+    state :opened
+    state :closed
+
+    event :view do
+      transitions :to => :read, :from => [:needs_attention]
+    end
+  end
+end
+
+class WithTrueEnum < ActiveRecord::Base
+  include AASM
+
+  # Fake this column for testing purposes
+  attr_accessor :aasm_state
+
+  def value
+    'value'
+  end
+
+  aasm :enum => true do
+    state :opened
+    state :closed
+
+    event :view do
+      transitions :to => :read, :from => [:needs_attention]
+    end
+  end
+end
+
+class WithFalseEnum < ActiveRecord::Base
+  include AASM
+
+  # Fake this column for testing purposes
+  attr_accessor :aasm_state
+
+  aasm :enum => false do
+    state :opened
+    state :closed
+
+    event :view do
+      transitions :to => :read, :from => [:needs_attention]
+    end
+  end
+end
+
 class Reader < ActiveRecord::Base
   include AASM
 

data/spec/spec_helper.rb

@@ -3,7 +3,6 @@ $LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib
 require 'aasm'
 
 require 'rspec'
-require 'rspec/autorun'
 
 require 'coveralls'
 Coveralls.wear!
@@ -12,6 +11,8 @@ Coveralls.wear!
 # require 'ruby-debug/completion'
 # require 'pry'
 
+SEQUEL_DB = defined?(JRUBY_VERSION) ? 'jdbc:sqlite::memory:' : 'sqlite:/'
+
 def load_schema
   config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
   ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")

data/spec/unit/callbacks_spec.rb

@@ -1,71 +1,88 @@
 require 'spec_helper'
+Dir[File.dirname(__FILE__) + "/../models/callbacks/*.rb"].sort.each { |f| require File.expand_path(f) }
 
 describe 'callbacks for the new DSL' do
 
   it "be called in order" do
-    callback = CallbackNewDsl.new
+    show_debug_log = false
+
+    callback = Callbacks::Basic.new(:log => show_debug_log)
     callback.aasm.current_state
 
-    expect(callback).to receive(:before).once.ordered
-    expect(callback).to receive(:event_guard).once.ordered.and_return(true)
-    expect(callback).to receive(:transition_guard).once.ordered.and_return(true)
-    expect(callback).to receive(:before_exit_open).once.ordered                   # these should be before the state changes
-    expect(callback).to receive(:exit_open).once.ordered
-    # expect(callback).to receive(:event_guard).once.ordered.and_return(true)
-    # expect(callback).to receive(:transition_guard).once.ordered.and_return(true)
-    expect(callback).to receive(:transitioning).once.ordered
-    expect(callback).to receive(:before_enter_closed).once.ordered
-    expect(callback).to receive(:enter_closed).once.ordered
-    expect(callback).to receive(:aasm_write_state).once.ordered.and_return(true)  # this is when the state changes
-    expect(callback).to receive(:after_exit_open).once.ordered                    # these should be after the state changes
-    expect(callback).to receive(:after_enter_closed).once.ordered
-    expect(callback).to receive(:after).once.ordered
+    unless show_debug_log
+      expect(callback).to receive(:before_event).once.ordered
+      expect(callback).to receive(:event_guard).once.ordered.and_return(true)
+      expect(callback).to receive(:transition_guard).once.ordered.and_return(true)
+      expect(callback).to receive(:before_exit_open).once.ordered                   # these should be before the state changes
+      expect(callback).to receive(:exit_open).once.ordered
+      # expect(callback).to receive(:event_guard).once.ordered.and_return(true)
+      # expect(callback).to receive(:transition_guard).once.ordered.and_return(true)
+      expect(callback).to receive(:after_transition).once.ordered
+      expect(callback).to receive(:before_enter_closed).once.ordered
+      expect(callback).to receive(:enter_closed).once.ordered
+      expect(callback).to receive(:aasm_write_state).once.ordered.and_return(true)  # this is when the state changes
+      expect(callback).to receive(:after_exit_open).once.ordered                    # these should be after the state changes
+      expect(callback).to receive(:after_enter_closed).once.ordered
+      expect(callback).to receive(:after_event).once.ordered
+    end
 
     # puts "------- close!"
     callback.close!
   end
 
   it "does not run any state callback if the event guard fails" do
-    callback = CallbackNewDsl.new(:log => false)
+    callback = Callbacks::Basic.new(:log => false)
     callback.aasm.current_state
 
-    expect(callback).to receive(:before).once.ordered
+    expect(callback).to receive(:before_event).once.ordered
     expect(callback).to receive(:event_guard).once.ordered.and_return(false)
     expect(callback).to_not receive(:transition_guard)
     expect(callback).to_not receive(:before_exit_open)
     expect(callback).to_not receive(:exit_open)
-    expect(callback).to_not receive(:transitioning)
+    expect(callback).to_not receive(:after_transition)
     expect(callback).to_not receive(:before_enter_closed)
     expect(callback).to_not receive(:enter_closed)
     expect(callback).to_not receive(:aasm_write_state)
     expect(callback).to_not receive(:after_exit_open)
     expect(callback).to_not receive(:after_enter_closed)
-    expect(callback).to_not receive(:after)
+    expect(callback).to_not receive(:after_event)
 
     expect {
       callback.close!
     }.to raise_error(AASM::InvalidTransition)
   end
 
+  it "it handles private callback methods as well" do
+    show_debug_log = false
+
+    callback = Callbacks::PrivateMethod.new(:log => show_debug_log)
+    callback.aasm.current_state
+
+    # puts "------- close!"
+    expect {
+      callback.close!
+    }.to_not raise_error
+  end
+
   context "if the transition guard fails" do
     it "does not run any state callback if guard is defined inline" do
       show_debug_log = false
-      callback = CallbackNewDsl.new(:log => show_debug_log, :fail_transition_guard => true)
+      callback = Callbacks::Basic.new(:log => show_debug_log, :fail_transition_guard => true)
       callback.aasm.current_state
 
       unless show_debug_log
-        expect(callback).to receive(:before).once.ordered
+        expect(callback).to receive(:before_event).once.ordered
         expect(callback).to receive(:event_guard).once.ordered.and_return(true)
         expect(callback).to receive(:transition_guard).once.ordered.and_return(false)
         expect(callback).to_not receive(:before_exit_open)
         expect(callback).to_not receive(:exit_open)
-        expect(callback).to_not receive(:transitioning)
+        expect(callback).to_not receive(:after_transition)
         expect(callback).to_not receive(:before_enter_closed)
         expect(callback).to_not receive(:enter_closed)
         expect(callback).to_not receive(:aasm_write_state)
         expect(callback).to_not receive(:after_exit_open)
         expect(callback).to_not receive(:after_enter_closed)
-        expect(callback).to_not receive(:after)
+        expect(callback).to_not receive(:after_event)
       end
 
       expect {
@@ -74,8 +91,6 @@ describe 'callbacks for the new DSL' do
     end
 
     it "does not run transition_guard twice for multiple permitted transitions" do
-      require 'models/callbacks/multiple_transitions_transition_guard'
-
       show_debug_log = false
       callback = Callbacks::MultipleTransitionsTransitionGuard.new(:log => show_debug_log, :fail_transition_guard => true)
       callback.aasm.current_state
@@ -102,7 +117,7 @@ describe 'callbacks for the new DSL' do
     end
 
     it "does not run any state callback if guard is defined with block" do
-      callback = GuardWithinBlock.new #(:log => true, :fail_transition_guard => true)
+      callback = Callbacks::GuardWithinBlock.new #(:log => true, :fail_transition_guard => true)
       callback.aasm.current_state
 
       expect(callback).to receive(:before).once.ordered
@@ -125,51 +140,44 @@ describe 'callbacks for the new DSL' do
   end
 
   it "should properly pass arguments" do
-    cb = CallbackNewDslArgs.new
-
-    # TODO: use expect syntax here
-    cb.should_receive(:before).with(:arg1, :arg2).once.ordered
-    cb.should_receive(:before_exit_open).once.ordered                   # these should be before the state changes
-    cb.should_receive(:transition_proc).with(:arg1, :arg2).once.ordered
-    cb.should_receive(:before_enter_closed).once.ordered
-    cb.should_receive(:aasm_write_state).once.ordered.and_return(true)  # this is when the state changes
-    cb.should_receive(:after_exit_open).once.ordered                    # these should be after the state changes
-    cb.should_receive(:after_enter_closed).once.ordered
-    cb.should_receive(:after).with(:arg1, :arg2).once.ordered
+    cb = Callbacks::WithArgs.new(:log => false)
+    cb.aasm.current_state
 
+    cb.reset_data
     cb.close!(:arg1, :arg2)
+    expect(cb.data).to eql 'before(:arg1,:arg2) before_exit_open transition_proc(:arg1,:arg2) before_enter_closed aasm_write_state after_exit_open after_enter_closed after(:arg1,:arg2)'
   end
 
   it "should call the callbacks given the to-state as argument" do
-    cb = CallbackWithStateArg.new
-    cb.should_receive(:before_method).with(:arg1).once.ordered
-    cb.should_receive(:transition_method).never
-    cb.should_receive(:transition_method2).with(:arg1).once.ordered
-    cb.should_receive(:after_method).with(:arg1).once.ordered
+    cb = Callbacks::WithStateArg.new
+    expect(cb).to receive(:before_method).with(:arg1).once.ordered
+    expect(cb).to receive(:transition_method).never
+    expect(cb).to receive(:transition_method2).with(:arg1).once.ordered
+    expect(cb).to receive(:after_method).with(:arg1).once.ordered
     cb.close!(:out_to_lunch, :arg1)
 
-    cb = CallbackWithStateArg.new
+    cb = Callbacks::WithStateArg.new
     some_object = double('some object')
-    cb.should_receive(:before_method).with(some_object).once.ordered
-    cb.should_receive(:transition_method2).with(some_object).once.ordered
-    cb.should_receive(:after_method).with(some_object).once.ordered
+    expect(cb).to receive(:before_method).with(some_object).once.ordered
+    expect(cb).to receive(:transition_method2).with(some_object).once.ordered
+    expect(cb).to receive(:after_method).with(some_object).once.ordered
     cb.close!(:out_to_lunch, some_object)
   end
 
   it "should call the proper methods just with arguments" do
-    cb = CallbackWithStateArg.new
-    cb.should_receive(:before_method).with(:arg1).once.ordered
-    cb.should_receive(:transition_method).with(:arg1).once.ordered
-    cb.should_receive(:transition_method).never
-    cb.should_receive(:after_method).with(:arg1).once.ordered
+    cb = Callbacks::WithStateArg.new
+    expect(cb).to receive(:before_method).with(:arg1).once.ordered
+    expect(cb).to receive(:transition_method).with(:arg1).once.ordered
+    expect(cb).to receive(:transition_method).never
+    expect(cb).to receive(:after_method).with(:arg1).once.ordered
     cb.close!(:arg1)
 
-    cb = CallbackWithStateArg.new
+    cb = Callbacks::WithStateArg.new
     some_object = double('some object')
-    cb.should_receive(:before_method).with(some_object).once.ordered
-    cb.should_receive(:transition_method).with(some_object).once.ordered
-    cb.should_receive(:transition_method).never
-    cb.should_receive(:after_method).with(some_object).once.ordered
+    expect(cb).to receive(:before_method).with(some_object).once.ordered
+    expect(cb).to receive(:transition_method).with(some_object).once.ordered
+    expect(cb).to receive(:transition_method).never
+    expect(cb).to receive(:after_method).with(some_object).once.ordered
     cb.close!(some_object)
   end
 end
@@ -178,6 +186,10 @@ describe 'event callbacks' do
   describe "with an error callback defined" do
     before do
       class Foo
+        # this hack is needed to allow testing of parameters, since RSpec
+        # destroys a method's arity when mocked
+        attr_accessor :data
+
         aasm do
           event :safe_close, :success => :success_callback, :error => :error_callback do
             transitions :to => :closed, :from => [:open]
@@ -188,16 +200,42 @@ describe 'event callbacks' do
       @foo = Foo.new
     end
 
-    it "should run error_callback if an exception is raised and error_callback defined" do
-      def @foo.error_callback(e); end
+    context "error_callback defined" do
+      it "should run error_callback if an exception is raised" do
+        def @foo.error_callback(e)
+          @data = [e]
+        end
+
+        allow(@foo).to receive(:before_enter).and_raise(e = StandardError.new)
+
+        @foo.safe_close!
+        expect(@foo.data).to eql [e]
+      end
+
+      it "should run error_callback without parameters if callback does not support any" do
+        def @foo.error_callback(e)
+          @data = []
+        end
+
+        allow(@foo).to receive(:before_enter).and_raise(e = StandardError.new)
+
+        @foo.safe_close!('arg1', 'arg2')
+        expect(@foo.data).to eql []
+      end
 
-      allow(@foo).to receive(:before_enter).and_raise(e=StandardError.new)
-      expect(@foo).to receive(:error_callback).with(e)
+      it "should run error_callback with parameters if callback supports them" do
+        def @foo.error_callback(e, arg1, arg2)
+          @data = [arg1, arg2]
+        end
 
-      @foo.safe_close!
+        allow(@foo).to receive(:before_enter).and_raise(e = StandardError.new)
+
+        @foo.safe_close!('arg1', 'arg2')
+        expect(@foo.data).to eql ['arg1', 'arg2']
+      end
     end
 
-    it "should raise NoMethodError if exceptionis raised and error_callback is declared but not defined" do
+    it "should raise NoMethodError if exception is raised and error_callback is declared but not defined" do
       allow(@foo).to receive(:before_enter).and_raise(StandardError)
       expect{@foo.safe_close!}.to raise_error(NoMethodError)
     end
@@ -253,4 +291,5 @@ describe 'event callbacks' do
       @foo.close!
     end
   end
+
 end

data/spec/unit/complex_example_spec.rb

@@ -8,7 +8,7 @@ describe 'on initialization' do
   end
 
   it 'should have an activation code' do
-    expect(auth.has_activation_code?).to be_true
+    expect(auth.has_activation_code?).to be_truthy
     expect(auth.activation_code).not_to be_nil
   end
 end
@@ -19,24 +19,24 @@ describe 'when being unsuspended' do
   it 'should be able to be unsuspended' do
     auth.activate!
     auth.suspend!
-    expect(auth.may_unsuspend?).to be_true
+    expect(auth.may_unsuspend?).to be true
   end
 
   it 'should not be able to be unsuspended into active' do
     auth.suspend!
-    expect(auth.may_unsuspend?(:active)).not_to be_true
+    expect(auth.may_unsuspend?(:active)).not_to be true
   end
 
   it 'should be able to be unsuspended into active if polite' do
     auth.suspend!
-    expect(auth.may_wait?(:waiting, :please)).to be_true
+    expect(auth.may_wait?(:waiting, :please)).to be true
     auth.wait!(nil, :please)
   end
 
   it 'should not be able to be unsuspended into active if not polite' do
     auth.suspend!
-    expect(auth.may_wait?(:waiting)).not_to be_true
-    expect(auth.may_wait?(:waiting, :rude)).not_to be_true
+    expect(auth.may_wait?(:waiting)).not_to be true
+    expect(auth.may_wait?(:waiting, :rude)).not_to be true
     expect {auth.wait!(nil, :rude)}.to raise_error(AASM::InvalidTransition)
     expect {auth.wait!}.to raise_error(AASM::InvalidTransition)
   end
@@ -46,7 +46,7 @@ describe 'when being unsuspended' do
     auth.suspend!
     auth.unsuspend!
 
-    expect(auth.may_unpassify?).not_to be_true
+    expect(auth.may_unpassify?).not_to be true
     expect {auth.unpassify!}.to raise_error(AASM::InvalidTransition)
   end
 
@@ -74,11 +74,11 @@ describe 'when being unsuspended' do
   end
 
   it "should be able to fire known events" do
-    expect(auth.aasm.may_fire_event?(:activate)).to be_true
+    expect(auth.aasm.may_fire_event?(:activate)).to be true
   end
 
   it "should not be able to fire unknown events" do
-    expect(auth.aasm.may_fire_event?(:unknown)).to be_false
+    expect(auth.aasm.may_fire_event?(:unknown)).to be false
   end
 
 end

data/spec/unit/event_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe 'adding an event' do
   let(:event) do
-    AASM::Event.new(:close_order, {:success => :success_callback}) do
+    AASM::Core::Event.new(:close_order, {:success => :success_callback}) do
       before :before_callback
       after :after_callback
       transitions :to => :closed, :from => [:open, :received]
@@ -36,41 +36,41 @@ end
 
 describe 'transition inspection' do
   let(:event) do
-    AASM::Event.new(:run) do
+    AASM::Core::Event.new(:run) do
       transitions :to => :running, :from => :sleeping
     end
   end
 
   it 'should support inspecting transitions from other states' do
     expect(event.transitions_from_state(:sleeping).map(&:to)).to eq([:running])
-    expect(event.transitions_from_state?(:sleeping)).to be_true
+    expect(event.transitions_from_state?(:sleeping)).to be_truthy
 
     expect(event.transitions_from_state(:cleaning).map(&:to)).to eq([])
-    expect(event.transitions_from_state?(:cleaning)).to be_false
+    expect(event.transitions_from_state?(:cleaning)).to be_falsey
   end
 
   it 'should support inspecting transitions to other states' do
     expect(event.transitions_to_state(:running).map(&:from)).to eq([:sleeping])
-    expect(event.transitions_to_state?(:running)).to be_true
+    expect(event.transitions_to_state?(:running)).to be_truthy
 
     expect(event.transitions_to_state(:cleaning).map(&:to)).to eq([])
-    expect(event.transitions_to_state?(:cleaning)).to be_false
+    expect(event.transitions_to_state?(:cleaning)).to be_falsey
   end
 end
 
 describe 'transition inspection without from' do
   let(:event) do
-    AASM::Event.new(:run) do
+    AASM::Core::Event.new(:run) do
       transitions :to => :running
     end
   end
 
   it 'should support inspecting transitions from other states' do
     expect(event.transitions_from_state(:sleeping).map(&:to)).to eq([:running])
-    expect(event.transitions_from_state?(:sleeping)).to be_true
+    expect(event.transitions_from_state?(:sleeping)).to be_truthy
 
     expect(event.transitions_from_state(:cleaning).map(&:to)).to eq([:running])
-    expect(event.transitions_from_state?(:cleaning)).to be_true
+    expect(event.transitions_from_state?(:cleaning)).to be_truthy
   end
 
 end
@@ -79,12 +79,12 @@ describe 'firing an event' do
   it 'should return nil if the transitions are empty' do
     obj = double('object', :aasm => double('aasm', :current_state => 'open'))
 
-    event = AASM::Event.new(:event)
+    event = AASM::Core::Event.new(:event)
     expect(event.fire(obj)).to be_nil
   end
 
   it 'should return the state of the first matching transition it finds' do
-    event = AASM::Event.new(:event) do
+    event = AASM::Core::Event.new(:event) do
       transitions :to => :closed, :from => [:open, :received]
     end
 
@@ -94,7 +94,7 @@ describe 'firing an event' do
   end
 
   it 'should call the guard with the params passed in' do
-    event = AASM::Event.new(:event) do
+    event = AASM::Core::Event.new(:event) do
       transitions :to => :closed, :from => [:open, :received], :guard => :guard_fn
     end
 

data/spec/unit/inspection_spec.rb

@@ -67,11 +67,11 @@ describe "special cases" do
     expect(Argument.aasm.states).to include(:valid)
 
     argument = Argument.new
-    expect(argument.invalid?).to be_true
+    expect(argument.invalid?).to be_truthy
     expect(argument.aasm.current_state).to eq(:invalid)
 
     argument.valid!
-    expect(argument.valid?).to be_true
+    expect(argument.valid?).to be_truthy
     expect(argument.aasm.current_state).to eq(:valid)
   end
 end

data/spec/unit/memory_leak_spec.rb

@@ -12,27 +12,27 @@
 
 #   it "should be created without memory leak" do
 #     machines_count = machines.size
-#     state_count = number_of_objects(AASM::State)
-#     event_count = number_of_objects(AASM::Event)
+#     state_count = number_of_objects(AASM::Core::State)
+#     event_count = number_of_objects(AASM::Core::Event)
 #     puts "event_count = #{event_count}"
-#     transition_count = number_of_objects(AASM::Transition)
+#     transition_count = number_of_objects(AASM::Core::Transition)
 
 #     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::State).should == state_count + 3                 # + Process
-#     puts "event_count = #{number_of_objects(AASM::Event)}"
-#     number_of_objects(AASM::Event).should == event_count + 2                 # + Process
-#     number_of_objects(AASM::Transition).should == transition_count + 2  # + Process
+#     number_of_objects(AASM::Core::State).should == state_count + 3                 # + Process
+#     puts "event_count = #{number_of_objects(AASM::Core::Event)}"
+#     number_of_objects(AASM::Core::Event).should == event_count + 2                 # + Process
+#     number_of_objects(AASM::Core::Transition).should == transition_count + 2  # + Process
 
 #     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::State).should == state_count + 3                 # + Process
-#     # ObjectSpace.each_object(AASM::Event) {|o| puts o.inspect}
-#     puts "event_count = #{number_of_objects(AASM::Event)}"
-#     number_of_objects(AASM::Event).should == event_count + 2                 # + Process
-#     number_of_objects(AASM::Transition).should == transition_count + 2  # + Process
+#     number_of_objects(AASM::Core::State).should == state_count + 3                 # + Process
+#     # ObjectSpace.each_object(AASM::Core::Event) {|o| puts o.inspect}
+#     puts "event_count = #{number_of_objects(AASM::Core::Event)}"
+#     number_of_objects(AASM::Core::Event).should == event_count + 2                 # + Process
+#     number_of_objects(AASM::Core::Transition).should == transition_count + 2  # + Process
 #   end
 
 # end