dump 1.0.4 → 1.0.5

data/spec/lib/dump_rake_spec.rb

@@ -1,25 +1,25 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 
 describe DumpRake do
-  describe "versions" do
-    it "should call Dump.list if called without version" do
+  describe 'versions' do
+    it 'should call Dump.list if called without version' do
       expect(DumpRake::Dump).to receive(:list).and_return([])
       DumpRake.versions
     end
 
-    it "should call Dump.list with options if called with version" do
+    it 'should call Dump.list with options if called with version' do
       expect(DumpRake::Dump).to receive(:list).with(:like => '123').and_return([])
       DumpRake.versions(:like => '123')
     end
 
-    it "should print versions" do
+    it 'should print versions' do
       expect(DumpRake::Dump).to receive(:list).and_return(%w[123.tgz 456.tgz])
-      expect(grab_output{
+      expect(grab_output do
         DumpRake.versions
-      }[:stdout]).to eq("123.tgz\n456.tgz\n")
+      end[:stdout]).to eq("123.tgz\n456.tgz\n")
     end
 
-    it "should not show summary if not asked for" do
+    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"))
         expect(DumpRake::DumpReader).not_to receive(:summary)
@@ -27,13 +27,13 @@ describe DumpRake do
       end
 
       expect(DumpRake::Dump).to receive(:list).and_return(dumps)
-      grab_output{
+      grab_output do
         expect($stderr).not_to receive(:puts)
         DumpRake.versions
-      }
+      end
     end
 
-    it "should show summary if asked for" 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"))
         expect(DumpRake::DumpReader).to receive(:summary).with(dump.path)
@@ -41,13 +41,13 @@ describe DumpRake do
       end
 
       expect(DumpRake::Dump).to receive(:list).and_return(dumps)
-      grab_output{
+      grab_output do
         expect($stderr).not_to receive(:puts)
         DumpRake.versions(:summary => '1')
-      }
+      end
     end
 
-    it "should show summary with scmema if asked for" 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"))
         expect(DumpRake::DumpReader).to receive(:summary).with(dump.path, :schema => true)
@@ -55,13 +55,13 @@ describe DumpRake do
       end
 
       expect(DumpRake::Dump).to receive(:list).and_return(dumps)
-      grab_output{
+      grab_output do
         expect($stderr).not_to receive(:puts)
         DumpRake.versions(:summary => '2')
-      }
+      end
     end
 
-    it "should show output to stderr if summary raises error" do
+    it 'should show output to stderr if summary raises error' do
       allow(DumpRake::DumpReader).to receive(:summary)
       dumps = %w[123.tgz 456.tgz].map do |s|
         double("dump_#{s}", :path => double("dump_#{s}_path"))
@@ -69,26 +69,26 @@ describe DumpRake do
       expect(DumpRake::DumpReader).to receive(:summary).with(dumps[1].path).and_raise('terrible error')
 
       expect(DumpRake::Dump).to receive(:list).and_return(dumps)
-      grab_output{
+      grab_output do
         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')
-      }
+      end
     end
   end
 
-  describe "create" do
-    describe "naming" do
+  describe 'create' do
+    describe 'naming' do
       it "should create file in 'rails app root'/dump" do
         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{
+        grab_output do
           DumpRake.create
-        }
+        end
       end
 
       it "should create file with name like 'yyyymmddhhmmss.tmp' when called without description" do
@@ -96,9 +96,9 @@ describe DumpRake do
         expect(DumpRake::DumpWriter).to receive(:create) do |path|
           expect(File.basename(path)).to match(/^\d{14}\.tmp$/)
         end
-        grab_output{
+        grab_output do
           DumpRake.create
-        }
+        end
       end
 
       it "should create file with name like 'yyyymmddhhmmss-Some text and _.tmp' when called with description 'Some text and !@'" do
@@ -106,9 +106,9 @@ describe DumpRake do
         expect(DumpRake::DumpWriter).to receive(:create) do |path|
           expect(File.basename(path)).to match(/^\d{14}-Some text and _\.tmp$/)
         end
-        grab_output{
+        grab_output do
           DumpRake.create(:desc => 'Some text and !@')
-        }
+        end
       end
 
       it "should create file with name like 'yyyymmddhhmmss@super tag,second.tmp' when called with description 'Some text and !@'" do
@@ -116,142 +116,142 @@ describe DumpRake do
         expect(DumpRake::DumpWriter).to receive(:create) do |path|
           expect(File.basename(path)).to match(/^\d{14}-Some text and _\.tmp$/)
         end
-        grab_output{
+        grab_output do
           DumpRake.create(:desc => 'Some text and !@')
-        }
+        end
       end
 
