dump 1.0.3 → 1.0.4

data/spec/lib/dump_rake/env/filter_spec.rb

@@ -4,53 +4,53 @@ Filter = DumpRake::Env::Filter
 describe Filter do
   it "should pass everything if initialized with nil" do
     filter = Filter.new(nil)
-    filter.pass?('a').should be_true
-    filter.pass?('b').should be_true
-    filter.pass?('c').should be_true
-    filter.pass?('d').should be_true
+    expect(filter.pass?('a')).to be_truthy
+    expect(filter.pass?('b')).to be_truthy
+    expect(filter.pass?('c')).to be_truthy
+    expect(filter.pass?('d')).to be_truthy
   end
 
   it "should pass only specified values" do
     filter = Filter.new('a,c')
-    filter.pass?('a').should be_true
-    filter.pass?('b').should be_false
-    filter.pass?('c').should be_true
-    filter.pass?('d').should be_false
+    expect(filter.pass?('a')).to be_truthy
+    expect(filter.pass?('b')).to be_falsey
+    expect(filter.pass?('c')).to be_truthy
+    expect(filter.pass?('d')).to be_falsey
   end
 
   it "should not pass anything if initialized empty" do
     filter = Filter.new('')
-    filter.pass?('a').should be_false
-    filter.pass?('b').should be_false
-    filter.pass?('c').should be_false
-    filter.pass?('d').should be_false
+    expect(filter.pass?('a')).to be_falsey
+    expect(filter.pass?('b')).to be_falsey
+    expect(filter.pass?('c')).to be_falsey
+    expect(filter.pass?('d')).to be_falsey
   end
 
   describe "when initialized with -" do
     it "should pass everything except specified values" do
       filter = Filter.new('-a,c')
-      filter.pass?('a').should be_false
-      filter.pass?('b').should be_true
-      filter.pass?('c').should be_false
-      filter.pass?('d').should be_true
+      expect(filter.pass?('a')).to be_falsey
+      expect(filter.pass?('b')).to be_truthy
+      expect(filter.pass?('c')).to be_falsey
+      expect(filter.pass?('d')).to be_truthy
     end
 
     it "should pass everything if initialized empty" do
       filter = Filter.new('-')
-      filter.pass?('a').should be_true
-      filter.pass?('b').should be_true
-      filter.pass?('c').should be_true
-      filter.pass?('d').should be_true
+      expect(filter.pass?('a')).to be_truthy
+      expect(filter.pass?('b')).to be_truthy
+      expect(filter.pass?('c')).to be_truthy
+      expect(filter.pass?('d')).to be_truthy
     end
   end
 
   describe "custom_pass?" do
     it "should pass only when any call to block returns true" do
       filter = Filter.new('a,c')
-      filter.custom_pass?{ |value| value == 'a' }.should be_true
-      filter.custom_pass?{ |value| value == 'b' }.should be_false
-      filter.custom_pass?{ |value| value == 'c' }.should be_true
-      filter.custom_pass?{ |value| value == 'd' }.should be_false
+      expect(filter.custom_pass?{ |value| value == 'a' }).to be_truthy
+      expect(filter.custom_pass?{ |value| value == 'b' }).to be_falsey
+      expect(filter.custom_pass?{ |value| value == 'c' }).to be_truthy
+      expect(filter.custom_pass?{ |value| value == 'd' }).to be_falsey
     end
   end
 end

data/spec/lib/dump_rake/env_spec.rb

@@ -25,45 +25,45 @@ describe Env do
     it "should set env to new_value for duration of block" do
       ENV['LIKE'] = 'old_value'
 
-      ENV['LIKE'].should == 'old_value'
+      expect(ENV['LIKE']).to eq('old_value')
       Env.with_env('LIKE' => 'new_value') do
-        ENV['LIKE'].should == 'new_value'
+        expect(ENV['LIKE']).to eq('new_value')
       end
-      ENV['LIKE'].should == 'old_value'
+      expect(ENV['LIKE']).to eq('old_value')
     end
 
     it "should use dictionary" do
       ENV['LIKE'] = 'old_value'
 
-      ENV['LIKE'].should == 'old_value'
+      expect(ENV['LIKE']).to eq('old_value')
       Env.with_env(:like => 'new_value') do
-        ENV['LIKE'].should == 'new_value'
+        expect(ENV['LIKE']).to eq('new_value')
       end
