dump 1.0.3 → 1.0.4

data/spec/lib/dump_rake_spec.rb

@@ -3,32 +3,32 @@ require File.dirname(__FILE__) + '/../spec_helper'
 describe DumpRake do
   describe "versions" do
     it "should call Dump.list if called without version" do
-      DumpRake::Dump.should_receive(:list).and_return([])
+      expect(DumpRake::Dump).to receive(:list).and_return([])
       DumpRake.versions
     end
 
     it "should call Dump.list with options if called with version" do
-      DumpRake::Dump.should_receive(:list).with(:like => '123').and_return([])
+      expect(DumpRake::Dump).to receive(:list).with(:like => '123').and_return([])
       DumpRake.versions(:like => '123')
     end
 
     it "should print versions" do
-      DumpRake::Dump.should_receive(:list).and_return(%w[123.tgz 456.tgz])
-      grab_output{
+      expect(DumpRake::Dump).to receive(:list).and_return(%w[123.tgz 456.tgz])
+      expect(grab_output{
         DumpRake.versions
-      }[:stdout].should == "123.tgz\n456.tgz\n"
+      }[:stdout]).to eq("123.tgz\n456.tgz\n")
     end
 
     it "should not show summary if not asked for" do
       dumps = %w[123.tgz 456.tgz].map do |s|
         dump = double("dump_#{s}", :path => double("dump_#{s}_path"))
-        DumpRake::DumpReader.should_not_receive(:summary)
+        expect(DumpRake::DumpReader).not_to receive(:summary)
         dump
       end
 
-      DumpRake::Dump.should_receive(:list).and_return(dumps)
+      expect(DumpRake::Dump).to receive(:list).and_return(dumps)
       grab_output{
-        $stderr.should_not_receive(:puts)
+        expect($stderr).not_to receive(:puts)
         DumpRake.versions
       }
     end
@@ -36,13 +36,13 @@ describe DumpRake do
     it "should show summary if asked for" do
       dumps = %w[123.tgz 456.tgz].map do |s|
         dump = double("dump_#{s}", :path => double("dump_#{s}_path"))
-        DumpRake::DumpReader.should_receive(:summary).with(dump.path)
+        expect(DumpRake::DumpReader).to receive(:summary).with(dump.path)
         dump
       end
 
-      DumpRake::Dump.should_receive(:list).and_return(dumps)
+      expect(DumpRake::Dump).to receive(:list).and_return(dumps)
       grab_output{
-        $stderr.should_not_receive(:puts)
+        expect($stderr).not_to receive(:puts)
         DumpRake.versions(:summary => '1')
       }
     end
@@ -50,29 +50,29 @@ describe DumpRake do
     it "should show summary with scmema if asked for" do
       dumps = %w[123.tgz 456.tgz].map do |s|
         dump = double("dump_#{s}", :path => double("dump_#{s}_path"))
-        DumpRake::DumpReader.should_receive(:summary).with(dump.path, :schema => true)
+        expect(DumpRake::DumpReader).to receive(:summary).with(dump.path, :schema => true)
         dump
       end
 
-      DumpRake::Dump.should_receive(:list).and_return(dumps)
+      expect(DumpRake::Dump).to receive(:list).and_return(dumps)
       grab_output{
-        $stderr.should_not_receive(:puts)
+        expect($stderr).not_to receive(:puts)
         DumpRake.versions(:summary => '2')
       }
     end
 
     it "should show output to stderr if summary raises error" do
-      DumpRake::DumpReader.stub(:summary)
+      allow(DumpRake::DumpReader).to receive(:summary)
       dumps = %w[123.tgz 456.tgz].map do |s|
         double("dump_#{s}", :path => double("dump_#{s}_path"))
       end
-      DumpRake::DumpReader.should_receive(:summary).with(dumps[1].path).and_raise('terrible error')
+      expect(DumpRake::DumpReader).to receive(:summary).with(dumps[1].path).and_raise('terrible error')
 
-      DumpRake::Dump.should_receive(:list).and_return(dumps)
+      expect(DumpRake::Dump).to receive(:list).and_return(dumps)
       grab_output{
-        $stderr.stub(:puts)
-        $stderr.should_receive(:puts) do |s|
-          s['terrible error'].should_not be_nil
+        allow($stderr).to receive(:puts)
+        expect($stderr).to receive(:puts) do |s|
+          expect(s['terrible error']).not_to be_nil
         end
         DumpRake.versions(:summary => 'true')
       }
@@ -82,9 +82,9 @@ describe DumpRake do
   describe "create" do
     describe "naming" do
       it "should create file in 'rails app root'/dump" do
