backup 3.0.19 → 3.0.20

data/spec/finder_spec.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe Backup::Finder do
+
+  describe '#find' do
+    let(:finder) { Backup::Finder.new('test_trigger', 'foo') }
+
+    before do
+      finder.stubs(:load_config!)
+    end
+
+    it 'should return the first model that matches the trigger' do
+      models = %w{ foo1 test_trigger foo2 test_trigger }.map do |trigger|
+        stub(:trigger => trigger.to_sym)
+      end
+      Backup::Model.expects(:all).returns(models)
+      Backup::Model.expects(:current=).with(models[1])
+
+      expect do
+        finder.find.should == models[1]
+      end.not_to raise_error
+    end
+
+    it 'should raise an error when no models match the trigger' do
+      models = %w{ foo1 foo2 foo3 }.map do |trigger|
+        stub(:trigger => trigger.to_sym)
+      end
+      Backup::Model.expects(:all).returns(models)
+      Backup::Model.expects(:current=).never
+
+      expect do
+        finder.find
+      end.to raise_error(
+        Backup::Errors::Finder::MissingTriggerError,
+        "Finder::MissingTriggerError: Could not find trigger 'test_trigger' in 'foo'."
+      )
+    end
+
+  end # describe '#find'
+
+  describe '#load_config!' do
+    let(:finder) { Backup::Finder.new('foo', 'config_file') }
+
+    context 'when given a valid config file' do
+
+      before do
+        File.expects(:exist?).with('config_file').returns(true)
+      end
+
+      it 'should load the config file' do
+        File.expects(:read).with('config_file').returns(:file_contents)
+        Backup.expects(:module_eval).with(:file_contents, 'config_file', 1)
+
+        finder.send(:load_config!)
+      end
+
+      it 'should reset Model.all' do
+        File.stubs(:read)
+        Backup.stubs(:module_eval)
+        Backup::Model.expects(:all=).with([])
+
+        finder.send(:load_config!)
+      end
+
+    end # context 'when given a valid config file'
+
+    context 'when given a config file that does not exist' do
+
+      before do
+        File.expects(:exist?).with('config_file').returns(false)
+      end
+
+      it 'should raise an error' do
+        Backup::Model.expects(:all=).never
+        File.expects(:read).never
+        Backup.expects(:module_eval).never
+
+        expect do
+          finder.send(:load_config!)
+        end.to raise_error(
+          Backup::Errors::Finder::MissingConfigError,
+          "Finder::MissingConfigError: Could not find configuration file: 'config_file'."
+        )
+      end
+
+    end # context 'when given a config file that does not exist'
+
+  end # describe '#find'
+end

data/spec/logger_spec.rb

@@ -1,66 +1,287 @@
 # encoding: utf-8
 
-require File.dirname(__FILE__) + '/spec_helper'
+require File.expand_path('../spec_helper.rb', __FILE__)
 require 'timecop'
 
 describe Backup::Logger do
+  let(:logger_time)  { Time.now.strftime("%Y/%m/%d %H:%M:%S") }
+  let(:logfile_path) { File.join(Backup::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|
-      Backup::Logger.unstub(message_type)
+      subject.unstub(message_type)
     end
+
+    subject.send(:remove_const, :QUIET) rescue nil
+    subject.send(:remove_instance_variable, :@messages) rescue nil
+    subject.send(:remove_instance_variable, :@has_warnings) rescue nil
   end
 
-  describe 'logging messages to STDOUT and a log file' do
-    before do
-      File.expects(:open).with(File.join(Backup::LOG_PATH, 'backup.log'), 'a')
+  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
 
-    context 'when logging regular messages' do
-      it do
-        Backup::Logger.expects(:puts).with("[#{ Time.now.strftime("%Y/%m/%d %H:%M:%S") }][\e[32mmessage\e[0m] This has been logged.")
+  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)
 
-        Backup::Logger.message "This has been logged."
-      end
+      subject.error('error message')
     end
+  end
 
-    context 'when logging error messages' do
-      it do
-        Backup::Logger.expects(:puts).with("[#{ Time.now.strftime("%Y/%m/%d %H:%M:%S") }][\e[31merror\e[0m] This has been logged.")
+  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)
 
