database_cleaner 1.1.1 → 1.2.0

data/spec/database_cleaner/base_spec.rb

@@ -77,7 +77,7 @@ module DatabaseCleaner
          Object.const_set('Ohm',         'Ohm mock')
          Object.const_set('Redis',       'Redis mock')
 
-         cleaner.orm.should == :active_record
+         cleaner.orm.should eq :active_record
          cleaner.should be_auto_detected
        end
 
@@ -91,7 +91,7 @@ module DatabaseCleaner
          Object.const_set('Ohm',         'Ohm mock')
          Object.const_set('Redis',       'Redis mock')
 
-         cleaner.orm.should == :data_mapper
+         cleaner.orm.should eq :data_mapper
          cleaner.should be_auto_detected
        end
 
@@ -104,7 +104,7 @@ module DatabaseCleaner
          Object.const_set('Ohm',         'Ohm mock')
          Object.const_set('Redis',       'Redis mock')
 
-         cleaner.orm.should == :mongo_mapper
+         cleaner.orm.should eq :mongo_mapper
          cleaner.should be_auto_detected
        end
 
@@ -116,7 +116,7 @@ module DatabaseCleaner
          Object.const_set('Ohm',         'Ohm mock')
          Object.const_set('Redis',       'Redis mock')
 
-         cleaner.orm.should == :mongoid
+         cleaner.orm.should eq :mongoid
          cleaner.should be_auto_detected
        end
 
@@ -127,7 +127,7 @@ module DatabaseCleaner
          Object.const_set('Ohm',         'Ohm mock')
          Object.const_set('Redis',       'Redis mock')
 
-         cleaner.orm.should == :couch_potato
+         cleaner.orm.should eq :couch_potato
          cleaner.should be_auto_detected
        end
 
@@ -137,7 +137,7 @@ module DatabaseCleaner
          Object.const_set('Ohm',    'Ohm mock')
          Object.const_set('Redis',  'Redis mock')
 
-         cleaner.orm.should == :sequel
+         cleaner.orm.should eq :sequel
          cleaner.should be_auto_detected
        end
 
@@ -145,42 +145,42 @@ module DatabaseCleaner
          Object.const_set('Ohm', 'Ohm mock')
          Object.const_set('Redis',       'Redis mock')
 
-         cleaner.orm.should == :ohm
+         cleaner.orm.should eq :ohm
          cleaner.should be_auto_detected
        end
 
        it 'detects Redis last' do
          Object.const_set('Redis',       'Redis mock')
 
-         cleaner.orm.should == :redis
+         cleaner.orm.should eq :redis
          cleaner.should be_auto_detected
        end
 
        it 'detects Moped seventh' do
          Object.const_set('Moped', 'Moped mock')
 
-         cleaner.orm.should == :moped
+         cleaner.orm.should eq :moped
          cleaner.should be_auto_detected
        end
     end
 
     describe "orm_module" do
       it "should ask ::DatabaseCleaner what the module is for its orm" do
-        orm = mock("orm")
-        mockule = mock("module")
+        orm = double("orm")
+        mockule = double("module")
 
         cleaner = ::DatabaseCleaner::Base.new
         cleaner.should_receive(:orm).and_return(orm)
 
         ::DatabaseCleaner.should_receive(:orm_module).with(orm).and_return(mockule)
 
-        cleaner.send(:orm_module).should == mockule
+        cleaner.send(:orm_module).should eq mockule
       end
     end
 
     describe "comparison" do
       it "should be equal if orm, connection and strategy are the same" do
-        strategy = mock("strategy")
+        strategy = double("strategy")
 
         one = DatabaseCleaner::Base.new(:active_record,:connection => :default)
         one.strategy = strategy
@@ -188,8 +188,8 @@ module DatabaseCleaner
         two = DatabaseCleaner::Base.new(:active_record,:connection => :default)
         two.strategy = strategy
 
-        one.should == two
-        two.should == one
+        one.should eq two
+        two.should eq one
       end
     end
 
