backup_checksum 3.0.23

data/spec/errors_spec.rb

@@ -0,0 +1,306 @@
+# encoding: utf-8
+
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+# Note: none of these tests require the use of the ErrorsHelper
+describe 'Errors::Error' do
+  let(:klass) { Backup::Errors::Error }
+
+  it 'allow errors to cascade through the system' do
+    class ErrorA < klass; end
+    class ErrorB < klass; end
+    class ErrorC < klass; end
+    class ErrorD < klass; end
+
+    expect do
+      begin
+        begin
+          begin
+            raise ErrorA, 'an error occurred in Zone A'
+          rescue => err
+            raise ErrorB.wrap(err, <<-EOS)
+              an error occurred in Zone B
+
+              the following error should give a reason
+            EOS
+          end
+        rescue => err
+          raise ErrorC.wrap(err)
+        end
+      rescue => err
+        raise ErrorD.wrap(err, 'an error occurred in Zone D')
+      end
+    end.to raise_error(ErrorD,
+      "ErrorD: an error occurred in Zone D\n" +
+      "  Reason: ErrorC\n" +
+      "  ErrorB: an error occurred in Zone B\n" +
+      "  \n" +
+      "  the following error should give a reason\n" +
+      "  Reason: ErrorA\n" +
+      "  an error occurred in Zone A"
+    )
+  end
+
+  describe '#initialize' do
+
+    it 'creates a StandardError' do
+      klass.new.should be_a_kind_of StandardError
+    end
+
+    context 'when given a message' do
+
+      it 'formats a simple message' do
+        err = klass.new('error message')
+        err.message.should == 'Error: error message'
+      end
+
+      it 'formats a multi-line message' do
+        err = klass.new("   error message\n" +
+          "     This is a multi-line error message.\n" +
+          "It should be properly indented.   ")
+
+        err.message.should == "Error: error message\n" +
+            "  This is a multi-line error message.\n" +
+            "  It should be properly indented."
+      end
+
+      context 'when given an original error' do
+
+        it 'includes the original error' do
+          orig_err = StandardError.new('original message')
+          err = klass.new('error message', orig_err)
+          err.message.should == "Error: error message\n" +
+              "  Reason: StandardError\n" +
+              "  original message"
+        end
+
+        it 'formats all messages' do
+          orig_err = StandardError.new(" original message\n" +
+            "     This is a multi-line error message.\n" +
+            "It should be properly indented.")
+          err = klass.new("   error message\n" +
+            "     This is a multi-line error message.\n" +
+            "It should be properly indented.   ", orig_err)
+
+          err.message.should == "Error: error message\n" +
+              "  This is a multi-line error message.\n" +
+              "  It should be properly indented.\n" +
+              "  Reason: StandardError\n" +
+              "  original message\n" +
+              "  This is a multi-line error message.\n" +
+              "  It should be properly indented."
+        end
+
+        it 'uses the original error backtrace' do
+          begin
+            raise StandardError.new
+          rescue => err
+            klass.new(nil, err).backtrace.
+                should == err.backtrace
+          end
+        end
+
+        it 'reports if original error had no message' do
+          orig_err = StandardError.new
+          err = klass.new('error message', orig_err)
+          err.message.should == "Error: error message\n" +
+              "  Reason: StandardError (no message given)"
+        end
+
+      end # context 'when given an original error'
+
+      context 'when given an original Errors::Error' do
+        let(:subklass) do
+          class SubKlass < klass; end
+          SubKlass
+        end
+
+        it 'includes the original error' do
+          orig_err = subklass.new('original message')
+          err = klass.new('error message', orig_err)
+          err.message.should == "Error: error message\n" +
+              "  Reason: SubKlass\n" +
+              "  original message"
+        end
+
+        it 'formats all messages' do
+          orig_err = subklass.new(" original message\n" +
+            "     This is a multi-line error message.\n" +
+            "It should be properly indented.")
+          err = klass.new("   error message\n" +
+            "     This is a multi-line error message.\n" +
+            "It should be properly indented.   ", orig_err)
+
+          err.message.should == "Error: error message\n" +
+              "  This is a multi-line error message.\n" +
+              "  It should be properly indented.\n" +
+              "  Reason: SubKlass\n" +
+              "  original message\n" +
+              "  This is a multi-line error message.\n" +
+              "  It should be properly indented."
+        end
+
+        it 'uses the original error backtrace' do
+          begin
+            raise subklass.new
+          rescue => err
+            klass.new(nil, err).backtrace.
+                should == err.backtrace
+          end
+        end
+
+        it 'reports if original error had no message' do
+          orig_err = subklass.new
+          err = klass.new('error message', orig_err)
+          err.message.should == "Error: error message\n" +
+              "  Reason: SubKlass (no message given)"
+        end
+
+      end # context 'when given an original Errors::Error'
+
+    end # context 'when given a message'
+
+    context 'when given no message' do
+
+      it 'strips the module namespace from the default message' do
+        err = klass.new
+        err.message.should == 'Error'
+      end
+
+      context 'when given an original error' do
+
+        it 'uses the original error message' do
+          orig_err = StandardError.new
+          err = klass.new(nil, orig_err)
+          err.message.should == 'Error: StandardError'
+
+          orig_err = StandardError.new('original message')
+          err = klass.new(nil, orig_err)
+          err.message.should == 'Error: StandardError: original message'
+
+          orig_err = StandardError.new(" original message\n" +
+            "     This is a multi-line error message.\n" +
+            "It should be properly indented.")
+          err = klass.new(nil, orig_err)
+          err.message.should == "Error: StandardError: original message\n" +
+              "  This is a multi-line error message.\n" +
+              "  It should be properly indented."
+        end
+
+      end # context 'when given an original error'
+
+      context 'when given an original Errors::Error' do
+        let(:subklass) do
+          class SubKlass < klass; end
+          SubKlass
+        end
+
+        it 'uses the original error message' do
+          orig_err = subklass.new
+          err = klass.new(nil, orig_err)
+          err.message.should == 'Error: SubKlass'
+
+          orig_err = subklass.new('original message')
+          err = klass.new(nil, orig_err)
+          err.message.should == 'Error: SubKlass: original message'
+
+          orig_err = subklass.new(" original message\n" +
+            "     This is a multi-line error message.\n" +
+            "It should be properly indented.")
+          err = klass.new(nil, orig_err)
+          err.message.should == "Error: SubKlass: original message\n" +
+              "  This is a multi-line error message.\n" +
+              "  It should be properly indented."
+        end
+
+      end # context 'when given an original Errors::Error'
+
+    end # context 'when given no message'
+
+  end # describe '#initialize'
+
+  describe '#wrap' do
+    describe 'swaps the parameters to provide a cleaner way to' do
+
+      it 'raise a wrapped error with a message' do
+        orig_err = StandardError.new <<-EOS
+          original message
+          This is a multi-line error message.
+          It should be properly indented.
+        EOS
+
+        expect do
+          raise klass.wrap(orig_err), <<-EOS
+            error message
+            This is a multi-line error message.
+            It should be properly indented.
+          EOS
+        end.to raise_error(klass,
+          "Error: error message\n" +
+          "  This is a multi-line error message.\n" +
+          "  It should be properly indented.\n" +
+          "  Reason: StandardError\n" +
+          "  original message\n" +
+          "  This is a multi-line error message.\n" +
+          "  It should be properly indented."
+        )
+      end
+
+      it 'return a wrapped error with a message' do
+        orig_err = StandardError.new <<-EOS
+          original message
+          This is a multi-line error message.
+          It should be properly indented.
+        EOS
+
+        err = klass.wrap(orig_err, <<-EOS)
+          error message
+          This will wrap the original error
+          and it's message will be given below
+        EOS
+
+        err.message.should ==
+          "Error: error message\n" +
+          "  This will wrap the original error\n" +
+          "  and it's message will be given below\n" +
+          "  Reason: StandardError\n" +
+          "  original message\n" +
+          "  This is a multi-line error message.\n" +
+          "  It should be properly indented."
+      end
+
+    end # describe 'swaps the parameters to provide a cleaner way to'
+  end # describe '#wrap'
+
+end # describe 'Errors::Error'
+
+describe 'ErrorHelper' do
+  let(:base) { Backup::Errors }
+
+  it 'dynamically creates namespaces and subclasses of Errors::Error' do
+    Backup::Errors::FooBarError.new.
+        should be_a_kind_of base::Error
+    Backup::Errors::Foo::Bar::Error.new.
+        should be_a_kind_of base::Error
+  end
+
+  context 'new error classes created within new namespaces' do
+    it 'retain the added portion of namespace in their messages' do
+      orig_err = StandardError.new('original message')
+      err = base::FooMod::FooError.new('error message', orig_err)
+      err.message.should ==
+          "FooMod::FooError: error message\n" +
+          "  Reason: StandardError\n" +
+          "  original message"
+
+      err2 = base::Foo::Bar::Mod::FooBarError.wrap(err, 'foobar message')
+      err2.message.should ==
+          "Foo::Bar::Mod::FooBarError: foobar message\n" +
+          "  Reason: FooMod::FooError\n" +
+          "  error message\n" +
+          "  Reason: StandardError\n" +
+          "  original message"
+    end
+  end
+
+end # describe ErrorHelper

