backup_checksum 3.0.23

data/spec/pipeline_spec.rb

@@ -0,0 +1,257 @@
+# encoding: utf-8
+
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe 'Backup::Pipeline' do
+  let(:pipeline)  { Backup::Pipeline.new }
+
+  describe '#initialize' do
+    it 'should create a new pipeline' do
+      pipeline.instance_variable_get(:@commands).should == []
+      pipeline.errors.should == []
+      pipeline.stderr.should == ''
+    end
+  end
+
+  describe '#<<' do
+    it 'should add a command string to @commands' do
+      pipeline << 'a command string'
+      pipeline.instance_variable_get(:@commands).should == ['a command string']
+    end
+  end
+
+  describe '#run' do
+    let(:stdout) { mock }
+    let(:stderr) { mock }
+
+    before do
+      pipeline.expects(:pipeline).returns('foo')
+      pipeline.stubs(:stderr_messages).returns('stderr_messages_output')
+      # stub CLI::Helpers#command_name so it simply returns what it's passed
+      pipeline.class.send(:define_method, :command_name, lambda {|arg| arg } )
+    end
+
+    context 'when pipeline command is successfully executed' do
+      before do
+        Open4.expects(:popen4).with('foo').yields(nil, nil, stdout, stderr)
+      end
+
+      context 'when all commands within the pipeline are successful' do
+        before do
+          stdout.expects(:read).returns("0|0:1|0:\n")
+        end
+
+        context 'when commands output no stderr messages' do
+          before do
+            stderr.expects(:read).returns('')
+          end
+
+          it 'should process the returned stdout/stderr and report no errors' do
+            Backup::Logger.expects(:warn).never
+
+            pipeline.run
+            pipeline.stderr.should == ''
+            pipeline.errors.should == []
+          end
+        end
+
+        context 'when successful commands output messages on stderr' do
+          before do
+            stderr.expects(:read).returns("stderr output\n")
+          end
+
+          it 'should log a warning with the stderr messages' do
+            Backup::Logger.expects(:warn).with('stderr_messages_output')
+
+            pipeline.run
+            pipeline.stderr.should == 'stderr output'
+            pipeline.errors.should == []
+          end
+        end
+      end # context 'when all commands within the pipeline are successful'
+
+      context 'when commands within the pipeline are not successful' do
+        before do
+          pipeline.instance_variable_set(:@commands, ['first', 'second', 'third'])
+          stderr.expects(:read).returns("stderr output\n")
+        end
+
+        context 'when the commands return in sequence' do
+          before do
+            stdout.expects(:read).returns("0|0:1|1:2|0:\n")
+          end
+
+          it 'should set @errors and @stderr without logging warnings' do
+            Backup::Logger.expects(:warn).never
+
+            pipeline.run
+            pipeline.stderr.should == 'stderr output'
+            pipeline.errors.count.should be(1)
+            pipeline.errors.first.should be_a_kind_of SystemCallError
+            pipeline.errors.first.errno.should be(1)
+            pipeline.errors.first.message.should match(
+              "'second' returned exit code: 1"
+            )
+          end
+        end # context 'when the commands return in sequence'
+
+        context 'when the commands return out of sequence' do
+          before do
+            stdout.expects(:read).returns("1|1:2|0:0|0:\n")
+          end
+
+          it 'should properly associate the exitstatus for each command' do
+            Backup::Logger.expects(:warn).never
+
+            pipeline.run
+            pipeline.stderr.should == 'stderr output'
+            pipeline.errors.count.should be(1)
+            pipeline.errors.first.should be_a_kind_of SystemCallError
+            pipeline.errors.first.errno.should be(1)
+            pipeline.errors.first.message.should match(
+              "'second' returned exit code: 1"
+            )
+          end
+        end # context 'when the commands return out of sequence'
+
+        context 'when multiple commands fail (out of sequence)' do
+          before do
+            stdout.expects(:read).returns("1|1:2|0:0|3:\n")
+          end
+
+          it 'should properly associate the exitstatus for each command' do
+            Backup::Logger.expects(:warn).never
+
+            pipeline.run
+            pipeline.stderr.should == 'stderr output'
+            pipeline.errors.count.should be(2)
+            pipeline.errors.each {|err| err.should be_a_kind_of SystemCallError }
+            pipeline.errors[0].errno.should be(3)
+            pipeline.errors[0].message.should match(
+              "'first' returned exit code: 3"
+            )
+            pipeline.errors[1].errno.should be(1)
+            pipeline.errors[1].message.should match(
+              "'second' returned exit code: 1"
+            )
+          end
+        end # context 'when the commands return (out of sequence)'
+
+      end # context 'when commands within the pipeline are not successful'
+    end # context 'when pipeline command is successfully executed'
+
+    context 'when pipeline command fails to execute' do
+      before do
+        Open4.expects(:popen4).with('foo').raises('exec failed')
+      end
+
+      it 'should raise an error' do
+        expect do
+          pipeline.run
+        end.to raise_error(
+          Backup::Errors::Pipeline::ExecutionError,
+          "Pipeline::ExecutionError: RuntimeError: exec failed"
+        )
+      end
+    end # context 'when pipeline command fails to execute'
+
+  end # describe '#run'
+
+  describe '#success?' do
+    it 'returns true when @errors is empty' do
+      pipeline.success?.should be_true
+    end
+
+    it 'returns false when @errors is not empty' do
+      pipeline.instance_variable_set(:@errors, ['foo'])
+      pipeline.success?.should be_false
+    end
+  end # describe '#success?'
+
+  describe '#error_messages' do
+    before do
+      pipeline.instance_variable_set(
+        :@errors, [
+          StandardError.new('standard error'),
+          RuntimeError.new('runtime error')
+        ]
+      )
+    end
+
+    context 'when #stderr_messages has messages' do
+      before do
+        pipeline.expects(:stderr_messages).returns('stderr messages')
+      end
+
+      it 'should output #stderr_messages and formatted system error messages' do
+        pipeline.error_messages.should == 'stderr messages' +
+          "The following system errors were returned:\n" +
+          "Error: StandardError: standard error\n" +
+          "Error: RuntimeError: runtime error"
+      end
+    end
+
+    context 'when #stderr_messages has no messages' do
+      before do
+        pipeline.expects(:stderr_messages).returns(false)
+      end
+
+      it 'should only output the formatted system error messages' do
+        pipeline.error_messages.should ==
+          "The following system errors were returned:\n" +
+          "Error: StandardError: standard error\n" +
+          "Error: RuntimeError: runtime error"
+      end
+    end
+  end # describe '#error_messages'
+
+  describe '#pipeline' do
+    context 'when there are multiple system commands to execute' do
+      before do
+        pipeline.instance_variable_set(:@commands, %w{ one two three })
+      end
+
+      it 'should build a pipeline with redirected/collected exit codes' do
+        pipeline.send(:pipeline).should ==
+          '( ( one 2>&4; echo "0|$?:" >&3 ) | ' +
+          '( two 2>&4; echo "1|$?:" >&3 ) | ' +
+          '( three 2>&4; echo "2|$?:" >&3 ) ) 3>&1- 4>&2'
+      end
+    end
+
+    context 'when there is only one system command to execute' do
+      before do
+        pipeline.instance_variable_set(:@commands, ['foo'])
+      end
+
+      it 'should build the command line in the same manner, but without pipes' do
+        pipeline.send(:pipeline).should ==
+          '( ( foo 2>&4; echo "0|$?:" >&3 ) ) 3>&1- 4>&2'
+      end
+    end
+  end # describe '#pipeline'
+
+  describe '#stderr_message' do
+    context 'when @stderr has messages' do
+      before do
+        pipeline.instance_variable_set(:@stderr, "stderr message\n output")
+      end
+
+      it 'should return a formatted message with the @stderr messages' do
+        pipeline.send(:stderr_messages).should ==
+          "  Pipeline STDERR Messages:\n" +
+          "  (Note: may be interleaved if multiple commands returned error messages)\n" +
+          "\n" +
+          "  stderr message\n" +
+          "  output\n"
+      end
+    end
+
+    context 'when @stderr is empty' do
+      it 'should return false' do
+        pipeline.send(:stderr_messages).should be_false
+      end
+    end
+  end # describe '#stderr_message'
+
+end #describe 'Backup::Pipeline'