-      ENV['LIKE'].should == 'old_value'
+      expect(ENV['LIKE']).to eq('old_value')
     end
   end
 
   describe "[]" do
     it "should mimic ENV" do
       ENV['VERSION'] = 'VERSION_value'
-      Env['VERSION'].should == ENV['VERSION']
+      expect(Env['VERSION']).to eq(ENV['VERSION'])
     end
 
     it "should return nil on non existing env variable" do
-      Env['DESCRIPTON'].should == nil
+      expect(Env['DESCRIPTON']).to eq(nil)
     end
 
     it "should get first value that is set" do
       ENV['VERSION'] = 'VERSION_value'
-      Env[:like].should == 'VERSION_value'
+      expect(Env[:like]).to eq('VERSION_value')
       ENV['VER'] = 'VER_value'
-      Env[:like].should == 'VER_value'
+      expect(Env[:like]).to eq('VER_value')
       ENV['LIKE'] = 'LIKE_value'
-      Env[:like].should == 'LIKE_value'
+      expect(Env[:like]).to eq('LIKE_value')
     end
 
     it "should return nil for unset variable" do
-      Env[:desc].should == nil
+      expect(Env[:desc]).to eq(nil)
     end
   end
 
@@ -75,15 +75,15 @@ describe Env do
     it "should return Filter" do
       ENV['TABLES'] = 'a,b,c'
       filter = Env.filter('TABLES')
-      filter.should be_instance_of(Env::Filter)
-      filter.invert.should be_false
-      filter.values.should == %w[a b c]
+      expect(filter).to be_instance_of(Env::Filter)
+      expect(filter.invert).to be_falsey
+      expect(filter.values).to eq(%w[a b c])
     end
 
     it "should cache created filter" do
       ENV['TABLES'] = 'a,b,c'
       ENV['TABLES2'] = 'a,b,c'
-      Env::Filter.should_receive(:new).with('a,b,c', nil).once
+      expect(Env::Filter).to receive(:new).with('a,b,c', nil).once
       Env.filter('TABLES')
       Env.filter('TABLES')
       Env.filter('TABLES2')
@@ -93,17 +93,17 @@ describe Env do
   describe "for_command" do
     describe "when no vars present" do
       it "should return empty hash for every command" do
-        Env.for_command(:create).should == {}
-        Env.for_command(:restore).should == {}
-        Env.for_command(:versions).should == {}
-        Env.for_command(:bad).should == {}
+        expect(Env.for_command(:create)).to eq({})
+        expect(Env.for_command(:restore)).to eq({})
+        expect(Env.for_command(:versions)).to eq({})
+        expect(Env.for_command(:bad)).to eq({})
       end
 
       it "should return empty hash for every command when asking for string keys" do
-        Env.for_command(:create, true).should == {}
-        Env.for_command(:restore, true).should == {}
-        Env.for_command(:versions, true).should == {}
-        Env.for_command(:bad, true).should == {}
+        expect(Env.for_command(:create, true)).to eq({})
+        expect(Env.for_command(:restore, true)).to eq({})
+        expect(Env.for_command(:versions, true)).to eq({})
+        expect(Env.for_command(:bad, true)).to eq({})
       end
     end
 
@@ -114,17 +114,17 @@ describe Env do
       end
 
       it "should return hash with symbol keys for every command" do
-        Env.for_command(:create).should == {:desc => 'Description'}
-        Env.for_command(:restore).should == {:like => 'Version'}
-        Env.for_command(:versions).should == {:like => 'Version'}
-        Env.for_command(:bad).should == {}
+        expect(Env.for_command(:create)).to eq({:desc => 'Description'})
+        expect(Env.for_command(:restore)).to eq({:like => 'Version'})
+        expect(Env.for_command(:versions)).to eq({:like => 'Version'})
+        expect(Env.for_command(:bad)).to eq({})
       end
 
       it "should return hash with symbol keys for every command when asking for string keys" do
-        Env.for_command(:create, true).should == {'DESC' => 'Description'}
-        Env.for_command(:restore, true).should == {'LIKE' => 'Version'}
-        Env.for_command(:versions, true).should == {'LIKE' => 'Version'}
-        Env.for_command(:bad, true).should == {}
+        expect(Env.for_command(:create, true)).to eq({'DESC' => 'Description'})
+        expect(Env.for_command(:restore, true)).to eq({'LIKE' => 'Version'})
+        expect(Env.for_command(:versions, true)).to eq({'LIKE' => 'Version'})
+        expect(Env.for_command(:bad, true)).to eq({})
       end
     end
   end
