backup-agoddard 3.0.27

data/spec/cli/helpers_spec.rb

@@ -0,0 +1,301 @@
+# 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

@@ -0,0 +1,411 @@
+# 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