data/spec/logger_spec.rb

@@ -0,0 +1,363 @@
+# encoding: utf-8
+
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe Backup::Logger do
+  let(:logger_time)  { Time.now.strftime("%Y/%m/%d %H:%M:%S") }
+  let(:logfile_path) { File.join(Backup::Config.log_path, 'backup.log') }
+  let(:logfile_mock) { mock }
+  let(:s) { sequence '' }
+
+  before do
+    Timecop.freeze(Time.now)
+
+    # stubbed in spec_helper
+    [:message, :error, :warn, :normal, :silent].each do |message_type|
+      subject.unstub(message_type)
+    end
+
+    subject.quiet = nil
+    subject.send(:remove_instance_variable, :@messages) rescue nil
+    subject.send(:remove_instance_variable, :@has_warnings) rescue nil
+  end
+
+  describe '#message' do
+    it 'sends a regular message to the console and log file' do
+      subject.expects(:loggify).in_sequence(s).
+          with('regular message', :message, :green).
+          returns(:green_regular_message)
+      subject.expects(:to_console).in_sequence(s).
+          with(:green_regular_message)
+      subject.expects(:loggify).in_sequence(s).
+          with('regular message', :message).
+          returns(:uncolored_regular_message)
+      subject.expects(:to_file).in_sequence(s).
+          with(:uncolored_regular_message)
+
+      subject.message('regular message')
+    end
+  end
+
+  describe '#error' do
+    it 'sends an error message to the console (stderr) and log file' do
+      subject.expects(:loggify).in_sequence(s).
+          with('error message', :error, :red).
+          returns(:red_error_message)
+      subject.expects(:to_console).in_sequence(s).
+          with(:red_error_message, true)
+      subject.expects(:loggify).in_sequence(s).
+          with('error message', :error).
+          returns(:uncolored_error_message)
+      subject.expects(:to_file).in_sequence(s).
+          with(:uncolored_error_message)
+
+      subject.error('error message')
+    end
+  end
+
+  describe '#warn' do
+    it 'sends a warning message to the console (stderr) and log file' do
+      subject.expects(:loggify).in_sequence(s).
+          with('warning message', :warning, :yellow).
+          returns(:yellow_warning_message)
+      subject.expects(:to_console).in_sequence(s).
+          with(:yellow_warning_message, true)
+      subject.expects(:loggify).in_sequence(s).
+          with('warning message', :warning).
+          returns(:uncolored_warning_message)
+      subject.expects(:to_file).in_sequence(s).
+          with(:uncolored_warning_message)
+
+      subject.warn('warning message')
+    end
+
+    it 'sets has_warnings? to true' do
+      subject.stubs(:to_console)
+      subject.stubs(:to_file)
+      expect { subject.warn('warning') }.to
+          change{ subject.has_warnings? }.from(false).to(true)
+    end
+  end
+
+  describe '#normal' do
+    it 'sends a normal, unformatted message to the console and log file' do
+      subject.expects(:loggify).in_sequence(s).
+          with('normal message').
+          returns(:unformatted_message)
+      subject.expects(:to_console).in_sequence(s).
+          with(:unformatted_message)
+      subject.expects(:loggify).in_sequence(s).
+          with('normal message').
+          returns(:unformatted_message)
+      subject.expects(:to_file).in_sequence(s).
+          with(:unformatted_message)
+
+      subject.normal('normal message')
+    end
+  end
+
+  describe '#silent' do
+    it 'sends a silent message to the log file' do
+      subject.expects(:to_console).never
+      subject.expects(:loggify).in_sequence(s).
+          with('silent message', :silent).
+          returns(:silent_message)
+      subject.expects(:to_file).in_sequence(s).
+          with(:silent_message)
+
+      subject.silent('silent message')
+    end
+  end
+
+  describe '#messages' do
+
+    it 'returns an empty array if no messages have been sent' do
+      subject.messages.should == []
+    end
+
+    it 'returns an array of all lines sent to the log file' do
+      File.stubs(:open).yields(stub(:puts))
+      strings = ['an array', 'of message', 'strings']
+      subject.send(:to_file, strings)
+      subject.messages.should == strings
+    end
+
+    it 'does not track lines sent to the console' do
+      subject.stubs(:puts)
+      strings = ['an array', 'of message', 'strings']
+      subject.send(:to_console, strings)
+      subject.messages.should == []
+    end
+
+  end # describe '#messages'
+
+  describe '#clear!' do
+    it 'should clear the log and reset has_warnings?' do
+      subject.messages << 'foo'
+      subject.instance_variable_set(:@has_warnings, true)
+      subject.messages.count.should == 1
+      subject.has_warnings?.should be_true
+
+      subject.clear!
+      subject.messages.should be_empty
+      subject.has_warnings?.should be_false
+    end
+  end # describe '#clear!'
+
+  describe '#truncate!' do
+    context 'when log file does not exist' do
+      before { File.stubs(:exist?).returns(false) }
+      it 'should do nothing' do
+        File.expects(:stat).never
+        subject.truncate!
+      end
+    end
+
+    context 'when log file is <= max_bytes' do
+      before { File.stubs(:exist?).returns(true) }
+      it 'should do nothing' do
+        stat = mock
+        File.expects(:stat).twice.with(
+          File.join(Backup::Config.log_path, 'backup.log')
+        ).returns(stat)
+
+        [1, 2].each do |size|
+          stat.expects(:size).returns(size)
+
+          FileUtils.expects(:mv).never
+          File.expects(:open).never
+          FileUtils.expects(:rm_f).never
+
+          subject.truncate!(2)
+        end
+      end
+    end
+
+    context 'when log file is > max_bytes' do
+      before do
+        FileUtils.unstub(:mkdir_p)
+        FileUtils.unstub(:mv)
+        FileUtils.unstub(:rm)
+        FileUtils.unstub(:rm_f)
+      end
+
+      it 'should truncate the file, removing older lines' do
+        max_bytes = 5_000
+        line_len  = 120
+        Dir.mktmpdir do |dir|
+          Backup::Config.update(:root_path => dir)
+          FileUtils.mkdir_p(Backup::Config.log_path)
+          log_file = File.join(Backup::Config.log_path, 'backup.log')
+
+          lineno = 0
+          over_max = (max_bytes * 1.25).to_i
+          File.open(log_file, 'w') do |f|
+            until f.pos > over_max
+              f.puts "#{ lineno += 1 }: ".ljust(line_len, 'x')
+            end
+          end
+          File.stat(log_file).size.
+              should be_within(line_len + 2).of(over_max)
+
+          subject.truncate!(max_bytes)
+
+          File.stat(log_file).size.
+              should be_within(line_len + 2).of(max_bytes)
+
+          File.readlines(log_file).last.chomp.
+              should == "#{ lineno }: ".ljust(line_len, 'x')
+
+          File.exist?(log_file + '~').should be_false
+        end
+      end
+    end
+
+  end # describe '#truncate!'
+
+  describe '#loggify' do
+
+    it 'returns an array of strings split on newline separators' do
+      str_aa = "first line\nsecond line"
+      str_ab = "first line\nsecond line\n"
+      expected_a = ["[#{logger_time}][msg_type] first line",
+                  "[#{logger_time}][msg_type] second line"]
+
+      str_b = 'string with no newline'
+      expected_b = ["[#{logger_time}][msg_type] string with no newline"]
+
+      subject.send(:loggify, str_aa, :msg_type).should == expected_a
+      subject.send(:loggify, str_ab, :msg_type).should == expected_a
+      subject.send(:loggify, str_b,  :msg_type).should == expected_b
+    end
+
+    it 'formats a string with color if color is given' do
+      green_type  = ["[#{logger_time}][#{"\e[32mmsg_type\e[0m"}] foo"]
+      yellow_type = ["[#{logger_time}][#{"\e[33mmsg_type\e[0m"}] foo"]
+      red_type    = ["[#{logger_time}][#{"\e[31mmsg_type\e[0m"}] foo"]
+
+      subject.send(:loggify, 'foo', :msg_type, :green ).should == green_type
+      subject.send(:loggify, 'foo', :msg_type, :yellow).should == yellow_type
+      subject.send(:loggify, 'foo', :msg_type, :red   ).should == red_type
+    end
+
+    it 'does not colorize if no color given' do
+      no_color = ["[#{logger_time}][msg_type] foo"]
+      subject.send(:loggify, 'foo', :msg_type).should == no_color
+    end
+
+    it 'accepts blank lines in the message' do
+      str = "first line\n\nthird line"
+      expected = ["[#{logger_time}][msg_type] first line",
+                  "[#{logger_time}][msg_type] ",
+                  "[#{logger_time}][msg_type] third line"]
+
+      subject.send(:loggify, str, :msg_type).should == expected
+    end
+
+    it 'accepts an object responding to #to_s for the message' do
+      obj = StandardError.new("first line\nsecond line")
+      expected = ["[#{logger_time}][msg_type] first line",
+                  "[#{logger_time}][msg_type] second line"]
+
+      subject.send(:loggify, obj, :msg_type).should == expected
+    end
+
+    it 'returns an unformatted lines if type is not given' do
+      str_a = 'single line'
+      str_b = "first line\n\nthird line"
+      expected_a = ['single line']
+      expected_b = ['first line', '', 'third line']
+
+      subject.send(:loggify, str_a).should == expected_a
+      subject.send(:loggify, str_b).should == expected_b
+    end
+
+  end # describe '#loggify'
+
+  describe '#to_console' do
+
+    context 'when +stderr+ is not set (false)' do
+      it 'writes an array of strings to stdout' do
+        lines = [ 'line one', 'line two', 'line three']
+        lines.each {|line| subject.expects(:puts).with(line).in_sequence(s) }
+        subject.send(:to_console, lines)
+      end
+    end
+
+    context 'when +stderr+ is set (true)' do
+      it 'writes an array of strings to stdout' do
+        lines = [ 'line one', 'line two', 'line three']
+        lines.each {|line| Kernel.expects(:warn).with(line).in_sequence(s) }
+        subject.send(:to_console, lines, true)
+      end
+    end
+
+    it 'returns nil if quiet? is true' do
+      subject.quiet = true
+      subject.expects(:puts).never
+      subject.send(:to_console, 'a string')
+    end
+
+  end # describe '#to_console'
+
+  describe '#to_file' do
+
+    it 'writes an array of strings to the log file' do
+      lines = ['line one', 'line two', 'line three']
+      File.stubs(:open).yields(logfile_mock)
+      lines.each {|line| logfile_mock.expects(:puts).with(line).in_sequence(s) }
+      subject.send(:to_file, lines)
+    end
+
+    it 'appends each line written to #messages' do
+      lines = ['line one', 'line two', 'line three']
+      File.stubs(:open)
+      a_mock = mock
+      subject.expects(:messages).returns(a_mock)
+      a_mock.expects(:push).with('line one', 'line two', 'line three')
+      subject.send(:to_file, lines)
+    end
+
+    it 'only opens the log file once to append multiple lines' do
+      lines = ['line one', 'line two', 'line three']
+      File.expects(:open).once.with(logfile_path, 'a').yields(logfile_mock)
+      logfile_mock.expects(:puts).times(3)
+      subject.send(:to_file, lines)
+    end
+
+  end # describe '#to_file'
+
+  describe 'color methods' do
+
+    it 'color methods send strings to #colorize with color codes' do
+      colors = [ [:green, 32], [:yellow, 33], [:red, 31] ]
+      colors.each do |color, code|
+        subject.expects(:colorize).with('foo', code).in_sequence(s)
+      end
+      colors.each {|color, code| subject.send(color, 'foo') }
+    end
+
+    it '#colorize adds the code to the string' do
+      [32, 33, 31].each do |code|
+        subject.send(:colorize, 'foo', code).
+            should == "\e[#{code}mfoo\e[0m"
+      end
+    end
+
+  end # color methods
+
+  describe '#quiet' do
+    it 'should be nil by default' do
+      # of course, 'before' is setting it to nil ;)
+      subject.quiet.should be_nil
+    end
+
+    it 'can be set true/false' do
+      subject.quiet = true
+      subject.quiet.should be_true
+      subject.quiet = false
+      subject.quiet.should be_false
+    end
+  end
+
+end