-        File.stub(:rename)
-        DumpRake::DumpWriter.should_receive(:create) do |path|
-          File.dirname(path).should == File.join(DumpRake::RailsRoot, 'dump')
+        allow(File).to receive(:rename)
+        expect(DumpRake::DumpWriter).to receive(:create) do |path|
+          expect(File.dirname(path)).to eq(File.join(DumpRake::RailsRoot, 'dump'))
         end
         grab_output{
           DumpRake.create
@@ -92,9 +92,9 @@ describe DumpRake do
       end
 
       it "should create file with name like 'yyyymmddhhmmss.tmp' when called without description" do
-        File.stub(:rename)
-        DumpRake::DumpWriter.should_receive(:create) do |path|
-          File.basename(path).should match(/^\d{14}\.tmp$/)
+        allow(File).to receive(:rename)
+        expect(DumpRake::DumpWriter).to receive(:create) do |path|
+          expect(File.basename(path)).to match(/^\d{14}\.tmp$/)
         end
         grab_output{
           DumpRake.create
@@ -102,9 +102,9 @@ describe DumpRake do
       end
 
       it "should create file with name like 'yyyymmddhhmmss-Some text and _.tmp' when called with description 'Some text and !@'" do
-        File.stub(:rename)
-        DumpRake::DumpWriter.should_receive(:create) do |path|
-          File.basename(path).should match(/^\d{14}-Some text and _\.tmp$/)
+        allow(File).to receive(:rename)
+        expect(DumpRake::DumpWriter).to receive(:create) do |path|
+          expect(File.basename(path)).to match(/^\d{14}-Some text and _\.tmp$/)
         end
         grab_output{
           DumpRake.create(:desc => 'Some text and !@')
@@ -112,9 +112,9 @@ describe DumpRake do
       end
 
       it "should create file with name like 'yyyymmddhhmmss@super tag,second.tmp' when called with description 'Some text and !@'" do
-        File.stub(:rename)
-        DumpRake::DumpWriter.should_receive(:create) do |path|
-          File.basename(path).should match(/^\d{14}-Some text and _\.tmp$/)
+        allow(File).to receive(:rename)
+        expect(DumpRake::DumpWriter).to receive(:create) do |path|
+          expect(File.basename(path)).to match(/^\d{14}-Some text and _\.tmp$/)
         end
         grab_output{
           DumpRake.create(:desc => 'Some text and !@')
@@ -122,30 +122,30 @@ describe DumpRake do
       end
 
       it "should rename file after creating" do
-        File.should_receive(:rename) do |tmp_path, tgz_path|
-          File.basename(tmp_path).should match(/^\d{14}-Some text and _\.tmp$/)
-          File.basename(tgz_path).should match(/^\d{14}-Some text and _\.tgz$/)
+        expect(File).to receive(:rename) do |tmp_path, tgz_path|
+          expect(File.basename(tmp_path)).to match(/^\d{14}-Some text and _\.tmp$/)
+          expect(File.basename(tgz_path)).to match(/^\d{14}-Some text and _\.tgz$/)
         end
-        DumpRake::DumpWriter.stub(:create)
+        allow(DumpRake::DumpWriter).to receive(:create)
         grab_output{
           DumpRake.create(:desc => 'Some text and !@')
         }
       end
 
       it "should output file name" do
-        File.stub(:rename)
-        DumpRake::DumpWriter.stub(:create)
-        grab_output{
+        allow(File).to receive(:rename)
+        allow(DumpRake::DumpWriter).to receive(:create)
+        expect(grab_output{
           DumpRake.create(:desc => 'Some text and !@')
-        }[:stdout].should match(/^\d{14}-Some text and _\.tgz$/)
+        }[:stdout]).to match(/^\d{14}-Some text and _\.tgz$/)
       end
     end
 
     describe "writing" do
       it "should dump schema, tables, assets" do
-        File.stub(:rename)
+        allow(File).to receive(:rename)
         @dump = double('dump')
-        DumpRake::DumpWriter.should_receive(:create)
+        expect(DumpRake::DumpWriter).to receive(:create)
 
         grab_output{
           DumpRake.create
@@ -157,43 +157,43 @@ describe DumpRake do
   describe "restore" do
     describe "without version" do
       it "should call Dump.list" do
-        DumpRake::Dump.stub(:list)
-        DumpRake::Dump.should_receive(:list).and_return([])
+        allow(DumpRake::Dump).to receive(:list)
+        expect(DumpRake::Dump).to receive(:list).and_return([])
         grab_output{
           DumpRake.restore
         }
       end
 
       it "should not call DumpReader.restore and should call Dump.list and output it to $stderr if there are no versions at all" do
-        DumpRake::Dump.stub(:list).and_return([])
-        DumpRake::DumpReader.should_not_receive(:restore)
+        allow(DumpRake::Dump).to receive(:list).and_return([])
+        expect(DumpRake::DumpReader).not_to receive(:restore)
         all_dumps = double('all_dumps')
-        DumpRake::Dump.should_receive(:list).with().and_return(all_dumps)
+        expect(DumpRake::Dump).to receive(:list).with(no_args).and_return(all_dumps)
         grab_output{
-          $stderr.should_receive(:puts).with(kind_of(String))
-          $stderr.should_receive(:puts).with(all_dumps)
+          expect($stderr).to receive(:puts).with(kind_of(String))
+          expect($stderr).to receive(:puts).with(all_dumps)
           DumpRake.restore
         }
       end
 
       it "should not call DumpReader.restore and should call Dump.list and output it to $stderr if there are no versions at all" do
-        DumpRake::Dump.stub(:list).and_return([])
-        DumpRake::DumpReader.should_not_receive(:restore)
+        allow(DumpRake::Dump).to receive(:list).and_return([])
+        expect(DumpRake::DumpReader).not_to receive(:restore)
         all_dumps = double('all_dumps')
-        DumpRake::Dump.should_receive(:list).with().and_return(all_dumps)
+        expect(DumpRake::Dump).to receive(:list).with(no_args).and_return(all_dumps)
         grab_output{
-          $stderr.should_receive(:puts).with(kind_of(String))
-          $stderr.should_receive(:puts).with(all_dumps)
+          expect($stderr).to receive(:puts).with(kind_of(String))
+          expect($stderr).to receive(:puts).with(all_dumps)
           DumpRake.restore('213')
         }
       end
 
       it "should call DumpReader.restore if there are versions" do
         @dump = double('dump', :path => 'dump/213.tgz')
-        DumpRake::Dump.should_receive(:list).once.and_return([@dump])
-        DumpRake::DumpReader.should_receive(:restore).with('dump/213.tgz')
+        expect(DumpRake::Dump).to receive(:list).once.and_return([@dump])
+        expect(DumpRake::DumpReader).to receive(:restore).with('dump/213.tgz')
         grab_output{
-          $stderr.should_not_receive(:puts)
+          expect($stderr).not_to receive(:puts)
           DumpRake.restore
         }
       end
@@ -201,32 +201,32 @@ describe DumpRake do
 
     describe "with version" do
       it "should call Dump.list with options" do
-        DumpRake::Dump.stub(:list)
-        DumpRake::Dump.should_receive(:list).with(:like => '213').and_return([])
+        allow(DumpRake::Dump).to receive(:list)
+        expect(DumpRake::Dump).to receive(:list).with(:like => '213').and_return([])
         grab_output{
           DumpRake.restore(:like => '213')
         }
       end
 
       it "should not call DumpReader.restore and should call versions if desired version not found" do
-        DumpRake::Dump.stub(:list).and_return([])
-        DumpRake::DumpReader.should_not_receive(:restore)
+        allow(DumpRake::Dump).to receive(:list).and_return([])
+        expect(DumpRake::DumpReader).not_to receive(:restore)
         all_dumps = double('all_dumps')
-        DumpRake::Dump.should_receive(:list).with().and_return(all_dumps)
+        expect(DumpRake::Dump).to receive(:list).with(no_args).and_return(all_dumps)
         grab_output{
-          $stderr.should_receive(:puts).with(kind_of(String))
-          $stderr.should_receive(:puts).with(all_dumps)
+          expect($stderr).to receive(:puts).with(kind_of(String))
+          expect($stderr).to receive(:puts).with(all_dumps)
           DumpRake.restore('213')
         }
       end
 
       it "should call DumpReader.restore if there is desired version" do
         @dump = double('dump', :path => 'dump/213.tgz')
-        DumpRake::Dump.should_receive(:list).once.and_return([@dump])
-        DumpRake::DumpReader.should_receive(:restore).with('dump/213.tgz')
-        DumpRake.should_not_receive(:versions)
+        expect(DumpRake::Dump).to receive(:list).once.and_return([@dump])
+        expect(DumpRake::DumpReader).to receive(:restore).with('dump/213.tgz')
+        expect(DumpRake).not_to receive(:versions)
         grab_output{
-          $stderr.should_not_receive(:puts)
+          expect($stderr).not_to receive(:puts)
           DumpRake.restore(:like => '213')
         }
       end
@@ -234,10 +234,10 @@ describe DumpRake do
       it "should call DumpReader.restore on last version if found multiple matching versions" do
         @dump_a = double('dump_a', :path => 'dump/213-a.tgz')
         @dump_b = double('dump_b', :path => 'dump/213-b.tgz')
-        DumpRake::Dump.should_receive(:list).once.and_return([@dump_a, @dump_b])
-        DumpRake::DumpReader.should_receive(:restore).with('dump/213-b.tgz')
+        expect(DumpRake::Dump).to receive(:list).once.and_return([@dump_a, @dump_b])
+        expect(DumpRake::DumpReader).to receive(:restore).with('dump/213-b.tgz')
         grab_output{
-          $stderr.should_not_receive(:puts)
+          expect($stderr).not_to receive(:puts)
           DumpRake.restore(:like => '213')
         }
       end
@@ -246,14 +246,14 @@ describe DumpRake do
 
   describe "cleanup" do
     it "should call ask for all files in dump dir and for dumps" do
-      DumpRake::Dump.should_receive(:list).with(:all => true).and_return([])
-      DumpRake::Dump.should_receive(:list).with({}).and_return([])
+      expect(DumpRake::Dump).to receive(:list).with(:all => true).and_return([])
+      expect(DumpRake::Dump).to receive(:list).with({}).and_return([])
       DumpRake.cleanup
     end
 
     it "should call Dump.list with options if called with version and tags" do
-      DumpRake::Dump.should_receive(:list).with(:like => '123', :tags => 'a,b,c', :all => true).and_return([])
-      DumpRake::Dump.should_receive(:list).with(:like => '123', :tags => 'a,b,c').and_return([])
+      expect(DumpRake::Dump).to receive(:list).with(:like => '123', :tags => 'a,b,c', :all => true).and_return([])
+      expect(DumpRake::Dump).to receive(:list).with(:like => '123', :tags => 'a,b,c').and_return([])
       DumpRake.cleanup(:like => '123', :tags => 'a,b,c')
     end
 
@@ -276,20 +276,20 @@ describe DumpRake do
         all_dumps = tmp_dumps[0, 1] + dumps[0, 5] + tmp_dumps[1, 1] + dumps[5, 5] + tmp_dumps[2, 1]
 
         (dumps.values_at(*ids) + [tmp_dumps[0], tmp_dumps[2]]).each do |dump|
-          dump.should_receive(:lock).and_yield
-          dump.path.should_receive(:unlink)
+          expect(dump).to receive(:lock).and_yield
+          expect(dump.path).to receive(:unlink)
         end
         [tmp_dumps[1]].each do |dump|
-          dump.should_receive(:lock)
-          dump.path.should_not_receive(:unlink)
+          expect(dump).to receive(:lock)
+          expect(dump.path).not_to receive(:unlink)
         end
         (dumps - dumps.values_at(*ids)).each do |dump|
-          dump.should_not_receive(:lock)
-          dump.path.should_not_receive(:unlink)
+          expect(dump).not_to receive(:lock)
+          expect(dump.path).not_to receive(:unlink)
         end
 
-        DumpRake::Dump.should_receive(:list).with(hash_including(:all => true)).and_return(all_dumps)
-        DumpRake::Dump.should_receive(:list).with(hash_not_including(:all => true)).and_return(dumps)
+        expect(DumpRake::Dump).to receive(:list).with(hash_including(:all => true)).and_return(all_dumps)
+        expect(DumpRake::Dump).to receive(:list).with(hash_not_including(:all => true)).and_return(dumps)
         grab_output{
           DumpRake.cleanup({:like => '123', :tags => 'a,b,c'}.merge(options))
         }
@@ -299,28 +299,28 @@ describe DumpRake do
     it "should print to stderr if can not delete dump" do
       dumps = %w[a b c d e f g h i j].map do |s|
         dump = double("dump_#{s}", :ext => 'tgz', :path => double("dump_#{s}_path"))
-        dump.stub(:lock).and_yield
-        dump.path.stub(:unlink)
+        allow(dump).to receive(:lock).and_yield
+        allow(dump.path).to receive(:unlink)
         dump
       end
 
-      dumps[3].path.should_receive(:unlink).and_raise('Horrible error')
+      expect(dumps[3].path).to receive(:unlink).and_raise('Horrible error')
 
-      DumpRake::Dump.stub(:list).and_return(dumps)
+      allow(DumpRake::Dump).to receive(:list).and_return(dumps)
       grab_output{
-        $stderr.stub(:puts)
-        $stderr.should_receive(:puts) do |s|
-          s[dumps[3].path.to_s].should_not be_nil
-          s['Horrible error'].should_not be_nil
+        allow($stderr).to receive(:puts)
+        expect($stderr).to receive(:puts) do |s|
+          expect(s[dumps[3].path.to_s]).not_to be_nil
+          expect(s['Horrible error']).not_to be_nil
         end
         DumpRake.cleanup
       }
     end
 
     it "should raise if called with :leave which is not a number or 'none'" do
-      proc{
+      expect{
         DumpRake.cleanup(:leave => 'nothing')
-      }.should raise_error
+      }.to raise_error
     end
   end
 end

data/spec/recipes/dump_spec.rb

@@ -24,7 +24,7 @@ describe "cap dump" do
           violated "command_string not specified" unless command_string
           full_command_string = command_string
           full_command_string = "cd #{@remote_path}; #{command_string}" if place == :remote
-          @cap.dump.should_receive(:"run_#{place}").with(full_command_string).and_return(options[:return_value] || '')
+          expect(@cap.dump).to receive(:"run_#{place}").with(full_command_string).and_return(options[:return_value] || '')
           DumpRake::Env.with_env name => options[:value] || 'some data' do
             cap_task = options[:cap_task] || "dump:#{place}:#{command}"
             grab_output{ @cap.find_and_execute_task(cap_task) }
@@ -37,17 +37,17 @@ describe "cap dump" do
   describe :dump_command do
 
     it "should return escaped string" do
-      @cap.dump.dump_command(:hello, :rake => 'rake', 'x x' => 'a b').should == 'rake -s dump:hello x\\ x\\=a\\ b'
+      expect(@cap.dump.dump_command(:hello, :rake => 'rake', 'x x' => 'a b')).to eq('rake -s dump:hello x\\ x\\=a\\ b')
     end
 
     it "should return escaped string for complex rake invocation command" do
-      @cap.dump.dump_command(:hello, :rake => 'bundler exec rake', 'x x' => 'a b').should == 'bundler exec rake -s dump:hello x\\ x\\=a\\ b'
+      expect(@cap.dump.dump_command(:hello, :rake => 'bundler exec rake', 'x x' => 'a b')).to eq('bundler exec rake -s dump:hello x\\ x\\=a\\ b')
     end
   end
 
   describe "do_transfer" do
     before do
-      @cap.dump.stub(:do_transfer_via)
+      allow(@cap.dump).to receive(:do_transfer_via)
     end
 
     [:up, :down].each do |direction|
@@ -55,47 +55,47 @@ describe "cap dump" do
         describe "if method not set" do
 
           it "should call got_rsync?" do
-            @cap.dump.should_receive(:got_rsync?)
+            expect(@cap.dump).to receive(:got_rsync?)
             grab_output{ @cap.dump.do_transfer(direction, 'a.tgz', 'b.tgz') }
           end
 
           describe "if got_rsync?" do
             it "should use rsync" do
-              @cap.dump.stub(:got_rsync?).and_return(true)
-              @cap.dump.should_receive(:do_transfer_via).with(:rsync, direction, 'a.tgz', 'b.tgz')
+              allow(@cap.dump).to receive(:got_rsync?).and_return(true)
+              expect(@cap.dump).to receive(:do_transfer_via).with(:rsync, direction, 'a.tgz', 'b.tgz')
               grab_output{ @cap.dump.do_transfer(direction, 'a.tgz', 'b.tgz') }
             end
 
             it "should raise if rsync fails" do
-              @cap.dump.stub(:got_rsync?).and_return(true)
-              @cap.dump.should_receive(:do_transfer_via).with(:rsync, direction, 'a.tgz', 'b.tgz').and_raise('problem using rsync')
-              proc{
+              allow(@cap.dump).to receive(:got_rsync?).and_return(true)
+              expect(@cap.dump).to receive(:do_transfer_via).with(:rsync, direction, 'a.tgz', 'b.tgz').and_raise('problem using rsync')
+              expect{
                 grab_output{ @cap.dump.do_transfer(direction, 'a.tgz', 'b.tgz') }
-              }.should raise_error('problem using rsync')
+              }.to raise_error('problem using rsync')
             end
           end
 
           describe "unless got_rsync?" do
             it "should try sftp" do
-              @cap.dump.stub(:got_rsync?).and_return(false)
-              @cap.dump.should_receive(:do_transfer_via).with(:sftp, direction, 'a.tgz', 'b.tgz')
+              allow(@cap.dump).to receive(:got_rsync?).and_return(false)
+              expect(@cap.dump).to receive(:do_transfer_via).with(:sftp, direction, 'a.tgz', 'b.tgz')
               grab_output{ @cap.dump.do_transfer(direction, 'a.tgz', 'b.tgz') }
             end
 
             it "should try scp after sftp" do
-              @cap.dump.stub(:got_rsync?).and_return(false)
-              @cap.dump.should_receive(:do_transfer_via).with(:sftp, direction, 'a.tgz', 'b.tgz').and_raise('problem using sftp')
-              @cap.dump.should_receive(:do_transfer_via).with(:scp, direction, 'a.tgz', 'b.tgz')
+              allow(@cap.dump).to receive(:got_rsync?).and_return(false)
+              expect(@cap.dump).to receive(:do_transfer_via).with(:sftp, direction, 'a.tgz', 'b.tgz').and_raise('problem using sftp')
+              expect(@cap.dump).to receive(:do_transfer_via).with(:scp, direction, 'a.tgz', 'b.tgz')
               grab_output{ @cap.dump.do_transfer(direction, 'a.tgz', 'b.tgz') }
             end
 
             it "should not rescue if scp also fails" do
-              @cap.dump.stub(:got_rsync?).and_return(false)
-              @cap.dump.should_receive(:do_transfer_via).with(:sftp, direction, 'a.tgz', 'b.tgz').and_raise('problem using sftp')
-              @cap.dump.should_receive(:do_transfer_via).with(:scp, direction, 'a.tgz', 'b.tgz').and_raise('problem using scp')
-              proc{
+              allow(@cap.dump).to receive(:got_rsync?).and_return(false)
+              expect(@cap.dump).to receive(:do_transfer_via).with(:sftp, direction, 'a.tgz', 'b.tgz').and_raise('problem using sftp')
+              expect(@cap.dump).to receive(:do_transfer_via).with(:scp, direction, 'a.tgz', 'b.tgz').and_raise('problem using scp')
+              expect{
                 grab_output{ @cap.dump.do_transfer(direction, 'a.tgz', 'b.tgz') }
-              }.should raise_error('problem using scp')
+              }.to raise_error('problem using scp')
             end
           end
         end
@@ -106,7 +106,7 @@ describe "cap dump" do
   describe "local" do
     describe "versions" do
       it "should call local rake task" do
-        @cap.dump.should_receive(:run_local).with("rake -s dump:versions SHOW_SIZE\\=true").and_return('')
+        expect(@cap.dump).to receive(:run_local).with("rake -s dump:versions SHOW_SIZE\\=true").and_return('')
         @cap.find_and_execute_task("dump:local:versions")
       end
 
@@ -117,16 +117,16 @@ describe "cap dump" do
       })
 
       it "should print result of rake task" do
-        @cap.dump.stub(:run_local).and_return(" 123M\t123123.tgz\n")
-        grab_output{
+        allow(@cap.dump).to receive(:run_local).and_return(" 123M\t123123.tgz\n")
+        expect(grab_output{
           @cap.find_and_execute_task("dump:local:versions")
-        }[:stdout].should == " 123M\t123123.tgz\n"
+        }[:stdout]).to eq(" 123M\t123123.tgz\n")
       end
     end
 
     describe "cleanup" do
       it "should call local rake task" do
-        @cap.dump.should_receive(:run_local).with("rake -s dump:cleanup").and_return('')
+        expect(@cap.dump).to receive(:run_local).with("rake -s dump:cleanup").and_return('')
         @cap.find_and_execute_task("dump:local:cleanup")
       end
 
@@ -137,30 +137,30 @@ describe "cap dump" do
       })
 
       it "should print result of rake task" do
-        @cap.dump.stub(:run_local).and_return("123123.tgz\n")
-        grab_output{
+        allow(@cap.dump).to receive(:run_local).and_return("123123.tgz\n")
+        expect(grab_output{
           @cap.find_and_execute_task("dump:local:cleanup")
-        }[:stdout].should == "123123.tgz\n"
+        }[:stdout]).to eq("123123.tgz\n")
       end
     end
 
     describe "create" do
       it "should raise if dump creation fails" do
-        @cap.dump.should_receive(:run_local).with("rake -s dump:create TAGS\\=local").and_return('')
-        proc{
+        expect(@cap.dump).to receive(:run_local).with("rake -s dump:create TAGS\\=local").and_return('')
+        expect{
           @cap.find_and_execute_task("dump:local:create")
-        }.should raise_error('Failed creating dump')
+        }.to raise_error('Failed creating dump')
       end
 
       it "should call local rake task with tag local" do
-        @cap.dump.should_receive(:run_local).with("rake -s dump:create TAGS\\=local").and_return('123.tgz')
+        expect(@cap.dump).to receive(:run_local).with("rake -s dump:create TAGS\\=local").and_return('123.tgz')
         grab_output{
           @cap.find_and_execute_task("dump:local:create")
         }
       end
 
       it "should call local rake task with additional tag local" do
-        @cap.dump.should_receive(:run_local).with("rake -s dump:create TAGS\\=local,photos").and_return('123.tgz')
+        expect(@cap.dump).to receive(:run_local).with("rake -s dump:create TAGS\\=local,photos").and_return('123.tgz')
         grab_output{
           DumpRake::Env.with_env :tags => 'photos' do
             @cap.find_and_execute_task("dump:local:create")
@@ -176,23 +176,23 @@ describe "cap dump" do
       }, :return_value => '123.tgz')
 
       it "should print result of rake task" do