-      it "should rename file after creating" do
+      it 'should rename file after creating' do
         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
         allow(DumpRake::DumpWriter).to receive(:create)
-        grab_output{
+        grab_output do
           DumpRake.create(:desc => 'Some text and !@')
-        }
+        end
       end
 
-      it "should output file name" do
+      it 'should output file name' do
         allow(File).to receive(:rename)
         allow(DumpRake::DumpWriter).to receive(:create)
-        expect(grab_output{
+        expect(grab_output do
           DumpRake.create(:desc => 'Some text and !@')
-        }[:stdout]).to match(/^\d{14}-Some text and _\.tgz$/)
+        end[:stdout]).to match(/^\d{14}-Some text and _\.tgz$/)
       end
     end
 
-    describe "writing" do
-      it "should dump schema, tables, assets" do
+    describe 'writing' do
+      it 'should dump schema, tables, assets' do
         allow(File).to receive(:rename)
         @dump = double('dump')
         expect(DumpRake::DumpWriter).to receive(:create)
 
-        grab_output{
+        grab_output do
           DumpRake.create
-        }
+        end
       end
     end
   end
 
-  describe "restore" do
-    describe "without version" do
-      it "should call Dump.list" do
+  describe 'restore' do
+    describe 'without version' do
+      it 'should call Dump.list' do
         allow(DumpRake::Dump).to receive(:list)
         expect(DumpRake::Dump).to receive(:list).and_return([])
-        grab_output{
+        grab_output do
           DumpRake.restore
-        }
+        end
       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
+      it 'should not call DumpReader.restore and should call Dump.list and output it to $stderr if there are no versions at all' do
         allow(DumpRake::Dump).to receive(:list).and_return([])
         expect(DumpRake::DumpReader).not_to receive(:restore)
         all_dumps = double('all_dumps')
         expect(DumpRake::Dump).to receive(:list).with(no_args).and_return(all_dumps)
-        grab_output{
+        grab_output do
           expect($stderr).to receive(:puts).with(kind_of(String))
           expect($stderr).to receive(:puts).with(all_dumps)
           DumpRake.restore
-        }
+        end
       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
+      it 'should not call DumpReader.restore and should call Dump.list and output it to $stderr if there are no versions at all' do
         allow(DumpRake::Dump).to receive(:list).and_return([])
         expect(DumpRake::DumpReader).not_to receive(:restore)
         all_dumps = double('all_dumps')
         expect(DumpRake::Dump).to receive(:list).with(no_args).and_return(all_dumps)
-        grab_output{
+        grab_output do
           expect($stderr).to receive(:puts).with(kind_of(String))
           expect($stderr).to receive(:puts).with(all_dumps)
           DumpRake.restore('213')
-        }
+        end
       end
 
-      it "should call DumpReader.restore if there are versions" do
+      it 'should call DumpReader.restore if there are versions' do
         @dump = double('dump', :path => '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{
+        grab_output do
           expect($stderr).not_to receive(:puts)
           DumpRake.restore
-        }
+        end
       end
     end
 
-    describe "with version" do
-      it "should call Dump.list with options" do
+    describe 'with version' do
+      it 'should call Dump.list with options' do
         allow(DumpRake::Dump).to receive(:list)
         expect(DumpRake::Dump).to receive(:list).with(:like => '213').and_return([])
-        grab_output{
+        grab_output do
           DumpRake.restore(:like => '213')
-        }
+        end
       end
 
-      it "should not call DumpReader.restore and should call versions if desired version not found" do
+      it 'should not call DumpReader.restore and should call versions if desired version not found' do
         allow(DumpRake::Dump).to receive(:list).and_return([])
         expect(DumpRake::DumpReader).not_to receive(:restore)
         all_dumps = double('all_dumps')
         expect(DumpRake::Dump).to receive(:list).with(no_args).and_return(all_dumps)
-        grab_output{
+        grab_output do
           expect($stderr).to receive(:puts).with(kind_of(String))
           expect($stderr).to receive(:puts).with(all_dumps)
           DumpRake.restore('213')
-        }
+        end
       end
 
-      it "should call DumpReader.restore if there is desired version" do
+      it 'should call DumpReader.restore if there is desired version' do
         @dump = double('dump', :path => 'dump/213.tgz')
         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{
+        grab_output do
           expect($stderr).not_to receive(:puts)
           DumpRake.restore(:like => '213')
-        }
+        end
       end
 
-      it "should call DumpReader.restore on last version if found multiple matching versions" 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')
         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{
+        grab_output do
           expect($stderr).not_to receive(:puts)
           DumpRake.restore(:like => '213')
-        }
+        end
       end
     end
   end
 
-  describe "cleanup" do
-    it "should call ask for all files in dump dir and for dumps" do
+  describe 'cleanup' do
+    it 'should call ask for all files in dump dir and for dumps' do
       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
