dump 1.0.3 → 1.0.4

data/spec/lib/dump_rake/dump_spec.rb

@@ -15,9 +15,9 @@ describe DumpRake::Dump do
     end
 
     it "should not yield if file does not exist" do
-      @yield_receiver.should_not_receive(:fire)
+      expect(@yield_receiver).not_to receive(:fire)
 
-      File.should_receive(:open).and_return(nil)
+      expect(File).to receive(:open).and_return(nil)
 
       DumpRake::Dump.new('hello').lock do
         @yield_receiver.fire
@@ -25,13 +25,13 @@ describe DumpRake::Dump do
     end
 
     it "should not yield if file can not be locked" do
-      @yield_receiver.should_not_receive(:fire)
+      expect(@yield_receiver).not_to receive(:fire)
 
       @file = double('file')
-      @file.should_receive(:flock).with(File::LOCK_EX | File::LOCK_NB).and_return(nil)
-      @file.should_receive(:flock).with(File::LOCK_UN)
-      @file.should_receive(:close)
-      File.should_receive(:open).and_return(@file)
+      expect(@file).to receive(:flock).with(File::LOCK_EX | File::LOCK_NB).and_return(nil)
+      expect(@file).to receive(:flock).with(File::LOCK_UN)
+      expect(@file).to receive(:close)
+      expect(File).to receive(:open).and_return(@file)
 
       DumpRake::Dump.new('hello').lock do
         @yield_receiver.fire
@@ -39,13 +39,13 @@ describe DumpRake::Dump do
     end
 
     it "should yield if file can not be locked" do
-      @yield_receiver.should_receive(:fire)
+      expect(@yield_receiver).to receive(:fire)
 
       @file = double('file')
-      @file.should_receive(:flock).with(File::LOCK_EX | File::LOCK_NB).and_return(true)
-      @file.should_receive(:flock).with(File::LOCK_UN)
-      @file.should_receive(:close)
-      File.should_receive(:open).and_return(@file)
+      expect(@file).to receive(:flock).with(File::LOCK_EX | File::LOCK_NB).and_return(true)
+      expect(@file).to receive(:flock).with(File::LOCK_UN)
+      expect(@file).to receive(:close)
+      expect(File).to receive(:open).and_return(@file)
 
       DumpRake::Dump.new('hello').lock do
         @yield_receiver.fire
@@ -55,39 +55,39 @@ describe DumpRake::Dump do
 
   describe "new" do
     it "should init with path if String sent" do
-      DumpRake::Dump.new('hello').path.should == Pathname('hello')
+      expect(DumpRake::Dump.new('hello').path).to eq(Pathname('hello'))
     end
 
     it "should init with path if Pathname sent" do
-      DumpRake::Dump.new(Pathname('hello')).path.should == Pathname('hello')
+      expect(DumpRake::Dump.new(Pathname('hello')).path).to eq(Pathname('hello'))
     end
 
     describe "with options" do
       before do
         @time = double('time')
-        @time.stub(:utc).and_return(@time)
-        @time.stub(:strftime).and_return('19650414065945')
-        Time.stub(:now).and_return(@time)
+        allow(@time).to receive(:utc).and_return(@time)
+        allow(@time).to receive(:strftime).and_return('19650414065945')
+        allow(Time).to receive(:now).and_return(@time)
       end
 
       it "should generate path with no options" do
-        DumpRake::Dump.new.path.should == Pathname('19650414065945.tgz')
+        expect(DumpRake::Dump.new.path).to eq(Pathname('19650414065945.tgz'))
       end
 
       it "should generate with dir" do
-        DumpRake::Dump.new(:dir => 'dump_dir').path.should == Pathname('dump_dir/19650414065945.tgz')
+        expect(DumpRake::Dump.new(:dir => 'dump_dir').path).to eq(Pathname('dump_dir/19650414065945.tgz'))
       end
 
       it "should generate path with description" do
-        DumpRake::Dump.new(:dir => 'dump_dir', :desc => 'hello world').path.should == Pathname('dump_dir/19650414065945-hello world.tgz')
+        expect(DumpRake::Dump.new(:dir => 'dump_dir', :desc => 'hello world').path).to eq(Pathname('dump_dir/19650414065945-hello world.tgz'))
       end
 
       it "should generate path with tags" do
-        DumpRake::Dump.new(:dir => 'dump_dir', :tags => ' mirror, hello world ').path.should == Pathname('dump_dir/19650414065945@hello world,mirror.tgz')
+        expect(DumpRake::Dump.new(:dir => 'dump_dir', :tags => ' mirror, hello world ').path).to eq(Pathname('dump_dir/19650414065945@hello world,mirror.tgz'))
       end
 
       it "should generate path with description and tags" do
-        DumpRake::Dump.new(:dir => 'dump_dir', :desc => 'Anniversary backup', :tags => ' mirror, hello world ').path.should == Pathname('dump_dir/19650414065945-Anniversary backup@hello world,mirror.tgz')
+        expect(DumpRake::Dump.new(:dir => 'dump_dir', :desc => 'Anniversary backup', :tags => ' mirror, hello world ').path).to eq(Pathname('dump_dir/19650414065945-Anniversary backup@hello world,mirror.tgz'))
       end
     end
   end