@@ -133,7 +133,7 @@ describe Env do
     it "should convert keys to strings" do
       @env = {:desc => 'text', :tags => 'a b c', 'LEAVE' => 'none', 'OTHER' => 'data'}
       Env.stringify!(@env)
-      @env.should == {'DESC' => 'text', 'TAGS' => 'a b c', 'LEAVE' => 'none', 'OTHER' => 'data'}
+      expect(@env).to eq({'DESC' => 'text', 'TAGS' => 'a b c', 'LEAVE' => 'none', 'OTHER' => 'data'})
     end
   end
 end

data/spec/lib/dump_rake/rails_root_spec.rb

@@ -17,7 +17,7 @@ end
 describe 'RailsRoot' do
   before do
     @root = double('root')
-    @root.should_receive(:to_s).and_return(@root)
+    expect(@root).to receive(:to_s).and_return(@root)
   end
 
   temp_remove_const Object, :Rails
@@ -26,20 +26,20 @@ describe 'RailsRoot' do
 
   it "should use Rails if it is present" do
     Object.const_set('Rails', double('rails'))
-    Rails.should_receive(:root).and_return(@root)
+    expect(Rails).to receive(:root).and_return(@root)
     load 'dump_rake/rails_root.rb'
-    DumpRake::RailsRoot.should === @root
+    expect(DumpRake::RailsRoot).to be === @root
   end
 
   it "should use RAILS_ROOT if it is present" do
     Object.const_set('RAILS_ROOT', @root)
     load 'dump_rake/rails_root.rb'
-    DumpRake::RailsRoot.should === @root
+    expect(DumpRake::RailsRoot).to be === @root
   end
 
   it "should use Dir.pwd else" do
-    Dir.should_receive(:pwd).and_return(@root)
+    expect(Dir).to receive(:pwd).and_return(@root)
     load 'dump_rake/rails_root.rb'
-    DumpRake::RailsRoot.should === @root
+    expect(DumpRake::RailsRoot).to be === @root
   end
 end

data/spec/lib/dump_rake/table_manipulation_spec.rb

@@ -8,126 +8,126 @@ describe TableManipulation do
 
   describe "schema_tables" do
     it "should return schema_tables" do
-      schema_tables.should == %w[schema_info schema_migrations]
+      expect(schema_tables).to eq(%w[schema_info schema_migrations])
     end
   end
 
   describe "verify_connection" do
     it "should return result of ActiveRecord::Base.connection.verify!" do
-      ActiveRecord::Base.connection.should_receive(:verify!).and_return(:result)
-      verify_connection.should == :result
+      expect(ActiveRecord::Base.connection).to receive(:verify!).and_return(:result)
+      expect(verify_connection).to eq(:result)
     end
   end
 
   describe "quote_table_name" do
     it "should return result of ActiveRecord::Base.connection.quote_table_name" do
-      ActiveRecord::Base.connection.should_receive(:quote_table_name).with('first').and_return('`first`')
-      quote_table_name('first').should == '`first`'
+      expect(ActiveRecord::Base.connection).to receive(:quote_table_name).with('first').and_return('`first`')
+      expect(quote_table_name('first')).to eq('`first`')
     end
   end
 
   describe "quote_column_name" do
     it "should return result of ActiveRecord::Base.connection.quote_column_name" do
-      ActiveRecord::Base.connection.should_receive(:quote_column_name).with('first').and_return('`first`')
-      quote_column_name('first').should == '`first`'
+      expect(ActiveRecord::Base.connection).to receive(:quote_column_name).with('first').and_return('`first`')
+      expect(quote_column_name('first')).to eq('`first`')
     end
   end
 
   describe "quote_value" do
     it "should return result of ActiveRecord::Base.connection.quote_value" do
-      ActiveRecord::Base.connection.should_receive(:quote).with('first').and_return('`first`')
-      quote_value('first').should == '`first`'
+      expect(ActiveRecord::Base.connection).to receive(:quote).with('first').and_return('`first`')
+      expect(quote_value('first')).to eq('`first`')
     end
   end
 
 
   describe "clear_table" do
     it "should call ActiveRecord::Base.connection.delete with sql for deleting everything from table" do
-      ActiveRecord::Base.connection.should_receive(:delete).with('DELETE FROM `first`', anything)
+      expect(ActiveRecord::Base.connection).to receive(:delete).with('DELETE FROM `first`', anything)
       clear_table('`first`')
     end
   end
 
   describe "insert_into_table" do
     it "should call ActiveRecord::Base.connection.insert with sql for insert if values is string" do
