diff --git a/spec/database_cleaner/active_record/base_spec.rb b/spec/database_cleaner/active_record/base_spec.rb
index 7e081ea..a312227 100644
--- a/spec/database_cleaner/active_record/base_spec.rb
+++ b/spec/database_cleaner/active_record/base_spec.rb
@@ -19,7 +19,7 @@ module DatabaseCleaner
       it "should default to DatabaseCleaner.root / config / database.yml" do
         ActiveRecord.config_file_location=nil
         DatabaseCleaner.should_receive(:app_root).and_return("/path/to")
-        subject.should == '/path/to/config/database.yml'
+        subject.should eq '/path/to/config/database.yml'
       end
     end
 
@@ -45,11 +45,11 @@ module DatabaseCleaner
           subject.stub(:load_config)
 
           subject.db = :my_db
-          subject.db.should == :my_db
+          subject.db.should eq :my_db
         end
 
         it "should default to :default" do
-          subject.db.should == :default
+          subject.db.should eq :default
         end
 
         it "should load_config when I set db" do
@@ -86,7 +86,7 @@ my_db:
 
         it "should store the relevant config in connection_hash" do
           subject.load_config
-          subject.connection_hash.should == { "database" => "one" }
+          subject.connection_hash.should eq( "database" => "one" )
         end
 
         it "should skip config if config file is not available" do
@@ -115,14 +115,14 @@ my_db:
       describe "connection_hash" do
         it "should store connection_hash" do
           subject.connection_hash = { :key => "value" }
-          subject.connection_hash.should == { :key => "value" }
+          subject.connection_hash.should eq( :key => "value" )
         end
       end
 
       describe "connection_class" do
         it { expect { subject.connection_class }.to_not raise_error }
         it "should default to ActiveRecord::Base" do
-          subject.connection_class.should == ::ActiveRecord::Base
+          subject.connection_class.should eq ::ActiveRecord::Base
         end
 
         context "with database models" do
@@ -131,14 +131,14 @@ my_db:
               subject.db = FakeModel
               subject.connection_hash = { }
               subject.load_config
-              subject.connection_class.should == FakeModel
+              subject.connection_class.should eq FakeModel
             end
           end
 
           context "connection_hash is not set" do
             it "allows for database models to be passed in" do
               subject.db = FakeModel
-              subject.connection_class.should == FakeModel
+              subject.connection_class.should eq FakeModel
             end
           end
         end
diff --git a/spec/database_cleaner/active_record/truncation/mysql2_spec.rb b/spec/database_cleaner/active_record/truncation/mysql2_spec.rb
index 29569a2..5af4715 100644
--- a/spec/database_cleaner/active_record/truncation/mysql2_spec.rb
+++ b/spec/database_cleaner/active_record/truncation/mysql2_spec.rb
@@ -17,7 +17,7 @@ module ActiveRecord
           2.times { User.create }
 
           connection.truncate_table('users')
-          User.count.should == 0
+          User.count.should eq 0
         end
 
         it "should reset AUTO_INCREMENT index of table" do
@@ -26,7 +26,7 @@ module ActiveRecord
 
           connection.truncate_table('users')
 
-          User.create.id.should == 1
+          User.create.id.should eq 1
         end
       end
 
diff --git a/spec/database_cleaner/active_record/truncation/mysql_spec.rb b/spec/database_cleaner/active_record/truncation/mysql_spec.rb
index 01b34c0..0508fe5 100644
--- a/spec/database_cleaner/active_record/truncation/mysql_spec.rb
+++ b/spec/database_cleaner/active_record/truncation/mysql_spec.rb
@@ -17,7 +17,7 @@ module ActiveRecord
           2.times { User.create }
 
           connection.truncate_table('users')
-          User.count.should == 0
+          User.count.should eq 0
         end
 
         it "should reset AUTO_INCREMENT index of table" do
@@ -26,7 +26,7 @@ module ActiveRecord
 
           connection.truncate_table('users')
 
-          User.create.id.should == 1
+          User.create.id.should eq 1
         end
       end
  