-        @cap.dump.stub(:run_local).and_return("123123.tgz\n")
-        grab_output{
+        allow(@cap.dump).to receive(:run_local).and_return("123123.tgz\n")
+        expect(grab_output{
           @cap.find_and_execute_task("dump:local:create")
-        }[:stdout].should == "123123.tgz\n"
+        }[:stdout]).to eq("123123.tgz\n")
       end
 
       it "should return stripped result of rake task" do
-        @cap.dump.stub(:run_local).and_return("123123.tgz\n")
+        allow(@cap.dump).to receive(:run_local).and_return("123123.tgz\n")
         grab_output{
-          @cap.find_and_execute_task("dump:local:create").should == "123123.tgz"
+          expect(@cap.find_and_execute_task("dump:local:create")).to eq("123123.tgz")
         }
       end
     end
 
     describe "restore" do
       it "should call local rake task" do
-        @cap.dump.should_receive(:run_local).with("rake -s dump:restore")
+        expect(@cap.dump).to receive(:run_local).with("rake -s dump:restore")
         @cap.find_and_execute_task("dump:local:restore")
       end
 
@@ -208,7 +208,7 @@ describe "cap dump" do
 
     describe "upload" do
       it "should run rake versions to get avaliable versions" do
-        @cap.dump.should_receive(:run_local).with("rake -s dump:versions").and_return('')
+        expect(@cap.dump).to receive(:run_local).with("rake -s dump:versions").and_return('')
         @cap.find_and_execute_task("dump:local:upload")
       end
 