+    it 'should call Dump.list with options if called with version and tags' do
       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')
@@ -290,13 +290,13 @@ describe DumpRake do
 
         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{
+        grab_output do
           DumpRake.cleanup({:like => '123', :tags => 'a,b,c'}.merge(options))
-        }
+        end
       end
     end
 
-    it "should print to stderr if can not delete dump" 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"))
         allow(dump).to receive(:lock).and_yield
@@ -307,20 +307,20 @@ describe DumpRake do
       expect(dumps[3].path).to receive(:unlink).and_raise('Horrible error')
 
       allow(DumpRake::Dump).to receive(:list).and_return(dumps)
-      grab_output{
+      grab_output do
         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
     end
 
     it "should raise if called with :leave which is not a number or 'none'" do
-      expect{
+      expect do
         DumpRake.cleanup(:leave => 'nothing')
-      }.to raise_error
+      end.to raise_error
     end
   end
 end

data/spec/recipes/dump_spec.rb

@@ -1,12 +1,12 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+require 'spec_helper'
 require 'capistrano'
 
-describe "cap dump" do
+describe 'cap dump' do
   before do
     @cap = Capistrano::Configuration.new
     Capistrano::Configuration.instance = @cap
-    @cap.load File.dirname(__FILE__) + '/../../recipes/dump.rb'
-    @remote_path = "/home/test/apps/dummy"
+    @cap.load File.expand_path('../../../recipes/dump.rb', __FILE__)
+    @remote_path = '/home/test/apps/dummy'
     @cap.set(:current_path, @remote_path)
   end
 
@@ -21,7 +21,7 @@ describe "cap dump" do
       command_string = command_strings[variable]
       DumpRake::Env::DICTIONARY[variable].each do |name|
         it "should pass #{variable} if it is set through environment variable #{name}" do
-          violated "command_string not specified" unless command_string
+          violated 'command_string not specified' unless command_string
           full_command_string = command_string
           full_command_string = "cd #{@remote_path}; #{command_string}" if place == :remote
           expect(@cap.dump).to receive(:"run_#{place}").with(full_command_string).and_return(options[:return_value] || '')
@@ -36,66 +36,66 @@ describe "cap dump" do
 
   describe :dump_command do
 
-    it "should return escaped string" do
+    it 'should return escaped string' do
       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
+    it 'should return escaped string for complex rake invocation command' do
       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
+  describe 'do_transfer' do
     before do
       allow(@cap.dump).to receive(:do_transfer_via)
     end
 
     [:up, :down].each do |direction|
       describe direction do
-        describe "if method not set" do
+        describe 'if method not set' do
 
-          it "should call got_rsync?" do
+          it 'should call got_rsync?' do
             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
+          describe 'if got_rsync?' do
+            it 'should use rsync' do
               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
+            it 'should raise if rsync fails' do
               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{
+              expect do
                 grab_output{ @cap.dump.do_transfer(direction, 'a.tgz', 'b.tgz') }
-              }.to raise_error('problem using rsync')
+              end.to raise_error('problem using rsync')
             end
           end
 
-          describe "unless got_rsync?" do
-            it "should try sftp" do
+          describe 'unless got_rsync?' do
+            it 'should try sftp' do
               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
+            it 'should try scp after sftp' do
               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
+            it 'should not rescue if scp also fails' do
               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{
+              expect do
                 grab_output{ @cap.dump.do_transfer(direction, 'a.tgz', 'b.tgz') }
-              }.to raise_error('problem using scp')
+              end.to raise_error('problem using scp')
             end
           end
         end
@@ -103,360 +103,384 @@ describe "cap dump" do
     end
   end
 
-  describe "local" do
-    describe "versions" do
-      it "should call local rake task" do
-        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")
+  describe 'local' do
+    it 'should call local:create' do
+      expect(@cap.dump.local).to receive(:create).and_return('')
+      @cap.find_and_execute_task('dump:local')
+    end
+
+    describe 'versions' do
+      it 'should call local rake task' do
+        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
 
       test_passing_environment_variables(:local, :versions, {
-        :like => "rake -s dump:versions LIKE\\=some\\ data SHOW_SIZE\\=true",
-        :tags => "rake -s dump:versions SHOW_SIZE\\=true TAGS\\=some\\ data",
-        :summary => "rake -s dump:versions SHOW_SIZE\\=true SUMMARY\\=some\\ data",
+        :like => 'rake -s dump:versions LIKE\\=some\\ data SHOW_SIZE\\=true',
+        :tags => 'rake -s dump:versions SHOW_SIZE\\=true TAGS\\=some\\ data',
+        :summary => 'rake -s dump:versions SHOW_SIZE\\=true SUMMARY\\=some\\ data',
       })
 
-      it "should print result of rake task" do
+      it 'should print result of rake task' do
         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]).to eq(" 123M\t123123.tgz\n")