-      ActiveRecord::Base.connection.should_receive(:insert).with("INSERT INTO `table` (`c1`,`c2`) VALUES (`v1`,`v2`)", anything)
+      expect(ActiveRecord::Base.connection).to receive(:insert).with("INSERT INTO `table` (`c1`,`c2`) VALUES (`v1`,`v2`)", anything)
       insert_into_table('`table`', '(`c1`,`c2`)', '(`v1`,`v2`)')
     end
 
     it "should call ActiveRecord::Base.connection.insert with sql for insert if values is array" do
-      ActiveRecord::Base.connection.should_receive(:insert).with("INSERT INTO `table` (`c1`,`c2`) VALUES (`v11`,`v12`),(`v21`,`v22`)", anything)
+      expect(ActiveRecord::Base.connection).to receive(:insert).with("INSERT INTO `table` (`c1`,`c2`) VALUES (`v11`,`v12`),(`v21`,`v22`)", anything)
       insert_into_table('`table`', '(`c1`,`c2`)', ['(`v11`,`v12`)', '(`v21`,`v22`)'])
     end
   end
 
   describe "join_for_sql" do
     it "should convert array ['`a`', '`b`'] to \"(`a`,`b`)\"" do
-      join_for_sql(%w[`a` `b`]).should == '(`a`,`b`)'
+      expect(join_for_sql(%w[`a` `b`])).to eq('(`a`,`b`)')
     end
   end
 
   describe "columns_insert_sql" do
     it "should return columns sql part for insert" do
-      should_receive(:quote_column_name).with('a').and_return('`a`')
-      should_receive(:quote_column_name).with('b').and_return('`b`')
+      expect(self).to receive(:quote_column_name).with('a').and_return('`a`')
+      expect(self).to receive(:quote_column_name).with('b').and_return('`b`')
 
-      columns_insert_sql(%w[a b]).should == '(`a`,`b`)'
+      expect(columns_insert_sql(%w[a b])).to eq('(`a`,`b`)')
     end
   end
 
   describe "values_insert_sql" do
     it "should return values sql part for insert" do
-      should_receive(:quote_value).with('a').and_return('`a`')
-      should_receive(:quote_value).with('b').and_return('`b`')
+      expect(self).to receive(:quote_value).with('a').and_return('`a`')
+      expect(self).to receive(:quote_value).with('b').and_return('`b`')
 
-      values_insert_sql(%w[a b]).should == '(`a`,`b`)'
+      expect(values_insert_sql(%w[a b])).to eq('(`a`,`b`)')
     end
   end
 
 
   describe "tables_to_dump" do
     it "should call ActiveRecord::Base.connection.tables" do
-      ActiveRecord::Base.connection.should_receive(:tables).and_return([])
+      expect(ActiveRecord::Base.connection).to receive(:tables).and_return([])
       tables_to_dump
     end
 
     it "should exclude sessions table from result" do
-      ActiveRecord::Base.connection.should_receive(:tables).and_return(%w[first second schema_info schema_migrations sessions])
-      tables_to_dump.should == %w[first second schema_info schema_migrations]
+      expect(ActiveRecord::Base.connection).to receive(:tables).and_return(%w[first second schema_info schema_migrations sessions])
+      expect(tables_to_dump).to eq(%w[first second schema_info schema_migrations])
     end
 
     describe "with user defined tables" do
       before do
-        ActiveRecord::Base.connection.should_receive(:tables).and_return(%w[first second schema_info schema_migrations sessions])
+        expect(ActiveRecord::Base.connection).to receive(:tables).and_return(%w[first second schema_info schema_migrations sessions])
       end
 
       it "should select certain tables" do
         DumpRake::Env.with_env(:tables => 'first,third,-fifth') do
-          tables_to_dump.should == %w[first schema_info schema_migrations]
+          expect(tables_to_dump).to eq(%w[first schema_info schema_migrations])
         end
       end
 
       it "should select skip certain tables" do
         DumpRake::Env.with_env(:tables => '-first,third,-fifth') do
-          tables_to_dump.should == %w[second schema_info schema_migrations sessions]
+          expect(tables_to_dump).to eq(%w[second schema_info schema_migrations sessions])
         end
       end
 
       it "should not exclude sessions table from result if asked to exclude nothing" do
         DumpRake::Env.with_env(:tables => '-') do
