backup 3.0.20 → 3.0.21

data/spec/cli/utility_spec.rb

@@ -3,36 +3,361 @@
 require File.expand_path('../../spec_helper.rb', __FILE__)
 
 describe 'Backup::CLI::Utility' do
-  let(:cli) { Backup::CLI::Utility }
+  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') }
 
-    context 'when errors occur' do
+    before  { Backup::Model.all.push(model_a, model_b) }
+    after   { Backup::Model.all.clear }
 
-      before do
-        @argv_save = ARGV
-      end
+    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)
 
-      after do
-        ARGV.replace(@argv_save)
-      end
+      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)
 
-      it 'should log the error and exit' do
-        ARGV.replace(['perform', '-t', 'foo'])
-        FileUtils.stubs(:mkdir_p).raises(SystemCallError, 'yikes!')
+      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)
+        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]        # (cloudfiles, dropbox, ftp, local, ninefold, rsync, s3, scp, sftp)
+          [--syncers=SYNCERS]          # (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

data/spec/compressor/base_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Backup::Compressor::Base do
+  let(:base) { Backup::Compressor::Base.new }
+
+  describe '#initialize' do
+    it 'should load defaults' do
+      Backup::Compressor::Base.any_instance.expects(:load_defaults!)
+      base
+    end
+  end
+
+  describe '#compressor_name' do
+    it 'should return class name with Backup namespace removed' do
+      base.send(:compressor_name).should == 'Compressor::Base'
+    end
+  end
+
+  describe '#log!' do
+    it 'should log a message' do
+      base.expects(:compressor_name).returns('Compressor Name')
+      Backup::Logger.expects(:message).with(
+        'Using Compressor Name for compression.'
+      )
+      base.send(:log!)
+    end
+  end
+
+end

data/spec/compressor/bzip2_spec.rb

@@ -5,54 +5,79 @@ require File.expand_path('../../spec_helper.rb', __FILE__)
 describe Backup::Compressor::Bzip2 do
   let(:compressor) { Backup::Compressor::Bzip2.new }
 
-  before do
-    Backup::Model.extension = 'tar'
-  end
+  describe 'setting configuration defaults' do
+    after { Backup::Configuration::Compressor::Bzip2.clear_defaults! }
 
-  describe 'the options' do
-    it do
-      compressor.send(:best).should == []
-    end
+    it 'uses and overrides configuration defaults' do
+      Backup::Configuration::Compressor::Bzip2.best.should be_false
+      Backup::Configuration::Compressor::Bzip2.fast.should be_false
+
+      compressor = Backup::Compressor::Bzip2.new
+      compressor.best.should be_false
+      compressor.fast.should be_false
+
+      Backup::Configuration::Compressor::Bzip2.defaults do |c|
+        c.best = true
+        c.fast = true
+      end
+      Backup::Configuration::Compressor::Bzip2.best.should be_true
+      Backup::Configuration::Compressor::Bzip2.fast.should be_true
 
-    it do
-      compressor.send(:fast).should == []
+      compressor = Backup::Compressor::Bzip2.new
+      compressor.best.should be_true
+      compressor.fast.should be_true
+
+      compressor = Backup::Compressor::Bzip2.new do |c|
+        c.best = false
+      end
+      compressor.best.should be_false
+      compressor.fast.should be_true
+
+      compressor = Backup::Compressor::Bzip2.new do |c|
+        c.fast = false
+      end
+      compressor.best.should be_true
+      compressor.fast.should be_false
     end
-  end
+  end # describe 'setting configuration defaults'
 
-  describe '#perform!' do
+  describe '#compress_with' do
     before do
-      [:run, :utility].each { |method| compressor.stubs(method) }
+      compressor.expects(:log!)
+      compressor.expects(:utility).with(:bzip2).returns('bzip2')
     end
 
-    it 'should perform the compression' do
-      compressor.expects(:utility).with(:bzip2).returns(:bzip2)
-      compressor.expects(:run).with("bzip2  '#{ File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar") }'")
-      compressor.perform!
+    it 'should yield with the --best option' do
+      compressor.best = true
+      compressor.compress_with do |cmd, ext|
+        cmd.should == 'bzip2 --best'
+        ext.should == '.bz2'
+      end
     end
 
-    it 'should perform the compression with the --best and --fast options' do
-      compressor = Backup::Compressor::Bzip2.new do |c|
-        c.best = true
-        c.fast = true
+    it 'should yield with the --fast option' do
+      compressor.fast = true
+      compressor.compress_with do |cmd, ext|
+        cmd.should == 'bzip2 --fast'
+        ext.should == '.bz2'
       end
-
-      compressor.stubs(:utility).returns(:bzip2)
-      compressor.expects(:run).with("bzip2 --best --fast '#{ File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar") }'")
-      compressor.perform!
     end
 
-    it 'should set the class variable @extension (Backup::Model.extension) to .bz2' do
-      compressor.stubs(:utility).returns(:bzip2)
-      compressor.expects(:run)
-
-      Backup::Model.extension.should == 'tar'
-      compressor.perform!
-      Backup::Model.extension.should == 'tar.bz2'
+    it 'should yield with the --best and --fast options' do
+      compressor.best = true
+      compressor.fast = true
+      compressor.compress_with do |cmd, ext|
+        cmd.should == 'bzip2 --best --fast'
+        ext.should == '.bz2'
+      end
     end
 
-    it 'should log' do
-      Backup::Logger.expects(:message).with("Backup::Compressor::Bzip2 started compressing the archive.")
-      compressor.perform!
+    it 'should yield with no options' do
+      compressor.compress_with do |cmd, ext|
+        cmd.should == 'bzip2'
+        ext.should == '.bz2'
+      end
     end
-  end
+  end # describe '#compress_with'
+
 end