@@ -220,20 +220,20 @@ describe "cap dump" do
       }, :cap_task => 'dump:local:upload')
 
       it "should not upload anything if there are no versions avaliable" do
-        @cap.dump.stub(:run_local).and_return('')
-        @cap.dump.should_not_receive(:do_transfer)
+        allow(@cap.dump).to receive(:run_local).and_return('')
+        expect(@cap.dump).not_to receive(:do_transfer)
         @cap.find_and_execute_task("dump:local:upload")
       end
 
       it "should transfer latest version dump" do
-        @cap.dump.stub(:run_local).and_return("100.tgz\n200.tgz\n300.tgz\n")
-        @cap.dump.should_receive(:do_transfer).with(:up, "dump/300.tgz", "#{@remote_path}/dump/300.tgz")
+        allow(@cap.dump).to receive(:run_local).and_return("100.tgz\n200.tgz\n300.tgz\n")
+        expect(@cap.dump).to receive(:do_transfer).with(:up, "dump/300.tgz", "#{@remote_path}/dump/300.tgz")
         @cap.find_and_execute_task("dump:local:upload")
       end
 
       it "should handle extra spaces around file names" do
-        @cap.dump.stub(:run_local).and_return("\r\n\r\n\r  100.tgz   \r\n\r\n\r  200.tgz   \r\n\r\n\r  300.tgz   \r\n\r\n\r  ")
-        @cap.dump.should_receive(:do_transfer).with(:up, "dump/300.tgz", "#{@remote_path}/dump/300.tgz")
+        allow(@cap.dump).to receive(:run_local).and_return("\r\n\r\n\r  100.tgz   \r\n\r\n\r  200.tgz   \r\n\r\n\r  300.tgz   \r\n\r\n\r  ")
+        expect(@cap.dump).to receive(:do_transfer).with(:up, "dump/300.tgz", "#{@remote_path}/dump/300.tgz")
         @cap.find_and_execute_task("dump:local:upload")
       end
     end