@@ -97,25 +97,25 @@ describe DumpRake::Dump do
       def stub_glob
         paths = %w[123 345 567].map do |name|
           path = dump_path("#{name}.tgz")
-          File.should_receive(:file?).with(path).at_least(1).and_return(true)
+          expect(File).to receive(:file?).with(path).at_least(1).and_return(true)
           path
         end
-        Dir.stub(:[]).and_return(paths)
+        allow(Dir).to receive(:[]).and_return(paths)
       end
 
       it "should search for files in dump dir when asked for list" do
-        Dir.should_receive(:[]).with(dump_path('*.tgz')).and_return([])
+        expect(Dir).to receive(:[]).with(dump_path('*.tgz')).and_return([])
         DumpRake::Dump.list
       end
 
       it "should return selves instances for each found file" do
         stub_glob
-        DumpRake::Dump.list.all?{ |dump| dump.should be_a(DumpRake::Dump) }
+        DumpRake::Dump.list.all?{ |dump| expect(dump).to be_a(DumpRake::Dump) }
       end
 
       it "should return dumps with name containting :like" do
         stub_glob
-        DumpRake::Dump.list(:like => '3').should == DumpRake::Dump.list.values_at(0, 1)
+        expect(DumpRake::Dump.list(:like => '3')).to eq(DumpRake::Dump.list.values_at(0, 1))
       end
     end
 
@@ -125,14 +125,14 @@ describe DumpRake::Dump do
         dumps_tags = [''] + %w[a  a,d  a,d,o  a,d,s  a,d,s,o  a,o  a,s  a,s,o  d  d,o  d,s  d,s,o  o  s  s,o  z]
         paths = dumps_tags.each_with_index.map do |dump_tags, i|
           path = dump_path("196504140659#{10 + i}@#{dump_tags}.tgz")
-          File.should_receive(:file?).with(path).at_least(1).and_return(true)
+          expect(File).to receive(:file?).with(path).at_least(1).and_return(true)
           path
         end
-        Dir.stub(:[]).and_return(paths)
+        allow(Dir).to receive(:[]).and_return(paths)
       end
 
       it "should return all dumps if no tags send" do
-        DumpRake::Dump.list(:tags => '').should == DumpRake::Dump.list
+        expect(DumpRake::Dump.list(:tags => '')).to eq(DumpRake::Dump.list)
       end
 
       {
@@ -147,7 +147,7 @@ describe DumpRake::Dump do
         '+d,+a'          => [2, 3, 4, 5],
       }.each do |tags, ids|
         it "should return dumps filtered by #{tags}" do
-          DumpRake::Dump.list(:tags => tags).should == DumpRake::Dump.list.values_at(*ids)
+          expect(DumpRake::Dump.list(:tags => tags)).to eq(DumpRake::Dump.list.values_at(*ids))
         end
       end
     end
@@ -155,7 +155,7 @@ describe DumpRake::Dump do
 
   describe "name" do
     it "should return file name" do
-      new_dump("19650414065945.tgz").name.should == '19650414065945.tgz'
+      expect(new_dump("19650414065945.tgz").name).to eq('19650414065945.tgz')
     end
   end
 
@@ -171,121 +171,121 @@ describe DumpRake::Dump do
 
     %w[tmp tgz].each do |ext|
       it "should return empty results for dump with wrong name" do
-        dump_name_parts("196504140659.#{ext}").should == [nil, '', [], nil]
-        dump_name_parts("196504140659-lala.#{ext}").should == [nil, '', [], nil]
-        dump_name_parts("196504140659@lala.#{ext}").should == [nil, '', [], nil]
-        dump_name_parts("19650414065945.ops").should == [nil, '', [], nil]
+        expect(dump_name_parts("196504140659.#{ext}")).to eq([nil, '', [], nil])
+        expect(dump_name_parts("196504140659-lala.#{ext}")).to eq([nil, '', [], nil])
+        expect(dump_name_parts("196504140659@lala.#{ext}")).to eq([nil, '', [], nil])
+        expect(dump_name_parts("19650414065945.ops")).to eq([nil, '', [], nil])
       end
 
       it "should return tags for dump with tags" do
-        dump_name_parts("19650414065945.#{ext}").should == [@time, '', [], ext]
-        dump_name_parts("19650414065945- Hello world &&& .#{ext}").should == [@time, 'Hello world _', [], ext]
-        dump_name_parts("19650414065945- Hello world &&& @ test , hello world , bad tag ~~~~.#{ext}").should == [@time, 'Hello world _', ['bad tag _', 'hello world', 'test'], ext]
-        dump_name_parts("19650414065945@test, test , hello world , bad tag ~~~~.#{ext}").should == [@time, '', ['bad tag _', 'hello world', 'test'], ext]
-        dump_name_parts("19650414065945-Hello world@test,super tag.#{ext}").should == [@time, 'Hello world', ['super tag', 'test'], ext]
+        expect(dump_name_parts("19650414065945.#{ext}")).to eq([@time, '', [], ext])
+        expect(dump_name_parts("19650414065945- Hello world &&& .#{ext}")).to eq([@time, 'Hello world _', [], ext])
+        expect(dump_name_parts("19650414065945- Hello world &&& @ test , hello world , bad tag ~~~~.#{ext}")).to eq([@time, 'Hello world _', ['bad tag _', 'hello world', 'test'], ext])
+        expect(dump_name_parts("19650414065945@test, test , hello world , bad tag ~~~~.#{ext}")).to eq([@time, '', ['bad tag _', 'hello world', 'test'], ext])
+        expect(dump_name_parts("19650414065945-Hello world@test,super tag.#{ext}")).to eq([@time, 'Hello world', ['super tag', 'test'], ext])
       end
     end
   end
 
   describe "path" do
     it "should return path" do