data/spec/spec_helper.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+##
+# Use Bundler
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'bundler/setup'
+
+##
+# Load Backup
+require 'backup'
+
+require 'timecop'
+
+module Backup::ExampleHelpers
+  # ripped from MiniTest :)
+  # RSpec doesn't have a method for this? Am I missing something?
+  def capture_io
+    require 'stringio'
+
+    orig_stdout, orig_stderr = $stdout, $stderr
+    captured_stdout, captured_stderr = StringIO.new, StringIO.new
+    $stdout, $stderr = captured_stdout, captured_stderr
+
+    yield
+
+    return captured_stdout.string, captured_stderr.string
+  ensure
+    $stdout = orig_stdout
+    $stderr = orig_stderr
+  end
+end
+
+require 'rspec/autorun'
+RSpec.configure do |config|
+  ##
+  # Use Mocha to mock with RSpec
+  config.mock_with :mocha
+
+  ##
+  # Example Helpers
+  config.include Backup::ExampleHelpers
+
+  ##
+  # Actions to perform before each example
+  config.before(:each) do
+    FileUtils.collect_method(:noop).each do |method|
+      FileUtils.stubs(method).raises("Unexpected call to FileUtils.#{method}")
+    end
+    Open4.stubs(:popen4).raises('Unexpected call to Open4::popen4()')
+
+    [:message, :error, :warn, :normal, :silent].each do |message_type|
+      Backup::Logger.stubs(message_type)
+    end
+  end
+end
+
+unless @_put_ruby_version
+  puts @_put_ruby_version = "\n\nRuby version: #{RUBY_DESCRIPTION}\n\n"
+end