+        expect(grab_output do
+          @cap.find_and_execute_task('dump:local:versions')
+        end[:stdout]).to eq(" 123M\t123123.tgz\n")
       end
     end
 
-    describe "cleanup" do
-      it "should call local rake task" do
-        expect(@cap.dump).to receive(:run_local).with("rake -s dump:cleanup").and_return('')
-        @cap.find_and_execute_task("dump:local:cleanup")
+    describe 'cleanup' do
+      it 'should call local rake task' do
+        expect(@cap.dump).to receive(:run_local).with('rake -s dump:cleanup').and_return('')
+        @cap.find_and_execute_task('dump:local:cleanup')
       end
 
       test_passing_environment_variables(:local, :cleanup, {
-        :like => "rake -s dump:cleanup LIKE\\=some\\ data",
-        :tags => "rake -s dump:cleanup TAGS\\=some\\ data",
-        :leave => "rake -s dump:cleanup LEAVE\\=some\\ data",
+        :like => 'rake -s dump:cleanup LIKE\\=some\\ data',
+        :tags => 'rake -s dump:cleanup TAGS\\=some\\ data',
+        :leave => 'rake -s dump:cleanup LEAVE\\=some\\ data',
       })
 
-      it "should print result of rake task" do
+      it 'should print result of rake task' do
         allow(@cap.dump).to receive(:run_local).and_return("123123.tgz\n")
-        expect(grab_output{
-          @cap.find_and_execute_task("dump:local:cleanup")
-        }[:stdout]).to eq("123123.tgz\n")
+        expect(grab_output do
+          @cap.find_and_execute_task('dump:local:cleanup')
+        end[:stdout]).to eq("123123.tgz\n")
       end
     end
 
-    describe "create" do
-      it "should raise if dump creation fails" do
-        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")
-        }.to raise_error('Failed creating dump')
+    describe 'create' do
+      it 'should raise if dump creation fails' do
+        expect(@cap.dump).to receive(:run_local).with('rake -s dump:create TAGS\\=local').and_return('')
+        expect do
+          @cap.find_and_execute_task('dump:local:create')
+        end.to raise_error('Failed creating dump')
       end
 
-      it "should call local rake task with tag local" do
-        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")
-        }
+      it 'should call local rake task with tag local' do
+        expect(@cap.dump).to receive(:run_local).with('rake -s dump:create TAGS\\=local').and_return('123.tgz')
+        grab_output do
+          @cap.find_and_execute_task('dump:local:create')
+        end
       end
 
-      it "should call local rake task with additional tag local" do
-        expect(@cap.dump).to receive(:run_local).with("rake -s dump:create TAGS\\=local,photos").and_return('123.tgz')
-        grab_output{
+      it 'should call local rake task with additional tag local' do
+        expect(@cap.dump).to receive(:run_local).with('rake -s dump:create TAGS\\=local,photos').and_return('123.tgz')
+        grab_output do
           DumpRake::Env.with_env :tags => 'photos' do
-            @cap.find_and_execute_task("dump:local:create")
+            @cap.find_and_execute_task('dump:local:create')
           end
-        }
+        end
       end
 
       test_passing_environment_variables(:local, :create, {
-        :desc => "rake -s dump:create DESC\\=some\\ data TAGS\\=local",
-        :tags => "rake -s dump:create TAGS\\=local,some\\ data",
-        :tables => "rake -s dump:create TABLES\\=some\\ data TAGS\\=local",
-        :assets => "rake -s dump:create ASSETS\\=some\\ data TAGS\\=local",
+        :desc => 'rake -s dump:create DESC\\=some\\ data TAGS\\=local',
+        :tags => 'rake -s dump:create TAGS\\=local,some\\ data',
+        :tables => 'rake -s dump:create TABLES\\=some\\ data TAGS\\=local',
+        :assets => 'rake -s dump:create ASSETS\\=some\\ data TAGS\\=local',
       }, :return_value => '123.tgz')
 
-      it "should print result of rake task" do
+      it 'should print result of rake task' do
         allow(@cap.dump).to receive(:run_local).and_return("123123.tgz\n")
-        expect(grab_output{
-          @cap.find_and_execute_task("dump:local:create")
-        }[:stdout]).to eq("123123.tgz\n")
+        expect(grab_output do
+          @cap.find_and_execute_task('dump:local:create')
+        end[:stdout]).to eq("123123.tgz\n")
       end
 
-      it "should return stripped result of rake task" do
+      it 'should return stripped result of rake task' do
         allow(@cap.dump).to receive(:run_local).and_return("123123.tgz\n")