@@ -198,19 +198,19 @@ module DatabaseCleaner
         subject { ::DatabaseCleaner::Base.new(:active_record,:connection => :my_db) }
 
         it "should store db from :connection in params hash" do
-          subject.db.should == :my_db
+          subject.db.should eq :my_db
         end
       end
 
       describe "orm" do
         it "should store orm" do
           cleaner = ::DatabaseCleaner::Base.new :a_orm
-          cleaner.orm.should == :a_orm
+          cleaner.orm.should eq :a_orm
         end
 
         it "converts string to symbols" do
           cleaner = ::DatabaseCleaner::Base.new "mongoid"
-          cleaner.orm.should == :mongoid
+          cleaner.orm.should eq :mongoid
         end
 
         it "is autodetected if orm is not provided" do
@@ -231,13 +231,13 @@ module DatabaseCleaner
 
     describe "db" do
       it "should default to :default" do
-        subject.db.should == :default
+        subject.db.should eq :default
       end
 
       it "should return any stored db value" do
         subject.stub(:strategy_db=)
         subject.db = :test_db
-        subject.db.should == :test_db
+        subject.db.should eq :test_db
       end
 
       it "should pass db to any specified strategy" do
@@ -247,7 +247,7 @@ module DatabaseCleaner
     end
 
     describe "strategy_db=" do
-      let(:strategy) { mock("strategy") }
+      let(:strategy) { double("strategy") }
 
       before(:each) do
         subject.strategy = strategy
@@ -272,21 +272,21 @@ module DatabaseCleaner
         before(:each) { strategy.stub(:respond_to?).with(:db=).and_return false }
 
         it "should check to see if db is :default" do
-          db = mock("default")
+          db = double("default")
           db.should_receive(:==).with(:default).and_return(true)
 
           subject.strategy_db = db
         end
 
         it "should raise an argument error when db isn't default" do
-          db = mock("a db")
+          db = double("a db")
           expect{ subject.strategy_db = db }.to raise_error ArgumentError
         end
       end
     end
 
     describe "clean_with" do
-      let (:strategy) { mock("strategy",:clean => true) }
+      let (:strategy) { double("strategy",:clean => true) }
 
       before(:each) { subject.stub(:create_strategy).with(anything).and_return(strategy) }
 
@@ -301,12 +301,12 @@ module DatabaseCleaner
       end
 
       it "should return the strategy" do
-        subject.clean_with( :strategy ).should == strategy
+        subject.clean_with( :strategy ).should eq strategy
       end
     end
 
     describe "clean_with!" do
-      let (:strategy) { mock("strategy",:clean => true) }
+      let (:strategy) { double("strategy",:clean => true) }
 
       before(:each) { subject.stub(:create_strategy).with(anything).and_return(strategy) }
 
@@ -321,12 +321,12 @@ module DatabaseCleaner
       end
 
       it "should return the strategy" do
-        subject.clean_with!( :strategy ).should == strategy
+        subject.clean_with!( :strategy ).should eq strategy
       end
     end
 
     describe "create_strategy" do
-      let(:strategy_class) { mock("strategy_class",:new => mock("instance")) }
+      let(:strategy_class) { double("strategy_class",:new => double("instance")) }
 
       before :each do
         subject.stub(:orm_strategy).and_return(strategy_class)
@@ -342,12 +342,12 @@ module DatabaseCleaner
         subject.create_strategy :strategy, {:params => {:lorum => "ipsum"}}
       end
       it "should return the resulting strategy" do
-        subject.create_strategy( :strategy ).should == strategy_class.new
+        subject.create_strategy( :strategy ).should eq strategy_class.new
       end
     end
 
     describe "strategy=" do
-      let(:mock_strategy) { mock("strategy") }
+      let(:mock_strategy) { double("strategy") }
 
       it "should proxy symbolised strategies to create_strategy" do
         subject.should_receive(:create_strategy).with(:symbol)
@@ -364,7 +364,7 @@ module DatabaseCleaner
       end
 
       it "should raise argument error when params given with strategy Object" do