-          tables_to_dump.should == %w[first second schema_info schema_migrations sessions]
+          expect(tables_to_dump).to eq(%w[first second schema_info schema_migrations sessions])
         end
       end
 
       it "should not exclude schema tables" do
         DumpRake::Env.with_env(:tables => '-second,schema_info,schema_migrations') do
-          tables_to_dump.should == %w[first schema_info schema_migrations sessions]
+          expect(tables_to_dump).to eq(%w[first schema_info schema_migrations sessions])
         end
       end
 
       it "should not exclude schema tables ever if asked to dump only certain tables" do
         DumpRake::Env.with_env(:tables => 'second') do
-          tables_to_dump.should == %w[second schema_info schema_migrations]
+          expect(tables_to_dump).to eq(%w[second schema_info schema_migrations])
         end
       end
     end
@@ -135,65 +135,65 @@ describe TableManipulation do
 
   describe "table_row_count" do
     it "should ruturn row count for table" do
-      ActiveRecord::Base.connection.should_receive(:select_value).with("SELECT COUNT(*) FROM #{quote_table_name('first')}").and_return('666')
-      table_row_count('first').should == 666
+      expect(ActiveRecord::Base.connection).to receive(:select_value).with("SELECT COUNT(*) FROM #{quote_table_name('first')}").and_return('666')
+      expect(table_row_count('first')).to eq(666)
     end
   end
 
   describe "table_chunk_size" do
     it "should return chunk_size based on estimated average for row size" do