diff --git a/spec/database_cleaner/active_record/truncation/postgresql_spec.rb b/spec/database_cleaner/active_record/truncation/postgresql_spec.rb
index 64c242d..f687a82 100644
--- a/spec/database_cleaner/active_record/truncation/postgresql_spec.rb
+++ b/spec/database_cleaner/active_record/truncation/postgresql_spec.rb
@@ -24,7 +24,7 @@ module ActiveRecord
           2.times { User.create }
 
           connection.truncate_table('users')
-          User.count.should == 0
+          User.count.should eq 0
         end
 
         it "resets AUTO_INCREMENT index of table" do
@@ -33,7 +33,7 @@ module ActiveRecord
 
           connection.truncate_table('users')
 
-          User.create.id.should == 1
+          User.create.id.should eq 1
         end
       end
 
diff --git a/spec/database_cleaner/active_record/truncation/shared_fast_truncation.rb b/spec/database_cleaner/active_record/truncation/shared_fast_truncation.rb
index e0cdb52..2f2e9b3 100644
--- a/spec/database_cleaner/active_record/truncation/shared_fast_truncation.rb
+++ b/spec/database_cleaner/active_record/truncation/shared_fast_truncation.rb
@@ -14,7 +14,7 @@ shared_examples_for "an adapter with pre-count truncation" do
         User.delete_all
 
         connection.pre_count_truncate_tables(%w[users]) # true is also the default
-        User.create.id.should == 1
+        User.create.id.should eq 1
       end
     end
 
@@ -33,7 +33,7 @@ shared_examples_for "an adapter with pre-count truncation" do
 
         connection.pre_count_truncate_tables(%w[users], :reset_ids => false)
 
-        User.create.id.should == 3
+        User.create.id.should eq 3
       end
     end
   end
diff --git a/spec/database_cleaner/active_record/truncation_spec.rb b/spec/database_cleaner/active_record/truncation_spec.rb
index 05ae0cf..a672d03 100644
--- a/spec/database_cleaner/active_record/truncation_spec.rb
+++ b/spec/database_cleaner/active_record/truncation_spec.rb
@@ -121,16 +121,16 @@ module DatabaseCleaner
         end
 
         subject { Truncation.new }
-        its(:pre_count?) { should == false }
+        its(:pre_count?) { should eq false }
 
         it 'should return true if @reset_id is set and non false or nil' do
           subject.instance_variable_set(:"@pre_count", true)
-          subject.send(:pre_count?).should == true
+          subject.send(:pre_count?).should eq true
         end
 
         it 'should return false if @reset_id is set to false' do
           subject.instance_variable_set(:"@pre_count", false)
-          subject.send(:pre_count?).should == false
+          subject.send(:pre_count?).should eq false
         end
       end
 
@@ -142,16 +142,16 @@ module DatabaseCleaner
         end
 
         subject { Truncation.new }
-        its(:reset_ids?) { should == true }
+        its(:reset_ids?) { should eq true }
 
         it 'should return true if @reset_id is set and non false or nil' do
           subject.instance_variable_set(:"@reset_ids", 'Something')
-          subject.send(:reset_ids?).should == true
+          subject.send(:reset_ids?).should eq true
         end
 
         it 'should return false if @reset_id is set to false' do
           subject.instance_variable_set(:"@reset_ids", false)
-          subject.send(:reset_ids?).should == false
+          subject.send(:reset_ids?).should eq false
         end
       end
     end
diff --git a/spec/database_cleaner/base_spec.rb b/spec/database_cleaner/base_spec.rb
index 569e5f0..4d15108 100644
--- a/spec/database_cleaner/base_spec.rb
+++ b/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,21 +145,21 @@ 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
@@ -174,7 +174,7 @@ module DatabaseCleaner
 
         ::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
 
@@ -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
@@ -301,7 +301,7 @@ module DatabaseCleaner
       end
 
       it "should return the strategy" do
-        subject.clean_with( :strategy ).should == strategy
+        subject.clean_with( :strategy ).should eq strategy
       end
     end
 
@@ -321,7 +321,7 @@ module DatabaseCleaner
       end
 
       it "should return the strategy" do