@@ -242,7 +242,7 @@ describe "cap dump" do
   describe "remote" do
     describe "versions" do
       it "should call remote rake task" do
-        @cap.dump.should_receive(:run_remote).with("cd #{@remote_path}; rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production SHOW_SIZE\\=true").and_return('')
+        expect(@cap.dump).to receive(:run_remote).with("cd #{@remote_path}; rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production SHOW_SIZE\\=true").and_return('')
         @cap.find_and_execute_task("dump:remote:versions")
       end
 
@@ -253,22 +253,22 @@ describe "cap dump" do
       })
 
       it "should print result of rake task" do
-        @cap.dump.stub(:run_remote).and_return(" 123M\t123123.tgz\n")
-        grab_output{
+        allow(@cap.dump).to receive(:run_remote).and_return(" 123M\t123123.tgz\n")
+        expect(grab_output{
           @cap.find_and_execute_task("dump:remote:versions")
-        }[:stdout].should == " 123M\t123123.tgz\n"
+        }[:stdout]).to eq(" 123M\t123123.tgz\n")
       end
 
       it "should use custom rake binary" do
-        @cap.dump.should_receive(:fetch_rake).and_return('/custom/rake')
-        @cap.dump.should_receive(:run_remote).with("cd #{@remote_path}; /custom/rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production SHOW_SIZE\\=true").and_return('')
+        expect(@cap.dump).to receive(:fetch_rake).and_return('/custom/rake')
+        expect(@cap.dump).to receive(:run_remote).with("cd #{@remote_path}; /custom/rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production SHOW_SIZE\\=true").and_return('')
         @cap.find_and_execute_task("dump:remote:versions")
       end
     end
 
     describe "cleanup" do
       it "should call remote rake task" do
