dump 1.0.0

data/spec/lib/dump_rake_spec.rb

@@ -0,0 +1,326 @@
+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([])
+      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([])
+      DumpRake.versions(:like => '123')
+    end
+
+    it "should print versions" do
+      DumpRake::Dump.should_receive(:list).and_return(%w[123.tgz 456.tgz])
+      grab_output{
+        DumpRake.versions
+      }[:stdout].should == "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 = mock("dump_#{s}", :path => mock("dump_#{s}_path"))
+        DumpRake::DumpReader.should_not_receive(:summary)
+        dump
+      end
+
+      DumpRake::Dump.should_receive(:list).and_return(dumps)
+      grab_output{
+        $stderr.should_not_receive(:puts)
+        DumpRake.versions
+      }
+    end
+
+    it "should show summary if asked for" do
+      dumps = %w[123.tgz 456.tgz].map do |s|
+        dump = mock("dump_#{s}", :path => mock("dump_#{s}_path"))
+        DumpRake::DumpReader.should_receive(:summary).with(dump.path)
+        dump
+      end
+
+      DumpRake::Dump.should_receive(:list).and_return(dumps)
+      grab_output{
+        $stderr.should_not_receive(:puts)
+        DumpRake.versions(:summary => '1')
+      }
+    end
+
+    it "should show summary with scmema if asked for" do
+      dumps = %w[123.tgz 456.tgz].map do |s|
+        dump = mock("dump_#{s}", :path => mock("dump_#{s}_path"))
+        DumpRake::DumpReader.should_receive(:summary).with(dump.path, :schema => true)
+        dump
+      end
+
+      DumpRake::Dump.should_receive(:list).and_return(dumps)
+      grab_output{
+        $stderr.should_not_receive(:puts)
+        DumpRake.versions(:summary => '2')
+      }
+    end
+
+    it "should show output to stderr if summary raises error" do
+      DumpRake::DumpReader.stub!(:summary)
+      dumps = %w[123.tgz 456.tgz].map do |s|
+        mock("dump_#{s}", :path => mock("dump_#{s}_path"))
+      end
+      DumpRake::DumpReader.should_receive(:summary).with(dumps[1].path).and_raise('terrible error')
+
+      DumpRake::Dump.should_receive(:list).and_return(dumps)
+      grab_output{
+        $stderr.stub!(:puts)
+        $stderr.should_receive(:puts) do |s|
+          s['terrible error'].should_not be_nil
+        end
+        DumpRake.versions(:summary => 'true')
+      }
+    end
+  end
+
+  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')
+        end
+        grab_output{
+          DumpRake.create
+        }
+      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$/)
+        end
+        grab_output{
+          DumpRake.create
+        }
+      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$/)
+        end
+        grab_output{
+          DumpRake.create(:desc => 'Some text and !@')
+        }
+      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$/)
+        end
+        grab_output{
+          DumpRake.create(:desc => 'Some text and !@')
+        }
+      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$/)
+        end
+        DumpRake::DumpWriter.stub!(: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{
+          DumpRake.create(:desc => 'Some text and !@')
+        }[:stdout].should match(/^\d{14}-Some text and _\.tgz$/)
+      end
+    end
+
+    describe "writing" do
+      it "should dump schema, tables, assets" do
+        File.stub!(:rename)
+        @dump = mock('dump')
+        DumpRake::DumpWriter.should_receive(:create)
+
+        grab_output{
+          DumpRake.create
+        }
+      end
+    end
+  end
+
+  describe "restore" do
+    describe "without version" do
+      it "should call Dump.list" do
+        DumpRake::Dump.stub!(:list)
+        DumpRake::Dump.should_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)
+        all_dumps = mock('all_dumps')
+        DumpRake::Dump.should_receive(:list).with().and_return(all_dumps)
+        grab_output{
+          $stderr.should_receive(:puts).with(kind_of(String))
+          $stderr.should_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)
+        all_dumps = mock('all_dumps')
+        DumpRake::Dump.should_receive(:list).with().and_return(all_dumps)
+        grab_output{
+          $stderr.should_receive(:puts).with(kind_of(String))
+          $stderr.should_receive(:puts).with(all_dumps)
+          DumpRake.restore('213')
+        }
+      end
+
+      it "should call DumpReader.restore if there are versions" do
+        @dump = mock('dump', :path => 'dump/213.tgz')
+        DumpRake::Dump.should_receive(:list).once.and_return([@dump])
+        DumpRake::DumpReader.should_receive(:restore).with('dump/213.tgz')
+        grab_output{
+          $stderr.should_not_receive(:puts)
+          DumpRake.restore
+        }
+      end
+    end
+
+    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([])
+        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)
+        all_dumps = mock('all_dumps')
+        DumpRake::Dump.should_receive(:list).with().and_return(all_dumps)
+        grab_output{
+          $stderr.should_receive(:puts).with(kind_of(String))
+          $stderr.should_receive(:puts).with(all_dumps)
+          DumpRake.restore('213')
+        }
+      end
+
+      it "should call DumpReader.restore if there is desired version" do
+        @dump = mock('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)
+        grab_output{
+          $stderr.should_not_receive(:puts)
+          DumpRake.restore(:like => '213')
+        }
+      end
+
+      it "should call DumpReader.restore on last version if found multiple matching versions" do
+        @dump_a = mock('dump_a', :path => 'dump/213-a.tgz')
+        @dump_b = mock('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')
+        grab_output{
+          $stderr.should_not_receive(:puts)
+          DumpRake.restore(:like => '213')
+        }
+      end
+    end
+  end
+
+  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([])
+      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([])
+      DumpRake.cleanup(:like => '123', :tags => 'a,b,c')
+    end
+
+    {
+      {} => [0..4],
+      {:leave => '3'} => [0..6],
+      {:leave => '5'} => [0..4],
+      {:leave => '9'} => [0],
+      {:leave => '10'} => [],
+      {:leave => '15'} => [],
+      {:leave => 'none'} => [0..9],
+    }.each do |options, ids|
+      it "should call delete #{ids} dumps when called with #{options}" do
+        dumps = %w[a b c d e f g h i j].map do |s|
+          mock("dump_#{s}", :ext => 'tgz', :path => mock("dump_#{s}_path"))
+        end
+        tmp_dumps = %w[a b c].map do |s|
+          mock("tmp_dump_#{s}", :ext => 'tmp', :path => mock("tmp_dump_#{s}_path"))
+        end
+        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)
+        end
+        [tmp_dumps[1]].each do |dump|
+          dump.should_receive(:lock)
+          dump.path.should_not_receive(:unlink)
+        end
+        (dumps - dumps.values_at(*ids)).each do |dump|
+          dump.should_not_receive(:lock)
+          dump.path.should_not_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)
+        grab_output{
+          DumpRake.cleanup({:like => '123', :tags => 'a,b,c'}.merge(options))
+        }
+      end
+    end
+
+    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 = mock("dump_#{s}", :ext => 'tgz', :path => mock("dump_#{s}_path"))
+        dump.stub!(:lock).and_yield
+        dump.path.stub!(:unlink)
+        dump
+      end
+
+      dumps[3].path.should_receive(:unlink).and_raise('Horrible error')
+
+      DumpRake::Dump.stub!(: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
+        end
+        DumpRake.cleanup
+      }
+    end
+
+    it "should raise if called with :leave which is not a number or 'none'" do
+      proc{
+        DumpRake.cleanup(:leave => 'nothing')
+      }.should raise_error
+    end
+  end
+end