-        expect{ subject.strategy = mock("object"), {:param => "one"} }.to raise_error ArgumentError
+        expect{ subject.strategy = double("object"), {:param => "one"} }.to raise_error ArgumentError
       end
 
       it "should attempt to set strategy db" do
@@ -375,7 +375,7 @@ module DatabaseCleaner
 
       it "should return the stored strategy" do
         result = subject.strategy = mock_strategy
-        result.should == mock_strategy
+        result.should eq mock_strategy
       end
     end
 
@@ -383,30 +383,30 @@ module DatabaseCleaner
       subject { ::DatabaseCleaner::Base.new :a_orm }
 
       it "returns a null strategy when strategy is not set and undetectable" do
-        subject.strategy.should == DatabaseCleaner::NullStrategy
+        subject.strategy.should eq DatabaseCleaner::NullStrategy
       end
 
       it "returns the set strategy" do
-        strategum = mock("strategy")
+        strategum = double("strategy")
         subject.strategy = strategum
-        subject.strategy.should == strategum
+        subject.strategy.should eq strategum
       end
     end
 
     describe "orm=" do
       it "should stored the desired orm" do
-        subject.orm.should_not == :desired_orm
+        subject.orm.should_not eq :desired_orm
         subject.orm = :desired_orm
-        subject.orm.should == :desired_orm
+        subject.orm.should eq :desired_orm
       end
     end
 
     describe "orm" do
-      let(:mock_orm) { mock("orm") }
+      let(:mock_orm) { double("orm") }
 
       it "should return orm if orm set" do
         subject.instance_variable_set "@orm", mock_orm
-        subject.orm.should == mock_orm
+        subject.orm.should eq mock_orm
       end
 
       context "orm isn't set" do
@@ -419,13 +419,13 @@ module DatabaseCleaner
 
         it "should return the result of autodetect if orm isn't set" do
           subject.stub(:autodetect).and_return(mock_orm)
-          subject.orm.should == mock_orm
+          subject.orm.should eq mock_orm
         end
       end
     end
 
     describe "proxy methods" do
-      let (:strategy) { mock("strategy") }
+      let (:strategy) { double("strategy") }
 
       before(:each) do
         subject.stub(:strategy).and_return(strategy)
@@ -466,7 +466,7 @@ module DatabaseCleaner
     end
 
     describe "orm_strategy" do
-      let (:strategy_class) { mock("strategy_class") }
+      let (:strategy_class) { double("strategy_class") }
 
       before(:each) do
         subject.stub(:orm_module).and_return(strategy_class)
@@ -475,10 +475,6 @@ module DatabaseCleaner
       context "in response to a LoadError" do
         before(:each) { subject.should_receive(:require).with(anything).and_raise(LoadError) }
 
-        it "should catch LoadErrors" do
-          expect { subject.send(:orm_strategy,:a_strategy) }.to_not raise_error LoadError
-        end
-
         it "should raise UnknownStrategySpecified" do
           expect { subject.send(:orm_strategy,:a_strategy) }.to raise_error UnknownStrategySpecified
         end
@@ -502,13 +498,13 @@ module DatabaseCleaner
       end
 
       it "should return the constant of the Strategy class requested" do
-        strategy_strategy_class = mock("strategy strategy_class")
+        strategy_strategy_class = double("strategy strategy_class")
 
         subject.stub(:require).with(anything).and_return(true)
 
         strategy_class.should_receive(:const_get).with("Cunningplan").and_return(strategy_strategy_class)
 
-        subject.send(:orm_strategy, :cunningplan).should == strategy_strategy_class
+        subject.send(:orm_strategy, :cunningplan).should eq strategy_strategy_class
       end
 
     end

data/spec/database_cleaner/configuration_spec.rb

@@ -13,7 +13,7 @@ module DatabaseCleaner
       @connections = nil
     end
     # hackey, hack.. connections needs to stick around until I can properly deprecate the API
-    def connections_stub!(array)
+    def connections_stub(array)
       @cleaners = ArrayHelper.zipmap((1..array.size).to_a, array)
       @connections = array
     end