-      should_receive(:table_columns).with('first').and_return(
+      expect(self).to receive(:table_columns).with('first').and_return(
         [double(:column, :type => :integer, :limit => nil)] * 3 +
         [double(:column, :type => :string, :limit => nil)] * 3 +
         [double(:column, :type => :text, :limit => nil)]
       )
-      table_chunk_size('first').should satisfy { |n|
+      expect(table_chunk_size('first')).to satisfy { |n|
         (TableManipulation::CHUNK_SIZE_MIN..TableManipulation::CHUNK_SIZE_MAX).include?(n)
       }
     end
 
     it "should not return value less than CHUNK_SIZE_MIN" do
-      should_receive(:table_columns).with('first').and_return(
+      expect(self).to receive(:table_columns).with('first').and_return(
         [double(:column, :type => :text, :limit => nil)] * 100
       )
-      table_chunk_size('first').should == TableManipulation::CHUNK_SIZE_MIN
+      expect(table_chunk_size('first')).to eq(TableManipulation::CHUNK_SIZE_MIN)
     end
 
     it "should not return value more than CHUNK_SIZE_MAX" do
-      should_receive(:table_columns).with('first').and_return(
+      expect(self).to receive(:table_columns).with('first').and_return(
         [double(:column, :type => :boolean, :limit => 1)] * 10
       )
-      table_chunk_size('first').should == TableManipulation::CHUNK_SIZE_MAX
+      expect(table_chunk_size('first')).to eq(TableManipulation::CHUNK_SIZE_MAX)
     end
   end
 
   describe "table_columns" do
     it "should return table column definitions" do
       columns = [double(:column), double(:column), double(:column)]
-      ActiveRecord::Base.connection.should_receive(:columns).with('first').and_return(columns)
-      table_columns('first').should == columns
+      expect(ActiveRecord::Base.connection).to receive(:columns).with('first').and_return(columns)
+      expect(table_columns('first')).to eq(columns)
     end
   end
 
   describe "table_has_primary_column?" do
     it "should return true only if table has column with name id and type :integer" do
-      should_receive(:table_primary_key).at_least(3).times.and_return('id')
+      expect(self).to receive(:table_primary_key).at_least(3).times.and_return('id')
 
-      should_receive(:table_columns).with('first').and_return([double(:column, :name => 'id', :type => :integer), double(:column, :name => 'title', :type => :integer)])
-      table_has_primary_column?('first').should be_true
+      expect(self).to receive(:table_columns).with('first').and_return([double(:column, :name => 'id', :type => :integer), double(:column, :name => 'title', :type => :integer)])
+      expect(table_has_primary_column?('first')).to be_truthy
 
-      should_receive(:table_columns).with('second').and_return([double(:column, :name => 'id', :type => :string), double(:column, :name => 'title', :type => :integer)])
-      table_has_primary_column?('second').should be_false
+      expect(self).to receive(:table_columns).with('second').and_return([double(:column, :name => 'id', :type => :string), double(:column, :name => 'title', :type => :integer)])
+      expect(table_has_primary_column?('second')).to be_falsey
 
-      should_receive(:table_columns).with('third').and_return([double(:column, :name => 'name', :type => :integer), double(:column, :name => 'title', :type => :integer)])
-      table_has_primary_column?('third').should be_false
+      expect(self).to receive(:table_columns).with('third').and_return([double(:column, :name => 'name', :type => :integer), double(:column, :name => 'title', :type => :integer)])
+      expect(table_has_primary_column?('third')).to be_falsey
     end
   end
 
   describe "table_primary_key" do
     it "should return id" do
-      table_primary_key('first').should == 'id'
-      table_primary_key(nil).should == 'id'
+      expect(table_primary_key('first')).to eq('id')
+      expect(table_primary_key(nil)).to eq('id')
     end
   end
 
@@ -206,42 +206,42 @@ describe TableManipulation do
     def verify_getting_rows
       i = 0
       each_table_row('first', @row_count) do |row|
-        row.should == {'id' => "#{i + 1}"}
+        expect(row).to eq({'id' => "#{i + 1}"})
         i += 1
       end
-      i.should == @row_count
+      expect(i).to eq(@row_count)
     end
 
     it "should get rows in chunks if table has primary column and chunk size is less than row count" do
-      should_receive(:table_has_primary_column?).with('first').and_return(true)
-      should_receive(:table_chunk_size).with('first').and_return(100)
+      expect(self).to receive(:table_has_primary_column?).with('first').and_return(true)
+      expect(self).to receive(:table_chunk_size).with('first').and_return(100)
       quoted_table_name = quote_table_name('first')
       quoted_primary_key = "#{quoted_table_name}.#{quote_column_name(table_primary_key('first'))}"
       sql = "SELECT * FROM #{quoted_table_name} WHERE #{quoted_primary_key} %s ORDER BY #{quoted_primary_key} ASC LIMIT 100"
 
-      should_receive(:select_all_by_sql).with(sql % '>= 0').and_return(@rows[0, 100])
+      expect(self).to receive(:select_all_by_sql).with(sql % '>= 0').and_return(@rows[0, 100])
       5.times do |i|
         last_primary_key = 100 + i * 100
-        should_receive(:select_all_by_sql).with(sql % "> #{last_primary_key}").and_return(@rows[last_primary_key, 100])
+        expect(self).to receive(:select_all_by_sql).with(sql % "> #{last_primary_key}").and_return(@rows[last_primary_key, 100])
       end
 
       verify_getting_rows
     end
 
     def verify_getting_rows_in_one_pass
-      should_receive(:select_all_by_sql).with("SELECT * FROM #{quote_table_name('first')}").and_return(@rows)
+      expect(self).to receive(:select_all_by_sql).with("SELECT * FROM #{quote_table_name('first')}").and_return(@rows)
       verify_getting_rows
     end
 
     it "should get rows in one pass if table has primary column but chunk size is not less than row count" do
-      should_receive(:table_has_primary_column?).with('first').and_return(true)
-      should_receive(:table_chunk_size).with('first').and_return(3_000)
+      expect(self).to receive(:table_has_primary_column?).with('first').and_return(true)
+      expect(self).to receive(:table_chunk_size).with('first').and_return(3_000)
       verify_getting_rows_in_one_pass
     end
 
     it "should get rows in one pass if table has no primary column" do
-      should_receive(:table_has_primary_column?).with('first').and_return(false)
-      should_not_receive(:table_chunk_size)
+      expect(self).to receive(:table_has_primary_column?).with('first').and_return(false)
+      expect(self).to_not receive(:table_chunk_size)
       verify_getting_rows_in_one_pass
     end
   end
@@ -249,8 +249,8 @@ describe TableManipulation do
   describe "select_all_by_sql" do
     it "should return all rows returned by database" do
       rows = [double(:row), double(:row), double(:row)]
-      ActiveRecord::Base.connection.should_receive(:select_all).with("SELECT * FROM abc WHERE x = y").and_return(rows)
-      select_all_by_sql("SELECT * FROM abc WHERE x = y").should == rows
+      expect(ActiveRecord::Base.connection).to receive(:select_all).with("SELECT * FROM abc WHERE x = y").and_return(rows)
+      expect(select_all_by_sql("SELECT * FROM abc WHERE x = y")).to eq(rows)
     end
   end
 end