-      new_dump("19650414065945.tgz").path.should == Pathname(File.join(DumpRake::RailsRoot, 'dump', "19650414065945.tgz"))
+      expect(new_dump("19650414065945.tgz").path).to eq(Pathname(File.join(DumpRake::RailsRoot, 'dump', "19650414065945.tgz")))
     end
   end
 
   describe "tgz_path" do
     it "should return path if extension is already tgz" do
-      new_dump("19650414065945.tgz").tgz_path.should == new_dump("19650414065945.tgz").path
+      expect(new_dump("19650414065945.tgz").tgz_path).to eq(new_dump("19650414065945.tgz").path)
     end
 
     it "should return path with tgz extension" do
-      new_dump("19650414065945.tmp").tgz_path.should == new_dump("19650414065945.tgz").path
+      expect(new_dump("19650414065945.tmp").tgz_path).to eq(new_dump("19650414065945.tgz").path)
     end
   end
 
   describe "tmp_path" do
     it "should return path if extension is already tmp" do
-      new_dump("19650414065945.tmp").tmp_path.should == new_dump("19650414065945.tmp").path
+      expect(new_dump("19650414065945.tmp").tmp_path).to eq(new_dump("19650414065945.tmp").path)
     end
 
     it "should return path with tmp extension" do
-      new_dump("19650414065945.tgz").tmp_path.should == new_dump("19650414065945.tmp").path
+      expect(new_dump("19650414065945.tgz").tmp_path).to eq(new_dump("19650414065945.tmp").path)
     end
   end
 
   describe "clean_description" do
     it "should shorten string to 50 chars and replace special symblos with '-'" do
-      DumpRake::Dump.new('').send(:clean_description, 'Special  Dump #12837192837 (before fixind *&^*&^ photos)').should == 'Special Dump #12837192837 (before fixind _ photos)'
-      DumpRake::Dump.new('').send(:clean_description, "To#{'o' * 100} long description").should == "T#{'o' * 49}"
+      expect(DumpRake::Dump.new('').send(:clean_description, 'Special  Dump #12837192837 (before fixind *&^*&^ photos)')).to eq('Special Dump #12837192837 (before fixind _ photos)')
+      expect(DumpRake::Dump.new('').send(:clean_description, "To#{'o' * 100} long description")).to eq("T#{'o' * 49}")
     end
 
     it "should accept non string" do
-      DumpRake::Dump.new('').send(:clean_description, nil).should == ''
+      expect(DumpRake::Dump.new('').send(:clean_description, nil)).to eq('')
     end
   end
 
   describe "clean_tag" do
     it "should shorten string to 20 chars and replace special symblos with '-'" do
-      DumpRake::Dump.new('').send(:clean_tag, 'Very special  tag #12837192837 (fixind *&^*&^)').should == 'very special tag _12'
-      DumpRake::Dump.new('').send(:clean_tag, "To#{'o' * 100} long tag").should == "t#{'o' * 19}"
+      expect(DumpRake::Dump.new('').send(:clean_tag, 'Very special  tag #12837192837 (fixind *&^*&^)')).to eq('very special tag _12')
+      expect(DumpRake::Dump.new('').send(:clean_tag, "To#{'o' * 100} long tag")).to eq("t#{'o' * 19}")
     end
 
     it "should not allow '-' or '+' to be first symbol" do
-      DumpRake::Dump.new('').send(:clean_tag, ' Very special tag').should == 'very special tag'
-      DumpRake::Dump.new('').send(:clean_tag, '-Very special tag').should == 'very special tag'
-      DumpRake::Dump.new('').send(:clean_tag, '-----------').should == ''
-      DumpRake::Dump.new('').send(:clean_tag, '+Very special tag').should == '_very special tag'
-      DumpRake::Dump.new('').send(:clean_tag, '+++++++++++').should == '_'
+      expect(DumpRake::Dump.new('').send(:clean_tag, ' Very special tag')).to eq('very special tag')
+      expect(DumpRake::Dump.new('').send(:clean_tag, '-Very special tag')).to eq('very special tag')
+      expect(DumpRake::Dump.new('').send(:clean_tag, '-----------')).to eq('')
+      expect(DumpRake::Dump.new('').send(:clean_tag, '+Very special tag')).to eq('_very special tag')
+      expect(DumpRake::Dump.new('').send(:clean_tag, '+++++++++++')).to eq('_')
     end
 
     it "should accept non string" do
-      DumpRake::Dump.new('').send(:clean_tag, nil).should == ''
+      expect(DumpRake::Dump.new('').send(:clean_tag, nil)).to eq('')
     end
   end
 
   describe "clean_tags" do
     it "should split string and return uniq non blank sorted tags" do