-        @cap.dump.should_receive(:run_remote).with("cd #{@remote_path}; rake -s dump:cleanup PROGRESS_TTY\\=\\+ RAILS_ENV\\=production").and_return('')
+        expect(@cap.dump).to receive(:run_remote).with("cd #{@remote_path}; rake -s dump:cleanup PROGRESS_TTY\\=\\+ RAILS_ENV\\=production").and_return('')
         @cap.find_and_execute_task("dump:remote:cleanup")
       end
 
@@ -279,36 +279,36 @@ describe "cap dump" do
       })
 
       it "should print result of rake task" do
-        @cap.dump.stub(:run_remote).and_return("123123.tgz\n")
-        grab_output{
+        allow(@cap.dump).to receive(:run_remote).and_return("123123.tgz\n")
+        expect(grab_output{
           @cap.find_and_execute_task("dump:remote:cleanup")
-        }[:stdout].should == "123123.tgz\n"
+        }[:stdout]).to eq("123123.tgz\n")
       end
 
       it "should use custom rake binary" do
-        @cap.dump.should_receive(:fetch_rake).and_return('/custom/rake')
-        @cap.dump.should_receive(:run_remote).with("cd #{@remote_path}; /custom/rake -s dump:cleanup PROGRESS_TTY\\=\\+ RAILS_ENV\\=production").and_return('')
+        expect(@cap.dump).to receive(:fetch_rake).and_return('/custom/rake')
+        expect(@cap.dump).to receive(:run_remote).with("cd #{@remote_path}; /custom/rake -s dump:cleanup PROGRESS_TTY\\=\\+ RAILS_ENV\\=production").and_return('')
         @cap.find_and_execute_task("dump:remote:cleanup")
       end
     end
 
     describe "create" do
       it "should raise if dump creation fails" do
-        @cap.dump.should_receive(:run_remote).with("cd #{@remote_path}; rake -s dump:create PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=remote").and_return('')
-        proc{
+        expect(@cap.dump).to receive(:run_remote).with("cd #{@remote_path}; rake -s dump:create PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=remote").and_return('')
+        expect{
           @cap.find_and_execute_task("dump:remote:create")
-        }.should raise_error('Failed creating dump')
+        }.to raise_error('Failed creating dump')
       end
 
       it "should call remote rake task with default rails_env and tag remote" do
-        @cap.dump.should_receive(:run_remote).with("cd #{@remote_path}; rake -s dump:create PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=remote").and_return('123.tgz')
+        expect(@cap.dump).to receive(:run_remote).with("cd #{@remote_path}; rake -s dump:create PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=remote").and_return('123.tgz')
         grab_output{
           @cap.find_and_execute_task("dump:remote:create")
         }
       end
 
       it "should call remote rake task with default rails_env and additional tag remote" do
-        @cap.dump.should_receive(:run_remote).with("cd #{@remote_path}; rake -s dump:create PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=remote,photos").and_return('123.tgz')
+        expect(@cap.dump).to receive(:run_remote).with("cd #{@remote_path}; rake -s dump:create PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=remote,photos").and_return('123.tgz')
         grab_output{
           DumpRake::Env.with_env :tags => 'photos' do
             @cap.find_and_execute_task("dump:remote:create")
@@ -317,8 +317,8 @@ describe "cap dump" do
       end
 
       it "should call remote rake task with fetched rails_env and default DESC remote" do
-        @cap.dump.should_receive(:fetch_rails_env).and_return('dev')
-        @cap.dump.should_receive(:run_remote).with("cd #{@remote_path}; rake -s dump:create PROGRESS_TTY\\=\\+ RAILS_ENV\\=dev TAGS\\=remote").and_return('123.tgz')
+        expect(@cap.dump).to receive(:fetch_rails_env).and_return('dev')
+        expect(@cap.dump).to receive(:run_remote).with("cd #{@remote_path}; rake -s dump:create PROGRESS_TTY\\=\\+ RAILS_ENV\\=dev TAGS\\=remote").and_return('123.tgz')
         grab_output{
           @cap.find_and_execute_task("dump:remote:create")
         }
@@ -332,22 +332,22 @@ describe "cap dump" do
       }, :return_value => '123.tgz')
 
       it "should print result of rake task" do
-        @cap.dump.stub(:run_remote).and_return("123123.tgz\n")
-        grab_output{
+        allow(@cap.dump).to receive(:run_remote).and_return("123123.tgz\n")
+        expect(grab_output{
           @cap.find_and_execute_task("dump:remote:create")
-        }[:stdout].should == "123123.tgz\n"
+        }[:stdout]).to eq("123123.tgz\n")
       end
 
       it "should return stripped result of rake task" do
-        @cap.dump.stub(:run_remote).and_return("123123.tgz\n")
+        allow(@cap.dump).to receive(:run_remote).and_return("123123.tgz\n")
         grab_output{
-          @cap.find_and_execute_task("dump:remote:create").should == "123123.tgz"
+          expect(@cap.find_and_execute_task("dump:remote:create")).to eq("123123.tgz")
         }
       end
 
       it "should use custom rake binary" do
-        @cap.dump.should_receive(:fetch_rake).and_return('/custom/rake')
-        @cap.dump.should_receive(:run_remote).with("cd #{@remote_path}; /custom/rake -s dump:create PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=remote").and_return('123.tgz')
+        expect(@cap.dump).to receive(:fetch_rake).and_return('/custom/rake')
+        expect(@cap.dump).to receive(:run_remote).with("cd #{@remote_path}; /custom/rake -s dump:create PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=remote").and_return('123.tgz')
         grab_output{
           @cap.find_and_execute_task("dump:remote:create")
         }
@@ -356,13 +356,13 @@ describe "cap dump" do
 
     describe "restore" do
       it "should call remote rake task with default rails_env" do
-        @cap.dump.should_receive(:run_remote).with("cd #{@remote_path}; rake -s dump:restore PROGRESS_TTY\\=\\+ RAILS_ENV\\=production")
+        expect(@cap.dump).to receive(:run_remote).with("cd #{@remote_path}; rake -s dump:restore PROGRESS_TTY\\=\\+ RAILS_ENV\\=production")
         @cap.find_and_execute_task("dump:remote:restore")
       end
 
       it "should call remote rake task with fetched rails_env" do
