aasm 4.11.1 → 5.2.0

data/spec/unit/abstract_class_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+if defined?(ActiveRecord)
+  require 'models/active_record/person'
+
+  load_schema
+  describe 'Abstract subclassing' do
+
+    it 'should have the parent states' do
+      Person.aasm.states.each do |state|
+        expect(Base.aasm.states).to include(state)
+      end
+      expect(Person.aasm.states).to eq(Base.aasm.states)
+    end
+
+    it 'should have the same events as its parent' do
+      expect(Base.aasm.events).to eq(Person.aasm.events)
+    end
+
+    it 'should not break aasm methods when super class is abstract_class' do
+      person = Person.new
+      person.status = 'active'
+      person.deactivate!
+      expect(person.aasm.current_state).to eq(:inactive)
+    end
+
+  end
+end

data/spec/unit/api_spec.rb

@@ -1,97 +1,104 @@
 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
+  load_schema
 
-  it "uses the provided method" do
-    expect(ProvidedState.new.aasm.current_state).to eql :beta
-  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 persistence storage" do
-    expect(PersistedState.new.aasm.current_state).to eql :alpha
-  end
+    it "uses display option" do
+      expect(DefaultState.new.aasm.human_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/callback_multiple_spec.rb

@@ -49,7 +49,7 @@ describe 'callbacks for the new DSL' do
 
     expect {
       callback.left_close!
-    }.to raise_error(AASM::InvalidTransition, "Event 'left_close' cannot transition from 'open'. Failed callback(s): [:after_transition, :event_guard].")
+    }.to raise_error(AASM::InvalidTransition, "Event 'left_close' cannot transition from 'open'. Failed callback(s): [:event_guard].")
 
   end
 
@@ -88,7 +88,7 @@ describe 'callbacks for the new DSL' do
 
       expect {
         callback.left_close!
-      }.to raise_error(AASM::InvalidTransition, "Event 'left_close' cannot transition from 'open'. Failed callback(s): [:after_transition, :event_guard, :transition_guard].")
+      }.to raise_error(AASM::InvalidTransition, "Event 'left_close' cannot transition from 'open'. Failed callback(s): [:transition_guard].")
     end
 
     it "does not run transition_guard twice for multiple permitted transitions" do
@@ -154,6 +154,8 @@ describe 'callbacks for the new DSL' do
     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(:before_success_method).with(:arg1).once.ordered
+    expect(cb).to receive(:success_method).with(:arg1).once.ordered
     expect(cb).to receive(:after_method).with(:arg1).once.ordered
     cb.close!(:out_to_lunch, :arg1)
 
@@ -161,6 +163,8 @@ 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(:before_success_method).with(some_object).once.ordered
+    expect(cb).to receive(:success_method).with(some_object).once.ordered
     expect(cb).to receive(:after_method).with(some_object).once.ordered
     cb.close!(:out_to_lunch, some_object)
   end
@@ -287,7 +291,7 @@ describe 'event callbacks' do
       expect(@foo).to receive(:aasm_event_failed).with(:null, :open)
       expect{
         @foo.null
-      }.to raise_error(AASM::InvalidTransition, "Event 'null' cannot transition from 'open'. Failed callback(s): [:always_false, :always_false].")
+      }.to raise_error(AASM::InvalidTransition, "Event 'null' cannot transition from 'open'. Failed callback(s): [:always_false].")
     end
 
     it 'should not call it if persist fails for bang fire' do

data/spec/unit/callbacks_spec.rb

@@ -3,14 +3,14 @@ Dir[File.dirname(__FILE__) + "/../models/callbacks/*.rb"].sort.each { |f| requir
 
 shared_examples 'an implemented callback that accepts error' do
   context 'with callback defined' do
-    it "should run error_callback if an exception is raised" do
+    it "should run error_callback if an exception is raised and always return false" do
       aasm_model.class.send(:define_method, callback_name) do |e|
         @data = [e]
       end
 
       allow(aasm_model).to receive(:before_enter).and_raise(e = StandardError.new)
 
-      aasm_model.safe_close!
+      expect(aasm_model.safe_close!).to be false
       expect(aasm_model.data).to eql [e]
     end
 
@@ -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)
@@ -200,6 +203,32 @@ describe 'callbacks for the new DSL' do
       }.to raise_error(AASM::InvalidTransition)
     end
 
