aasm 4.11.1 → 4.12.1

data/spec/models/simple_multiple_example.rb

@@ -27,4 +27,16 @@ class SimpleMultipleExample
       transitions :from => :processing, :to => :sleeping
     end
   end
+
+  aasm(:question) do
+    state :answered, :initial => true
+    state :asked
+
+    event :ask, :binding_event => :start do
+      transitions :from => :answered, :to => :asked
+    end
+    event :answer, :binding_event => :stop do
+      transitions :from => :asked, :to => :answered
+    end
+  end
 end

data/spec/models/sub_class.rb

@@ -1,7 +1,41 @@
 require_relative 'super_class'
 
 class SubClass < SuperClass
+  # Add an after callback that is not defined in the parent
+  aasm.state_machine.events[:foo].options[:after] = [:after_foo_event]
+
+  # Add global callback that is not defined in the parent
+  aasm.state_machine.global_callbacks[:after_all_transitions] = :after_all_event
+
+  attr_accessor :called_after
+
+  def after_foo_event
+    self.called_after = true
+  end
+
+  def after_all_event; end
 end
 
 class SubClassMultiple < SuperClassMultiple
+  # Add after callbacks that are not defined in the parent
+  aasm(:left).state_machine.events[:foo].options[:after] = [:left_after_foo_event]
+  aasm(:right).state_machine.events[:close].options[:after] = [:right_after_close_event]
+
+  # Add global callback that is not defined in the parent
+  aasm(:left).state_machine.global_callbacks[:after_all_transitions] = :left_after_all_event
+  aasm(:right).state_machine.global_callbacks[:after_all_transitions] = :right_after_all_event
+
+  attr_accessor :left_called_after, :right_called_after
+
+  def left_after_foo_event
+    self.left_called_after = true
+  end
+
+  def right_after_close_event
+    self.right_called_after = true
+  end
+
+  def left_after_all_event; end
+
+  def right_after_all_event; end
 end

data/spec/spec_helper.rb

@@ -19,39 +19,6 @@ def load_schema
   require File.dirname(__FILE__) + "/database.rb"
 end
 
-# Dynamoid initialization
-begin
-  require 'dynamoid'
-  require 'aws-sdk-resources'
-
-  ENV['ACCESS_KEY'] ||= 'abcd'
-  ENV['SECRET_KEY'] ||= '1234'
-
-  Aws.config.update({
-    region: 'us-west-2',
-    credentials: Aws::Credentials.new(ENV['ACCESS_KEY'], ENV['SECRET_KEY'])
-  })
-
-  Dynamoid.configure do |config|
-    config.namespace = "dynamoid_tests"
-    config.endpoint = 'http://127.0.0.1:30180'
-    config.warn_on_scan = false
-  end
-
-  Dynamoid.logger.level = Logger::FATAL
-
-  RSpec.configure do |c|
-    c.before(:each) do
-      Dynamoid.adapter.list_tables.each do |table|
-        Dynamoid.adapter.delete_table(table) if table =~ /^#{Dynamoid::Config.namespace}/
-      end
-      Dynamoid.adapter.tables.clear
-    end
-  end
-rescue LoadError
-  # Without Dynamoid settings
-end
-
 # custom spec helpers
 Dir[File.dirname(__FILE__) + "/spec_helpers/**/*.rb"].sort.each { |f| require File.expand_path(f) }
 

data/spec/spec_helpers/active_record.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+begin
+  require 'active_record'
+  puts "active_record gem found, running ActiveRecord specs \e[32m#{'✔'}\e[0m"
+rescue LoadError
+  puts "active_record gem not found, not running ActiveRecord specs \e[31m#{'✖'}\e[0m"
+end

data/spec/spec_helpers/dynamoid.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+begin
+  require 'dynamoid'
+  require 'aws-sdk-resources'
+  puts "dynamoid gem found, running Dynamoid specs \e[32m#{'✔'}\e[0m"
+
+  ENV['ACCESS_KEY'] ||= 'abcd'
+  ENV['SECRET_KEY'] ||= '1234'
+
+  Aws.config.update({
+    region: 'us-west-2',
+    credentials: Aws::Credentials.new(ENV['ACCESS_KEY'], ENV['SECRET_KEY'])
+  })
+
+  Dynamoid.configure do |config|
+    config.namespace = "dynamoid_tests"
+    config.endpoint = 'http://127.0.0.1:30180'
+    config.warn_on_scan = false
+  end
+
+  Dynamoid.logger.level = Logger::FATAL
+
+  RSpec.configure do |c|
+    c.before(:each) do
+      Dynamoid.adapter.list_tables.each do |table|
+        Dynamoid.adapter.delete_table(table) if table =~ /^#{Dynamoid::Config.namespace}/
+      end
+      Dynamoid.adapter.tables.clear
+    end
+  end
+rescue LoadError
+  puts "dynamoid gem not found, not running Dynamoid specs \e[31m#{'✖'}\e[0m"
+end