-        grab_output{
-          expect(@cap.find_and_execute_task("dump:local:create")).to eq("123123.tgz")
-        }
+        grab_output do
+          expect(@cap.find_and_execute_task('dump:local:create')).to eq('123123.tgz')
+        end
       end
     end
 
-    describe "restore" do
-      it "should call local rake task" do
-        expect(@cap.dump).to receive(:run_local).with("rake -s dump:restore")
-        @cap.find_and_execute_task("dump:local:restore")
+    describe 'restore' do
+      it 'should call local rake task' do
+        expect(@cap.dump).to receive(:run_local).with('rake -s dump:restore')
+        @cap.find_and_execute_task('dump:local:restore')
       end
 
       test_passing_environment_variables(:local, :restore, {
-        :like => "rake -s dump:restore LIKE\\=some\\ data",
-        :tags => "rake -s dump:restore TAGS\\=some\\ data",
-        :migrate_down => "rake -s dump:restore MIGRATE_DOWN\\=some\\ data",
-        :restore_schema => "rake -s dump:restore RESTORE_SCHEMA\\=some\\ data",
-        :restore_tables => "rake -s dump:restore RESTORE_TABLES\\=some\\ data",
-        :restore_assets => "rake -s dump:restore RESTORE_ASSETS\\=some\\ data",
+        :like => 'rake -s dump:restore LIKE\\=some\\ data',
+        :tags => 'rake -s dump:restore TAGS\\=some\\ data',
+        :migrate_down => 'rake -s dump:restore MIGRATE_DOWN\\=some\\ data',
+        :restore_schema => 'rake -s dump:restore RESTORE_SCHEMA\\=some\\ data',
+        :restore_tables => 'rake -s dump:restore RESTORE_TABLES\\=some\\ data',
+        :restore_assets => 'rake -s dump:restore RESTORE_ASSETS\\=some\\ data',
       })
     end
 
-    describe "upload" do
-      it "should run rake versions to get avaliable versions" do
-        expect(@cap.dump).to receive(:run_local).with("rake -s dump:versions").and_return('')
-        @cap.find_and_execute_task("dump:local:upload")
+    describe 'upload' do
+      it 'should run rake versions to get avaliable versions' do
+        expect(@cap.dump).to receive(:run_local).with('rake -s dump:versions').and_return('')
+        @cap.find_and_execute_task('dump:local:upload')
       end
 
       test_passing_environment_variables(:local, :transfer, {
-        :like => "rake -s dump:versions LIKE\\=some\\ data",
-        :tags => "rake -s dump:versions TAGS\\=some\\ data",
-        :summary => "rake -s dump:versions", # block sending summary to versions
-        :transfer_via => "rake -s dump:versions", # tranfer_via is used internally
+        :like => 'rake -s dump:versions LIKE\\=some\\ data',
+        :tags => 'rake -s dump:versions TAGS\\=some\\ data',
+        :summary => 'rake -s dump:versions', # block sending summary to versions
+        :transfer_via => 'rake -s dump:versions', # tranfer_via is used internally
       }, :cap_task => 'dump:local:upload')
 
-      it "should not upload anything if there are no versions avaliable" do
+      it 'should not upload anything if there are no versions avaliable' do
         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")
+        @cap.find_and_execute_task('dump:local:upload')
       end
 
-      it "should transfer latest version dump" do
+      it 'should transfer latest version dump' do
         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")
+        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
+      it 'should handle extra spaces around file names' do
         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")
+        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
   end
 
-  describe "remote" do
-    describe "versions" do
-      it "should call remote rake task" do
+  describe 'remote' do
+    it 'should call remote:create' do
+      expect(@cap.dump.remote).to receive(:create).and_return('')
+      @cap.find_and_execute_task('dump:remote')
+    end
+
+    describe 'versions' do
+      it 'should call remote rake task' do
         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")
+        @cap.find_and_execute_task('dump:remote:versions')
       end
 
       test_passing_environment_variables(:remote, :versions, {
-        :like => "rake -s dump:versions LIKE\\=some\\ data PROGRESS_TTY\\=\\+ RAILS_ENV\\=production SHOW_SIZE\\=true",
-        :tags => "rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production SHOW_SIZE\\=true TAGS\\=some\\ data",
-        :summary => "rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production SHOW_SIZE\\=true SUMMARY\\=some\\ data",
+        :like => 'rake -s dump:versions LIKE\\=some\\ data PROGRESS_TTY\\=\\+ RAILS_ENV\\=production SHOW_SIZE\\=true',
+        :tags => 'rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production SHOW_SIZE\\=true TAGS\\=some\\ data',
+        :summary => 'rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production SHOW_SIZE\\=true SUMMARY\\=some\\ data',
       })
 