data/spec/splitter_spec.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe Backup::Splitter do
+  let(:model) { Backup::Model.new(:test_trigger, 'test label') }
+  let(:splitter) { Backup::Splitter.new(model, 250) }
+  let(:package) { mock }
+
+  describe '#initialize' do
+    it 'should set instance variables' do
+      splitter.instance_variable_get(:@model).should be(model)
+      splitter.instance_variable_get(:@chunk_size).should be(250)
+    end
+  end
+
+  describe '#split_with' do
+    it 'should yield the split command, performing before/after methods' do
+      s = sequence ''
+      given_block = mock
+      block = lambda {|arg| given_block.got(arg) }
+      splitter.instance_variable_set(:@split_command, 'split command')
+
+      splitter.expects(:before_packaging).in_sequence(s)
+      given_block.expects(:got).in_sequence(s).with('split command')
+      splitter.expects(:after_packaging).in_sequence(s)
+
+      splitter.split_with(&block)
+    end
+  end
+
+  # Note: using a 'M' suffix for the byte size is not OSX compatible
+  describe '#before_packaging' do
+    before do
+      model.instance_variable_set(:@package, package)
+      splitter.expects(:utility).with(:split).returns('split')
+      package.expects(:basename).returns('base_filename')
+    end
+
+    it 'should set @package and @split_command' do
+      Backup::Logger.expects(:message).with(
+        'Splitter configured with a chunk size of 250MB.'
+      )
+      splitter.send(:before_packaging)
+
+      splitter.instance_variable_get(:@package).should be(package)
+
+      split_suffix = File.join(Backup::Config.tmp_path, 'base_filename-')
+      splitter.instance_variable_get(:@split_command).should ==
+          "split -b 250m - '#{ split_suffix }'"
+    end
+  end
+
+  describe '#after_packaging' do
+    before do
+      splitter.instance_variable_set(:@package, package)
+    end
+
+    context 'when splitting occurred during packaging' do
+      before do
+        splitter.expects(:chunk_suffixes).returns(['aa', 'ab'])
+      end
+
+      it 'should set the chunk_suffixes for the package' do
+        package.expects(:chunk_suffixes=).with(['aa', 'ab'])
+        splitter.send(:after_packaging)
+      end
+    end
+
+    context 'when splitting did not occur during packaging' do
+      before do
+        splitter.expects(:chunk_suffixes).returns(['aa'])
+        package.expects(:basename).twice.returns('base_filename')
+      end
+
+      it 'should remove the suffix from the only package file' do
+        package.expects(:chunk_suffixes=).never
+        FileUtils.expects(:mv).with(
+          File.join(Backup::Config.tmp_path, 'base_filename-aa'),
+          File.join(Backup::Config.tmp_path, 'base_filename')
+        )
+        splitter.send(:after_packaging)
+      end
+    end
+  end # describe '#after_packaging'
+
+  describe '#chunk_suffixes' do
+    before do
+      splitter.expects(:chunks).returns(
+        ['/path/to/file.tar-aa', '/path/to/file.tar-ab']
+      )
+    end
+
+    it 'should return an array of chunk suffixes' do
+      splitter.send(:chunk_suffixes).should == ['aa', 'ab']
+    end
+  end
+
+  describe '#chunks' do
+    before do
+      splitter.instance_variable_set(:@package, package)
+      package.expects(:basename).returns('base_filename')
+      FileUtils.unstub(:touch)
+    end
+
+    it 'should return a sorted array of chunked file paths' do
+      Dir.mktmpdir do |dir|
+        Backup::Config.expects(:tmp_path).returns(dir)
+        FileUtils.touch(File.join(dir, 'base_filename-aa'))
+        FileUtils.touch(File.join(dir, 'base_filename-ab'))
+
+        splitter.send(:chunks).should == [
+          File.join(dir, 'base_filename-aa'),
+          File.join(dir, 'base_filename-ab')
+        ]
+      end
+    end
+  end
+
+end

data/spec/storage/base_spec.rb

