backup 3.0.27 → 3.1.0

data/spec/cli/helpers_spec.rb

@@ -1,301 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path('../../spec_helper.rb', __FILE__)
-
-describe Backup::CLI::Helpers do
-  let(:helpers) { Module.new.extend(Backup::CLI::Helpers) }
-
-  describe '#run' do
-    let(:stdout_io) { stub(:read => stdout_messages) }
-    let(:stderr_io) { stub(:read => stderr_messages) }
-    let(:stdin_io)  { stub(:close) }
-    let(:process_status) { stub(:success? => process_success) }
-    let(:command) { '/path/to/cmd_name arg1 arg2' }
-
-    context 'when the command is successful' do
-      let(:process_success) { true }
-
-      before do
-        Backup::Logger.expects(:message).with(
-          "Running system utility 'cmd_name'..."
-        )
-
-        Open4.expects(:popen4).with(command).yields(
-          nil, stdin_io, stdout_io, stderr_io
-        ).returns(process_status)
-      end
-
-      context 'and generates no messages' do
-        let(:stdout_messages) { '' }
-        let(:stderr_messages) { '' }
-
-        it 'should return stdout and generate no additional log messages' do
-          helpers.send(:run, command).should == ''
-        end
-      end
-
-      context 'and generates only stdout messages' do
-        let(:stdout_messages) { "out line1\nout line2\n" }
-        let(:stderr_messages) { '' }
-
-        it 'should return stdout and log the stdout messages' do
-          Backup::Logger.expects(:message).with(
-            "cmd_name:STDOUT: out line1\ncmd_name:STDOUT: out line2"
-          )
-          helpers.send(:run, command).should == stdout_messages.strip
-        end
-      end
-
-      context 'and generates only stderr messages' do
-        let(:stdout_messages) { '' }
-        let(:stderr_messages) { "err line1\nerr line2\n" }
-
-        it 'should return stdout and log the stderr messages' do
-          Backup::Logger.expects(:warn).with(
-            "cmd_name:STDERR: err line1\ncmd_name:STDERR: err line2"
-          )
-          helpers.send(:run, command).should == ''
-        end
-      end
-
-      context 'and generates messages on both stdout and stderr' do
-        let(:stdout_messages) { "out line1\nout line2\n" }
-        let(:stderr_messages) { "err line1\nerr line2\n" }
-
-        it 'should return stdout and log both stdout and stderr messages' do
-          Backup::Logger.expects(:message).with(
-            "cmd_name:STDOUT: out line1\ncmd_name:STDOUT: out line2"
-          )
-          Backup::Logger.expects(:warn).with(
-            "cmd_name:STDERR: err line1\ncmd_name:STDERR: err line2"
-          )
-          helpers.send(:run, command).should == stdout_messages.strip
-        end
-      end
-    end # context 'when the command is successful'
-
-    context 'when the command is not successful' do
-      let(:process_success) { false }
-      let(:message_head) do
-        "CLI::SystemCallError: 'cmd_name' Failed on #{ RUBY_PLATFORM }\n" +
-        "  The following information should help to determine the problem:\n" +
-        "  Command was: /path/to/cmd_name arg1 arg2\n" +
-        "  Exit Status: 1\n"
-      end
-
-      before do
-        Backup::Logger.expects(:message).with(
-          "Running system utility 'cmd_name'..."
-        )
-
-        Open4.expects(:popen4).with(command).yields(
-          nil, stdin_io, stdout_io, stderr_io
-        ).returns(process_status)
-
-        process_status.stubs(:exitstatus).returns(1)
-      end
-
-      context 'and generates no messages' do
-        let(:stdout_messages) { '' }
-        let(:stderr_messages) { '' }
-
-        it 'should raise an error reporting no messages' do
-          expect do
-            helpers.send(:run, command)
-          end.to raise_error {|err|
-            err.message.should == message_head +
-              "  STDOUT Messages: None\n" +
-              "  STDERR Messages: None"
-          }
-        end
-      end
-
-      context 'and generates only stdout messages' do
-        let(:stdout_messages) { "out line1\nout line2\n" }
-        let(:stderr_messages) { '' }
-
-        it 'should raise an error and report the stdout messages' do
-          expect do
-            helpers.send(:run, command)
-          end.to raise_error {|err|
-            err.message.should == message_head +
-              "  STDOUT Messages: \n" +
-              "  out line1\n" +
-              "  out line2\n" +
-              "  STDERR Messages: None"
-          }
-        end
-      end
-
-      context 'and generates only stderr messages' do
-        let(:stdout_messages) { '' }
-        let(:stderr_messages) { "err line1\nerr line2\n" }
-
-        it 'should raise an error and report the stderr messages' do
-          expect do
-            helpers.send(:run, command)
-          end.to raise_error {|err|
-            err.message.should == message_head +
-              "  STDOUT Messages: None\n" +
-              "  STDERR Messages: \n" +
-              "  err line1\n" +
-              "  err line2"
-          }
-        end
-      end
-
-      context 'and generates messages on both stdout and stderr' do
-        let(:stdout_messages) { "out line1\nout line2\n" }
-        let(:stderr_messages) { "err line1\nerr line2\n" }
-
-        it 'should raise an error and report the stdout and stderr messages' do
-          expect do
-            helpers.send(:run, command)
-          end.to raise_error {|err|
-            err.message.should == message_head +
-              "  STDOUT Messages: \n" +
-              "  out line1\n" +
-              "  out line2\n" +
-              "  STDERR Messages: \n" +
-              "  err line1\n" +
-              "  err line2"
-          }
-        end
-      end
-    end # context 'when the command is not successful'
-
-    context 'when the system fails to execute the command' do
-      before do
-        Backup::Logger.expects(:message).with(
-          "Running system utility 'cmd_name'..."
-        )
-
-        Open4.expects(:popen4).raises("exec call failed")
-      end
-
-      it 'should raise an error wrapping the system error raised' do
-        expect do
-          helpers.send(:run, command)
-        end.to raise_error {|err|
-          err.message.should == "CLI::SystemCallError: " +
-            "Failed to execute system command on #{ RUBY_PLATFORM }\n" +
-            "  Command was: /path/to/cmd_name arg1 arg2\n" +
-            "  Reason: RuntimeError\n" +
-            "  exec call failed"
-        }
-      end
-    end # context 'when the system fails to execute the command'
-  end # describe '#run'
-
-  describe '#utility' do
-    after { Backup::CLI::Helpers::UTILITY.clear }
-
-    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.send(: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.send(:utility, :cache_me).should == 'cached_path'
-        helpers.send(: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.send(:utility, :once_only).should == 'cached_path'
-        Class.new.extend(Backup::CLI::Helpers).send(
-            :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.send(:utility, :unknown)
-        end.to raise_error(Backup::Errors::CLI::UtilityNotFoundError) {|err|
-          err.message.should match(/Could not locate 'unknown'/)
-        }
-      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.send(:utility, :not_cached)
-        end.to raise_error(Backup::Errors::CLI::UtilityNotFoundError) {|err|
-          err.message.should match(/Could not locate 'not_cached'/)
-        }
-
-        expect do
-          helpers.send(:utility, :not_cached)
-        end.to raise_error(Backup::Errors::CLI::UtilityNotFoundError) {|err|
-          err.message.should match(/Could not locate 'not_cached'/)
-        }
-      end
-    end
-
-    it 'should raise an error if name is nil' do
-      expect do
-        helpers.send(:utility, nil)
-      end.to raise_error(
-        Backup::Errors::CLI::UtilityNotFoundError,
-          'CLI::UtilityNotFoundError: Utility Name Empty'
-      )
-    end
-
-    it 'should raise an error if name is empty' do
-      expect do
-        helpers.send(:utility, ' ')
-      end.to raise_error(
-        Backup::Errors::CLI::UtilityNotFoundError,
-          'CLI::UtilityNotFoundError: Utility Name Empty'
-      )
-    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.send(: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.send(: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.send(: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.send(: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.send(:command_name, cmd).should == 'command'
-      end
-    end
-  end # describe '#command_name'
-
-end

data/spec/cli/utility_spec.rb

@@ -1,411 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path('../../spec_helper.rb', __FILE__)
-
-describe 'Backup::CLI::Utility' do
-  let(:cli)     { Backup::CLI::Utility }
-  let(:utility) { Backup::CLI::Utility.new }
-  let(:s)       { sequence '' }
-
-  before  { @argv_save = ARGV }
-  after   { ARGV.replace(@argv_save) }
-
-  describe '#perform' do
-    let(:model_a) { Backup::Model.new(:test_trigger_a, 'test label a') }
-    let(:model_b) { Backup::Model.new(:test_trigger_b, 'test label b') }
-
-    after   { Backup::Model.all.clear }
-
-    it 'should perform the backup for the given trigger' do
-      Backup::Logger.expects(:quiet=).in_sequence(s)
-      Backup::Config.expects(:update).in_sequence(s)
-
-      FileUtils.expects(:mkdir_p).in_sequence(s).with(Backup::Config.log_path)
-      FileUtils.expects(:mkdir_p).in_sequence(s).with(Backup::Config.cache_path)
-      FileUtils.expects(:mkdir_p).in_sequence(s).with(Backup::Config.tmp_path)
-
-      Backup::Config.expects(:load_config!).in_sequence(s)
-
-      Backup::Logger.expects(:truncate!)
-
-      model_a.expects(:prepare!).in_sequence(s)
-      model_a.expects(:perform!).in_sequence(s)
-      Backup::Logger.expects(:clear!).in_sequence(s)
-
-      expect do
-        ARGV.replace(['perform', '-t', 'test_trigger_a'])
-        cli.start
-      end.not_to raise_error
-    end
-
-    it 'should perform backups for the multiple triggers' do
-      Backup::Logger.expects(:quiet=).in_sequence(s)
-      Backup::Config.expects(:update).in_sequence(s)
-
-      FileUtils.expects(:mkdir_p).in_sequence(s).with(Backup::Config.log_path)
-      FileUtils.expects(:mkdir_p).in_sequence(s).with(Backup::Config.cache_path)
-      FileUtils.expects(:mkdir_p).in_sequence(s).with(Backup::Config.tmp_path)
-
-      Backup::Config.expects(:load_config!).in_sequence(s)
-
-      Backup::Logger.expects(:truncate!)
-
-      model_a.expects(:prepare!).in_sequence(s)
-      model_a.expects(:perform!).in_sequence(s)
-      Backup::Logger.expects(:clear!).in_sequence(s)
-
-      model_b.expects(:prepare!).in_sequence(s)
-      model_b.expects(:perform!).in_sequence(s)
-      Backup::Logger.expects(:clear!).in_sequence(s)
-
-      expect do
-        ARGV.replace(['perform', '-t', 'test_trigger_a,test_trigger_b'])
-        cli.start
-      end.not_to raise_error
-    end
-
-    it 'should perform backups for the multiple triggers when using wildcard' do
-      Backup::Logger.expects(:quiet=).in_sequence(s)
-      Backup::Config.expects(:update).in_sequence(s)
-
-      FileUtils.expects(:mkdir_p).in_sequence(s).with(Backup::Config.log_path)
-      FileUtils.expects(:mkdir_p).in_sequence(s).with(Backup::Config.cache_path)
-      FileUtils.expects(:mkdir_p).in_sequence(s).with(Backup::Config.tmp_path)
-
-      Backup::Config.expects(:load_config!).in_sequence(s)
-
-      Backup::Logger.expects(:truncate!)
-
-      model_a.expects(:prepare!).in_sequence(s)
-      model_a.expects(:perform!).in_sequence(s)
-      Backup::Logger.expects(:clear!).in_sequence(s)
-
-      model_b.expects(:prepare!).in_sequence(s)
-      model_b.expects(:perform!).in_sequence(s)
-      Backup::Logger.expects(:clear!).in_sequence(s)
-
-      expect do
-        ARGV.replace(['perform', '-t', 'test_trigger_*'])
-        cli.start
-      end.not_to raise_error
-    end
-
-    context 'when errors occur' do
-      it 'should log the error and exit' do
-        Backup::Logger.stubs(:quiet=).raises(SystemCallError, 'yikes!')
-        Backup::Logger.expects(:error).with do |err|
-          err.message.should ==
-              "CLIError: SystemCallError: unknown error - yikes!"
-        end
-
-        expect do
-          ARGV.replace(['perform', '-t', 'foo'])
-          cli.start
-        end.to raise_error(SystemExit) {|exit| exit.status.should == 1 }
-      end
-    end # context 'when errors occur'
-
-  end # describe '#perform'
-
-  describe '#generate:model' do
-    before do
-      FileUtils.unstub(:mkdir_p)
-      FileUtils.unstub(:touch)
-    end
-
-    after do
-      Backup::Config.send(:reset!)
-    end
-
-    context 'when given a config_path' do
-      context 'when no config file exists' do
-        it 'should create both a config and a model under the given path' do
-          Dir.mktmpdir do |path|
-            model_file  = File.join(path, 'custom', 'models', 'test_trigger.rb')
-            config_file = File.join(path, 'custom', 'config.rb')
-
-            out, err = capture_io do
-              ARGV.replace(['generate:model',
-                 '--config-path', File.join(path, 'custom'),
-                 '--trigger', 'test_trigger'
-              ])
-              cli.start
-            end
-
-            out.should == "Generated model file: '#{ model_file }'.\n" +
-                "Generated configuration file: '#{ config_file }'.\n"
-            File.exist?(model_file).should be_true
-            File.exist?(config_file).should be_true
-          end
-        end
-      end
-
-      context 'when a config file already exists' do
-        it 'should only create a model under the given path' do
-          Dir.mktmpdir do |path|
-            model_file  = File.join(path, 'custom', 'models', 'test_trigger.rb')
-            config_file = File.join(path, 'custom', 'config.rb')
-            FileUtils.mkdir_p(File.join(path, 'custom'))
-            FileUtils.touch(config_file)
-
-            out, err = capture_io do
-              ARGV.replace(['generate:model',
-                 '--config-path', File.join(path, 'custom'),
-                 '--trigger', 'test_trigger'
-              ])
-              cli.start
-            end
-
-            out.should == "Generated model file: '#{ model_file }'.\n"
-            File.exist?(model_file).should be_true
-          end
-        end
-      end
-
-# These pass, but generate Thor warnings...
-#
-#      context 'when a model file already exists' do
-#        it 'should prompt to overwrite the model under the given path' do
-#          Dir.mktmpdir do |path|
-#            model_file  = File.join(path, 'models', 'test_trigger.rb')
-#            config_file = File.join(path, 'config.rb')
-#
-#            cli.any_instance.expects(:overwrite?).with(model_file).returns(false)
-#
-#            out, err = capture_io do
-#              ARGV.replace(['generate:model',
-#                 '--config-path', path,
-#                 '--trigger', 'test_trigger'
-#              ])
-#              cli.start
-#            end
-#
-#            out.should == "Generated configuration file: '#{ config_file }'.\n"
-#            File.exist?(config_file).should be_true
-#            File.exist?(model_file).should be_false
-#          end
-#        end
-#      end
-
-    end # context 'when given a config_path'
-
-    context 'when not given a config_path' do
-      it 'should create both a config and a model under the root path' do
-        Dir.mktmpdir do |path|
-          Backup::Config.update(:root_path => path)
-          model_file  = File.join(path, 'models', 'test_trigger.rb')
-          config_file = File.join(path, 'config.rb')
-
-          out, err = capture_io do
-            ARGV.replace(['generate:model', '--trigger', 'test_trigger'])
-            cli.start
-          end
-
-          out.should == "Generated model file: '#{ model_file }'.\n" +
-              "Generated configuration file: '#{ config_file }'.\n"
-          File.exist?(model_file).should be_true
-          File.exist?(config_file).should be_true
-        end
-      end
-    end
-
-    it 'should generate the proper help output' do
-      ruby19_output = <<-EOS
-        Usage:
-          #{ File.basename($0) } generate:model --trigger=TRIGGER
-
-        Options:
-          --trigger=TRIGGER
-          [--config-path=CONFIG_PATH]  # Path to your Backup configuration directory
-          [--databases=DATABASES]      # (mongodb, mysql, postgresql, redis, riak)
-          [--storages=STORAGES]        # (cloud_files, dropbox, ftp, local, ninefold, rsync, s3, scp, sftp)
-          [--syncers=SYNCERS]          # (cloud_files, rsync_local, rsync_pull, rsync_push, s3)
-          [--encryptors=ENCRYPTORS]    # (gpg, openssl)
-          [--compressors=COMPRESSORS]  # (bzip2, custom, gzip, lzma, pbzip2)
-          [--notifiers=NOTIFIERS]      # (campfire, hipchat, mail, prowl, pushover, twitter)
-          [--archives]
-          [--splitter]                 # use `--no-splitter` to disable
-                                      # Default: true
-        Generates a Backup model file
-
-        Note:
-          '--config-path' is the path to the directory where 'config.rb' is located.
-          The model file will be created as '<config_path>/models/<trigger>.rb'
-          Default: #{ Backup::Config.root_path }
-      EOS
-
-      out, err = capture_io do
-        ARGV.replace(['help', 'generate:model'])
-        cli.start
-      end
-
-      expected_lines = ruby19_output.split("\n").map(&:strip).select {|e| !e.empty? }
-      output_lines = out.split("\n").map(&:strip).select {|e| !e.empty? }
-
-      output_lines.sort.should == expected_lines.sort
-    end
-  end # describe '#generate:model'
-
-  describe '#generate:config' do
-    before do
-      FileUtils.unstub(:mkdir_p)
-      FileUtils.unstub(:touch)
-    end
-
-    after do
-      Backup::Config.send(:reset!)
-    end
-
-    context 'when given a config_path' do
-      it 'should create a config file in the given path' do
-        Dir.mktmpdir do |path|
-          config_file = File.join(path, 'custom', 'config.rb')
-
-          out, err = capture_io do
-            ARGV.replace(['generate:config',
-                '--config-path', File.join(path, 'custom'),
-            ])
-            cli.start
-          end
-
-          out.should == "Generated configuration file: '#{ config_file }'.\n"
-          File.exist?(config_file).should be_true
-        end
-      end
-    end
-
-    context 'when not given a config_path' do
-      it 'should create a config file in the root path' do
-        Dir.mktmpdir do |path|
-          Backup::Config.update(:root_path => path)
-          config_file = File.join(path, 'config.rb')
-
-          out, err = capture_io do
-            ARGV.replace(['generate:config'])
-            cli.start
-          end
-
-          out.should == "Generated configuration file: '#{ config_file }'.\n"
-          File.exist?(config_file).should be_true
-        end
-      end
-    end
-
-# These pass, but generate Thor warnings...
-#
-#    context 'when a config file already exists' do
-#      it 'should prompt to overwrite the config file' do
-#        Dir.mktmpdir do |path|
-#          Backup::Config.update(:root_path => path)
-#          config_file = File.join(path, 'config.rb')
-#
-#          cli.any_instance.expects(:overwrite?).with(config_file).returns(false)
-#
-#          out, err = capture_io do
-#            ARGV.replace(['generate:config'])
-#            cli.start
-#          end
-#
-#          out.should be_empty
-#          File.exist?(config_file).should be_false
-#        end
-#      end
-#    end
-
-  end # describe '#generate:config'
-
-  describe '#decrypt' do
-
-# These pass, but generate Thor warnings...
-#
-#    it 'should perform OpenSSL decryption' do
-#      ARGV.replace(['decrypt', '--encryptor', 'openssl',
-#                    '--in', 'in_file',
-#                    '--out', 'out_file',
-#                    '--base64', '--salt',
-#                    '--password-file', 'pwd_file'])
-#
-#      cli.any_instance.expects(:`).with(
-#        "openssl aes-256-cbc -d -base64 -pass file:pwd_file -salt " +
-#        "-in 'in_file' -out 'out_file'"
-#      )
-#      cli.start
-#    end
-#
-#    it 'should omit -pass option if no --password-file given' do
-#      ARGV.replace(['decrypt', '--encryptor', 'openssl',
-#                    '--in', 'in_file',
-#                    '--out', 'out_file',
-#                    '--base64', '--salt'])
-#
-#      cli.any_instance.expects(:`).with(
-#        "openssl aes-256-cbc -d -base64  -salt " +
-#        "-in 'in_file' -out 'out_file'"
-#      )
-#      cli.start
-#    end
-#
-#    it 'should perform GnuPG decryption' do
-#      ARGV.replace(['decrypt', '--encryptor', 'gpg',
-#                    '--in', 'in_file',
-#                    '--out', 'out_file'])
-#
-#      cli.any_instance.expects(:`).with(
-#        "gpg -o 'out_file' -d 'in_file'"
-#      )
-#      cli.start
-#    end
-
-    it 'should show a message if given an invalid encryptor' do
-      ARGV.replace(['decrypt', '--encryptor', 'foo',
-                    '--in', 'in_file',
-                    '--out', 'out_file'])
-      out, err = capture_io do
-        cli.start
-      end
-      err.should == ''
-      out.should == "Unknown encryptor: foo\n" +
-          "Use either 'openssl' or 'gpg'.\n"
-    end
-  end
-
-#  would have the same Thor warnings issues...
-#  describe '#dependencies' do
-#  end
-
-  describe '#version' do
-    it 'should output the current version' do
-      utility.expects(:puts).with("Backup #{ Backup::Version.current }")
-      utility.version
-    end
-
-    it 'should output the current version for "-v"' do
-      ARGV.replace ['-v']
-      out, err = capture_io do
-        cli.start
-      end
-      out.should == "Backup #{ Backup::Version.current }\n"
-    end
-  end
-
-  describe '#overwrite?' do
-    context 'when the path exists' do
-      before { File.expects(:exist?).returns(true) }
-
-      it 'should prompt user' do
-        utility.expects(:yes?).with(
-          "A file already exists at 'a/path'. Do you want to overwrite? [y/n]"
-        ).returns(:response)
-        utility.send(:overwrite?, 'a/path').should == :response
-      end
-    end
-
-    context 'when the path does not exist' do
-      before { File.expects(:exist?).returns(false) }
-      it 'should return true' do
-        utility.expects(:yes?).never
-        utility.send(:overwrite?, 'a/path').should be_true
-      end
-    end
-  end
-end