backup 3.0.20 → 3.0.21

data/spec/cleaner_spec.rb

@@ -0,0 +1,304 @@
+# encoding: utf-8
+
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe 'Backup::Cleaner' do
+  let(:model)   { Backup::Model.new(:test_trigger, 'test label') }
+  let(:cleaner) { Backup::Cleaner }
+
+  describe '#prepare' do
+    let(:error_tail) do
+      "  Please check the log for messages and/or your notifications\n" +
+      "  concerning this backup: 'test label (test_trigger)'\n" +
+      "  The temporary files which had to be removed should not have existed."
+    end
+
+    context 'when neither the tmp_path is dirty or package files exist' do
+      it 'should do nothing' do
+        cleaner.expects(:packaging_folder_dirty?).returns(false)
+        cleaner.expects(:tmp_path_package_files).returns([])
+        FileUtils.expects(:rm_rf).never
+        FileUtils.expects(:rm_f).never
+        Backup::Logger.expects(:warn).never
+
+        cleaner.prepare(model)
+      end
+    end
+
+    context 'when the tmp_path is dirty' do
+      it 'should remove tmp_path and log a warning' do
+        cleaner.expects(:packaging_folder_dirty?).returns(true)
+        cleaner.expects(:tmp_path_package_files).returns([])
+        FileUtils.expects(:rm_f).never
+
+        FileUtils.expects(:rm_rf).with(
+          File.join(Backup::Config.tmp_path, 'test_trigger')
+        )
+        Backup::Logger.expects(:warn).with do |err|
+          err.should be_an_instance_of Backup::Errors::CleanerError
+          err.message.should == "CleanerError: Cleanup Warning\n" +
+            "  The temporary backup folder still contains files!\n" +
+            "  '#{ File.join(Backup::Config.tmp_path, 'test_trigger') }'\n" +
+            "  These files will now be removed.\n" +
+            "  \n" + error_tail
+        end
+
+        cleaner.prepare(model)
+      end
+    end
+
+    context 'when package files exist' do
+      it 'should remove the files and log a warning' do
+        cleaner.expects(:packaging_folder_dirty?).returns(false)
+        cleaner.expects(:tmp_path_package_files).returns(['file1', 'file2'])
+        FileUtils.expects(:rm_rf).never
+
+        FileUtils.expects(:rm_f).with('file1')
+        FileUtils.expects(:rm_f).with('file2')
+
+        Backup::Logger.expects(:warn).with do |err|
+          err.should be_an_instance_of Backup::Errors::CleanerError
+          err.message.should == "CleanerError: Cleanup Warning\n" +
+            "  The temporary backup folder '#{ Backup::Config.tmp_path }'\n" +
+            "  appears to contain the package files from the previous backup!\n" +
+            "  file1\n" +
+            "  file2\n" +
+            "  These files will now be removed.\n" +
+            "  \n" + error_tail
+        end
+
+        cleaner.prepare(model)
+      end
+    end
+
+    context 'both the tmp_path is dirty and package files exist' do
+      it 'should clean both and log a warning' do
+        cleaner.expects(:packaging_folder_dirty?).returns(true)
+        cleaner.expects(:tmp_path_package_files).returns(['file1', 'file2'])
+
+        FileUtils.expects(:rm_rf).with(
+          File.join(Backup::Config.tmp_path, 'test_trigger')
+        )
+        FileUtils.expects(:rm_f).with('file1')
+        FileUtils.expects(:rm_f).with('file2')
+
+        Backup::Logger.expects(:warn).with do |err|
+          err.should be_an_instance_of Backup::Errors::CleanerError
+          err.message.should == "CleanerError: Cleanup Warning\n" +
+            "  The temporary backup folder still contains files!\n" +
+            "  '#{ File.join(Backup::Config.tmp_path, 'test_trigger') }'\n" +
+            "  These files will now be removed.\n" +
+            "  \n" +
+            "  #{ '-' * 74 }\n" +
+            "  The temporary backup folder '#{ Backup::Config.tmp_path }'\n" +
+            "  appears to contain the package files from the previous backup!\n" +
+            "  file1\n" +
+            "  file2\n" +
+            "  These files will now be removed.\n" +
+            "  \n" + error_tail
+        end
+
+        cleaner.prepare(model)
+      end
+    end
+
+  end # describe '#prepare'
+
+  describe '#remove_packaging' do
+    it 'should remove the packaging directory and log a message' do
+      Backup::Logger.expects(:message).with(
+        "Cleaning up the temporary files..."
+      )
+      FileUtils.expects(:rm_rf).with(
+        File.join(Backup::Config.tmp_path, 'test_trigger')
+      )
+
+      cleaner.remove_packaging(model)
+    end
+  end
+
+  describe '#remove_package' do
+    let(:package) { mock }
+    it 'should remove the files for the given package and log a message' do
+      package.expects(:filenames).returns(['file1', 'file2'])
+      Backup::Logger.expects(:message).with(
+        "Cleaning up the package files..."
+      )
+      FileUtils.expects(:rm_f).with(
+        File.join(Backup::Config.tmp_path, 'file1')
+      )
+      FileUtils.expects(:rm_f).with(
+        File.join(Backup::Config.tmp_path, 'file2')
+      )
+
+      cleaner.remove_package(package)
+    end
+  end
+
+  describe '#warnings' do
+    let(:error_tail) do
+      "  Make sure you check these files before the next scheduled backup for\n" +
+      "  'test label (test_trigger)'\n" +
+      "  These files will be removed at that time!"
+    end
+
+    context 'when neither the tmp_path is dirty or package files exist' do
+      it 'should do nothing' do
+        cleaner.expects(:packaging_folder_dirty?).returns(false)
+        cleaner.expects(:tmp_path_package_files).returns([])
+        Backup::Logger.expects(:warn).never
+
+        cleaner.warnings(model)
+      end
+    end
+
+    context 'when the tmp_path is dirty' do
+      it 'should remove tmp_path and log a warning' do
+        cleaner.expects(:packaging_folder_dirty?).returns(true)
+        cleaner.expects(:tmp_path_package_files).returns([])
+
+        Backup::Logger.expects(:warn).with do |err|
+          err.should be_an_instance_of Backup::Errors::CleanerError
+          err.message.should == "CleanerError: Cleanup Warning\n" +
+            "  The temporary backup folder still contains files!\n" +
+            "  '#{ File.join(Backup::Config.tmp_path, 'test_trigger') }'\n" +
+            "  This folder may contain completed Archives and/or Database backups.\n" +
+            "  \n" + error_tail
+        end
+
+        cleaner.warnings(model)
+      end
+    end
+
+    context 'when package files exist' do
+      it 'should remove the files and log a warning' do
+        cleaner.expects(:packaging_folder_dirty?).returns(false)
+        cleaner.expects(:tmp_path_package_files).returns(['file1', 'file2'])
+
+        Backup::Logger.expects(:warn).with do |err|
+          err.should be_an_instance_of Backup::Errors::CleanerError
+          err.message.should == "CleanerError: Cleanup Warning\n" +
+            "  The temporary backup folder '#{ Backup::Config.tmp_path }'\n" +
+            "  appears to contain the backup files which were to be stored:\n" +
+            "  file1\n" +
+            "  file2\n" +
+            "  \n" + error_tail
+        end
+
+        cleaner.warnings(model)
+      end
+    end
+
+    context 'both the tmp_path is dirty and package files exist' do
+      it 'should clean both and log a warning' do
+        cleaner.expects(:packaging_folder_dirty?).returns(true)
+        cleaner.expects(:tmp_path_package_files).returns(['file1', 'file2'])
+
+        Backup::Logger.expects(:warn).with do |err|
+          err.should be_an_instance_of Backup::Errors::CleanerError
+          err.message.should == "CleanerError: Cleanup Warning\n" +
+            "  The temporary backup folder still contains files!\n" +
+            "  '#{ File.join(Backup::Config.tmp_path, 'test_trigger') }'\n" +
+            "  This folder may contain completed Archives and/or Database backups.\n" +
+            "  \n" +
+            "  #{ '-' * 74 }\n" +
+            "  The temporary backup folder '#{ Backup::Config.tmp_path }'\n" +
+            "  appears to contain the backup files which were to be stored:\n" +
+            "  file1\n" +
+            "  file2\n" +
+            "  \n" + error_tail
+        end
+
+        cleaner.warnings(model)
+      end
+    end
+
+  end # describe '#warnings'
+
+  describe '#packaging_folder_dirty?' do
+    before do
+      cleaner.instance_variable_set(:@model, model)
+      FileUtils.unstub(:mkdir_p)
+    end
+
+    context 'when files exist in the packaging folder' do
+      it 'should return true' do
+        Dir.mktmpdir do |path|
+          Backup::Config.update(:root_path => path)
+          FileUtils.mkdir_p(
+            File.join(Backup::Config.tmp_path, 'test_trigger', 'archives')
+          )
+          cleaner.send(:packaging_folder_dirty?).should be_true
+        end
+      end
+    end
+
+    context 'when files do not exist in the packaging folder' do
+      it 'should return false' do
+        Dir.mktmpdir do |path|
+          Backup::Config.update(:root_path => path)
+          FileUtils.mkdir_p(
+            File.join(Backup::Config.tmp_path, 'test_trigger')
+          )
+          cleaner.send(:packaging_folder_dirty?).should be_false
+        end
+      end
+    end
+  end
+
+  describe '#tmp_path_package_files' do
+    before do
+      cleaner.instance_variable_set(:@model, model)
+      FileUtils.unstub(:mkdir_p)
+      FileUtils.unstub(:touch)
+    end
+
+    context 'when packaging files exist in the tmp_path' do
+      it 'should return the files' do
+        Dir.mktmpdir do |path|
+          Backup::Config.update(:root_path => path)
+          FileUtils.mkdir_p(Backup::Config.tmp_path)
+
+          package_files = [
+            '2012.01.06.12.05.30.test_trigger.tar',
+            '2012.02.06.12.05.30.test_trigger.tar-aa',
+            '2012.03.06.12.05.30.test_trigger.tar.enc',
+            '2012.04.06.12.05.30.test_trigger.tar.enc-aa'
+          ].map! {|f| File.join(Backup::Config.tmp_path, f) }
+
+          other_files = [
+            '2012.01.06.12.05.30.test_trigger.target.tar',
+            '2012.01.06.12.05.30.other_trigger.tar',
+            'foo.tar'
+          ].map! {|f| File.join(Backup::Config.tmp_path, f) }
+
+          FileUtils.touch(package_files + other_files)
+          Dir[File.join(Backup::Config.tmp_path, '*')].count.should be(7)
+
+          cleaner.send(:tmp_path_package_files).sort.should == package_files
+        end
+      end
+    end
+
+    context 'when no packaging files exist in the tmp_path' do
+      it 'should return an empty array' do
+        Dir.mktmpdir do |path|
+          Backup::Config.update(:root_path => path)
+          FileUtils.mkdir_p(Backup::Config.tmp_path)
+
+          other_files = [
+            '2012.01.06.12.05.30.test_trigger.target.tar',
+            '2012.01.06.12.05.30.other_trigger.tar',
+            'foo.tar'
+          ].map! {|f| File.join(Backup::Config.tmp_path, f) }
+
+          FileUtils.touch(other_files)
+          Dir[File.join(Backup::Config.tmp_path, '*')].count.should be(3)
+
+          cleaner.send(:tmp_path_package_files).should == []
+        end
+      end
+    end
+  end
+
+end