-        Backup::Logger.error "This has been logged."
-      end
+      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 '#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
 
-    context 'when logging warn messages' do
-      it do
-        Backup::Logger.expects(:puts).with("[#{ Time.now.strftime("%Y/%m/%d %H:%M:%S") }][\e[33mwarning\e[0m] This has been logged.")
+    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"]
 
-        Backup::Logger.warn "This has been logged."
+      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 logging silent messages' do
-      it do
-        Backup::Logger.expects(:puts).never
+    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
 
-        Backup::Logger.silent "This has been logged."
+    it 'returns nil if quiet? is true' do
+      subject.send(:const_set, :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
-  end
 
-  describe 'logging messages to log file and not STDOUT' do
-    it do
-      Backup::Logger.send(:const_set, :QUIET, true)
+    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
 
-      Backup::Logger.expects(:puts).never
-      File.expects(:open).times(4).with(File.join(Backup::LOG_PATH, 'backup.log'), 'a')
+  end # color methods
 
-      Backup::Logger.message "This has been logged."
-      Backup::Logger.error   "This has been logged."
-      Backup::Logger.warn    "This has been logged."
-      Backup::Logger.normal  "This has been logged."
+  describe '#quiet?' do
+    it 'reports if the QUIET constant has been set' do
+      expect { subject.send(:const_set, :QUIET, true) }.to
+          change{ subject.send(:quiet?) }.from(false).to(true)
     end
   end
+
 end

data/spec/model_spec.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-require File.dirname(__FILE__) + '/spec_helper'
+require File.expand_path('../spec_helper.rb', __FILE__)
 
 describe Backup::Model do
 
@@ -13,7 +13,7 @@ describe Backup::Model do
       def initialize(&block); end
     end
     class Backup::Storage::TestStorage
-      def initialize(&block); end
+      def initialize(storage_id = nil, &block); end
     end
     class Backup::Compressor::TestGzip
       def initialize(&block); end
@@ -121,6 +121,15 @@ describe Backup::Model do
 
       model.storages.count.should == 2
     end
+
+    it 'should accept an optional storage_id parameter' do
+      model = Backup::Model.new('mysql-s3', 'MySQL S3 Backup for MyApp') do
+        store_with('TestStorage', 'test storage_id')
+      end
+
+      model.storages.count.should == 1
+    end
+
   end
 
   describe 'archives' do
@@ -200,37 +209,133 @@ describe Backup::Model do
   end
 
   describe '#package!' do
+    let(:packager) { Backup::Packager.new(model) }
+
     before do
       [:utility, :run].each { |method| model.stubs(method) }
     end
 
     it 'should package the folder' do
-      model.expects(:utility).with(:tar).returns(:tar)
-      model.expects(:run).with(%|tar -c -f '#{ File.join( Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar" ) }' -C '#{ Backup::TMP_PATH }' '#{ Backup::TRIGGER }'|)
-      model.send(:package!)
-    end
-
-    it 'should log' do
-      Backup::Logger.expects(:message).with("Backup started packaging everything to a single archive file.")
-      model.send(:package!)
+      packager.expects(:utility).with(:tar).returns(:tar)
+      packager.expects(:run).with(%|tar -c -f '#{ File.join( Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar" ) }' -C '#{ Backup::TMP_PATH }' '#{ Backup::TRIGGER }'|)
+      Backup::Logger.expects(:message).with("Backup::Packager started packaging the backup files.")
+      packager.package!
     end
   end
 
   describe '#clean!' do
+    let(:cleaner) { Backup::Cleaner.new(model) }
+
     before do
       [:utility, :run, :rm].each { |method| model.stubs(method) }
     end
 
-    it 'should remove the temporary files and folders that were created' do
-      model.expects(:utility).with(:rm).returns(:rm)
-      model.expects(:run).with("rm -rf '#{ File.join(Backup::TMP_PATH, Backup::TRIGGER) }' '#{ File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar") }'")
-      model.send(:clean!)
+    context 'when the backup archive is not chunked' do
+      it 'should remove the temporary files and folders that were created' do
+        cleaner.expects(:utility).with(:rm).returns(:rm)
+        Backup::Model.chunk_suffixes = []
+        cleaner.expects(:run).with "rm -rf '#{ File.join(Backup::TMP_PATH, Backup::TRIGGER) }' " +
+                                "'#{ File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar") }'"
+        cleaner.clean!
+      end
+    end
+
+    context 'when the backup archive is chunked' do
+      it 'should remove the temporary files and folders that were created' do
+        cleaner.expects(:utility).with(:rm).returns(:rm)
+        Backup::Model.chunk_suffixes = ["aa", "ab", "ac"]
+        cleaner.expects(:run).with "rm -rf '#{ File.join(Backup::TMP_PATH, Backup::TRIGGER) }' " +
+                                "'#{ File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar") }' " +
+                                "'#{ File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar-aa") }' " +
+                                "'#{ File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar-ab") }' " +
+                                "'#{ File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar-ac") }'"
+        cleaner.clean!
+      end
     end
 
     it do