-      it "should print result of rake task" do
+      it 'should print result of rake task' do
         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]).to eq(" 123M\t123123.tgz\n")
+        expect(grab_output do
+          @cap.find_and_execute_task('dump:remote:versions')
+        end[:stdout]).to eq(" 123M\t123123.tgz\n")
       end
 
-      it "should use custom rake binary" do
+      it 'should use custom rake binary' do
         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")
+        @cap.find_and_execute_task('dump:remote:versions')
       end
     end
 
-    describe "cleanup" do
-      it "should call remote rake task" do
+    describe 'cleanup' do
+      it 'should call remote rake task' do
         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")
+        @cap.find_and_execute_task('dump:remote:cleanup')
       end
 
       test_passing_environment_variables(:remote, :cleanup, {
-        :like => "rake -s dump:cleanup LIKE\\=some\\ data PROGRESS_TTY\\=\\+ RAILS_ENV\\=production",
-        :tags => "rake -s dump:cleanup PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=some\\ data",
-        :leave => "rake -s dump:cleanup LEAVE\\=some\\ data PROGRESS_TTY\\=\\+ RAILS_ENV\\=production",
+        :like => 'rake -s dump:cleanup LIKE\\=some\\ data PROGRESS_TTY\\=\\+ RAILS_ENV\\=production',
+        :tags => 'rake -s dump:cleanup PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=some\\ data',
+        :leave => 'rake -s dump:cleanup LEAVE\\=some\\ data PROGRESS_TTY\\=\\+ RAILS_ENV\\=production',
       })
 
-      it "should print result of rake task" do
+      it 'should print result of rake task' do
         allow(@cap.dump).to receive(:run_remote).and_return("123123.tgz\n")
-        expect(grab_output{
-          @cap.find_and_execute_task("dump:remote:cleanup")
-        }[:stdout]).to eq("123123.tgz\n")
+        expect(grab_output do
+          @cap.find_and_execute_task('dump:remote:cleanup')
+        end[:stdout]).to eq("123123.tgz\n")
       end
 
-      it "should use custom rake binary" do
+      it 'should use custom rake binary' do
         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")
+        @cap.find_and_execute_task('dump:remote:cleanup')
       end
     end
 
-    describe "create" do
-      it "should raise if dump creation fails" do
+    describe 'create' do
+      it 'should raise if dump creation fails' do
         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")
-        }.to raise_error('Failed creating dump')
+        expect do
+          @cap.find_and_execute_task('dump:remote:create')
+        end.to raise_error('Failed creating dump')
       end
 
-      it "should call remote rake task with default rails_env and tag remote" do
+      it 'should call remote rake task with default rails_env and tag remote' do
         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")
-        }
+        grab_output do
+          @cap.find_and_execute_task('dump:remote:create')
+        end
       end
 
-      it "should call remote rake task with default rails_env and additional tag remote" do
+      it 'should call remote rake task with default rails_env and additional tag remote' do
         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{
+        grab_output do
           DumpRake::Env.with_env :tags => 'photos' do
-            @cap.find_and_execute_task("dump:remote:create")
+            @cap.find_and_execute_task('dump:remote:create')
           end
-        }
+        end
       end
 
-      it "should call remote rake task with fetched rails_env and default DESC remote" do
+      it 'should call remote rake task with fetched rails_env and default DESC remote' do
         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")
-        }
+        grab_output do
+          @cap.find_and_execute_task('dump:remote:create')
+        end
       end
 
       test_passing_environment_variables(:remote, :create, {
-        :desc => "rake -s dump:create DESC\\=some\\ data PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=remote",
-        :tags => "rake -s dump:create PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=remote,some\\ data",
-        :assets => "rake -s dump:create ASSETS\\=some\\ data PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=remote",
-        :tables => "rake -s dump:create PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TABLES\\=some\\ data TAGS\\=remote",
+        :desc => 'rake -s dump:create DESC\\=some\\ data PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=remote',
+        :tags => 'rake -s dump:create PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=remote,some\\ data',
+        :assets => 'rake -s dump:create ASSETS\\=some\\ data PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=remote',
+        :tables => 'rake -s dump:create PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TABLES\\=some\\ data TAGS\\=remote',
       }, :return_value => '123.tgz')
 
-      it "should print result of rake task" do
+      it 'should print result of rake task' do
         allow(@cap.dump).to receive(:run_remote).and_return("123123.tgz\n")
-        expect(grab_output{
-          @cap.find_and_execute_task("dump:remote:create")
-        }[:stdout]).to eq("123123.tgz\n")
+        expect(grab_output do
+          @cap.find_and_execute_task('dump:remote:create')
+        end[:stdout]).to eq("123123.tgz\n")
       end
 