-        subject.clean_with!( :strategy ).should == strategy
+        subject.clean_with!( :strategy ).should eq strategy
       end
     end
 
@@ -342,7 +342,7 @@ 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
 
@@ -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,21 +383,21 @@ 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 = 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
 
@@ -406,7 +406,7 @@ module DatabaseCleaner
 
       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,7 +419,7 @@ 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
@@ -508,7 +508,7 @@ module DatabaseCleaner
 
         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
diff --git a/spec/database_cleaner/configuration_spec.rb b/spec/database_cleaner/configuration_spec.rb
index e79b853..73f2bba 100644
--- a/spec/database_cleaner/configuration_spec.rb
+++ b/spec/database_cleaner/configuration_spec.rb
@@ -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
 
@@ -134,7 +134,7 @@ describe ::DatabaseCleaner do
       cleaner = double("cleaner").as_null_object
       ::DatabaseCleaner::Base.stub(:new).and_return(cleaner)
 
-      ::DatabaseCleaner.connections.should == [cleaner]
+      ::DatabaseCleaner.connections.should eq [cleaner]
     end
   end
 
@@ -229,9 +229,9 @@ 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
@@ -246,9 +246,9 @@ describe ::DatabaseCleaner do
 
         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
@@ -261,18 +261,18 @@ describe ::DatabaseCleaner do
       ::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
 
@@ -281,32 +281,32 @@ describe ::DatabaseCleaner do
 
     it "should return DatabaseCleaner::ActiveRecord for :active_record" do
       ::DatabaseCleaner::ActiveRecord = double("ar module") unless defined? ::DatabaseCleaner::ActiveRecord
-      subject.orm_module(:active_record).should == DatabaseCleaner::ActiveRecord
+      subject.orm_module(:active_record).should eq DatabaseCleaner::ActiveRecord
     end
 
     it "should return DatabaseCleaner::DataMapper for :data_mapper" do
       ::DatabaseCleaner::DataMapper = double("dm module") unless defined? ::DatabaseCleaner::DataMapper
-      subject.orm_module(:data_mapper).should == DatabaseCleaner::DataMapper
+      subject.orm_module(:data_mapper).should eq DatabaseCleaner::DataMapper
     end
 
     it "should return DatabaseCleaner::MongoMapper for :mongo_mapper" do
       ::DatabaseCleaner::MongoMapper = double("mm module") unless defined? ::DatabaseCleaner::MongoMapper
-      subject.orm_module(:mongo_mapper).should == DatabaseCleaner::MongoMapper
+      subject.orm_module(:mongo_mapper).should eq DatabaseCleaner::MongoMapper
     end
 
     it "should return DatabaseCleaner::Mongoid for :mongoid" do
       ::DatabaseCleaner::Mongoid = double("mongoid module") unless defined? ::DatabaseCleaner::Mongoid
-      subject.orm_module(:mongoid).should == DatabaseCleaner::Mongoid
+      subject.orm_module(:mongoid).should eq DatabaseCleaner::Mongoid
     end
 
     it "should return DatabaseCleaner::Mongo for :mongo" do
       ::DatabaseCleaner::Mongo = double("mongo module") unless defined? ::DatabaseCleaner::Mongo
-      subject.orm_module(:mongo).should == DatabaseCleaner::Mongo
+      subject.orm_module(:mongo).should eq DatabaseCleaner::Mongo
     end
 
     it "should return DatabaseCleaner::CouchPotato for :couch_potato" do
       ::DatabaseCleaner::CouchPotato = double("cp module") unless defined? ::DatabaseCleaner::CouchPotato
-      subject.orm_module(:couch_potato).should == DatabaseCleaner::CouchPotato
+      subject.orm_module(:couch_potato).should eq DatabaseCleaner::CouchPotato
     end
 
   end
diff --git a/spec/database_cleaner/data_mapper/base_spec.rb b/spec/database_cleaner/data_mapper/base_spec.rb
index 6f57ddb..cb15f4a 100644
--- a/spec/database_cleaner/data_mapper/base_spec.rb
+++ b/spec/database_cleaner/data_mapper/base_spec.rb
@@ -19,11 +19,11 @@ module DatabaseCleaner
 
       it "should store my desired db" do
         subject.db = :my_db