+    it "does not propagate failures to next attempt of same transition" do
+      callback = Callbacks::Basic.new(:log => false, :fail_transition_guard => true)
+
+      expect {
+        callback.close!
+      }.to raise_error(AASM::InvalidTransition, "Event 'close' cannot transition from 'open'. Failed callback(s): [:transition_guard].")
+
+      expect {
+        callback.close!
+      }.to raise_error(AASM::InvalidTransition, "Event 'close' cannot transition from 'open'. Failed callback(s): [:transition_guard].")
+    end
+
+    it "does not propagate failures to next attempt of same event when no transition is applicable" do
+      callback = Callbacks::Basic.new(:log => false, :fail_transition_guard => true)
+
+      expect {
+        callback.close!
+      }.to raise_error(AASM::InvalidTransition, "Event 'close' cannot transition from 'open'. Failed callback(s): [:transition_guard].")
+
+      callback.aasm.current_state = :closed
+
+      expect {
+        callback.close!
+      }.to raise_error(AASM::InvalidTransition, "Event 'close' cannot transition from 'closed'.")
+    end
+
     it "does not run transition_guard twice for multiple permitted transitions" do
       show_debug_log = false
       callback = Callbacks::MultipleTransitionsTransitionGuard.new(:log => show_debug_log, :fail_transition_guard => true)
@@ -217,6 +246,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 +270,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)
@@ -284,7 +315,9 @@ 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(:before_success_method).with(:arg1).once.ordered
     expect(cb).to receive(:success_method).with(:arg1).once.ordered
+    expect(cb).to receive(:success_method3).with(:arg1).once.ordered
     expect(cb).to receive(:success_method).never
     expect(cb).to receive(:after_method).with(:arg1).once.ordered
     cb.close!(:arg1)
@@ -294,7 +327,9 @@ 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(:before_success_method).with(some_object).once.ordered
     expect(cb).to receive(:success_method).with(some_object).once.ordered
+    expect(cb).to receive(:success_method3).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)

data/spec/unit/complex_example_spec.rb

@@ -30,14 +30,14 @@ describe 'when being unsuspended' do
   it 'should be able to be unsuspended into active if polite' do
     auth.suspend!
     expect(auth.may_wait?(:waiting, :please)).to be true
-    auth.wait!(nil, :please)
+    auth.wait!(: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.wait!(nil, :rude)}.to raise_error(AASM::InvalidTransition)
+    expect {auth.wait!(:rude)}.to raise_error(AASM::InvalidTransition)
     expect {auth.wait!}.to raise_error(AASM::InvalidTransition)
   end
 
@@ -77,8 +77,17 @@ describe 'when being unsuspended' do
     expect(auth.aasm.may_fire_event?(:activate)).to be true
   end
 
+  it "should be able to fire event by name" do
+    expect(auth.aasm.fire(:activate)).to be true
+    expect(auth.aasm.current_state).to eq(:active)
+  end
+
+  it "should be able to fire! event by name" do
+    expect(auth.aasm.fire!(:activate)).to be true
+    expect(auth.aasm.current_state).to eq(:active)
+  end
+
   it "should not be able to fire unknown events" do
     expect(auth.aasm.may_fire_event?(:unknown)).to be false
   end
-
 end

data/spec/unit/complex_multiple_example_spec.rb

@@ -39,18 +39,18 @@ describe 'when being unsuspended' do
   it 'should be able to wait into waiting if polite' do
     auth.left_suspend!
     expect(auth.may_left_wait?(:waiting, :please)).to be true
-    auth.left_wait!(nil, :please)
+    auth.left_wait!(:please)
 
     auth.right_suspend!
     expect(auth.may_right_wait?(:waiting)).to be false
-    auth.right_wait!(nil, :please)
+    auth.right_wait!(:please)
   end
 
   it 'should not be able to be unsuspended into active if not polite' do
     auth.left_suspend!
     expect(auth.may_left_wait?(:waiting)).not_to be true
     expect(auth.may_left_wait?(:waiting, :rude)).not_to be true
-    expect {auth.left_wait!(nil, :rude)}.to raise_error(AASM::InvalidTransition)
+    expect {auth.left_wait!(:rude)}.to raise_error(AASM::InvalidTransition)
     expect {auth.left_wait!}.to raise_error(AASM::InvalidTransition)
   end
 
@@ -91,9 +91,25 @@ describe 'when being unsuspended' do
     expect(auth.aasm(:right).may_fire_event?(:right_activate)).to be true
   end
 
-  it "should not be able to fire unknown events" do
+  it 'should not be able to fire unknown events' do
     expect(auth.aasm(:left).may_fire_event?(:unknown)).to be false
     expect(auth.aasm(:right).may_fire_event?(:unknown)).to be false
   end
 
+  it 'should be able to fire event by name' do
+    expect(auth.aasm(:left).fire(:left_activate)).to be true
+    expect(auth.aasm(:left).current_state).to eq(:active)
+
+    expect(auth.aasm(:right).fire(:right_activate)).to be true
+    expect(auth.aasm(:right).current_state).to eq(:active)
+  end
+
+  it 'should be able to fire! event by name' do
+    expect(auth.aasm(:left).fire!(:left_activate)).to be true
+    expect(auth.aasm(:left).current_state).to eq(:active)
+
+    expect(auth.aasm(:right).fire!(:right_activate)).to be true
+    expect(auth.aasm(:right).current_state).to eq(:active)
+  end
+
 end

data/spec/unit/event_multiple_spec.rb