-      DumpRake::Dump.new('').send(:clean_tags, ' perfect  tag , hello,Hello,this  is (*^(*&').should == ['hello', 'perfect tag', 'this is _']
-      DumpRake::Dump.new('').send(:clean_tags, "l#{'o' * 100}ng tag").should == ["l#{'o' * 19}"]
+      expect(DumpRake::Dump.new('').send(:clean_tags, ' perfect  tag , hello,Hello,this  is (*^(*&')).to eq(['hello', 'perfect tag', 'this is _'])
+      expect(DumpRake::Dump.new('').send(:clean_tags, "l#{'o' * 100}ng tag")).to eq(["l#{'o' * 19}"])
     end
 
     it "should accept non string" do
-      DumpRake::Dump.new('').send(:clean_tags, nil).should == []
+      expect(DumpRake::Dump.new('').send(:clean_tags, nil)).to eq([])
     end
   end
 
   describe "get_filter_tags" do
     it "should split string and return uniq non blank sorted tags" do
-      DumpRake::Dump.new('').send(:get_filter_tags, 'a,+b,+c,-d').should == {:simple => %w[a], :mandatory => %w[b c], :forbidden => %w[d]}
-      DumpRake::Dump.new('').send(:get_filter_tags, ' a , + b , + c , - d ').should == {:simple => %w[a], :mandatory => %w[b c], :forbidden => %w[d]}
-      DumpRake::Dump.new('').send(:get_filter_tags, ' a , + c , + b , - d ').should == {:simple => %w[a], :mandatory => %w[b c], :forbidden => %w[d]}
-      DumpRake::Dump.new('').send(:get_filter_tags, ' a , + b , + , - ').should == {:simple => %w[a], :mandatory => %w[b], :forbidden => []}
-      DumpRake::Dump.new('').send(:get_filter_tags, ' a , a , + b , + b , - d , - d ').should == {:simple => %w[a], :mandatory => %w[b], :forbidden => %w[d]}
-      proc{ DumpRake::Dump.new('').send(:get_filter_tags, 'a,+a') }.should_not raise_error
-      proc{ DumpRake::Dump.new('').send(:get_filter_tags, 'a,-a') }.should raise_error
-      proc{ DumpRake::Dump.new('').send(:get_filter_tags, '+a,-a') }.should raise_error
+      expect(DumpRake::Dump.new('').send(:get_filter_tags, 'a,+b,+c,-d')).to eq({:simple => %w[a], :mandatory => %w[b c], :forbidden => %w[d]})
+      expect(DumpRake::Dump.new('').send(:get_filter_tags, ' a , + b , + c , - d ')).to eq({:simple => %w[a], :mandatory => %w[b c], :forbidden => %w[d]})
+      expect(DumpRake::Dump.new('').send(:get_filter_tags, ' a , + c , + b , - d ')).to eq({:simple => %w[a], :mandatory => %w[b c], :forbidden => %w[d]})
+      expect(DumpRake::Dump.new('').send(:get_filter_tags, ' a , + b , + , - ')).to eq({:simple => %w[a], :mandatory => %w[b], :forbidden => []})
+      expect(DumpRake::Dump.new('').send(:get_filter_tags, ' a , a , + b , + b , - d , - d ')).to eq({:simple => %w[a], :mandatory => %w[b], :forbidden => %w[d]})
+      expect{ DumpRake::Dump.new('').send(:get_filter_tags, 'a,+a') }.not_to raise_error
+      expect{ DumpRake::Dump.new('').send(:get_filter_tags, 'a,-a') }.to raise_error
+      expect{ DumpRake::Dump.new('').send(:get_filter_tags, '+a,-a') }.to raise_error
     end
 
     it "should accept non string" do
-      DumpRake::Dump.new('').send(:get_filter_tags, nil).should == {:simple => [], :mandatory => [], :forbidden => []}
+      expect(DumpRake::Dump.new('').send(:get_filter_tags, nil)).to eq({:simple => [], :mandatory => [], :forbidden => []})
     end
   end
 
   describe "assets_root_link" do
     it "should create tem dir, chdir there, symlink rails app root to assets, yield and unlink assets ever if something raised" do
-      Dir.should_receive(:mktmpdir).and_yield('/tmp/abc')
-      Dir.should_receive(:chdir).with('/tmp/abc').and_yield
-      File.should_receive(:symlink).with(DumpRake::RailsRoot, 'assets')
-      File.should_receive(:unlink).with('assets')
-      proc{
+      expect(Dir).to receive(:mktmpdir).and_yield('/tmp/abc')
+      expect(Dir).to receive(:chdir).with('/tmp/abc').and_yield
+      expect(File).to receive(:symlink).with(DumpRake::RailsRoot, 'assets')
+      expect(File).to receive(:unlink).with('assets')
+      expect{
         DumpRake::Dump.new('').send(:assets_root_link) do |dir, prefix|
-          dir.should == '/tmp/abc'
-          prefix.should == 'assets'
+          expect(dir).to eq('/tmp/abc')
+          expect(prefix).to eq('assets')
           @yielded = true
           raise 'just test'
         end
-      }.should raise_error('just test')
-      @yielded.should == true
+      }.to raise_error('just test')
+      expect(@yielded).to eq(true)
     end
   end
 end

data/spec/lib/dump_rake/dump_writer_spec.rb

@@ -7,21 +7,21 @@ describe DumpWriter do
   describe "create" do
     it "should create selves instance and open" do
       @dump = double('dump')