@@ -0,0 +1,160 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Backup::Storage::Base do
+  let(:model)   { Backup::Model.new(:test_trigger, 'test label') }
+  let(:package) { mock("package") }
+  let(:checksum_creator) { mock("checksum_creator") }
+  let(:base)    { Backup::Storage::Base.new(model) }
+
+  describe '#initialize' do
+    it 'should set instance variables' do
+      base.instance_variable_get(:@model).should be(model)
+      base.instance_variable_defined?(:@storage_id).should be_true
+      base.instance_variable_get(:@storage_id).should be_nil
+      base.keep.should be_nil
+    end
+
+    context 'when given a storage_id' do
+      it 'should set @storage_id' do
+        base = Backup::Storage::Base.new(model, 'my storage id')
+        base.instance_variable_get(:@storage_id).should == 'my storage id'
+      end
+    end
+
+    context 'when configuration defaults are set' do
+      after { Backup::Configuration::Storage::Base.clear_defaults! }
+      it 'should use the defaults' do
+        Backup::Configuration::Storage::Base.defaults do |base|
+          base.keep = 5
+        end
+        base = Backup::Storage::Base.new(model)
+        base.keep.should be(5)
+      end
+    end
+  end # describe '#initialize'
+
+  describe '#perform!' do
+    before do
+      model.instance_variable_set(:@package, package)
+    end
+
+    it 'should call #transfer!, then #cycle!' do
+      s = sequence ''
+      base.expects(:transfer!).in_sequence(s)
+      base.expects(:cycle!).in_sequence(s)
+      base.perform!
+      base.instance_variable_get(:@package).should be(package)
+    end
+
+    it "should process checksum file" do
+      model.instance_variable_set(:@checksum_creator, checksum_creator)
+      package.stubs(:filenames).returns []
+      package.stubs(:checksum_name).returns ""
+      s = sequence ''
+      checksum_creator.expects(:process_checksum_file_before_transfer).in_sequence(s)
+      base.expects(:transfer!).in_sequence(s)
+
+      base.perform!
+
+      base.instance_variable_get(:@checksum_creator).should be(checksum_creator)
+    end
+  end
+
+  describe '#storage_name' do
+    context 'when given a storage_id' do
+      before { base.storage_id = 'storage id' }
+      it 'should return a log-friendly name with the storage_id' do
+        base.send(:storage_name).should == 'Storage::Base (storage id)'
+      end
+    end
+
+    context 'when not given a storage_id' do
+      it 'should return a log-friendly name without a storage_id' do
+        base.send(:storage_name).should == 'Storage::Base'
+      end
+    end
+  end
+
+  describe '#local_path' do
+    it 'should return the configured tmp_path' do
+      base.send(:local_path).should == Backup::Config.tmp_path
+    end
+  end
+
+  describe '#remote_path_for' do
+    before do
+      package.expects(:trigger).returns('test_trigger')
+      package.expects(:time).returns('backup_time')
+      base.expects(:path).returns('base/remote/path')
+    end
+
+    it 'should return the remote_path for the given package' do
+      base.send(:remote_path_for, package).should ==
+          File.join('base/remote/path', 'test_trigger', 'backup_time')
+    end
+  end
+
+  describe '#files_to_transfer_for' do
+    let(:given_block) { mock }
+    before do
+      package.stubs(:filenames).returns(
+        ['2011.12.31.11.00.02.backup.tar.enc-aa',
+         '2011.12.31.11.00.02.backup.tar.enc-ab']
+      )
+    end
+
+    it 'should yield the full filename and the filename without the timestamp' do
+      given_block.expects(:got).with(
+        '2011.12.31.11.00.02.backup.tar.enc-aa', 'backup.tar.enc-aa'
+      )
+      given_block.expects(:got).with(
+        '2011.12.31.11.00.02.backup.tar.enc-ab', 'backup.tar.enc-ab'
+      )
+      base.send(:files_to_transfer_for, package) do |local_file, remote_file|
+        given_block.got(local_file, remote_file)
+      end
+    end
+
+    it 'should have an alias method called #transferred_files_for' do
+      base.method(:transferred_files_for).should ==
+          base.method(:files_to_transfer_for)
+    end
+  end
+
+  describe '#cycle!' do
+    before do
+      base.stubs(:storage_name).returns('Storage Name')
+      base.instance_variable_set(:@package, package)
+    end
+
+    context 'when keep is set and > 0' do
+      before { base.keep = 1 }
+      it 'should cycle' do
+        s = sequence ''
+        Backup::Logger.expects(:message).in_sequence(s).
+            with('Storage Name: Cycling Started...')
+        Backup::Storage::Cycler.expects(:cycle!).in_sequence(s).
+            with(base, package)
+        Backup::Logger.expects(:message).in_sequence(s).
+            with('Storage Name: Cycling Complete!')
+
+        base.send(:cycle!)
+      end
+    end
+
+    context 'when keep is not set or == 0' do
+      it 'should return nil when not set' do
+        base.keep = nil
+        base.send(:cycle!).should be_nil
+      end
+
+      it 'should return nil when == 0' do
+        base.keep = 0
+        base.send(:cycle!).should be_nil
+      end
+    end
+  end
+
+end