data/spec/spec_helpers/mongoid.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+begin
+  require 'mongoid'
+  puts "mongoid gem found, running mongoid specs \e[32m#{'✔'}\e[0m"
+rescue LoadError
+  puts "mongoid gem not found, not running mongoid specs \e[31m#{'✖'}\e[0m"
+end

data/spec/spec_helpers/redis.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+begin
+  require 'redis-objects'
+  puts "redis-objects gem found, running Redis specs \e[32m#{'✔'}\e[0m"
+
+  Redis.current = Redis.new(host: '127.0.0.1', port: 6379)
+
+  RSpec.configure do |c|
+    c.before(:each) do
+      Redis.current.keys('redis_*').each { |k| Redis.current.del k }
+    end
+  end
+rescue LoadError
+  puts "redis-objects gem not found, not running Redis specs \e[31m#{'✖'}\e[0m"
+end

data/spec/spec_helpers/remove_warnings.rb

@@ -0,0 +1 @@
+AASM::Configuration.hide_warnings = true

data/spec/spec_helpers/sequel.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+begin
+  require 'sequel'
+  puts "sequel gem found, running Sequel specs \e[32m#{'✔'}\e[0m"
+rescue LoadError
+  puts "sequel gem not found, not running Sequel specs \e[31m#{'✖'}\e[0m"
+end

data/spec/unit/api_spec.rb

@@ -1,97 +1,100 @@
 require 'spec_helper'
-require 'models/default_state.rb'
-require 'models/provided_state.rb'
-require 'models/active_record/persisted_state.rb'
-require 'models/active_record/provided_and_persisted_state.rb'
 
-load_schema
+if defined?(ActiveRecord)
+  require 'models/default_state.rb'
+  require 'models/provided_state.rb'
+  require 'models/active_record/persisted_state.rb'
+  require 'models/active_record/provided_and_persisted_state.rb'
 
-describe "reading the current state" do
-  it "uses the AASM default" do
-    expect(DefaultState.new.aasm.current_state).to eql :alpha
-  end
-
-  it "uses the provided method" do
-    expect(ProvidedState.new.aasm.current_state).to eql :beta
-  end
+  load_schema
 
-  it "uses the persistence storage" do
-    expect(PersistedState.new.aasm.current_state).to eql :alpha
-  end
+  describe "reading the current state" do
+    it "uses the AASM default" do
+      expect(DefaultState.new.aasm.current_state).to eql :alpha
+    end
 
-  it "uses the provided method even if persisted" do
-    expect(ProvidedAndPersistedState.new.aasm.current_state).to eql :gamma
-  end
+    it "uses the provided method" do
+      expect(ProvidedState.new.aasm.current_state).to eql :beta
+    end
 
-  context "after dup" do
     it "uses the persistence storage" do
-      source = PersistedState.create!
-      copy = source.dup
-      copy.save!
+      expect(PersistedState.new.aasm.current_state).to eql :alpha
+    end
 
-      copy.release!
+    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!
 
-      expect(source.aasm_state).to eql 'alpha'
-      expect(source.aasm.current_state).to eql :alpha
+        copy.release!
 
-      source2 = PersistedState.find(source.id)
-      expect(source2.reload.aasm_state).to eql 'alpha'
-      expect(source2.aasm.current_state).to eql :alpha
+        expect(source.aasm_state).to eql 'alpha'
+        expect(source.aasm.current_state).to eql :alpha
 
-      expect(copy.aasm_state).to eql 'beta'
-      expect(copy.aasm.current_state).to eql :beta
+        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
-end
 
-describe "writing and persisting the current state" do
-  it "uses the AASM default" do
-    o = DefaultState.new
-    o.release!
-    expect(o.persisted_store).to be_nil
-  end
+  describe "writing and persisting the current state" do
+    it "uses the AASM default" do
+      o = DefaultState.new
+      o.release!
+      expect(o.persisted_store).to be_nil
+    end
 