-      it "should return stripped result of rake task" do
+      it 'should return stripped result of rake task' do
         allow(@cap.dump).to receive(:run_remote).and_return("123123.tgz\n")
-        grab_output{
-          expect(@cap.find_and_execute_task("dump:remote:create")).to eq("123123.tgz")
-        }
+        grab_output do
+          expect(@cap.find_and_execute_task('dump:remote:create')).to eq('123123.tgz')
+        end
       end
 
-      it "should use custom rake binary" do
+      it 'should use custom rake binary' do
         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")
-        }
+        grab_output do
+          @cap.find_and_execute_task('dump:remote:create')
+        end
       end
     end
 
-    describe "restore" do
-      it "should call remote rake task with default rails_env" do
+    describe 'restore' do
+      it 'should call remote rake task with default rails_env' do
         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")
+        @cap.find_and_execute_task('dump:remote:restore')
       end
 
-      it "should call remote rake task with fetched rails_env" do
+      it 'should call remote rake task with fetched rails_env' do
         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")
+        @cap.find_and_execute_task('dump:remote:restore')
       end
 
       test_passing_environment_variables(:remote, :restore, {
-        :like => "rake -s dump:restore LIKE\\=some\\ data PROGRESS_TTY\\=\\+ RAILS_ENV\\=production",
-        :tags => "rake -s dump:restore PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=some\\ data",
-        :migrate_down => "rake -s dump:restore MIGRATE_DOWN\\=some\\ data PROGRESS_TTY\\=\\+ RAILS_ENV\\=production",
-        :restore_schema => "rake -s dump:restore PROGRESS_TTY\\=\\+ RAILS_ENV\\=production RESTORE_SCHEMA\\=some\\ data",
-        :restore_tables => "rake -s dump:restore PROGRESS_TTY\\=\\+ RAILS_ENV\\=production RESTORE_TABLES\\=some\\ data",
-        :restore_assets => "rake -s dump:restore PROGRESS_TTY\\=\\+ RAILS_ENV\\=production RESTORE_ASSETS\\=some\\ data",
+        :like => 'rake -s dump:restore LIKE\\=some\\ data PROGRESS_TTY\\=\\+ RAILS_ENV\\=production',
+        :tags => 'rake -s dump:restore PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=some\\ data',
+        :migrate_down => 'rake -s dump:restore MIGRATE_DOWN\\=some\\ data PROGRESS_TTY\\=\\+ RAILS_ENV\\=production',
+        :restore_schema => 'rake -s dump:restore PROGRESS_TTY\\=\\+ RAILS_ENV\\=production RESTORE_SCHEMA\\=some\\ data',
+        :restore_tables => 'rake -s dump:restore PROGRESS_TTY\\=\\+ RAILS_ENV\\=production RESTORE_TABLES\\=some\\ data',
+        :restore_assets => 'rake -s dump:restore PROGRESS_TTY\\=\\+ RAILS_ENV\\=production RESTORE_ASSETS\\=some\\ data',
       })
 
-      it "should use custom rake binary" do
+      it 'should use custom rake binary' do
         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")
+        @cap.find_and_execute_task('dump:remote:restore')
       end
     end
 
-    describe "download" do
-      it "should run rake versions to get avaliable versions" do
+    describe 'download' do
+      it 'should run rake versions to get avaliable versions' do
         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")
+        @cap.find_and_execute_task('dump:remote:download')
       end
 
-      it "should block sending summary to versions" do
+      it 'should block sending summary to versions' do
         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")
+            @cap.find_and_execute_task('dump:remote:download')
           end
         end
       end
 
       test_passing_environment_variables(:remote, :transfer, {
-        :like => "rake -s dump:versions LIKE\\=some\\ data PROGRESS_TTY\\=\\+ RAILS_ENV\\=production",
-        :tags => "rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=some\\ data",
-        :summary => "rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production", # block sending summary to versions
-        :transfer_via => "rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production", # tranfer_via is used internally
-      }, :cap_task => "dump:remote:download")
+        :like => 'rake -s dump:versions LIKE\\=some\\ data PROGRESS_TTY\\=\\+ RAILS_ENV\\=production',
+        :tags => 'rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production TAGS\\=some\\ data',
+        :summary => 'rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production', # block sending summary to versions
+        :transfer_via => 'rake -s dump:versions PROGRESS_TTY\\=\\+ RAILS_ENV\\=production', # tranfer_via is used internally
+      }, :cap_task => 'dump:remote:download')
 
-      it "should not download anything if there are no versions avaliable" do
+      it 'should not download anything if there are no versions avaliable' do
         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")
+        @cap.find_and_execute_task('dump:remote:download')
       end
 
-      it "should transfer latest version dump" do
+      it 'should transfer latest version dump' do
         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")
