Update Readme to clearify success callback.

Add test case for callback order for active record
Fixes #683

README.md

@@ -260,8 +260,8 @@ begin
   new_state       enter
   ...update state...
   event           before_success      # if persist successful
-  transition      success             # if persist successful
-  event           success             # if persist successful
+  transition      success             # if persist successful, database update not guaranteed
+  event           success             # if persist successful, database update not guaranteed
   old_state       after_exit
   new_state       after_enter
   event           after
@@ -275,6 +275,8 @@ ensure
 end
 ```
 
+Use event's `after_commit` callback if it should be fired after database update.
+
 #### The current event triggered
 
 While running the callbacks you can easily retrieve the name of the event triggered

spec/database.rb

@@ -27,7 +27,7 @@
     t.string "status"
   end
 
-  %w(validators multiple_validators workers invalid_persistors multiple_invalid_persistors silent_persistors multiple_silent_persistors).each do |table_name|
+  %w(validators multiple_validators workers invalid_persistors multiple_invalid_persistors silent_persistors multiple_silent_persistors active_record_callbacks).each do |table_name|
     ActiveRecord::Migration.create_table table_name, :force => true do |t|
       t.string "name"
       t.string "status"

spec/models/active_record/active_record_callback.rb

@@ -0,0 +1,93 @@
+class ActiveRecordCallback < ActiveRecord::Base
+  include AASM
+
+  def reset_data
+    @data = []
+  end
+
+  def data
+    @data.join(' ')
+  end
+
+  aasm column: :status do
+    before_all_events       :before_all_events
+    after_all_events        :after_all_events
+    ensure_on_all_events    :ensure_on_all_events
+    after_all_transitions   :after_all_transitions
+
+    state :open, :initial => true,
+    :before_enter => :before_enter_open,
+    :enter        => :enter_open,
+    :after_enter  => :after_enter_open,
+    :before_exit  => :before_exit_open,
+    :exit         => :exit_open,
+    :after_exit   => :after_exit_open
+
+    state :closed,
+    :before_enter => :before_enter_closed,
+    :enter        => :enter_closed,
+    :after_enter  => :after_enter_closed,
+    :before_exit  => :before_exit_closed,
+    :exit         => :exit_closed,
+    :after_exit   => :after_exit_closed
+
+    event :close,
+        :before => :before_event,
+        :after => :after_event,
+        :guard => :event_guard,
+        :before_success => :event_before_success,
+        :after_commit => :event_after_commit,
+        :ensure => :ensure_event do
+    transitions :to => :closed, :from => [:open],
+                :guard => :transition_guard,
+                :after => :after_transition,
+                :success => :success_transition
+    end
+
+    event :open, :before => :before_event, :after => :after_event  do
+    transitions :to => :open, :from => :closed
+    end
+  end
+
+  def log(text)
+    @data ||= []
+    @data << text
+    #puts text
+  end
+
+  def aasm_write_state(*args);  log('aasm_write_state'); true;  end
+  def before_enter_open;        log('before_enter_open');       end
+  def enter_open;               log('enter_open');              end
+  def before_exit_open;         log('before_exit_open');        end
+  def after_enter_open;         log('after_enter_open');        end
+  def exit_open;                log('exit_open');               end
+  def after_exit_open;          log('after_exit_open');         end
+
+  def before_enter_closed;      log('before_enter_closed'); end
+  def enter_closed;             log('enter_closed');        end
+  def before_exit_closed;       log('before_exit_closed');  end
+  def exit_closed;              log('exit_closed');         end
+  def after_enter_closed;       log('after_enter_closed');  end
+  def after_exit_closed;        log('after_exit_closed');   end
+
+  def event_guard;              log('event_guard');         !@fail_event_guard;      end
+  def transition_guard;         log('transition_guard');    !@fail_transition_guard; end
+
+  def event_before_success;     log('event_before_success'); end
+
+  def after_transition;         log('after_transition');        end
+  def after_all_transitions;    log('after_all_transitions');   end
+
+  def before_all_events;        log('before_all_events')    end
+  def before_event;             log('before_event');        end
+  def after_event;              log('after_event');         end
+  def after_all_events;         log('after_all_events');    end
+
+  def after_transition;         log('after_transition');    end
+  def success_transition;       log('transition_success');  end
+
+  def ensure_event;             log('ensure');              end
+  def ensure_on_all_events;     log('ensure');              end
+
+  def event_after_commit;       log('after_commit');        end 
+end

spec/unit/persistence/active_record_persistence_spec.rb

@@ -647,6 +647,41 @@
         end
       end
 
+      describe 'callbacks for the new DSL' do
+
+        it "be called in order" do
+          show_debug_log = false
+
+          callback = ActiveRecordCallback.create
+          callback.aasm.current_state
+
+          unless show_debug_log
+            expect(callback).to receive(:before_all_events).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(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_all_transitions).once.ordered
+            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
+            expect(callback).to receive(:after_all_events).once.ordered
+            expect(callback).to receive(:ensure_event).once.ordered
+            expect(callback).to receive(:ensure_on_all_events).once.ordered
+            expect(callback).to receive(:event_after_commit).once.ordered
+          end
+
+          callback.close!
+        end
+      end
+
       describe 'before and after transaction callbacks' do
         [:after, :before].each do |event_type|
           describe "#{event_type}_transaction callback" do