@@ -31,70 +31,70 @@ describe ::DatabaseCleaner do
     it "should accept :active_record" do
       cleaner = ::DatabaseCleaner[:active_record]
       cleaner.should be_a(::DatabaseCleaner::Base)
-      cleaner.orm.should == :active_record
-      ::DatabaseCleaner.connections.size.should == 1
+      cleaner.orm.should eq :active_record
+      ::DatabaseCleaner.connections.size.should eq 1
     end
 
     it "should accept :data_mapper" do
       cleaner = ::DatabaseCleaner[:data_mapper]
       cleaner.should be_a(::DatabaseCleaner::Base)
-      cleaner.orm.should == :data_mapper
-      ::DatabaseCleaner.connections.size.should == 1
+      cleaner.orm.should eq :data_mapper
+      ::DatabaseCleaner.connections.size.should eq 1
     end
 
     it "should accept :mongo_mapper" do
       cleaner = ::DatabaseCleaner[:mongo_mapper]
       cleaner.should be_a(::DatabaseCleaner::Base)
-      cleaner.orm.should == :mongo_mapper
-      ::DatabaseCleaner.connections.size.should == 1
+      cleaner.orm.should eq :mongo_mapper
+      ::DatabaseCleaner.connections.size.should eq 1
     end
 
     it "should accept :couch_potato" do
       cleaner = ::DatabaseCleaner[:couch_potato]
       cleaner.should be_a(::DatabaseCleaner::Base)
-      cleaner.orm.should == :couch_potato
-      ::DatabaseCleaner.connections.size.should == 1
+      cleaner.orm.should eq :couch_potato
+      ::DatabaseCleaner.connections.size.should eq 1
     end
 
     it "should accept :moped" do
       cleaner = ::DatabaseCleaner[:moped]
       cleaner.should be_a(::DatabaseCleaner::Base)
-      cleaner.orm.should == :moped
-      ::DatabaseCleaner.connections.size.should == 1
+      cleaner.orm.should eq :moped
+      ::DatabaseCleaner.connections.size.should eq 1
     end
 
     it 'accepts :ohm' do
       cleaner = ::DatabaseCleaner[:ohm]
       cleaner.should be_a(::DatabaseCleaner::Base)
-      cleaner.orm.should == :ohm
-      ::DatabaseCleaner.connections.size.should == 1
+      cleaner.orm.should eq :ohm
+      ::DatabaseCleaner.connections.size.should eq 1
     end
   end
 
   it "should accept multiple orm's" do
     ::DatabaseCleaner[:couch_potato]
     ::DatabaseCleaner[:data_mapper]
-    ::DatabaseCleaner.connections.size.should == 2
-    ::DatabaseCleaner.connections[0].orm.should == :couch_potato
-    ::DatabaseCleaner.connections[1].orm.should == :data_mapper
+    ::DatabaseCleaner.connections.size.should eq 2
+    ::DatabaseCleaner.connections[0].orm.should eq :couch_potato
+    ::DatabaseCleaner.connections[1].orm.should eq :data_mapper
   end
 
   context "connection/db specification" do
     it "should accept a connection parameter and store it" do
       cleaner = ::DatabaseCleaner[:active_record, {:connection => :first_connection}]
       cleaner.should be_a(::DatabaseCleaner::Base)
-      cleaner.orm.should == :active_record
-      cleaner.db.should == :first_connection
+      cleaner.orm.should eq :active_record
+      cleaner.db.should eq :first_connection
     end
 
     it "should accept multiple connections for a single orm" do
       ::DatabaseCleaner[:data_mapper,{:connection => :first_db}]
       ::DatabaseCleaner[:data_mapper,{:connection => :second_db}]
-      ::DatabaseCleaner.connections.size.should == 2
-      ::DatabaseCleaner.connections[0].orm.should == :data_mapper
-      ::DatabaseCleaner.connections[0].db.should  == :first_db
-      ::DatabaseCleaner.connections[1].orm.should == :data_mapper
-      ::DatabaseCleaner.connections[1].db.should  == :second_db
+      ::DatabaseCleaner.connections.size.should eq 2
+      ::DatabaseCleaner.connections[0].orm.should eq :data_mapper
+      ::DatabaseCleaner.connections[0].db.should  eq :first_db
+      ::DatabaseCleaner.connections[1].orm.should eq :data_mapper
+      ::DatabaseCleaner.connections[1].db.should  eq :second_db
     end
 
     it "should accept multiple connections and multiple orms" do
