aasm 4.0.3 → 4.0.4

data/spec/models/callbacks/with_args.rb

@@ -0,0 +1,45 @@
+module Callbacks
+  class WithArgs
+    include AASM
+
+    aasm do
+      state :open, :initial => true,
+        :before_enter => :before_enter_open,
+        :after_enter  => :after_enter_open,
+        :before_exit  => :before_exit_open,
+        :after_exit   => :after_exit_open
+
+      state :closed,
+        :before_enter => :before_enter_closed,
+        :after_enter  => :after_enter_closed,
+        :before_exit  => :before_exit_closed,
+        :after_exit   => :after_exit_closed
+
+      event :close, :before => :before, :after => :after do
+        transitions :to => :closed, :from => [:open], :after => :transition_proc
+      end
+
+      event :open, :before => :before, :after => :after do
+        transitions :to => :open, :from => :closed
+      end
+    end
+
+    def log(text)
+      # puts text
+    end
+
+    def before_enter_open; log('before_enter_open'); end
+    def before_exit_open; log('before_exit_open'); end
+    def after_enter_open; log('after_enter_open'); end
+    def after_exit_open; log('after_exit_open'); end
+
+    def before_enter_closed; log('before_enter_closed'); end
+    def before_exit_closed; log('before_enter_closed'); end
+    def after_enter_closed; log('after_enter_closed'); end
+    def after_exit_closed; log('after_exit_closed'); end
+
+    def before(*args); log('before'); end
+    def transition_proc(arg1, arg2); log('transition_proc'); end
+    def after(*args); log('after'); end
+  end
+end

data/spec/models/callbacks/with_state_args.rb

@@ -0,0 +1,26 @@
+module Callbacks
+  class WithStateArg
+
+    include AASM
+
+    aasm do
+      state :open, :inital => true
+      state :closed
+      state :out_to_lunch
+
+      event :close, :before => :before_method, :after => :after_method do
+        transitions :to => :closed, :from => [:open], :after => :transition_method
+        transitions :to => :out_to_lunch, :from => [:open], :after => :transition_method2
+      end
+    end
+
+    def before_method(arg); end
+
+    def after_method(arg); end
+
+    def transition_method(arg); end
+
+    def transition_method2(arg); end
+
+  end
+end

data/spec/models/persistence.rb

@@ -2,7 +2,11 @@ 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
@@ -14,6 +18,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/unit/callbacks_spec.rb

@@ -1,46 +1,51 @@
 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!
@@ -50,22 +55,22 @@ describe 'callbacks for the new DSL' do
   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 +79,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 +105,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,7 +128,7 @@ describe 'callbacks for the new DSL' do
   end
 
   it "should properly pass arguments" do
-    cb = CallbackNewDslArgs.new
+    cb = Callbacks::WithArgs.new
 
     # TODO: use expect syntax here
     cb.should_receive(:before).with(:arg1, :arg2).once.ordered
@@ -141,14 +144,14 @@ describe 'callbacks for the new DSL' do
   end
 
   it "should call the callbacks given the to-state as argument" do
-    cb = CallbackWithStateArg.new
+    cb = Callbacks::WithStateArg.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.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
@@ -157,14 +160,14 @@ describe 'callbacks for the new DSL' do
   end
 
   it "should call the proper methods just with arguments" do
-    cb = CallbackWithStateArg.new
+    cb = Callbacks::WithStateArg.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.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
@@ -191,7 +194,7 @@ describe 'event callbacks' do
     it "should run error_callback if an exception is raised and error_callback defined" do
       def @foo.error_callback(e); end
 
-      allow(@foo).to receive(:before_enter).and_raise(e=StandardError.new)
+      allow(@foo).to receive(:before_enter).and_raise(e = StandardError.new)
       expect(@foo).to receive(:error_callback).with(e)
 
       @foo.safe_close!

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,7 +36,7 @@ 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
@@ -60,7 +60,7 @@ 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
@@ -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/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

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -64,58 +64,45 @@ describe "instance methods" do
   end
 
   describe "aasm_enum" do
-    subject { lambda{ gate.send(:aasm_enum) } }
-
     context "when AASM enum setting contains an explicit enum method name" do
-      let(:enum) { :test }
-
-      before :each do
-        AASM::StateMachine[Gate].config.stub(:enum).and_return(enum)
-      end
+      let(:with_enum) { WithEnum.new }
 
       it "returns whatever value was set in AASM config" do
-        expect(subject.call).to eq enum
+        expect(with_enum.send(:aasm_enum)).to eq :test
       end
     end
 
     context "when AASM enum setting is simply set to true" do
+      let(:with_true_enum) { WithTrueEnum.new }
       before :each do
-        AASM::StateMachine[Gate].config.stub(:enum).and_return(true)
-        Gate.aasm.stub(:attribute_name).and_return(:value)
-        gate.stub(:aasm_guess_enum_method).and_return(:values)
+        WithTrueEnum.aasm.stub(:attribute_name).and_return(:value)
       end
 
       it "infers enum method name from pluralized column name" do
-        expect(subject.call).to eq :values
-        expect(gate).to have_received :aasm_guess_enum_method
+        expect(with_true_enum.send(:aasm_enum)).to eq :values
       end
     end
 
     context "when AASM enum setting is explicitly disabled" do
-      before :each do
-        AASM::StateMachine[Gate].config.stub(:enum).and_return(false)
-      end
+      let(:with_false_enum) { WithFalseEnum.new }
 
       it "returns nil" do
-        expect(subject.call).to be_nil
+        expect(with_false_enum.send(:aasm_enum)).to be_nil
       end
     end
 
     context "when AASM enum setting is not enabled" do
       before :each do
-        AASM::StateMachine[Gate].config.stub(:enum).and_return(nil)
         Gate.aasm.stub(:attribute_name).and_return(:value)
       end
 
       context "when AASM column looks like enum" do
         before :each do
           gate.stub(:aasm_column_looks_like_enum).and_return(true)
-          gate.stub(:aasm_guess_enum_method).and_return(:values)
         end
 
         it "infers enum method name from pluralized column name" do
-          expect(subject.call).to eq :values
-          expect(gate).to have_received :aasm_guess_enum_method
+          expect(gate.send(:aasm_enum)).to eq :values
         end
       end
 
@@ -126,7 +113,7 @@ describe "instance methods" do
         end
 
         it "returns nil, as we're not using enum" do
-          expect(subject.call).to be_nil
+          expect(gate.send(:aasm_enum)).to be_nil
         end
       end
     end
@@ -265,20 +252,9 @@ describe "instance methods" do
     expect(gate.aasm.current_state).to be_nil
   end
 
-  it "should call aasm_ensure_initial_state on validation before create" do
-    expect(gate).to receive(:aasm_ensure_initial_state).and_return(true)
-    gate.valid?
-  end
-
-  it "should call aasm_ensure_initial_state before create, even if skipping validations" do
-    expect(gate).to receive(:aasm_ensure_initial_state).and_return(true)
-    gate.save(:validate => false)
-  end
-
-  it "should not call aasm_ensure_initial_state on validation before update" do
-    allow(gate).to receive(:new_record?).and_return(false)
-    expect(gate).not_to receive(:aasm_ensure_initial_state)
-    gate.valid?
+  it "should initialize the aasm state on instantiation" do
+    expect(Gate.new.aasm_state).to eql 'opened'
+    expect(Gate.new.aasm.current_state).to eql :opened
   end
 
 end