-      Backup::Logger.expects(:message).with("Backup started cleaning up the temporary files.")
+      Backup::Logger.expects(:message).with("Backup::Cleaner started cleaning up the temporary files.")
       model.send(:clean!)
     end
   end
 
+  describe '#split_into_chunks_of' do
+    it do
+      model.should respond_to(:split_into_chunks_of)
+    end
+
+    it do
+      model.split_into_chunks_of(500)
+      model.chunk_size.should == 500
+    end
+
+    it do
+      model.chunk_size.should == nil
+    end
+  end
+
+  describe '#perform!' do
+
+    # for the purposes of testing the error handling, we're just going to
+    # stub the first thing this method calls and raise an error
+    describe 'when errors occur' do
+      let(:model) { Backup::Model.new('foo', 'foo') {} }
+
+      before do
+        # method ensures that #clean! is always run before exiting
+        model.expects(:clean!)
+      end
+
+      it 'logs, notifies and continues if a StandardError is rescued' do
+        model.stubs(:databases).raises(StandardError, 'non-fatal error')
+
+        Backup::Logger.expects(:error).twice
+        Backup::Logger.expects(:message).once
+
+        Backup::Errors::ModelError.expects(:wrap).with do |err, msg|
+          err.message.should == 'non-fatal error'
+          msg.should match(/Backup for foo \(foo\) Failed!/)
+        end
+
+        Backup::Errors::ModelError.expects(:new).with do |msg|
+          msg.should match(/Backup will now attempt to continue/)
+        end
+
+        # notifiers called, but any Exception is ignored
+        notifier = mock
+        notifier.expects(:perform!).raises(Exception)
+        model.expects(:notifiers).returns([notifier])
+
+        # returns to allow next trigger to run
+        expect { model.perform! }.not_to raise_error
+      end
+
+      it 'logs, notifies and exits if an Exception is rescued' do
+        model.stubs(:databases).raises(Exception, 'fatal error')
+
+        Backup::Logger.expects(:error).times(3)
+        Backup::Logger.expects(:message).never
+
+        Backup::Errors::ModelError.expects(:wrap).with do |err, msg|
+          err.message.should == 'fatal error'
+          msg.should match(/Backup for foo \(foo\) Failed!/)
+        end
+
+        Backup::Errors::ModelError.expects(:new).with do |msg|
+          msg.should match(/Backup will now exit/)
+        end
+
+        expect do
+          # notifiers called, but any Exception is ignored
+          notifier = mock
+          notifier.expects(:perform!).raises(Exception)
+          model.expects(:notifiers).returns([notifier])
+        end.not_to raise_error
+
+        expect { model.perform! }.to raise_error(SystemExit)
+      end
+
+    end # context 'when errors occur'
+
+  end # describe '#perform!'
 end