@@ -103,19 +103,19 @@ describe ::DatabaseCleaner do
       ::DatabaseCleaner[:active_record,{:connection => :first_db} ]
       ::DatabaseCleaner[:data_mapper,  {:connection => :second_db}]
 
-      ::DatabaseCleaner.connections.size.should == 4
+      ::DatabaseCleaner.connections.size.should eq 4
 
-      ::DatabaseCleaner.connections[0].orm.should == :data_mapper
-      ::DatabaseCleaner.connections[0].db.should  == :first_db
+      ::DatabaseCleaner.connections[0].orm.should eq :data_mapper
+      ::DatabaseCleaner.connections[0].db.should  eq :first_db
 
-      ::DatabaseCleaner.connections[1].orm.should == :active_record
-      ::DatabaseCleaner.connections[1].db.should  == :second_db
+      ::DatabaseCleaner.connections[1].orm.should eq :active_record
+      ::DatabaseCleaner.connections[1].db.should  eq :second_db
 
-      ::DatabaseCleaner.connections[2].orm.should == :active_record
-      ::DatabaseCleaner.connections[2].db.should  == :first_db
+      ::DatabaseCleaner.connections[2].orm.should eq :active_record
+      ::DatabaseCleaner.connections[2].db.should  eq :first_db
 
-      ::DatabaseCleaner.connections[3].orm.should == :data_mapper
-      ::DatabaseCleaner.connections[3].db.should  == :second_db
+      ::DatabaseCleaner.connections[3].orm.should eq :data_mapper
+      ::DatabaseCleaner.connections[3].db.should  eq :second_db
     end
   end
 
@@ -123,7 +123,7 @@ describe ::DatabaseCleaner do
     it "should retrieve a db rather than create a new one" do
       pending
       connection = ::DatabaseCleaner[:active_record].strategy = :truncation
-      ::DatabaseCleaner[:active_record].should == connection
+      ::DatabaseCleaner[:active_record].should eq connection
     end
   end
 
@@ -131,10 +131,10 @@ describe ::DatabaseCleaner do
     subject { ::DatabaseCleaner }
 
     it "should give me a default (autodetection) databasecleaner by default" do
-      cleaner = mock("cleaner").as_null_object
-      ::DatabaseCleaner::Base.stub!(:new).and_return(cleaner)
+      cleaner = double("cleaner").as_null_object
+      ::DatabaseCleaner::Base.stub(:new).and_return(cleaner)
 
-      ::DatabaseCleaner.connections.should == [cleaner]
+      ::DatabaseCleaner.connections.should eq [cleaner]
     end
   end
 
@@ -142,13 +142,13 @@ describe ::DatabaseCleaner do
     let(:connection) { ::DatabaseCleaner.connections.first }
 
     it "should proxy strategy=" do
-      stratagum = mock("stratagum")
+      stratagum = double("stratagum")
       connection.should_receive(:strategy=).with(stratagum)
       ::DatabaseCleaner.strategy = stratagum
     end
 
     it "should proxy orm=" do
-      orm = mock("orm")
+      orm = double("orm")
       connection.should_receive(:orm=).with(orm)
       ::DatabaseCleaner.orm = orm
     end
@@ -164,7 +164,7 @@ describe ::DatabaseCleaner do
     end
 
     it "should proxy clean_with" do
-      stratagem = mock("stratgem")
+      stratagem = double("stratgem")
       connection.should_receive(:clean_with).with(stratagem, {})
       ::DatabaseCleaner.clean_with stratagem, {}
     end
@@ -175,18 +175,18 @@ describe ::DatabaseCleaner do
     #these are relativly simple, all we need to do is make sure all connections are cleaned/started/cleaned_with appropriatly.
     context "simple proxy methods" do
 