-  it "uses the provided method" do
-    o = ProvidedState.new
-    o.release!
-    expect(o.persisted_store).to eql :beta
-  end
+    it "uses the provided method" do
+      o = ProvidedState.new
+      o.release!
+      expect(o.persisted_store).to eql :beta
+    end
 
-  it "uses the persistence storage" do
-    o = PersistedState.new
-    o.release!
-    expect(o.persisted_store).to be_nil
-  end
+    it "uses the persistence storage" do
+      o = PersistedState.new
+      o.release!
+      expect(o.persisted_store).to be_nil
+    end
 
-  it "uses the provided method even if persisted" do
-    o = ProvidedAndPersistedState.new
-    o.release!
-    expect(o.persisted_store).to eql :beta
+    it "uses the provided method even if persisted" do
+      o = ProvidedAndPersistedState.new
+      o.release!
+      expect(o.persisted_store).to eql :beta
+    end
   end
-end
 
-describe "writing the current state without persisting it" do
-  it "uses the AASM default" do
-    o = DefaultState.new
-    o.release
-    expect(o.transient_store).to be_nil
-  end
+  describe "writing the current state without persisting it" do
+    it "uses the AASM default" do
+      o = DefaultState.new
+      o.release
+      expect(o.transient_store).to be_nil
+    end
 
-  it "uses the provided method" do
-    o = ProvidedState.new
-    o.release
-    expect(o.transient_store).to eql :beta
-  end
+    it "uses the provided method" do
+      o = ProvidedState.new
+      o.release
+      expect(o.transient_store).to eql :beta
+    end
 
-  it "uses the persistence storage" do
-    o = PersistedState.new
-    o.release
-    expect(o.transient_store).to be_nil
-  end
+    it "uses the persistence storage" do
+      o = PersistedState.new
+      o.release
+      expect(o.transient_store).to be_nil
+    end
 
-  it "uses the provided method even if persisted" do
-    o = ProvidedAndPersistedState.new
-    o.release
-    expect(o.transient_store).to eql :beta
+    it "uses the provided method even if persisted" do
+      o = ProvidedAndPersistedState.new
+      o.release
+      expect(o.transient_store).to eql :beta
+    end
   end
 end

data/spec/unit/callbacks_spec.rb

@@ -118,6 +118,7 @@ describe 'callbacks for the new DSL' do
       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(:event_before_success).once.ordered
       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
@@ -143,6 +144,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(:event_before_success)
     expect(callback).to_not receive(:success_transition)
     expect(callback).to_not receive(:after_exit_open)
     expect(callback).to_not receive(:after_enter_closed)
@@ -186,6 +188,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(:event_before_success)
         expect(callback).to_not receive(:success_transition)
         expect(callback).to_not receive(:after_exit_open)
         expect(callback).to_not receive(:after_enter_closed)
@@ -217,6 +220,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(:event_before_success)
         expect(callback).to_not receive(:success_transition)
         expect(callback).to_not receive(:before_enter_closed)
         expect(callback).to_not receive(:enter_closed)
@@ -240,6 +244,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(:event_before_success)
       expect(callback).to_not receive(:success_transition)
       expect(callback).to_not receive(:after_exit_open)
       expect(callback).to_not receive(:after_enter_closed)

data/spec/unit/event_spec.rb

@@ -325,6 +325,12 @@ describe 'parametrised events' do
     pe.dress!(:working, 'blue', 'jeans')
   end
 
+  it 'should call :after transition method if arg is nil' do
+    dryer = nil
+    expect(pe).to receive(:wet_hair).with(dryer)
+    pe.shower!(dryer)
+  end
+
   it 'should call :after transition proc' do
     pe.wakeup!(:showering)
     expect(pe).to receive(:wear_clothes).with('purple', 'slacks')
@@ -344,6 +350,12 @@ describe 'parametrised events' do
     pe.dress!(:working, 'foundation', 'SPF')
   end
 
+  it 'should call :success transition method if arg is nil' do
+    shirt_color = nil
+    expect(pe).to receive(:wear_clothes).with(shirt_color)
+    pe.shower!(shirt_color)
+  end
+
   it 'should call :success transition proc' do
     pe.wakeup!(:showering)
     expect(pe).to receive(:wear_makeup).with('purple', 'slacks')