data/spec/cli/helpers_spec.rb

@@ -3,7 +3,148 @@
 require File.expand_path('../../spec_helper.rb', __FILE__)
 
 describe Backup::CLI::Helpers do
-  let(:helpers) { Module.new.extend(subject) }
+  let(:helpers) { Module.new.extend(Backup::CLI::Helpers) }
+
+  describe '#run' do
+    let(:stdin)   { mock }
+    let(:stdout)  { mock }
+    let(:stderr)  { mock }
+    let(:process_status) { mock }
+
+    it 'should run the given command using POpen4' do
+      Open4.expects(:popen4).with('/path/to/command args').
+        returns([123, stdin, stdout, stderr])
+      Process.expects(:waitpid2).with(123).returns([123, process_status])
+      stdout.expects(:read).returns('stdout message')
+      stderr.expects(:read).returns('stderr message')
+
+      helpers.expects(:command_name).with('/path/to/command args').
+          returns('command')
+      helpers.expects(:raise_if_command_failed!).with(
+        'command',
+        {:status => process_status,
+         :stdout => 'stdout message',
+         :stderr => 'stderr message',
+         :ignore_exit_codes => [0]}
+      )
+
+      helpers.run('/path/to/command args').should == 'stdout message'
+    end
+
+    it 'should accept ignore_exit_codes and add 0 to the list' do
+      Open4.expects(:popen4).with('/path/to/command args').
+        returns([123, stdin, stdout, stderr])
+      Process.expects(:waitpid2).with(123).returns([123, process_status])
+      stdout.expects(:read).returns('stdout message')
+      stderr.expects(:read).returns('stderr message')
+
+      helpers.expects(:command_name).with('/path/to/command args').
+          returns('command')
+      helpers.expects(:raise_if_command_failed!).with(
+        'command',
+        {:status => process_status,
+         :stdout => 'stdout message',
+         :stderr => 'stderr message',
+         :ignore_exit_codes => [1, 2, 0]}
+      )
+
+      helpers.run(
+        '/path/to/command args', :ignore_exit_codes => [1, 2]
+      ).should == 'stdout message'
+    end
+  end
+
+  describe '#utility' do
+    context 'when a system path for the utility is available' do
+      it 'should return the system path with newline removed' do
+        helpers.expects(:`).with('which foo 2>/dev/null').returns("system_path\n")
+        helpers.utility(:foo).should == 'system_path'
+      end
+
+      it 'should cache the returned path' do
+        helpers.expects(:`).once.with('which cache_me 2>/dev/null').
+            returns("cached_path\n")
+
+        helpers.utility(:cache_me).should == 'cached_path'
+        helpers.utility(:cache_me).should == 'cached_path'
+      end
+
+      it 'should cache the value for all extended objects' do
+        helpers.expects(:`).once.with('which once_only 2>/dev/null').
+            returns("cached_path\n")
+
+        helpers.utility(:once_only).should == 'cached_path'
+        Class.new.extend(Backup::CLI::Helpers).utility(:once_only).
+            should == 'cached_path'
+      end
+    end
+
+
+    context 'when a system path for the utility is not available' do
+      it 'should raise an error' do
+        helpers.expects(:`).with('which unknown 2>/dev/null').returns("\n")
+
+        expect do
+          helpers.utility(:unknown)
+        end.to raise_error(Backup::Errors::CLI::UtilityNotFoundError) {|err|
+          err.message.should match(/Path to 'unknown' could not be found/)
+        }
+      end
+
+      it 'should not cache any value for the utility' do
+        helpers.expects(:`).with('which not_cached 2>/dev/null').twice.returns("\n")
+
+        expect do
+          helpers.utility(:not_cached)
+        end.to raise_error(Backup::Errors::CLI::UtilityNotFoundError) {|err|
+          err.message.should match(/Path to 'not_cached' could not be found/)
+        }
+
+        expect do
+          helpers.utility(:not_cached)
+        end.to raise_error(Backup::Errors::CLI::UtilityNotFoundError) {|err|
+          err.message.should match(/Path to 'not_cached' could not be found/)
+        }
+      end
+    end
+  end # describe '#utility'
+
+  describe '#command_name' do
+    context 'given a command line path with no arguments' do
+      it 'should return the base command name' do
+        cmd = '/path/to/a/command'
+        helpers.command_name(cmd).should == 'command'
+      end
+    end
+
+    context 'given a command line path with a single argument' do
+      it 'should return the base command name' do
+        cmd = '/path/to/a/command with_args'
+        helpers.command_name(cmd).should == 'command'
+      end
+    end
+
+    context 'given a command line path with multiple arguments' do
+      it 'should return the base command name' do
+        cmd = '/path/to/a/command with multiple args'
+        helpers.command_name(cmd).should == 'command'
+      end
+    end
+
+    context 'given a command with no path and arguments' do
+      it 'should return the base command name' do
+        cmd = 'command args'
+        helpers.command_name(cmd).should == 'command'
+      end
+    end
+
+    context 'given a command with no path and no arguments' do
+      it 'should return the base command name' do
+        cmd = 'command'
+        helpers.command_name(cmd).should == 'command'
+      end
+    end
+  end # describe '#command_name'
 
   describe '#raise_if_command_failed!' do