-      let(:active_record) { mock("active_mock") }
-      let(:data_mapper)   { mock("data_mock")   }
+      let(:active_record) { double("active_mock") }
+      let(:data_mapper)   { double("data_mock")   }
 
       before(:each) do
-        ::DatabaseCleaner.stub!(:connections).and_return([active_record,data_mapper])
+        ::DatabaseCleaner.stub(:connections).and_return([active_record,data_mapper])
       end
 
       it "should proxy orm to all connections" do
         active_record.should_receive(:orm=)
         data_mapper.should_receive(:orm=)
 
-        ::DatabaseCleaner.orm = mock("orm")
+        ::DatabaseCleaner.orm = double("orm")
       end
 
       it "should proxy start to all connections" do
@@ -204,7 +204,7 @@ describe ::DatabaseCleaner do
       end
 
       it "should proxy clean_with to all connections" do
-        stratagem = mock("stratgem")
+        stratagem = double("stratgem")
         active_record.should_receive(:clean_with).with(stratagem)
         data_mapper.should_receive(:clean_with).with(stratagem)
 
@@ -217,11 +217,11 @@ describe ::DatabaseCleaner do
     context "multiple orm proxy methods" do
 
       pending "should proxy orm to all connections and remove duplicate connections" do
-        active_record_1 = mock("active_mock_on_db_one").as_null_object
-        active_record_2 = mock("active_mock_on_db_two").as_null_object
-        data_mapper_1   = mock("data_mock_on_db_one").as_null_object
+        active_record_1 = double("active_mock_on_db_one").as_null_object
+        active_record_2 = double("active_mock_on_db_two").as_null_object
+        data_mapper_1   = double("data_mock_on_db_one").as_null_object
 
-        ::DatabaseCleaner.connections_stub! [active_record_1,active_record_2,data_mapper_1]
+        ::DatabaseCleaner.connections_stub [active_record_1,active_record_2,data_mapper_1]
 
         active_record_1.should_receive(:orm=).with(:data_mapper)
         active_record_2.should_receive(:orm=).with(:data_mapper)
@@ -229,50 +229,50 @@ describe ::DatabaseCleaner do
 
         active_record_1.should_receive(:==).with(data_mapper_1).and_return(true)
 
-        ::DatabaseCleaner.connections.size.should == 3
+        ::DatabaseCleaner.connections.size.should eq 3
         ::DatabaseCleaner.orm = :data_mapper
-        ::DatabaseCleaner.connections.size.should == 2
+        ::DatabaseCleaner.connections.size.should eq 2
       end
 
       it "should proxy strategy to all connections and remove duplicate connections" do
-        active_record_1 = mock("active_mock_strategy_one").as_null_object
-        active_record_2 = mock("active_mock_strategy_two").as_null_object
-        strategy = mock("strategy")
+        active_record_1 = double("active_mock_strategy_one").as_null_object
+        active_record_2 = double("active_mock_strategy_two").as_null_object
+        strategy = double("strategy")
 
-        ::DatabaseCleaner.connections_stub! [active_record_1,active_record_2]
+        ::DatabaseCleaner.connections_stub [active_record_1,active_record_2]
 
         active_record_1.should_receive(:strategy=).with(strategy)
         active_record_2.should_receive(:strategy=).with(strategy)
 
         active_record_1.should_receive(:==).with(active_record_2).and_return(true)
 
-        ::DatabaseCleaner.connections.size.should == 2
+        ::DatabaseCleaner.connections.size.should eq 2
         ::DatabaseCleaner.strategy = strategy
-        ::DatabaseCleaner.connections.size.should == 1
+        ::DatabaseCleaner.connections.size.should eq 1
       end
     end
   end
 
   describe "remove_duplicates" do
     it "should remove duplicates if they are identical" do
-      orm = mock("orm")
-      connection = mock("a datamapper connection", :orm => orm )
+      orm = double("orm")
+      connection = double("a datamapper connection", :orm => orm )
 