-        @cap.dump.should_receive(:fetch_rails_env).and_return('dev')
-        @cap.dump.should_receive(:run_remote).with("cd #{@remote_path}; rake -s dump:restore PROGRESS_TTY\\=\\+ RAILS_ENV\\=dev")
+        expect(@cap.dump).to receive(:fetch_rails_env).and_return('dev')
+        expect(@cap.dump).to receive(:run_remote).with("cd #{@remote_path}; rake -s dump:restore PROGRESS_TTY\\=\\+ RAILS_ENV\\=dev")
         @cap.find_and_execute_task("dump:remote:restore")
       end
 
@@ -376,20 +376,20 @@ describe "cap dump" do
       })
 
       it "should use custom rake binary" do
-        @cap.dump.should_receive(:fetch_rake).and_return('/custom/rake')
-        @cap.dump.should_receive(:run_remote).with("cd #{@remote_path}; /custom/rake -s dump:restore PROGRESS_TTY\\=\\+ RAILS_ENV\\=production")
+        expect(@cap.dump).to receive(:fetch_rake).and_return('/custom/rake')
+        expect(@cap.dump).to receive(:run_remote).with("cd #{@remote_path}; /custom/rake -s dump:restore PROGRESS_TTY\\=\\+ RAILS_ENV\\=production")
         @cap.find_and_execute_task("dump:remote:restore")
       end
     end
 
     describe "download" do
       it "should run rake versions to get avaliable versions" do
-        @cap.dump.should_receive(:run_remote).with("cd #{@remote_path}; rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production").and_return('')
+        expect(@cap.dump).to receive(:run_remote).with("cd #{@remote_path}; rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production").and_return('')
         @cap.find_and_execute_task("dump:remote:download")
       end
 
       it "should block sending summary to versions" do
-        @cap.dump.should_receive(:run_remote).with("cd #{@remote_path}; rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production").and_return('')
+        expect(@cap.dump).to receive(:run_remote).with("cd #{@remote_path}; rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production").and_return('')
         DumpRake::Env::DICTIONARY[:summary].each do |name|
           DumpRake::Env.with_env name => 'true' do
             @cap.find_and_execute_task("dump:remote:download")
@@ -405,35 +405,35 @@ describe "cap dump" do
       }, :cap_task => "dump:remote:download")
 
       it "should not download anything if there are no versions avaliable" do
-        @cap.dump.stub(:run_remote).and_return('')
-        @cap.dump.should_not_receive(:do_transfer)
+        allow(@cap.dump).to receive(:run_remote).and_return('')
+        expect(@cap.dump).not_to receive(:do_transfer)
         @cap.find_and_execute_task("dump:remote:download")
       end
 
       it "should transfer latest version dump" do
-        @cap.dump.stub(:run_remote).and_return("100.tgz\n200.tgz\n300.tgz\n")
-        @cap.dump.should_receive(:do_transfer).with(:down, "#{@remote_path}/dump/300.tgz", "dump/300.tgz")
-        FileUtils.stub(:mkpath)
+        allow(@cap.dump).to receive(:run_remote).and_return("100.tgz\n200.tgz\n300.tgz\n")
+        expect(@cap.dump).to receive(:do_transfer).with(:down, "#{@remote_path}/dump/300.tgz", "dump/300.tgz")
+        allow(FileUtils).to receive(:mkpath)
         @cap.find_and_execute_task("dump:remote:download")
       end
 
       it "should handle extra spaces around file names" do
-        @cap.dump.stub(:run_remote).and_return("\r\n\r\n\r  100.tgz   \r\n\r\n\r  200.tgz   \r\n\r\n\r  300.tgz   \r\n\r\n\r  ")
-        @cap.dump.should_receive(:do_transfer).with(:down, "#{@remote_path}/dump/300.tgz", "dump/300.tgz")
-        FileUtils.stub(:mkpath)
+        allow(@cap.dump).to receive(:run_remote).and_return("\r\n\r\n\r  100.tgz   \r\n\r\n\r  200.tgz   \r\n\r\n\r  300.tgz   \r\n\r\n\r  ")
+        expect(@cap.dump).to receive(:do_transfer).with(:down, "#{@remote_path}/dump/300.tgz", "dump/300.tgz")
+        allow(FileUtils).to receive(:mkpath)
         @cap.find_and_execute_task("dump:remote:download")
       end
 
       it "should create local dump dir" do
-        @cap.dump.stub(:run_remote).and_return("100.tgz\n200.tgz\n300.tgz\n")
-        @cap.dump.stub(:do_transfer)
-        FileUtils.should_receive(:mkpath).with('dump')
+        allow(@cap.dump).to receive(:run_remote).and_return("100.tgz\n200.tgz\n300.tgz\n")
+        allow(@cap.dump).to receive(:do_transfer)
+        expect(FileUtils).to receive(:mkpath).with('dump')
         @cap.find_and_execute_task("dump:remote:download")
       end
 
       it "should run rake versions use custom rake binary" do
-        @cap.dump.should_receive(:fetch_rake).and_return('/custom/rake')
-        @cap.dump.should_receive(:run_remote).with("cd #{@remote_path}; /custom/rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production").and_return('')
+        expect(@cap.dump).to receive(:fetch_rake).and_return('/custom/rake')
+        expect(@cap.dump).to receive(:run_remote).with("cd #{@remote_path}; /custom/rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production").and_return('')
         @cap.find_and_execute_task("dump:remote:download")
       end
     end
@@ -445,55 +445,55 @@ describe "cap dump" do
       dst = way[1]
       describe name do
         it "should create auto-backup with tag auto-backup" do
-          @cap.dump.namespaces[dst].should_receive(:create){ DumpRake::Env[:tags].should == 'auto-backup'; '' }
+          expect(@cap.dump.namespaces[dst]).to receive(:create){ expect(DumpRake::Env[:tags]).to eq('auto-backup'); '' }
           @cap.find_and_execute_task("dump:mirror:#{dir}")
         end
 
         it "should create auto-backup with additional tag auto-backup" do
-          @cap.dump.namespaces[dst].should_receive(:create){ DumpRake::Env[:tags].should == 'auto-backup,photos'; '' }
+          expect(@cap.dump.namespaces[dst]).to receive(:create){ expect(DumpRake::Env[:tags]).to eq('auto-backup,photos'); '' }
           DumpRake::Env.with_env :tags => 'photos' do
             @cap.find_and_execute_task("dump:mirror:#{dir}")
           end
         end
 
         it "should not call local:create if auto-backup fails" do
-          @cap.dump.namespaces[dst].stub(:create).and_return('')
-          @cap.dump.namespaces[src].should_not_receive(:create)
+          allow(@cap.dump.namespaces[dst]).to receive(:create).and_return('')
+          expect(@cap.dump.namespaces[src]).not_to receive(:create)
           @cap.find_and_execute_task("dump:mirror:#{dir}")
         end
 
         it "should call local:create if auto-backup succeedes with tags mirror and mirror-#{dir}" do