data/spec/unit/guard_spec.rb

@@ -70,3 +70,20 @@ describe "event guards" do
   end
 
 end
+
+if defined?(ActiveRecord)
+
+  Dir[File.dirname(__FILE__) + "/../models/active_record/*.rb"].sort.each do |f|
+    require File.expand_path(f)
+  end
+
+  load_schema
+
+  describe "ActiveRecord per-transition guards" do
+    let(:example) { ComplexActiveRecordExample.new }
+
+    it "should be able to increment" do
+      expect(example.may_increment?).to be true
+    end
+  end
+end

data/spec/unit/guard_with_params_spec.rb

@@ -7,4 +7,8 @@ describe "guards with params" do
   it "list permitted states" do
     expect(guard.aasm.states({:permitted => true}, user).map(&:name)).to eql [:reviewed]
   end
+
+  it "list no states if user is blank" do
+    expect(guard.aasm.states({:permitted => true}, nil).map(&:name)).to eql []
+  end
 end

data/spec/unit/guard_without_from_specified_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe "transitions without from specified" do
+  let(:guardian) { GuardianWithoutFromSpecified.new }
+
+  it "allows the transitions if guard succeeds" do
+    expect { guardian.use_guards_where_the_first_fails! }.to_not raise_error
+    expect(guardian).to be_gamma
+  end
+end

data/spec/unit/localizer_spec.rb

@@ -1,76 +1,78 @@
 require 'spec_helper'
-require 'active_record'
-require 'i18n'
 
-I18n.enforce_available_locales = false
-load_schema
+if defined?(ActiceRecord)
+  require 'i18n'
 
-describe AASM::Localizer, "new style" do
-  before(:all) do
-    I18n.load_path << 'spec/en.yml'
-    I18n.default_locale = :en
-    I18n.reload!
-  end
-
-  after(:all) do
-    I18n.load_path.clear
-  end
-
-  let (:foo_opened) { LocalizerTestModel.new }
-  let (:foo_closed) { LocalizerTestModel.new.tap { |x| x.aasm_state = :closed  } }
+  I18n.enforce_available_locales = false
+  load_schema
 
-  context 'aasm.human_state' do
-    it 'should return translated state value' do
-      expect(foo_opened.aasm.human_state).to eq("It's open now!")
+  describe AASM::Localizer, "new style" do
+    before(:all) do
+      I18n.load_path << 'spec/en.yml'
+      I18n.default_locale = :en
+      I18n.reload!
     end
 
-    it 'should return humanized value if not localized' do
-      expect(foo_closed.aasm.human_state).to eq("Closed")
+    after(:all) do
+      I18n.load_path.clear
     end
-  end
 
-  context 'aasm.human_event_name' do
-    it 'should return translated event name' do
-      expect(LocalizerTestModel.aasm.human_event_name(:close)).to eq("Let's close it!")
-    end
+    let (:foo_opened) { LocalizerTestModel.new }
+    let (:foo_closed) { LocalizerTestModel.new.tap { |x| x.aasm_state = :closed  } }
 
-    it 'should return humanized event name' do
-      expect(LocalizerTestModel.aasm.human_event_name(:open)).to eq("Open")
+    context 'aasm.human_state' do
+      it 'should return translated state value' do
+        expect(foo_opened.aasm.human_state).to eq("It's open now!")
+      end
+
+      it 'should return humanized value if not localized' do
+        expect(foo_closed.aasm.human_state).to eq("Closed")
+      end
     end
-  end
-end
 
-describe AASM::Localizer, "deprecated style" do
-  before(:all) do
-    I18n.load_path << 'spec/en_deprecated_style.yml'
-    I18n.default_locale = :en
-    I18n.reload!
-  end
+    context 'aasm.human_event_name' do
+      it 'should return translated event name' do
+        expect(LocalizerTestModel.aasm.human_event_name(:close)).to eq("Let's close it!")
+      end
 
-  after(:all) do
-    I18n.load_path.clear
+      it 'should return humanized event name' do
+        expect(LocalizerTestModel.aasm.human_event_name(:open)).to eq("Open")
+      end
+    end
   end
 
-  let (:foo_opened) { LocalizerTestModel.new }
-  let (:foo_closed) { LocalizerTestModel.new.tap { |x| x.aasm_state = :closed  } }
-
-  context 'aasm.human_state' do
-    it 'should return translated state value' do
-      expect(foo_opened.aasm.human_state).to eq("It's open now!")
+  describe AASM::Localizer, "deprecated style" do
+    before(:all) do
+      I18n.load_path << 'spec/en_deprecated_style.yml'
+      I18n.default_locale = :en
+      I18n.reload!
     end
 
