backup_checksum 3.0.23

data/spec/cli/helpers_spec.rb

@@ -0,0 +1,176 @@
+# 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(: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
+
+    it 'returns nil if status exit code is in ignore_exit_codes' do
+      process_data = { :status => '3', :ignore_exit_codes => [1,3,5] }
+      helpers.raise_if_command_failed!('foo', process_data).should be_nil
+    end
+
+    it 'raises an error with stdout/stderr data' do
+      process_data = { :status => '3', :ignore_exit_codes => [2,4,6],
+                       :stdout => 'stdout data', :stderr => 'stderr data' }
+
+      expect do
+        helpers.raise_if_command_failed!('utility_name', process_data)
+      end.to raise_error(
+        Backup::Errors::CLI::SystemCallError,
+        "CLI::SystemCallError: Failed to run utility_name on #{RUBY_PLATFORM}\n" +
+        "  The following information should help to determine the problem:\n" +
+        "  Exit Code: 3\n" +
+        "  STDERR:\n" +
+        "  stderr data\n" +
+        "  STDOUT:\n" +
+        "  stdout data"
+      )
+    end
+
+  end
+
+end

data/spec/cli/utility_spec.rb

@@ -0,0 +1,363 @@
+# 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') }
+
+    before  { Backup::Model.all.push(model_a, model_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)
+      Backup::Config.expects(:load_config!).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::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)
+      Backup::Config.expects(:load_config!).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::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
+
+    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
+
+    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, gzip, lzma, pbzip2)
+          [--notifiers=NOTIFIERS]      # (campfire, hipchat, mail, presently, prowl, 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:config' do
+    before do
+      FileUtils.unstub(:mkdir_p)
+      FileUtils.unstub(:touch)
+    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 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