-          @cap.dump.namespaces[dst].stub(:create).and_return('123.tgz')
-          @cap.dump.namespaces[src].should_receive(:create){ DumpRake::Env[:tags].should == "mirror"; '' }
+          allow(@cap.dump.namespaces[dst]).to receive(:create).and_return('123.tgz')
+          expect(@cap.dump.namespaces[src]).to receive(:create){ expect(DumpRake::Env[:tags]).to eq("mirror"); '' }
           @cap.find_and_execute_task("dump:mirror:#{dir}")
         end
 
         it "should call local:create if auto-backup succeedes with additional tags mirror and mirror-#{dir}" do
-          @cap.dump.namespaces[dst].stub(:create).and_return('123.tgz')
-          @cap.dump.namespaces[src].should_receive(:create){ DumpRake::Env[:tags].should == "mirror,photos"; '' }
+          allow(@cap.dump.namespaces[dst]).to receive(:create).and_return('123.tgz')
+          expect(@cap.dump.namespaces[src]).to receive(:create){ expect(DumpRake::Env[:tags]).to eq("mirror,photos"); '' }
           DumpRake::Env.with_env :tags => 'photos' do
             @cap.find_and_execute_task("dump:mirror:#{dir}")
           end
         end
 
         it "should not call local:upload or remote:restore if local:create fails" do
-          @cap.dump.namespaces[dst].stub(:create).and_return('123.tgz')
-          @cap.dump.namespaces[src].stub(:create).and_return('')
-          @cap.dump.namespaces[src].should_not_receive(:upload)
-          @cap.dump.namespaces[dst].should_not_receive(:restore)
+          allow(@cap.dump.namespaces[dst]).to receive(:create).and_return('123.tgz')
+          allow(@cap.dump.namespaces[src]).to receive(:create).and_return('')
+          expect(@cap.dump.namespaces[src]).not_to receive(:upload)
+          expect(@cap.dump.namespaces[dst]).not_to receive(:restore)
           @cap.find_and_execute_task("dump:mirror:#{dir}")
         end
 
         it "should call local:upload and remote:restore with only varibale ver set to file name if local:create returns file name" do
-          @cap.dump.namespaces[dst].stub(:create).and_return('123.tgz')
-          @cap.dump.namespaces[src].stub(:create).and_return('123.tgz')
+          allow(@cap.dump.namespaces[dst]).to receive(:create).and_return('123.tgz')
+          allow(@cap.dump.namespaces[src]).to receive(:create).and_return('123.tgz')
           test_env = proc{
-            DumpRake::Env[:like].should == '123.tgz'
-            DumpRake::Env[:tags].should == nil
-            DumpRake::Env[:desc].should == nil
+            expect(DumpRake::Env[:like]).to eq('123.tgz')
+            expect(DumpRake::Env[:tags]).to eq(nil)
+            expect(DumpRake::Env[:desc]).to eq(nil)
           }
-          @cap.dump.namespaces[src].should_receive(:"#{dir}load").ordered(&test_env)
-          @cap.dump.namespaces[dst].should_receive(:restore).ordered(&test_env)
+          expect(@cap.dump.namespaces[src]).to receive(:"#{dir}load").ordered(&test_env)
+          expect(@cap.dump.namespaces[dst]).to receive(:restore).ordered(&test_env)
           DumpRake::Env.with_env all_dictionary_variables do
             @cap.find_and_execute_task("dump:mirror:#{dir}")
           end
@@ -504,33 +504,33 @@ describe "cap dump" do
 
   describe "backup" do
     it "should call remote:create" do
-      @cap.dump.remote.should_receive(:create).and_return('')
+      expect(@cap.dump.remote).to receive(:create).and_return('')
       @cap.find_and_execute_task("dump:backup")
     end
 
     it "should not call remote:download if remote:create returns blank" do
-      @cap.dump.remote.stub(:create).and_return('')
-      @cap.dump.remote.should_not_receive(:download)
+      allow(@cap.dump.remote).to receive(:create).and_return('')
+      expect(@cap.dump.remote).not_to receive(:download)
       @cap.find_and_execute_task("dump:backup")
     end
 
     it "should call remote:download if remote:create returns file name" do
-      @cap.dump.remote.stub(:create).and_return('123.tgz')
-      @cap.dump.remote.should_receive(:download).ordered
+      allow(@cap.dump.remote).to receive(:create).and_return('123.tgz')
+      expect(@cap.dump.remote).to receive(:download).ordered
       @cap.find_and_execute_task("dump:backup")
     end
 
     it "should call remote:create with tag backup" do
-      def (@cap.dump.remote).create
-        DumpRake::Env[:tags].should == 'backup'
+      expect(@cap.dump.remote).to receive(:create) do
+        expect(DumpRake::Env[:tags]).to eq('backup')
         ''
       end
       @cap.find_and_execute_task("dump:backup")
     end
 
     it "should call remote:create with additional tag backup" do
-      def (@cap.dump.remote).create
-        DumpRake::Env[:tags].should == 'backup,photos'
+      expect(@cap.dump.remote).to receive(:create) do
+        expect(DumpRake::Env[:tags]).to eq('backup,photos')
         ''
       end
       DumpRake::Env.with_env :tags => 'photos' do
@@ -539,8 +539,8 @@ describe "cap dump" do
     end
 
     it "should pass description if it is set" do
-      def (@cap.dump.remote).create
-        DumpRake::Env[:desc].should == 'remote dump'
+      expect(@cap.dump.remote).to receive(:create) do
+        expect(DumpRake::Env[:desc]).to eq('remote dump')
         ''
       end
       DumpRake::Env.with_env :desc => 'remote dump' do
@@ -549,11 +549,11 @@ describe "cap dump" do
     end
 
     it "should send only ver variable" do
-      @cap.dump.remote.stub(:create).and_return('123.tgz')
-      def (@cap.dump.remote).download
-        DumpRake::Env[:like].should == '123.tgz'
-        DumpRake::Env[:tags].should == nil
-        DumpRake::Env[:desc].should == nil
+      allow(@cap.dump.remote).to receive(:create).and_return('123.tgz')
+      expect(@cap.dump.remote).to receive(:download) do
+        expect(DumpRake::Env[:like]).to eq('123.tgz')
+        expect(DumpRake::Env[:tags]).to eq(nil)
+        expect(DumpRake::Env[:desc]).to eq(nil)
         ''
       end
       DumpRake::Env.with_env all_dictionary_variables do