-    it 'should return humanized value if not localized' do
-      expect(foo_closed.aasm.human_state).to eq("Closed")
+    after(:all) do
+      I18n.load_path.clear
     end
-  end
 
-  context 'aasm.human_event_name' do
-    it 'should return translated event name' do
-      expect(LocalizerTestModel.aasm.human_event_name(:close)).to eq("Let's close it!")
+    let (:foo_opened) { LocalizerTestModel.new }
+    let (:foo_closed) { LocalizerTestModel.new.tap { |x| x.aasm_state = :closed  } }
+
+    context 'aasm.human_state' do
+      it 'should return translated state value' do
+        expect(foo_opened.aasm.human_state).to eq("It's open now!")
+      end
+
+      it 'should return humanized value if not localized' do
+        expect(foo_closed.aasm.human_state).to eq("Closed")
+      end
     end
 
-    it 'should return humanized event name' do
-      expect(LocalizerTestModel.aasm.human_event_name(:open)).to eq("Open")
+    context 'aasm.human_event_name' do
+      it 'should return translated event name' do
+        expect(LocalizerTestModel.aasm.human_event_name(:close)).to eq("Let's close it!")
+      end
+
+      it 'should return humanized event name' do
+        expect(LocalizerTestModel.aasm.human_event_name(:open)).to eq("Open")
+      end
     end
   end
 end

data/spec/unit/multiple_transitions_that_differ_only_by_guard_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe "multiple transitions that differ only by guard" do
+  let(:job) { MultipleTransitionsThatDifferOnlyByGuard.new }
+
+  it 'does not follow the first transition if its guard fails' do
+    expect{job.go}.not_to raise_error
+  end
+
+  it 'executes the second transition\'s callbacks' do
+    job.go
+    expect(job.executed_second).to be_truthy
+  end
+end

data/spec/unit/namespaced_multiple_example_spec.rb

@@ -11,6 +11,10 @@ describe 'state machine' do
     expect(namespaced.aasm(:review_status).current_state).to eq(:unapproved)
     expect(namespaced).to respond_to(:review_unapproved?)
     expect(namespaced).to be_review_unapproved
+
+    expect(namespaced.aasm(:car).current_state).to eq(:unsold)
+    expect(namespaced).to respond_to(:car_unsold?)
+    expect(namespaced).to be_car_unsold
   end
 
   it 'allows transitions to other states' do
@@ -25,6 +29,12 @@ describe 'state machine' do
     namespaced.approve_review!
     expect(namespaced).to respond_to(:review_approved?)
     expect(namespaced).to be_review_approved
+
+    expect(namespaced).to respond_to(:sell_car)
+    expect(namespaced).to respond_to(:sell_car!)
+    namespaced.sell_car!
+    expect(namespaced).to respond_to(:car_sold?)
+    expect(namespaced).to be_car_sold
   end
 
   it 'denies transitions to other states' do
@@ -41,6 +51,13 @@ describe 'state machine' do
     expect {namespaced.approve_review}.to raise_error(AASM::InvalidTransition)
     expect {namespaced.approve_review!}.to raise_error(AASM::InvalidTransition)
     namespaced.unapprove_review
+
+    expect {namespaced.return_car}.to raise_error(AASM::InvalidTransition)
+    expect {namespaced.return_car!}.to raise_error(AASM::InvalidTransition)
+    namespaced.sell_car
+    expect {namespaced.sell_car}.to raise_error(AASM::InvalidTransition)
+    expect {namespaced.sell_car!}.to raise_error(AASM::InvalidTransition)
+    namespaced.return_car
   end
 
   it 'defines constants for each state name' do
@@ -49,5 +66,10 @@ describe 'state machine' do
 
     expect(NamespacedMultipleExample::STATE_REVIEW_UNAPPROVED).to eq(:unapproved)
     expect(NamespacedMultipleExample::STATE_REVIEW_APPROVED).to eq(:approved)
+
+    expect(NamespacedMultipleExample::STATE_CAR_UNSOLD).to eq(:unsold)
+    expect(NamespacedMultipleExample::STATE_CAR_SOLD).to eq(:sold)
   end
+
+
 end