data/spec/recipes/dump_spec.rb

@@ -0,0 +1,553 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'capistrano'
+
+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.set(:current_path, @remote_path)
+  end
+
+  def all_dictionary_variables
+    DumpRake::Env::DICTIONARY.each_with_object({}) do |(key, value), filled_env|
+      filled_env[key] = value.join(' ')
+    end
+  end
+
+  def self.test_passing_environment_variables(place, command, command_strings, options = {})
+    DumpRake::Env.variable_names_for_command(command).each do |variable|
+      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
+          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] || '')
+          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) }
+          end
+        end
+      end
+    end
+  end
+
+  describe "do_transfer" do
+    before do
+      @cap.dump.stub!(:do_transfer_via)
+    end
+
+    [:up, :down].each do |direction|
+      describe direction do
+        describe "if method not set" do
+
+          it "should call got_rsync?" do
+            @cap.dump.should_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')
+              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{
+                grab_output{ @cap.dump.do_transfer(direction, 'a.tgz', 'b.tgz') }
+              }.should 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')
+              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')
+              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{
+                grab_output{ @cap.dump.do_transfer(direction, 'a.tgz', 'b.tgz') }
+              }.should raise_error('problem using scp')
+            end
+          end
+        end
+      end
+    end
+  end
+
+  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('')
+        @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",
+      })
+
+      it "should print result of rake task" do
+        @cap.dump.stub!(:run_local).and_return(" 123M\t123123.tgz\n")
+        grab_output{
+          @cap.find_and_execute_task("dump:local:versions")
+        }[:stdout].should == " 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('')
+        @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",
+      })
+
+      it "should print result of rake task" do
+        @cap.dump.stub!(:run_local).and_return("123123.tgz\n")
+        grab_output{
+          @cap.find_and_execute_task("dump:local:cleanup")
+        }[:stdout].should == "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{
+          @cap.find_and_execute_task("dump:local:create")
+        }.should 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')
+        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')
+        grab_output{
+          DumpRake::Env.with_env :tags => 'photos' do
+            @cap.find_and_execute_task("dump:local:create")
+          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",
+      }, :return_value => '123.tgz')
+
+      it "should print result of rake task" do
+        @cap.dump.stub!(:run_local).and_return("123123.tgz\n")
+        grab_output{
+          @cap.find_and_execute_task("dump:local:create")
+        }[:stdout].should == "123123.tgz\n"
+      end
+
+      it "should return stripped result of rake task" do
+        @cap.dump.stub!(:run_local).and_return("123123.tgz\n")
+        grab_output{
+          @cap.find_and_execute_task("dump:local:create").should == "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")
+        @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",
+      })
+    end
+
+    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('')
+        @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
+      }, :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)
+        @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")
+        @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")
+        @cap.find_and_execute_task("dump:local:upload")
+      end
+    end
+  end
+
+  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('')
+        @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",
+      })
+
+      it "should print result of rake task" do
+        @cap.dump.stub!(:run_remote).and_return(" 123M\t123123.tgz\n")
+        grab_output{
+          @cap.find_and_execute_task("dump:remote:versions")
+        }[:stdout].should == " 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('')
+        @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('')
+        @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",
+      })
+
+      it "should print result of rake task" do
+        @cap.dump.stub!(:run_remote).and_return("123123.tgz\n")
+        grab_output{
+          @cap.find_and_execute_task("dump:remote:cleanup")
+        }[:stdout].should == "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('')
+        @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{
+          @cap.find_and_execute_task("dump:remote:create")
+        }.should 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')
+        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')
+        grab_output{
+          DumpRake::Env.with_env :tags => 'photos' do
+            @cap.find_and_execute_task("dump:remote:create")
+          end
+        }
+      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')
+        grab_output{
+          @cap.find_and_execute_task("dump:remote:create")
+        }
+      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",
+      }, :return_value => '123.tgz')
+
+      it "should print result of rake task" do
+        @cap.dump.stub!(:run_remote).and_return("123123.tgz\n")
+        grab_output{
+          @cap.find_and_execute_task("dump:remote:create")
+        }[:stdout].should == "123123.tgz\n"
+      end
+
+      it "should return stripped result of rake task" do
+        @cap.dump.stub!(:run_remote).and_return("123123.tgz\n")
+        grab_output{
+          @cap.find_and_execute_task("dump:remote:create").should == "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')
+        grab_output{
+          @cap.find_and_execute_task("dump:remote:create")
+        }
+      end
+    end
+
+    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")
+        @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")
+        @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",
+      })
+
+      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")
+        @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('')
+        @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('')
+        DumpRake::Env::DICTIONARY[:summary].each do |name|
+          DumpRake::Env.with_env name => 'true' do
+            @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")
+
+      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)
+        @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)
+        @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)
+        @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')
+        @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('')
+        @cap.find_and_execute_task("dump:remote:download")
+      end
+    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
+          @cap.dump.namespaces[dst].should_receive(:create){ DumpRake::Env[:tags].should == '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'; '' }
+          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)
+          @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"; '' }
+          @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"; '' }
+          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)
+          @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')
+          test_env = proc{
+            DumpRake::Env[:like].should == '123.tgz'
+            DumpRake::Env[:tags].should == nil
+            DumpRake::Env[:desc].should == nil
+          }
+          @cap.dump.namespaces[src].should_receive(:"#{dir}load").ordered(&test_env)
+          @cap.dump.namespaces[dst].should_receive(:restore).ordered(&test_env)
+          DumpRake::Env.with_env all_dictionary_variables do
+            @cap.find_and_execute_task("dump:mirror:#{dir}")
+          end
+        end
+      end
+    end
+  end
+
+  describe "backup" do
+    it "should call remote:create" do
+      @cap.dump.remote.should_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)
+      @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
+      @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'
+        ''
+      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'
+        ''
+      end
+      DumpRake::Env.with_env :tags => 'photos' do
+        @cap.find_and_execute_task("dump:backup")
+      end
+    end
+
+    it "should pass description if it is set" do
+      def (@cap.dump.remote).create
+        DumpRake::Env[:desc].should == 'remote dump'
+        ''
+      end
+      DumpRake::Env.with_env :desc => 'remote dump' do
+        @cap.find_and_execute_task("dump:backup")
+      end
+    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
+        ''
+      end
+      DumpRake::Env.with_env all_dictionary_variables do
+        @cap.find_and_execute_task("dump:backup")
+      end
+    end
+  end
+end