backup 3.0.27 → 3.1.0

data/spec/pipeline_spec.rb

@@ -1,259 +0,0 @@
-# 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')
-      # 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('')
-            pipeline.stubs(:stderr_messages).returns(false)
-          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")
-            pipeline.stubs(:stderr_messages).returns('stderr_messages_output')
-          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")
-          pipeline.stubs(:stderr_messages).returns('success? should be false')
-        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 1>&2 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 1>&2 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

@@ -1,60 +0,0 @@
-# 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 |method|
-      Backup::Logger.stubs(method).raises("Unexpected call to Backup::Logger.#{ method }")
-    end
-  end
-end
-
-unless @_put_ruby_version
-  puts @_put_ruby_version = "\n\nRuby version: #{ RUBY_DESCRIPTION }\n\n"
-end

data/spec/splitter_spec.rb

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

@@ -1,166 +0,0 @@
-# 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 }
-  let(:storage) { Backup::Storage::Base.new(model) }
-
-  it 'should include Configuration::Helpers' do
-    Backup::Storage::Base.
-      include?(Backup::Configuration::Helpers).should be_true
-  end
-
-  describe '#initialize' do
-    after { Backup::Storage::Base.clear_defaults! }
-
-    it 'should load pre-configured defaults' do
-      Backup::Storage::Base.any_instance.expects(:load_defaults!)
-      storage
-    end
-
-    it 'should set a reference to the model' do
-      storage.instance_variable_get(:@model).should == model
-    end
-
-    it 'should set a reference to the storage_id' do
-      storage = Backup::Storage::Base.new(model, 'test_id')
-      storage.storage_id.should == 'test_id'
-    end
-
-    it 'should not require the storage_id' do
-      storage.instance_variable_defined?(:@storage_id).should be_true
-      storage.storage_id.should be_nil
-    end
-
-    context 'when no pre-configured defaults have been set' do
-      it 'should set default values' do
-        storage.keep.should be_nil
-        storage.storage_id.should be_nil
-      end
-    end # context 'when no pre-configured defaults have been set'
-
-    context 'when pre-configured defaults have been set' do
-      before do
-        Backup::Storage::Base.defaults do |s|
-          s.keep = 5
-        end
-      end
-
-      it 'should use pre-configured defaults' do
-        storage.keep.should be(5)
-      end
-    end # context 'when pre-configured defaults have been set'
-  end # describe '#initialize'
-
-  describe '#perform!' do
-    before do
-      model.instance_variable_set(:@package, package)
-    end
-
-    it 'should call #transfer!, then #cycle!' do
-      s = sequence ''
-      storage.expects(:transfer!).in_sequence(s)
-      storage.expects(:cycle!).in_sequence(s)
-      storage.perform!
-      storage.instance_variable_get(:@package).should be(package)
-    end
-  end
-
-  describe '#storage_name' do
-    context 'when given a storage_id' do
-      before { storage.storage_id = 'storage id' }
-      it 'should return a log-friendly name with the storage_id' do
-        storage.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
-        storage.send(:storage_name).should == 'Storage::Base'
-      end
-    end
-  end
-
-  describe '#local_path' do
-    it 'should return the configured tmp_path' do
-      storage.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')
-      storage.expects(:path).returns('base/remote/path')
-    end
-
-    it 'should return the remote_path for the given package' do
-      storage.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'
-      )
-      storage.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
-      storage.method(:transferred_files_for).should ==
-          storage.method(:files_to_transfer_for)
-    end
-  end
-
-  describe '#cycle!' do
-    before do
-      storage.stubs(:storage_name).returns('Storage Name')
-      storage.instance_variable_set(:@package, package)
-    end
-
-    context 'when keep is set and > 0' do
-      before { storage.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(storage, package)
-        Backup::Logger.expects(:message).in_sequence(s).
-            with('Storage Name: Cycling Complete!')
-
-        storage.send(:cycle!)
-      end
-    end
-
-    context 'when keep is not set or == 0' do
-      it 'should return nil when not set' do
-        storage.keep = nil
-        storage.send(:cycle!).should be_nil
-      end
-
-      it 'should return nil when == 0' do
-        storage.keep = 0
-        storage.send(:cycle!).should be_nil
-      end
-    end
-  end
-
-end