aasm 4.9.0 → 4.10.0

data/spec/models/parametrised_event.rb

@@ -12,18 +12,24 @@ class ParametrisedEvent
     end
 
     event :dress do
-      transitions :from => :sleeping, :to => :working, :after => :wear_clothes
-      transitions :from => :showering, :to => [:working, :dating], :after => Proc.new { |*args| wear_clothes(*args) }
-      transitions :from => :showering, :to => :prettying_up, :after => [:condition_hair, :fix_hair]
+      transitions :from => :sleeping, :to => :working, :after => :wear_clothes, :success => :wear_makeup
+      transitions :from => :showering, :to => [:working, :dating], :after => Proc.new { |*args| wear_clothes(*args) }, :success => proc { |*args| wear_makeup(*args) }
+      transitions :from => :showering, :to => :prettying_up, :after => [:condition_hair, :fix_hair], :success => [:touch_up_hair]
     end
   end
 
   def wear_clothes(shirt_color, trouser_type=nil)
   end
 
+  def wear_makeup(makeup, moisturizer)
+  end
+
   def condition_hair
   end
 
   def fix_hair
   end
+
+  def touch_up_hair
+  end
 end

data/spec/models/states_on_one_line_example.rb

@@ -0,0 +1,8 @@
+class StatesOnOneLineExample
+  include AASM
+
+  aasm :one_line do
+    state :initial, :initial => true
+    state :first, :second
+  end
+end

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ $LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib
 require 'aasm'
 require 'rspec'
 require 'aasm/rspec'
+require 'pry'
 
 # require 'ruby-debug'; Debugger.settings[:autoeval] = true; debugger; rubys_debugger = 'annoying'
 # require 'ruby-debug/completion'

data/spec/unit/api_spec.rb

@@ -22,6 +22,26 @@ describe "reading the current state" do
   it "uses the provided method even if persisted" do
     expect(ProvidedAndPersistedState.new.aasm.current_state).to eql :gamma
   end
+
+  context "after dup" do
+    it "uses the persistence storage" do
+      source = PersistedState.create!
+      copy = source.dup
+      copy.save!
+
+      copy.release!
+
+      expect(source.aasm_state).to eql 'alpha'
+      expect(source.aasm.current_state).to eql :alpha
+
+      source2 = PersistedState.find(source.id)
+      expect(source2.reload.aasm_state).to eql 'alpha'
+      expect(source2.aasm.current_state).to eql :alpha
+
+      expect(copy.aasm_state).to eql 'beta'
+      expect(copy.aasm.current_state).to eql :beta
+    end
+  end
 end
 
 describe "writing and persisting the current state" do

data/spec/unit/callbacks_spec.rb

@@ -109,7 +109,7 @@ describe 'callbacks for the new DSL' do
       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(: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)
@@ -117,8 +117,9 @@ describe 'callbacks for the new DSL' do
       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(:aasm_write_state).once.ordered.and_return(true)   # this is when the state changes
+      expect(callback).to receive(:success_transition).once.ordered.and_return(true) # these should be after the state changes
+      expect(callback).to receive(:after_exit_open).once.ordered
       expect(callback).to receive(:after_enter_closed).once.ordered
       expect(callback).to receive(:after_event).once.ordered
     end
@@ -142,6 +143,7 @@ describe 'callbacks for the new DSL' do
     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(:success_transition)
     expect(callback).to_not receive(:after_exit_open)
     expect(callback).to_not receive(:after_enter_closed)
     expect(callback).to_not receive(:after_event)
@@ -184,6 +186,7 @@ describe 'callbacks for the new DSL' do
         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(:success_transition)
         expect(callback).to_not receive(:after_exit_open)
         expect(callback).to_not receive(:after_enter_closed)
         expect(callback).to_not receive(:after_event)
@@ -214,6 +217,7 @@ describe 'callbacks for the new DSL' do
         expect(callback).to receive(:after).once.ordered
 
         expect(callback).to_not receive(:transitioning)