-        subject.db.should == :my_db
+        subject.db.should eq :my_db
       end
 
       it "should default to :default" do
-        subject.db.should == :default
+        subject.db.should eq :default
       end
     end
   end
diff --git a/spec/database_cleaner/generic/base_spec.rb b/spec/database_cleaner/generic/base_spec.rb
index ef3ee1e..f34da65 100644
--- a/spec/database_cleaner/generic/base_spec.rb
+++ b/spec/database_cleaner/generic/base_spec.rb
@@ -16,7 +16,7 @@ module ::DatabaseCleaner
 
       it_should_behave_like "a generic strategy"
 
-      its(:db) { should == :default }
+      its(:db) { should eq :default }
     end
   end
 end
diff --git a/spec/database_cleaner/generic/truncation_spec.rb b/spec/database_cleaner/generic/truncation_spec.rb
index 9e50650..c25fe23 100644
--- a/spec/database_cleaner/generic/truncation_spec.rb
+++ b/spec/database_cleaner/generic/truncation_spec.rb
@@ -57,40 +57,40 @@ module ::DatabaseCleaner
 
         context "" do
           subject { TruncationExample.new( { :only => ["something"] } ) }
-          its(:only)   { should == ["something"] }
-          its(:except) { should == [] }
+          its(:only)   { should eq ["something"] }
+          its(:except) { should eq [] }
         end
 
         context "" do
           subject { TruncationExample.new( { :except => ["something"] } ) }
-          its(:only)   { should == nil }
+          its(:only)   { should eq nil }
           its(:except) { should include("something") }
         end
 
         context "" do
           subject { TruncationExample.new( { :reset_ids => ["something"] } ) }
-          its(:reset_ids?) { should == true }
+          its(:reset_ids?) { should eq true }
         end
 
         context "" do
           subject { TruncationExample.new( { :reset_ids => nil } ) }
-          its(:reset_ids?) { should == false }
+          its(:reset_ids?) { should eq false }
         end
 
         context "" do
           subject { TruncationExample.new( { :pre_count => ["something"] } ) }
-          its(:pre_count?) { should == true }
+          its(:pre_count?) { should eq true }
         end
 
         context "" do
           subject { TruncationExample.new( { :pre_count => nil } ) }
-          its(:pre_count?) { should == false }
+          its(:pre_count?) { should eq false }
         end
 
         context "" do
           subject { MigrationExample.new }
-          its(:only)   { should == nil }
-          its(:except) { should == %w[migration_storage_name] }
+          its(:only)   { should eq nil }
+          its(:except) { should eq %w[migration_storage_name] }
         end
 
         context "" do
diff --git a/spec/database_cleaner/mongo_mapper/base_spec.rb b/spec/database_cleaner/mongo_mapper/base_spec.rb
index 11c0f05..9db2a8b 100644
--- a/spec/database_cleaner/mongo_mapper/base_spec.rb
+++ b/spec/database_cleaner/mongo_mapper/base_spec.rb
@@ -21,11 +21,11 @@ module DatabaseCleaner
 
         it "should store my desired db" do
           subject.db = :my_db
-          subject.db.should == :my_db
+          subject.db.should eq :my_db
         end
 
         it "should default to :default" do
-          subject.db.should == :default
+          subject.db.should eq :default
         end
       end
     end
diff --git a/spec/database_cleaner/ohm/truncation_spec.rb b/spec/database_cleaner/ohm/truncation_spec.rb
index d638b0a..0b21773 100644
--- a/spec/database_cleaner/ohm/truncation_spec.rb
+++ b/spec/database_cleaner/ohm/truncation_spec.rb
@@ -39,19 +39,19 @@ module DatabaseCleaner
       it "truncates all keys by default" do
         create_widget
         create_gadget
-        @redis.keys.size.should == 6
+        @redis.keys.size.should eq 6
         Truncation.new.clean