+        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")
+        @cap.find_and_execute_task('dump:remote:download')
       end
 
-      it "should handle extra spaces around file names" do
+      it 'should handle extra spaces around file names' do
         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")
+        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")
+        @cap.find_and_execute_task('dump:remote:download')
       end
 
-      it "should create local dump dir" do
+      it 'should create local dump dir' do
         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")
+        @cap.find_and_execute_task('dump:remote:download')
       end
 
-      it "should run rake versions use custom rake binary" do
+      it 'should run rake versions use custom rake binary' do
         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")
+        @cap.find_and_execute_task('dump:remote:download')
       end
     end
   end
 
-  describe "mirror" do
-    {"up" => [:local, :remote], "down" => [:remote, :local]}.each do |dir, way|
+  describe 'upload' do
+    it 'should call local:upload' do
+      expect(@cap.dump.local).to receive(:upload).and_return('')
+      @cap.find_and_execute_task('dump:upload')
+    end
+  end
+
+  describe 'download' do
+    it 'should call remote:download' do
+      expect(@cap.dump.remote).to receive(:download).and_return('')
+      @cap.find_and_execute_task('dump:download')
+    end
+  end
+
+  describe 'mirror' do
+    {'up' => [:local, :remote], 'down' => [:remote, :local]}.each do |dir, way|
       src = way[0]
       dst = way[1]
       describe name do
-        it "should create auto-backup with tag auto-backup" do
+        it 'should create auto-backup with tag auto-backup' do
           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
+        it 'should create auto-backup with additional tag auto-backup' do
           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
+        it 'should not call local:create if auto-backup fails' do
           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}")
@@ -464,19 +488,19 @@ describe "cap dump" do
 
         it "should call local:create if auto-backup succeedes with tags mirror and mirror-#{dir}" do
           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"); '' }
+          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
           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"); '' }
+          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
+        it 'should not call local:upload or remote:restore if local:create fails' do
           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)
@@ -484,14 +508,14 @@ describe "cap dump" do
           @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
+        it 'should call local:upload and remote:restore with only varibale ver set to file name if local:create returns file name' do
           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{
+          test_env = proc do
             expect(DumpRake::Env[:like]).to eq('123.tgz')
             expect(DumpRake::Env[:tags]).to eq(nil)
             expect(DumpRake::Env[:desc]).to eq(nil)
-          }
+          end
           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
@@ -502,53 +526,53 @@ describe "cap dump" do
     end
   end
 
-  describe "backup" do
-    it "should call remote:create" do
+  describe 'backup' do
+    it 'should call remote:create' do
       expect(@cap.dump.remote).to receive(:create).and_return('')
-      @cap.find_and_execute_task("dump:backup")
+      @cap.find_and_execute_task('dump:backup')
     end
 
-    it "should not call remote:download if remote:create returns blank" do
+    it 'should not call remote:download if remote:create returns blank' do
       allow(@cap.dump.remote).to receive(:create).and_return('')
       expect(@cap.dump.remote).not_to receive(:download)
-      @cap.find_and_execute_task("dump:backup")
+      @cap.find_and_execute_task('dump:backup')
     end
 
-    it "should call remote:download if remote:create returns file name" do
+    it 'should call remote:download if remote:create returns file name' do
       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")
+      @cap.find_and_execute_task('dump:backup')
     end
 
-    it "should call remote:create with tag backup" do
+    it 'should call remote:create with tag backup' do
       expect(@cap.dump.remote).to receive(:create) do
         expect(DumpRake::Env[:tags]).to eq('backup')
         ''
       end
-      @cap.find_and_execute_task("dump:backup")
+      @cap.find_and_execute_task('dump:backup')
     end
 
-    it "should call remote:create with additional tag backup" do
+    it 'should call remote:create with additional tag backup' do
       expect(@cap.dump.remote).to receive(:create) do
         expect(DumpRake::Env[:tags]).to eq('backup,photos')
         ''
       end
       DumpRake::Env.with_env :tags => 'photos' do
-        @cap.find_and_execute_task("dump:backup")
+        @cap.find_and_execute_task('dump:backup')
       end
     end
 
-    it "should pass description if it is set" do
+    it 'should pass description if it is set' do
       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
-        @cap.find_and_execute_task("dump:backup")
+        @cap.find_and_execute_task('dump:backup')
       end
     end
 
-    it "should send only ver variable" do
+    it 'should send only ver variable' do
       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')
@@ -557,7 +581,7 @@ describe "cap dump" do
         ''
       end
       DumpRake::Env.with_env all_dictionary_variables do
-        @cap.find_and_execute_task("dump:backup")
+        @cap.find_and_execute_task('dump:backup')
       end
     end
   end