-      @dump.should_receive(:open)
-      DumpWriter.should_receive(:new).with('/abc/123.tmp').and_return(@dump)
+      expect(@dump).to receive(:open)
+      expect(DumpWriter).to receive(:new).with('/abc/123.tmp').and_return(@dump)
       DumpWriter.create('/abc/123.tmp')
     end
 
     it "should call dump subroutines" do
       @dump = double('dump')
-      @dump.stub(:open).and_yield(@dump)
-      @dump.stub(:silence).and_yield
-      DumpWriter.stub(:new).and_return(@dump)
+      allow(@dump).to receive(:open).and_yield(@dump)
+      allow(@dump).to receive(:silence).and_yield
+      allow(DumpWriter).to receive(:new).and_return(@dump)
 
-      @dump.should_receive(:write_schema).ordered
-      @dump.should_receive(:write_tables).ordered
-      @dump.should_receive(:write_assets).ordered
-      @dump.should_receive(:write_config).ordered
+      expect(@dump).to receive(:write_schema).ordered
+      expect(@dump).to receive(:write_tables).ordered
+      expect(@dump).to receive(:write_assets).ordered
+      expect(@dump).to receive(:write_config).ordered
 
       DumpWriter.create('/abc/123.tmp')
     end
@@ -29,24 +29,24 @@ describe DumpWriter do
 
   describe "open" do
     it "should create dir for dump" do
-      Zlib::GzipWriter.stub(:open)
-      FileUtils.should_receive(:mkpath).with('/abc/def/ghi')
+      allow(Zlib::GzipWriter).to receive(:open)
+      expect(FileUtils).to receive(:mkpath).with('/abc/def/ghi')
       DumpWriter.new('/abc/def/ghi/123.tgz').open
     end
 
     it "should set stream to gzipped tar writer" do
-      FileUtils.stub(:mkpath)
+      allow(FileUtils).to receive(:mkpath)
       @gzip = double('gzip')
       @stream = double('stream')
-      Zlib::GzipWriter.should_receive(:open).with(Pathname("123.tgz")).and_yield(@gzip)
-      Archive::Tar::Minitar::Output.should_receive(:open).with(@gzip).and_yield(@stream)
-      @gzip.should_receive(:mtime=).with(Time.utc(2000))
+      expect(Zlib::GzipWriter).to receive(:open).with(Pathname("123.tgz")).and_yield(@gzip)
+      expect(Archive::Tar::Minitar::Output).to receive(:open).with(@gzip).and_yield(@stream)
+      expect(@gzip).to receive(:mtime=).with(Time.utc(2000))
 
       @dump = DumpWriter.new('123.tgz')
-      @dump.should_receive(:lock).and_yield
+      expect(@dump).to receive(:lock).and_yield
       @dump.open do |dump|
-        dump.should == @dump
-        dump.stream.should == @stream
+        expect(dump).to eq(@dump)
+        expect(dump.stream).to eq(@stream)
       end
     end
   end
@@ -57,25 +57,25 @@ describe DumpWriter do
       @stream = double('stream', :tar => @tar)
       @config = {:tables => {}}
       @dump = DumpWriter.new('123.tgz')
-      @dump.stub(:stream).and_return(@stream)
-      @dump.stub(:config).and_return(@config)
-      Progress.stub(:io).and_return(StringIO.new)
+      allow(@dump).to receive(:stream).and_return(@stream)
+      allow(@dump).to receive(:config).and_return(@config)
+      allow(Progress).to receive(:io).and_return(StringIO.new)
     end
 
     describe "create_file" do
       it "should create temp file, yield it for writing, create file in tar and write it there" do
         @temp = double('temp', :open => true, :length => 6, :read => 'qwfpgj')
-        @temp.should_receive(:write).with('qwfpgj')
-        @temp.stub(:eof?).and_return(false, true)
-        Tempfile.should_receive(:open).and_yield(@temp)
+        expect(@temp).to receive(:write).with('qwfpgj')
+        allow(@temp).to receive(:eof?).and_return(false, true)
+        expect(Tempfile).to receive(:open).and_yield(@temp)
 
         @file = double('file')
-        @file.should_receive(:write).with('qwfpgj')
+        expect(@file).to receive(:write).with('qwfpgj')
 
-        @stream.tar.should_receive(:add_file_simple).with('abc/def.txt', :mode => 0100444, :size => 6).and_yield(@file)
+        expect(@stream.tar).to receive(:add_file_simple).with('abc/def.txt', :mode => 0100444, :size => 6).and_yield(@file)
 
         @dump.create_file('abc/def.txt') do |file|
-          file.should == @temp
+          expect(file).to eq(@temp)
           file.write('qwfpgj')
         end
       end
@@ -83,40 +83,40 @@ describe DumpWriter do
 
     describe "write_schema" do
       it "should create file schema.rb" do
-        @dump.should_receive(:create_file).with('schema.rb')
+        expect(@dump).to receive(:create_file).with('schema.rb')
         @dump.write_schema
       end
 
       it "should set ENV[SCHEMA] to path of returned file" do
         @file = double('file', :path => 'db/schema.rb')