+        expect(callback).to_not receive(:success_transition)
         expect(callback).to_not receive(:before_enter_closed)
         expect(callback).to_not receive(:enter_closed)
         expect(callback).to_not receive(:after_enter_closed)
@@ -236,6 +240,7 @@ describe 'callbacks for the new DSL' do
       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(:success_transition)
       expect(callback).to_not receive(:after_exit_open)
       expect(callback).to_not receive(:after_enter_closed)
       expect(callback).to_not receive(:after)
@@ -252,14 +257,16 @@ describe 'callbacks for the new DSL' do
 
     cb.reset_data
     cb.close!(:arg1, :arg2)
-    expect(cb.data).to eql 'before(:arg1,:arg2) before_exit_open(:arg1,:arg2) transition_proc(:arg1,:arg2) before_enter_closed(:arg1,:arg2) aasm_write_state after_exit_open(:arg1,:arg2) after_enter_closed(:arg1,:arg2) after(:arg1,:arg2)'
+    expect(cb.data).to eql 'before(:arg1,:arg2) before_exit_open(:arg1,:arg2) transition_proc(:arg1,:arg2) before_enter_closed(:arg1,:arg2) aasm_write_state transition_success(:arg1,:arg2) after_exit_open(:arg1,:arg2) after_enter_closed(:arg1,:arg2) after(:arg1,:arg2)'
   end
 
   it "should call the callbacks given the to-state as argument" do
     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(:success_method).never
     expect(cb).to receive(:transition_method2).with(:arg1).once.ordered
+    expect(cb).to receive(:success_method2).with(:arg1).once.ordered
     expect(cb).to receive(:after_method).with(:arg1).once.ordered
     cb.close!(:out_to_lunch, :arg1)
 
