3 files changed, 72 insertions, 80 deletions
diff --git a/activemodel/test/state_machine/event_test.rb b/activemodel/test/state_machine/event_test.rb
index 7f4a9afdd8..45adb4298a 100644
--- a/activemodel/test/state_machine/event_test.rb
+++ b/activemodel/test/state_machine/event_test.rb
@@ -20,12 +20,10 @@ class EventTest < ActiveModel::TestCase
     assert_equal @success, new_event.success
   end
 
-  uses_mocha 'StateTransition creation' do
-    test 'should create StateTransitions' do
-      ActiveModel::StateMachine::StateTransition.expects(:new).with(:to => :closed, :from => :open)
-      ActiveModel::StateMachine::StateTransition.expects(:new).with(:to => :closed, :from => :received)
-      new_event
-    end
+  test 'should create StateTransitions' do
+    ActiveModel::StateMachine::StateTransition.expects(:new).with(:to => :closed, :from => :open)
+    ActiveModel::StateMachine::StateTransition.expects(:new).with(:to => :closed, :from => :received)
+    new_event
   end
 end
 
diff --git a/activemodel/test/state_machine/state_test.rb b/activemodel/test/state_machine/state_test.rb
index daaf0829f0..319ac82d9b 100644
--- a/activemodel/test/state_machine/state_test.rb
+++ b/activemodel/test/state_machine/state_test.rb
@@ -43,32 +43,30 @@ class StateTest < ActiveModel::TestCase
     assert_equal new_state, new_state
   end
 
-  uses_mocha 'state actions' do
-    test 'should send a message to the record for an action if the action is present as a symbol' do
-      state = new_state(:entering => :foo)
+  test 'should send a message to the record for an action if the action is present as a symbol' do
+    state = new_state(:entering => :foo)
 
-      record = stub
-      record.expects(:foo)
+    record = stub
+    record.expects(:foo)
 
-      state.call_action(:entering, record)
-    end
+    state.call_action(:entering, record)
+  end
 
-    test 'should send a message to the record for an action if the action is present as a string' do
-      state = new_state(:entering => 'foo')
+  test 'should send a message to the record for an action if the action is present as a string' do
+    state = new_state(:entering => 'foo')
 
-      record = stub
-      record.expects(:foo)
+    record = stub
+    record.expects(:foo)
 
-      state.call_action(:entering, record)
-    end
+    state.call_action(:entering, record)
+  end
 
-    test 'should call a proc, passing in the record for an action if the action is present' do
-      state = new_state(:entering => Proc.new {|r| r.foobar})
+  test 'should call a proc, passing in the record for an action if the action is present' do
+    state = new_state(:entering => Proc.new {|r| r.foobar})
 
-      record = stub
-      record.expects(:foobar)
-    
-      state.call_action(:entering, record)
-    end
+    record = stub
+    record.expects(:foobar)
+  
+    state.call_action(:entering, record)
   end
 end
diff --git a/activemodel/test/state_machine/state_transition_test.rb b/activemodel/test/state_machine/state_transition_test.rb
index 5165bb1c97..b59ff5a6a7 100644
--- a/activemodel/test/state_machine/state_transition_test.rb
+++ b/activemodel/test/state_machine/state_transition_test.rb
@@ -10,39 +10,37 @@ class StateTransitionTest < ActiveModel::TestCase
     assert_equal opts,        st.options
   end
 
-  uses_mocha 'checking ActiveModel StateMachine transitions' do
-    test 'should pass equality check if from and to are the same' do
-      opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-      st = ActiveModel::StateMachine::StateTransition.new(opts)
+  test 'should pass equality check if from and to are the same' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+    st = ActiveModel::StateMachine::StateTransition.new(opts)
 
-      obj = stub
-      obj.stubs(:from).returns(opts[:from])
-      obj.stubs(:to).returns(opts[:to])
+    obj = stub
+    obj.stubs(:from).returns(opts[:from])
+    obj.stubs(:to).returns(opts[:to])
 
-      assert_equal st, obj
-    end
+    assert_equal st, obj
+  end
 
-    test 'should fail equality check if from are not the same' do
-      opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-      st = ActiveModel::StateMachine::StateTransition.new(opts)
+  test 'should fail equality check if from are not the same' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+    st = ActiveModel::StateMachine::StateTransition.new(opts)
 
-      obj = stub
-      obj.stubs(:from).returns('blah')
-      obj.stubs(:to).returns(opts[:to])
+    obj = stub
+    obj.stubs(:from).returns('blah')
+    obj.stubs(:to).returns(opts[:to])
 
-      assert_not_equal st, obj
-    end
-  
-    test 'should fail equality check if to are not the same' do
-      opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-      st = ActiveModel::StateMachine::StateTransition.new(opts)
+    assert_not_equal st, obj
+  end
+
+  test 'should fail equality check if to are not the same' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
+    st = ActiveModel::StateMachine::StateTransition.new(opts)
 
-      obj = stub
-      obj.stubs(:from).returns(opts[:from])
-      obj.stubs(:to).returns('blah')
+    obj = stub
+    obj.stubs(:from).returns(opts[:from])
+    obj.stubs(:to).returns('blah')
 
-      assert_not_equal st, obj
-    end
+    assert_not_equal st, obj
   end
 end
 
@@ -54,35 +52,33 @@ class StateTransitionGuardCheckTest < ActiveModel::TestCase
     assert st.perform(nil)
   end
 
-  uses_mocha 'checking ActiveModel StateMachine transition guard checks' do
-    test 'should call the method on the object if guard is a symbol' do
-      opts = {:from => 'foo', :to => 'bar', :guard => :test_guard}
-      st = ActiveModel::StateMachine::StateTransition.new(opts)
-    
-      obj = stub
-      obj.expects(:test_guard)
-      
-      st.perform(obj)
-    end
-    
-    test 'should call the method on the object if guard is a string' do
-      opts = {:from => 'foo', :to => 'bar', :guard => 'test_guard'}
-      st = ActiveModel::StateMachine::StateTransition.new(opts)
-    
-      obj = stub
-      obj.expects(:test_guard)
-      
-      st.perform(obj)
-    end
-    
-    test 'should call the proc passing the object if the guard is a proc' do
-      opts = {:from => 'foo', :to => 'bar', :guard => Proc.new {|o| o.test_guard}}
-      st = ActiveModel::StateMachine::StateTransition.new(opts)
+  test 'should call the method on the object if guard is a symbol' do
+    opts = {:from => 'foo', :to => 'bar', :guard => :test_guard}
+    st = ActiveModel::StateMachine::StateTransition.new(opts)
+  
+    obj = stub
+    obj.expects(:test_guard)
     
-      obj = stub
-      obj.expects(:test_guard)
+    st.perform(obj)
+  end
+  
+  test 'should call the method on the object if guard is a string' do
+    opts = {:from => 'foo', :to => 'bar', :guard => 'test_guard'}
+    st = ActiveModel::StateMachine::StateTransition.new(opts)
+  
+    obj = stub
+    obj.expects(:test_guard)
     
-      st.perform(obj)
-    end
+    st.perform(obj)
+  end
+  
+  test 'should call the proc passing the object if the guard is a proc' do
+    opts = {:from => 'foo', :to => 'bar', :guard => Proc.new {|o| o.test_guard}}
+    st = ActiveModel::StateMachine::StateTransition.new(opts)
+  
+    obj = stub
+    obj.expects(:test_guard)
+  
+    st.perform(obj)
   end
 end