-        @dump.stub(:create_file).and_yield(@file)
-        DumpRake::Env.should_receive(:with_env).with('SCHEMA' => 'db/schema.rb')
+        allow(@dump).to receive(:create_file).and_yield(@file)
+        expect(DumpRake::Env).to receive(:with_env).with('SCHEMA' => 'db/schema.rb')
         @dump.write_schema
       end
 
       it "should call rake task db:schema:dump" do
         @file = double('file', :path => 'db/schema.rb')
-        @dump.stub(:create_file).and_yield(@file)
+        allow(@dump).to receive(:create_file).and_yield(@file)
         @task = double('task')
-        Rake::Task.should_receive(:[]).with('db:schema:dump').and_return(@task)
-        @task.should_receive(:invoke)
+        expect(Rake::Task).to receive(:[]).with('db:schema:dump').and_return(@task)
+        expect(@task).to receive(:invoke)
         @dump.write_schema
       end
     end
 
     describe "write_tables" do
       it "should verify connection" do
-        @dump.stub(:tables_to_dump).and_return([])
-        @dump.should_receive(:verify_connection)
+        allow(@dump).to receive(:tables_to_dump).and_return([])
+        expect(@dump).to receive(:verify_connection)
         @dump.write_tables
       end
 
       it "should call write_table for each table returned by tables_to_dump" do
-        @dump.stub(:verify_connection)
-        @dump.stub(:tables_to_dump).and_return(%w[first second])
+        allow(@dump).to receive(:verify_connection)
+        allow(@dump).to receive(:tables_to_dump).and_return(%w[first second])
 
-        @dump.should_receive(:write_table).with('first')
-        @dump.should_receive(:write_table).with('second')
+        expect(@dump).to receive(:write_table).with('first')
+        expect(@dump).to receive(:write_table).with('second')
 
         @dump.write_tables
       end
@@ -124,15 +124,15 @@ describe DumpWriter do
 
     describe "write_table" do
       it "should get row count and store it to config" do
-        @dump.should_receive(:table_row_count).with('first').and_return(666)
-        @dump.stub(:create_file)
+        expect(@dump).to receive(:table_row_count).with('first').and_return(666)
+        allow(@dump).to receive(:create_file)
         @dump.write_table('first')
-        @config[:tables]['first'].should == 666
+        expect(@config[:tables]['first']).to eq(666)
       end
 
       it "should create_file" do
-        @dump.stub(:table_row_count).and_return(666)
-        @dump.should_receive(:create_file)
+        allow(@dump).to receive(:table_row_count).and_return(666)
+        expect(@dump).to receive(:create_file)
         @dump.write_table('first')
       end
 
@@ -142,24 +142,24 @@ describe DumpWriter do
           double('column', :name => 'name'),
           double('column', :name => 'associated_id')
         ]
-        ActiveRecord::Base.connection.stub(:columns).and_return(@column_definitions)
+        allow(ActiveRecord::Base.connection).to receive(:columns).and_return(@column_definitions)
         @rows = [
           {'id' => 1, 'name' => 'a', 'associated_id' => 100},
           {'id' => 2, 'name' => 'b', 'associated_id' => 666},
         ]
 
         @file = double('file')
-        @dump.stub(:table_row_count).and_return(666)
-        @dump.stub(:create_file).and_yield(@file)
+        allow(@dump).to receive(:table_row_count).and_return(666)
+        allow(@dump).to receive(:create_file).and_yield(@file)
 
         column_names = @column_definitions.map(&:name).sort
-        @file.should_receive(:write).with(Marshal.dump(column_names)).ordered
-        each_tabler_row_yielder = @dump.should_receive(:each_table_row)
+        expect(Marshal).to receive(:dump).with(column_names, @file).ordered
+        each_tabler_row_yielder = expect(@dump).to receive(:each_table_row)
         @rows.each do |row|
           each_tabler_row_yielder.and_yield(row)
-          @file.should_receive(:write).with(Marshal.dump(row.values_at(*column_names))).ordered
+          expect(Marshal).to receive(:dump).with(row.values_at(*column_names), @file).ordered
           @column_definitions.each do |column_definition|
-            column_definition.should_receive(:type_cast).with(row[column_definition.name]).and_return(row[column_definition.name])
+            expect(column_definition).to receive(:type_cast).with(row[column_definition.name]).and_return(row[column_definition.name])
           end
         end
 
@@ -169,87 +169,87 @@ describe DumpWriter do
 
     describe "write_assets" do
       before do
-        @dump.stub(:assets_root_link).and_yield('/tmp', 'assets')
+        allow(@dump).to receive(:assets_root_link).and_yield('/tmp', 'assets')
       end
 
       it "should call assets_to_dump" do
-        @dump.should_receive(:assets_to_dump).and_return([])
+        expect(@dump).to receive(:assets_to_dump).and_return([])
         @dump.write_assets
       end
 
       it "should change root to rails app root" do
         @file = double('file')
-        @dump.stub(:assets_to_dump).and_return(%w[images videos])
-        @dump.stub(:create_file).and_yield(@file)
+        allow(@dump).to receive(:assets_to_dump).and_return(%w[images videos])
+        allow(@dump).to receive(:create_file).and_yield(@file)
 
-        Dir.should_receive(:chdir).with(DumpRake::RailsRoot)
+        expect(Dir).to receive(:chdir).with(DumpRake::RailsRoot)
         @dump.write_assets
       end
 
       it "should put assets to config" do
         @file = double('file')