@@ -267,6 +274,7 @@ describe 'callbacks for the new DSL' do
     some_object = double('some object')
     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(:success_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
@@ -276,6 +284,8 @@ describe 'callbacks for the new DSL' do
     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(:success_method).with(:arg1).once.ordered
+    expect(cb).to receive(:success_method).never
     expect(cb).to receive(:after_method).with(:arg1).once.ordered
     cb.close!(:arg1)
 
@@ -284,6 +294,8 @@ describe 'callbacks for the new DSL' do
     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(:success_method).with(some_object).once.ordered
+    expect(cb).to receive(:success_method).never
     expect(cb).to receive(:after_method).with(some_object).once.ordered
     cb.close!(some_object)
   end
@@ -299,7 +311,7 @@ describe 'event callbacks' do
 
         aasm do
           event :safe_close, :success => :success_callback, :error => :error_callback do
-            transitions :to => :closed, :from => [:open]
+            transitions :to => :closed, :from => [:open], :success => :transition_success_callback
           end
         end
       end

data/spec/unit/event_spec.rb

@@ -6,7 +6,7 @@ describe 'adding an event' do
     AASM::Core::Event.new(:close_order, state_machine, {:success => :success_callback}) do
       before :before_callback
       after :after_callback
-      transitions :to => :closed, :from => [:open, :received]
+      transitions :to => :closed, :from => [:open, :received], success: [:transition_success_callback]
     end
   end
 
@@ -337,6 +337,24 @@ describe 'parametrised events' do
     expect(pe).to receive(:fix_hair)
     pe.dress!(:prettying_up)
   end
+
+  it 'should call :success transition method with args' do
+    pe.wakeup!(:showering)
+    expect(pe).to receive(:wear_makeup).with('foundation', 'SPF')
+    pe.dress!(:working, 'foundation', 'SPF')
+  end
+
+  it 'should call :success transition proc' do
+    pe.wakeup!(:showering)
+    expect(pe).to receive(:wear_makeup).with('purple', 'slacks')
+    pe.dress!(:dating, 'purple', 'slacks')
+  end
+
+  it 'should call :success transition with an array of methods' do
+    pe.wakeup!(:showering)
+    expect(pe).to receive(:touch_up_hair)
+    pe.dress!(:prettying_up)
+  end
 end
 
 describe 'event firing without persistence' do

data/spec/unit/exception_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe AASM::InvalidTransition do
+  it 'should not be lazy detecting originating state' do
+    process = ProcessWithNewDsl.new
+    expect { process.stop! }.to raise_error do |err|
+      process.start
+      expect(err.message).to eql("Event 'stop' cannot transition from 'sleeping'. ")
+    end
+  end
+end

data/spec/unit/memory_leak_spec.rb

@@ -7,7 +7,7 @@
 #   end
 
 #   def machines
-#     AASM::StateMachine.instance_variable_get("@machines")
+#     AASM::StateMachineStore.instance_variable_get("@stores")
 #   end
 
 #   it "should be created without memory leak" do

data/spec/unit/namespaced_multiple_example_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe 'state machine' do
+  let(:namespaced) { NamespacedMultipleExample.new }
+
+  it 'starts with an initial state' do
+    expect(namespaced.aasm(:status).current_state).to eq(:unapproved)
+    expect(namespaced).to respond_to(:unapproved?)
+    expect(namespaced).to be_unapproved
+
+    expect(namespaced.aasm(:review_status).current_state).to eq(:unapproved)
+    expect(namespaced).to respond_to(:review_unapproved?)
+    expect(namespaced).to be_review_unapproved
+  end
+
+  it 'allows transitions to other states' do
+    expect(namespaced).to respond_to(:approve)
+    expect(namespaced).to respond_to(:approve!)
+    namespaced.approve!
+    expect(namespaced).to respond_to(:approved?)
+    expect(namespaced).to be_approved
+
+    expect(namespaced).to respond_to(:approve_review)
+    expect(namespaced).to respond_to(:approve_review!)
+    namespaced.approve_review!
+    expect(namespaced).to respond_to(:review_approved?)
+    expect(namespaced).to be_review_approved
+  end
+
+  it 'denies transitions to other states' do
+    expect {namespaced.unapprove}.to raise_error(AASM::InvalidTransition)
+    expect {namespaced.unapprove!}.to raise_error(AASM::InvalidTransition)
+    namespaced.approve
+    expect {namespaced.approve}.to raise_error(AASM::InvalidTransition)
+    expect {namespaced.approve!}.to raise_error(AASM::InvalidTransition)
+    namespaced.unapprove
+
+    expect {namespaced.unapprove_review}.to raise_error(AASM::InvalidTransition)
+    expect {namespaced.unapprove_review!}.to raise_error(AASM::InvalidTransition)
+    namespaced.approve_review
+    expect {namespaced.approve_review}.to raise_error(AASM::InvalidTransition)
+    expect {namespaced.approve_review!}.to raise_error(AASM::InvalidTransition)
+    namespaced.unapprove_review
+  end
+
+  it 'defines constants for each state name' do
+    expect(NamespacedMultipleExample::STATE_UNAPPROVED).to eq(:unapproved)
+    expect(NamespacedMultipleExample::STATE_APPROVED).to eq(:approved)
+
+    expect(NamespacedMultipleExample::STATE_REVIEW_UNAPPROVED).to eq(:unapproved)
+    expect(NamespacedMultipleExample::STATE_REVIEW_APPROVED).to eq(:approved)
+  end
+end

data/spec/unit/override_warning_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe 'warns when overrides a method' do
+  module Clumsy
+    def self.included base
+      base.send :include, AASM
+
+      base.aasm do
+        state :valid
+        event(:save) { }
+      end
+    end
+  end
+
+  describe 'state' do
+    class Base
+      def valid?; end
+    end
+    it do
+      expect { Base.send :include, Clumsy }.
+        to output(/Base: overriding method 'valid\?'!/).to_stderr
+    end
+  end
+
+  describe 'event' do
+    context 'may?' do
+      class Base
+        def may_save?; end
+        def save!; end
+        def save; end
+      end
+      let(:klass) { Base }
+      it do
+        expect { Base.send :include, Clumsy }.
+          to output(/Base: overriding method 'may_save\?'!/).to_stderr
+        expect { Base.send :include, Clumsy }.
+          to output(/Base: overriding method 'save!'!/).to_stderr
+        expect { Base.send :include, Clumsy }.
+          to output(/Base: overriding method 'save'!/).to_stderr
+      end
+    end
+  end
+end

data/spec/unit/persistence/active_record_persistence_multiple_spec.rb

@@ -452,7 +452,7 @@ describe 'transitions with persistence' do
 
       it "should only rollback changes in the main transaction not the nested one" do
         # change configuration to not require new transaction
-        AASM::StateMachine[MultipleTransactor][:left].config.requires_new_transaction = false
+        AASM::StateMachineStore[MultipleTransactor][:left].config.requires_new_transaction = false
 
         expect(transactor).to be_sleeping
         expect(worker.status).to eq('sleeping')

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -486,7 +486,7 @@ describe 'transitions with persistence' do
 
       it "should only rollback changes in the main transaction not the nested one" do
         # change configuration to not require new transaction
-        AASM::StateMachine[Transactor][:default].config.requires_new_transaction = false
+        AASM::StateMachineStore[Transactor][:default].config.requires_new_transaction = false
 
         expect(transactor).to be_sleeping
         expect(worker.status).to eq('sleeping')

data/spec/unit/persistence/mongoid_persistence_spec.rb

@@ -71,6 +71,17 @@ describe 'mongoid' do
 
     end
 
+    describe "relations object" do
+
+      it "should load relations object ids" do
+        parent  =  Parent.create
+        child_1 = Child.create(parent_id: parent.id)
+        child_2 = Child.create(parent_id: parent.id)
+        expect(parent.child_ids).to eql [child_1.id, child_2.id]
+      end
+
+    end
+
   rescue LoadError
     puts "--------------------------------------------------------------------------"
     puts "Not running Mongoid specs because mongoid gem is not installed!!!"

data/spec/unit/persistence/redis_persistence_spec.rb

@@ -0,0 +1,77 @@
+
+describe 'redis' do
+  begin
+    require 'redis-objects'
+    require 'logger'
+    require 'spec_helper'
+
+    before(:all) do
+      Redis.current = Redis.new(host: '127.0.0.1', port: 6379)
+
+      @model = Class.new do
+        attr_accessor :default
+
+        include Redis::Objects
+        include AASM
+
+        value :status
+
+        def id
+          1
+        end
+
+        aasm column: :status
+        aasm do
+          state :alpha, initial: true
+          state :beta
+          state :gamma
+          event :release do
+            transitions from: [:alpha, :beta, :gamma], to: :beta
+          end
+        end
+      end
+    end
+
+    describe "instance methods" do
+      let(:model) {@model.new}
+
+      it "should respond to aasm persistence methods" do
+        expect(model).to respond_to(:aasm_read_state)
+        expect(model).to respond_to(:aasm_write_state)
+        expect(model).to respond_to(:aasm_write_state_without_persistence)
+      end
+
+      it "should return the initial state when new and the aasm field is nil" do
+        expect(model.aasm.current_state).to eq(:alpha)
+      end
+
+      it "should return the aasm column when new and the aasm field is not nil" do
+        model.status = "beta"
+        expect(model.aasm.current_state).to eq(:beta)
+      end
+
+      it "should allow a nil state" do
+        model.status = nil
+        expect(model.aasm.current_state).to be_nil
+        end
+    end
+
+    describe 'subclasses' do
+      it "should have the same states as its parent class" do
+        expect(Class.new(@model).aasm.states).to eq(@model.aasm.states)
+      end
+
+      it "should have the same events as its parent class" do
+        expect(Class.new(@model).aasm.events).to eq(@model.aasm.events)
+      end
+
+      it "should have the same column as its parent even for the new dsl" do
+        expect(@model.aasm.attribute_name).to eq(:status)
+        expect(Class.new(@model).aasm.attribute_name).to eq(:status)
+      end
+    end
+
+  rescue LoadError
+    puts "Not running Redis specs because sequel gem is not installed!!!"
+  end
+end