@@ -37,7 +37,7 @@ describe 'parametrised events' do
   end
 
   it 'should transition to default state when :after transition invoked' do
-    pe.dress!(nil, 'purple', 'dressy')
+    pe.dress!('purple', 'dressy')
     expect(pe.aasm(:left).current_state).to eq(:working)
   end
 

data/spec/unit/event_spec.rb

@@ -106,7 +106,7 @@ describe 'firing an event' do
     obj = double('object', :aasm => double('aasm', :current_state => :open))
     expect(obj).to receive(:guard_fn).with('arg1', 'arg2').and_return(true)
 
-    expect(event.fire(obj, {}, nil, 'arg1', 'arg2')).to eq(:closed)
+    expect(event.fire(obj, {}, 'arg1', 'arg2')).to eq(:closed)
   end
 
   context 'when given a gaurd proc' do
@@ -118,7 +118,7 @@ describe 'firing an event' do
       line_number = __LINE__ - 2
       obj = double('object', :aasm => double('aasm', :current_state => :student))
 
-      event.fire(obj, {}, nil)
+      event.fire(obj, {})
       expect(event.failed_callbacks).to eq ["#{__FILE__}##{line_number}"]
     end
   end
@@ -133,7 +133,7 @@ describe 'firing an event' do
       obj = double('object', :aasm => double('aasm', :current_state => :student))
       allow(obj).to receive(:paid_tuition?).and_return(false)
 
-      event.fire(obj, {}, nil)
+      event.fire(obj, {})
       expect(event.failed_callbacks).to eq [:paid_tuition?]
     end
   end
@@ -294,6 +294,19 @@ describe 'current event' do
     pe.wakeup!
     expect(pe.aasm.current_event).to eql :wakeup!
   end
+
+  describe "when calling events with fire/fire!" do
+    it "fire should populate aasm.current_event and transition (sleeping to showering)" do
+      pe.aasm.fire(:wakeup)
+      expect(pe.aasm.current_event).to eq :wakeup
+      expect(pe.aasm.current_state).to eq :showering
+    end
+    it "fire! should populate aasm.current_event and transition (sleeping to showering)" do
+      pe.aasm.fire!(:wakeup)
+      expect(pe.aasm.current_event).to eq :wakeup!
+      expect(pe.aasm.current_state).to eq :showering
+    end
+  end
 end
 
 describe 'parametrised events' do
@@ -315,7 +328,7 @@ describe 'parametrised events' do
   end
 
   it 'should transition to default state when :after transition invoked' do
-    pe.dress!(nil, 'purple', 'dressy')
+    pe.dress!('purple', 'dressy')
     expect(pe.aasm.current_state).to eq(:working)
   end
 
@@ -325,6 +338,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 +363,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/exception_spec.rb

@@ -5,7 +5,7 @@ describe AASM::InvalidTransition 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'. ")
+      expect(err.message).to eql("Event 'stop' cannot transition from 'sleeping'.")
     end
   end
 end

data/spec/unit/guard_arguments_check_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe "nil as first argument" do
+  let(:guard) { GuardArgumentsCheck.new }
+
+  it 'does not raise errors' do
+    expect { guard.mark_as_reviewed(nil, 'second arg') }.not_to raise_error
+  end
+end

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/inspection_multiple_spec.rb

@@ -166,11 +166,15 @@ describe "special cases" do
 end
 
 describe 'aasm.states_for_select' do
-  it "should return a select friendly array of states" do
-    expect(FooMultiple.aasm(:left)).to respond_to(:states_for_select)
-    expect(FooMultiple.aasm(:left).states_for_select).to eq(
-      [['Open', 'open'], ['Closed', 'closed'], ['Final', 'final']]
-    )
+  context 'without I18n' do
+    before { allow(Module).to receive(:const_defined?).with(:I18n).and_return(nil) }
+
+    it "should return a select friendly array of states" do
+      expect(FooMultiple.aasm(:left)).to respond_to(:states_for_select)
+      expect(FooMultiple.aasm(:left).states_for_select).to eq(
+        [['Open', 'open'], ['Closed', 'closed'], ['Final', 'final']]
+      )
+    end
   end
 end
 

data/spec/unit/inspection_spec.rb

@@ -102,9 +102,13 @@ describe "special cases" do
 end
 
 describe 'aasm.states_for_select' do
-  it "should return a select friendly array of states" do
-    expect(Foo.aasm).to respond_to(:states_for_select)
-    expect(Foo.aasm.states_for_select).to eq([['Open', 'open'], ['Closed', 'closed'], ['Final', 'final']])
+  context 'without I18n' do
+    before { allow(Module).to receive(:const_defined?).with(:I18n).and_return(nil) }
+
+    it "should return a select friendly array of states" do
+      expect(Foo.aasm).to respond_to(:states_for_select)
+      expect(Foo.aasm.states_for_select).to eq([['Open', 'open'], ['Closed', 'closed'], ['Final', 'final']])
+    end
   end
 end