-        @redis.keys.size.should == 0
+        @redis.keys.size.should eq 0
       end
 
       context "when keys are provided to the :only option" do
         it "only truncates the specified keys" do
           create_widget
           create_gadget
-          @redis.keys.size.should == 6
+          @redis.keys.size.should eq 6
           Truncation.new(:only => ['*Widget*']).clean
-          @redis.keys.size.should == 3
-          @redis.get('DatabaseCleaner::Ohm::Gadget:id').should == '1'
+          @redis.keys.size.should eq 3
+          @redis.get('DatabaseCleaner::Ohm::Gadget:id').should eq '1'
         end
       end
 
@@ -59,10 +59,10 @@ module DatabaseCleaner
         it "truncates all but the specified keys" do
           create_widget
           create_gadget
-          @redis.keys.size.should == 6
+          @redis.keys.size.should eq 6
           Truncation.new(:except => ['*Widget*']).clean
-          @redis.keys.size.should == 3
-          @redis.get('DatabaseCleaner::Ohm::Widget:id').should == '1'
+          @redis.keys.size.should eq 3
+          @redis.get('DatabaseCleaner::Ohm::Widget:id').should eq '1'
         end
       end
     end
diff --git a/spec/database_cleaner/redis/base_spec.rb b/spec/database_cleaner/redis/base_spec.rb
index 89704e5..5b425f9 100644
--- a/spec/database_cleaner/redis/base_spec.rb
+++ b/spec/database_cleaner/redis/base_spec.rb
@@ -21,11 +21,11 @@ module DatabaseCleaner
       it "should store my describe db" do
         url = 'redis://localhost:6379/2'
         subject.db = 'redis://localhost:6379/2'
-        subject.db.should == url
+        subject.db.should eq url
       end
 
       it "should default to :default" do
-        subject.db.should == :default
+        subject.db.should eq :default
       end
     end
   end
diff --git a/spec/database_cleaner/redis/truncation_spec.rb b/spec/database_cleaner/redis/truncation_spec.rb
index 5406306..b179b77 100644
--- a/spec/database_cleaner/redis/truncation_spec.rb
+++ b/spec/database_cleaner/redis/truncation_spec.rb
@@ -31,19 +31,19 @@ module DatabaseCleaner
       it "truncates all keys by default" do
         create_widget
         create_gadget
-        @redis.keys.size.should == 2
+        @redis.keys.size.should eq 2
         Truncation.new.clean
-        @redis.keys.size.should == 0
+        @redis.keys.size.should eq 0
       end
 
       context "when keys are provided to the :only option" do
         it "only truncates the specified keys" do
           create_widget
           create_gadget
-          @redis.keys.size.should == 2
+          @redis.keys.size.should eq 2
           Truncation.new(:only => ['Widge*']).clean
-          @redis.keys.size.should == 1
-          @redis.get('Gadget').should == '1'
+          @redis.keys.size.should eq 1
+          @redis.get('Gadget').should eq '1'
         end
       end
 
@@ -51,10 +51,10 @@ module DatabaseCleaner
         it "truncates all but the specified keys" do
           create_widget
           create_gadget
-          @redis.keys.size.should == 2
+          @redis.keys.size.should eq 2
           Truncation.new(:except => ['Widg*']).clean
-          @redis.keys.size.should == 1
-          @redis.get('Widget').should == '1'
+          @redis.keys.size.should eq 1
+          @redis.get('Widget').should eq '1'
         end
       end
     end
diff --git a/spec/database_cleaner/sequel/base_spec.rb b/spec/database_cleaner/sequel/base_spec.rb
index 9d3da56..956afa8 100644
--- a/spec/database_cleaner/sequel/base_spec.rb
+++ b/spec/database_cleaner/sequel/base_spec.rb
@@ -20,12 +20,12 @@ module DatabaseCleaner
 
       it "should store my desired db" do
         subject.db = :my_db
-        subject.db.should == :my_db
+        subject.db.should eq :my_db
       end
 
       it "should default to :default" do
         pending "I figure out how to use Sequel and write some real tests for it..."
-        subject.db.should == :default
+        subject.db.should eq :default
       end
     end
   end