-      ::DatabaseCleaner.connections_stub!  [connection,connection,connection]
+      ::DatabaseCleaner.connections_stub  [connection,connection,connection]
 
       ::DatabaseCleaner.remove_duplicates
-      ::DatabaseCleaner.connections.size.should == 1
+      ::DatabaseCleaner.connections.size.should eq 1
     end
   end
 
   describe "app_root" do
     it "should default to Dir.pwd" do
-      DatabaseCleaner.app_root.should == Dir.pwd
+      DatabaseCleaner.app_root.should eq Dir.pwd
     end
 
     it "should store specific paths" do
       DatabaseCleaner.app_root = '/path/to'
-      DatabaseCleaner.app_root.should == '/path/to'
+      DatabaseCleaner.app_root.should eq '/path/to'
     end
   end
 
@@ -280,33 +280,33 @@ describe ::DatabaseCleaner do
     subject { ::DatabaseCleaner }
 
     it "should return DatabaseCleaner::ActiveRecord for :active_record" do
-      ::DatabaseCleaner::ActiveRecord = mock("ar module") unless defined? ::DatabaseCleaner::ActiveRecord
-      subject.orm_module(:active_record).should == DatabaseCleaner::ActiveRecord
+      ::DatabaseCleaner::ActiveRecord = double("ar module") unless defined? ::DatabaseCleaner::ActiveRecord
+      subject.orm_module(:active_record).should eq DatabaseCleaner::ActiveRecord
     end
 
     it "should return DatabaseCleaner::DataMapper for :data_mapper" do
-      ::DatabaseCleaner::DataMapper = mock("dm module") unless defined? ::DatabaseCleaner::DataMapper
-      subject.orm_module(:data_mapper).should == DatabaseCleaner::DataMapper
+      ::DatabaseCleaner::DataMapper = double("dm module") unless defined? ::DatabaseCleaner::DataMapper
+      subject.orm_module(:data_mapper).should eq DatabaseCleaner::DataMapper
     end
 
     it "should return DatabaseCleaner::MongoMapper for :mongo_mapper" do
-      ::DatabaseCleaner::MongoMapper = mock("mm module") unless defined? ::DatabaseCleaner::MongoMapper
-      subject.orm_module(:mongo_mapper).should == DatabaseCleaner::MongoMapper
+      ::DatabaseCleaner::MongoMapper = double("mm module") unless defined? ::DatabaseCleaner::MongoMapper
+      subject.orm_module(:mongo_mapper).should eq DatabaseCleaner::MongoMapper
     end
 
     it "should return DatabaseCleaner::Mongoid for :mongoid" do
-      ::DatabaseCleaner::Mongoid = mock("mongoid module") unless defined? ::DatabaseCleaner::Mongoid
-      subject.orm_module(:mongoid).should == DatabaseCleaner::Mongoid
+      ::DatabaseCleaner::Mongoid = double("mongoid module") unless defined? ::DatabaseCleaner::Mongoid
+      subject.orm_module(:mongoid).should eq DatabaseCleaner::Mongoid
     end
 
     it "should return DatabaseCleaner::Mongo for :mongo" do
-      ::DatabaseCleaner::Mongo = mock("mongo module") unless defined? ::DatabaseCleaner::Mongo
-      subject.orm_module(:mongo).should == DatabaseCleaner::Mongo
+      ::DatabaseCleaner::Mongo = double("mongo module") unless defined? ::DatabaseCleaner::Mongo
+      subject.orm_module(:mongo).should eq DatabaseCleaner::Mongo
     end
 
     it "should return DatabaseCleaner::CouchPotato for :couch_potato" do
-      ::DatabaseCleaner::CouchPotato = mock("cp module") unless defined? ::DatabaseCleaner::CouchPotato
-      subject.orm_module(:couch_potato).should == DatabaseCleaner::CouchPotato
+      ::DatabaseCleaner::CouchPotato = double("cp module") unless defined? ::DatabaseCleaner::CouchPotato
+      subject.orm_module(:couch_potato).should eq DatabaseCleaner::CouchPotato
     end
 
   end