-        @dump.stub(:assets_to_dump).and_return(%w[images/* videos])
-        @dump.stub(:create_file).and_yield(@file)
-        Dir.stub(:chdir).and_yield
+        allow(@dump).to receive(:assets_to_dump).and_return(%w[images/* videos])
+        allow(@dump).to receive(:create_file).and_yield(@file)
+        allow(Dir).to receive(:chdir).and_yield
         @tar = double('tar_writer')
-        Archive::Tar::Minitar::Output.stub(:open).and_yield(@tar)
-        Dir.stub(:[]).and_return([])
-        Dir.should_receive(:[]).with(*%w[images/* videos]).and_return(%w[images/a images/b videos])
+        allow(Archive::Tar::Minitar::Output).to receive(:open).and_yield(@tar)
+        allow(Dir).to receive(:[]).and_return([])
+        expect(Dir).to receive(:[]).with(*%w[images/* videos]).and_return(%w[images/a images/b videos])
 
         @dump.write_assets
         counts = {:files => 0, :total => 0}
-        @config[:assets].should == {'images/a' => counts, 'images/b' => counts, 'videos' => counts}
+        expect(@config[:assets]).to eq({'images/a' => counts, 'images/b' => counts, 'videos' => counts})
       end
 
       it "should use glob to find files" do
         @file = double('file')
-        @dump.stub(:assets_to_dump).and_return(%w[images/* videos])
-        @dump.stub(:create_file).and_yield(@file)
-        Dir.stub(:chdir).and_yield
+        allow(@dump).to receive(:assets_to_dump).and_return(%w[images/* videos])
+        allow(@dump).to receive(:create_file).and_yield(@file)
+        allow(Dir).to receive(:chdir).and_yield
         @tar = double('tar_writer')
-        Archive::Tar::Minitar::Output.stub(:open).and_yield(@tar)
+        allow(Archive::Tar::Minitar::Output).to receive(:open).and_yield(@tar)
 
-        Dir.should_receive(:[]).with(*%w[images/* videos]).and_return(%w[images/a images/b videos])
-        Dir.should_receive(:[]).with('images/a/**/*').and_return([])
-        Dir.should_receive(:[]).with('images/b/**/*').and_return([])
-        Dir.should_receive(:[]).with('videos/**/*').and_return([])
+        expect(Dir).to receive(:[]).with(*%w[images/* videos]).and_return(%w[images/a images/b videos])
+        expect(Dir).to receive(:[]).with('images/a/**/*').and_return([])
+        expect(Dir).to receive(:[]).with('images/b/**/*').and_return([])
+        expect(Dir).to receive(:[]).with('videos/**/*').and_return([])
 
         @dump.write_assets
       end
 
       it "should pack each file from assets_root_link" do
         @file = double('file')
-        @dump.stub(:assets_to_dump).and_return(%w[images/* videos])
-        @dump.stub(:create_file).and_yield(@file)
-        Dir.stub(:chdir).and_yield
+        allow(@dump).to receive(:assets_to_dump).and_return(%w[images/* videos])
+        allow(@dump).to receive(:create_file).and_yield(@file)
+        allow(Dir).to receive(:chdir).and_yield
         @tar = double('tar_writer')
-        Archive::Tar::Minitar::Output.stub(:open).and_yield(@tar)
+        allow(Archive::Tar::Minitar::Output).to receive(:open).and_yield(@tar)
 
-        Dir.should_receive(:[]).with(*%w[images/* videos]).and_return(%w[images/a images/b videos])
-        Dir.should_receive(:[]).with('images/a/**/*').and_return([])
-        Dir.should_receive(:[]).with('images/b/**/*').and_return([])
-        Dir.should_receive(:[]).with('videos/**/*').and_return([])
+        expect(Dir).to receive(:[]).with(*%w[images/* videos]).and_return(%w[images/a images/b videos])
+        expect(Dir).to receive(:[]).with('images/a/**/*').and_return([])
+        expect(Dir).to receive(:[]).with('images/b/**/*').and_return([])
+        expect(Dir).to receive(:[]).with('videos/**/*').and_return([])
 
-        @dump.should_receive(:assets_root_link).exactly(3).times
+        expect(@dump).to receive(:assets_root_link).exactly(3).times
 
         @dump.write_assets
       end
 
       it "should pack each file" do
         @file = double('file')
-        @dump.stub(:assets_to_dump).and_return(%w[images/* videos])
-        @dump.stub(:create_file).and_yield(@file)
-        Dir.stub(:chdir).and_yield
+        allow(@dump).to receive(:assets_to_dump).and_return(%w[images/* videos])
+        allow(@dump).to receive(:create_file).and_yield(@file)
+        allow(Dir).to receive(:chdir).and_yield
         @tar = double('tar_writer')
-        Archive::Tar::Minitar::Output.stub(:open).and_yield(@tar)
+        allow(Archive::Tar::Minitar::Output).to receive(:open).and_yield(@tar)
 
-        Dir.should_receive(:[]).with(*%w[images/* videos]).and_return(%w[images/a images/b videos])
-        Dir.should_receive(:[]).with('images/a/**/*').and_return(%w[a.jpg b.jpg])
-        Dir.should_receive(:[]).with('images/b/**/*').and_return(%w[c.jpg d.jpg])
-        Dir.should_receive(:[]).with('videos/**/*').and_return(%w[a.mov b.mov])
+        expect(Dir).to receive(:[]).with(*%w[images/* videos]).and_return(%w[images/a images/b videos])
+        expect(Dir).to receive(:[]).with('images/a/**/*').and_return(%w[a.jpg b.jpg])
+        expect(Dir).to receive(:[]).with('images/b/**/*').and_return(%w[c.jpg d.jpg])
+        expect(Dir).to receive(:[]).with('videos/**/*').and_return(%w[a.mov b.mov])
 
         %w[a.jpg b.jpg c.jpg d.jpg a.mov b.mov].each do |file_name|
-          Archive::Tar::Minitar.should_receive(:pack_file).with("assets/#{file_name}", @stream)
+          expect(Archive::Tar::Minitar).to receive(:pack_file).with("assets/#{file_name}", @stream)
         end
 
         @dump.write_assets
@@ -257,17 +257,17 @@ describe DumpWriter do
 
       it "should not raise if something fails when packing" do
         @file = double('file')
-        @dump.stub(:assets_to_dump).and_return(%w[videos])
-        @dump.stub(:create_file).and_yield(@file)
-        Dir.stub(:chdir).and_yield
+        allow(@dump).to receive(:assets_to_dump).and_return(%w[videos])
+        allow(@dump).to receive(:create_file).and_yield(@file)
+        allow(Dir).to receive(:chdir).and_yield
         @tar = double('tar_writer')
-        Archive::Tar::Minitar::Output.stub(:open).and_yield(@tar)
+        allow(Archive::Tar::Minitar::Output).to receive(:open).and_yield(@tar)
 
-        Dir.should_receive(:[]).with(*%w[videos]).and_return(%w[videos])
-        Dir.should_receive(:[]).with('videos/**/*').and_return(%w[a.mov b.mov])
+        expect(Dir).to receive(:[]).with(*%w[videos]).and_return(%w[videos])
+        expect(Dir).to receive(:[]).with('videos/**/*').and_return(%w[a.mov b.mov])
 
-        Archive::Tar::Minitar.should_receive(:pack_file).with('assets/a.mov', @stream).and_raise('file not found')
-        Archive::Tar::Minitar.should_receive(:pack_file).with('assets/b.mov', @stream)
+        expect(Archive::Tar::Minitar).to receive(:pack_file).with('assets/a.mov', @stream).and_raise('file not found')
+        expect(Archive::Tar::Minitar).to receive(:pack_file).with('assets/b.mov', @stream)
 
         grab_output {
           @dump.write_assets
@@ -278,16 +278,16 @@ describe DumpWriter do
 
     describe "write_config" do
       it "should create file config" do
-        @dump.should_receive(:create_file).with('config')
+        expect(@dump).to receive(:create_file).with('config')
         @dump.write_config
       end
 
       it "should dump column names and values of each row" do
         @file = double('file')
-        @dump.stub(:create_file).and_yield(@file)
+        allow(@dump).to receive(:create_file).and_yield(@file)
         @config.replace({:tables => {'first' => 1, 'second' => 2}, :assets => %w[images videos]})
 
-        @file.should_receive(:write).with(Marshal.dump(@config))
+        expect(Marshal).to receive(:dump).with(@config, @file)
         @dump.write_config
       end
     end
@@ -295,33 +295,33 @@ describe DumpWriter do
     describe "assets_to_dump" do
       it "should call rake task assets" do
         @task = double('task')
-        Rake::Task.should_receive(:[]).with('assets').and_return(@task)
-        @task.should_receive(:invoke)
+        expect(Rake::Task).to receive(:[]).with('assets').and_return(@task)
+        expect(@task).to receive(:invoke)
         @dump.assets_to_dump
       end
 
       it "should return array of assets if separator is colon" do
         @task = double('task')
-        Rake::Task.stub(:[]).and_return(@task)
-        @task.stub(:invoke)
+        allow(Rake::Task).to receive(:[]).and_return(@task)
+        allow(@task).to receive(:invoke)
         DumpRake::Env.with_env(:assets => 'images:videos') do
-          @dump.assets_to_dump.should == %w[images videos]
+          expect(@dump.assets_to_dump).to eq(%w[images videos])
         end
       end
 
       it "should return array of assets if separator is comma" do
         @task = double('task')
-        Rake::Task.stub(:[]).and_return(@task)
-        @task.stub(:invoke)
+        allow(Rake::Task).to receive(:[]).and_return(@task)
+        allow(@task).to receive(:invoke)
         DumpRake::Env.with_env(:assets => 'images,videos') do
-          @dump.assets_to_dump.should == %w[images videos]
+          expect(@dump.assets_to_dump).to eq(%w[images videos])
         end
       end
 
       it "should return empty array if calling rake task assets raises an exception" do
-        Rake::Task.stub(:[]).and_raise('task assets not found')
+        allow(Rake::Task).to receive(:[]).and_raise('task assets not found')
         DumpRake::Env.with_env(:assets => 'images:videos') do
-          @dump.assets_to_dump.should == []
+          expect(@dump.assets_to_dump).to eq([])
         end
       end
     end