backup-agoddard 3.0.27

data/spec/hooks_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe Backup::Hooks do
+  let(:model)   { Backup::Model.new(:test_trigger, 'test label') }
+
+  describe "#before!" do
+    it "accepts model as first arg" do
+      m = nil
+      h = Backup::Hooks.new(model) do
+        before do |a|
+          m = a
+        end
+      end
+
+      h.before!
+      m.should == model
+    end
+  end
+  describe "#after!" do
+    it "accepts model as first arg" do
+      m = nil
+      h = Backup::Hooks.new(model) do
+        after do |a|
+          m = a
+        end
+      end
+
+      h.after!
+      m.should == model
+    end
+  end
+end
+

data/spec/logger_spec.rb

@@ -0,0 +1,367 @@
+# 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
+
+      after do
+        Backup::Config.send(:reset!)
+      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

data/spec/model_spec.rb

@@ -0,0 +1,694 @@
+# encoding: utf-8
+
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe 'Backup::Model' do
+  let(:model) { Backup::Model.new(:test_trigger, 'test label') }
+  let(:s)     { sequence '' }
+
+  before do
+    Backup::Model.all.clear
+  end
+
+  describe '.all' do
+    it 'should be an empty array by default' do
+      Backup::Model.all.should == []
+    end
+  end
+
+  describe 'finder methods' do
+    before do
+      [:a, :b, :c, :b, :d].each_with_index do |sym, i|
+        Backup::Model.new("trigger_#{sym}", "label#{i}")
+      end
+    end
+
+    describe '.find' do
+      it 'should return the first matching model' do
+        Backup::Model.find('trigger_b').label.should == 'label1'
+      end
+
+      it 'should accept symbols' do
+        Backup::Model.find(:trigger_b).label.should == 'label1'
+      end
+
+      it 'should raise an error if trigger is not found' do
+        expect do
+          Backup::Model.find(:f)
+        end.to raise_error(
+          Backup::Errors::Model::MissingTriggerError,
+          "Model::MissingTriggerError: Could not find trigger 'f'."
+        )
+      end
+    end
+
+    describe '.find_matching' do
+      it 'should find all triggers matching a wildcard' do
+        Backup::Model.find_matching('tri*_b').count.should be(2)
+        Backup::Model.find_matching('trigg*').count.should be(5)
+      end
+
+      it 'should return an empty array if no matches are found' do
+        Backup::Model.find_matching('foo*').should == []
+      end
+    end
+
+  end # describe 'finder methods'
+
+  describe '#initialize' do
+
+    it 'should convert trigger to a string' do
+      Backup::Model.new(:foo, :bar).trigger.should == 'foo'
+    end
+
+    it 'should convert label to a string' do
+      Backup::Model.new(:foo, :bar).label.should == 'bar'
+    end
+
+    it 'should set all procedure variables to an empty array' do
+      model.send(:procedure_instance_variables).each do |var|
+        model.instance_variable_get(var).should == []
+      end
+    end
+
+    it 'should accept and instance_eval a block' do
+      block = lambda {|model| throw(:instance, model) }
+      caught = catch(:instance) do
+        Backup::Model.new('gotcha', '', &block)
+      end
+      caught.trigger.should == 'gotcha'
+    end
+
+    it 'should add itself to Model.all' do
+      Backup::Model.all.should == [model]
+    end
+
+  end # describe '#initialize'
+
+  describe 'DSL Methods' do
+
+    module Fake
+      module NoArg
+        class Base
+          attr_accessor :block_arg
+          def initialize(&block)
+            instance_eval(&block) if block_given?
+          end
+        end
+      end
+      module OneArg
+        class Base
+          attr_accessor :arg1, :block_arg
+          def initialize(arg1, &block)
+            @arg1 = arg1
+            instance_eval(&block) if block_given?
+          end
+        end
+      end
+      module TwoArgs
+        class Base
+          attr_accessor :arg1, :arg2, :block_arg
+          def initialize(arg1, arg2, &block)
+            @arg1 = arg1
+            @arg2 = arg2
+            instance_eval(&block) if block_given?
+          end
+        end
+      end
+    end
+
+    # Set +const+ to +replacement+ for the calling block
+    def using_fake(const, replacement)
+      orig = Backup.const_get(const)
+      Backup.send(:remove_const, const)
+      Backup.const_set(const, replacement)
+      yield
+      Backup.send(:remove_const, const)
+      Backup.const_set(const, orig)
+    end
+
+    describe '#archive' do
+      it 'should add archives' do
+        using_fake('Archive', Fake::TwoArgs::Base) do
+          model.archive('foo') {|a| a.block_arg = :foo }
+          model.archive('bar') {|a| a.block_arg = :bar }
+          model.archives.count.should == 2
+          a1, a2 = model.archives
+          a1.arg1.should be(model)
+          a1.arg2.should == 'foo'
+          a1.block_arg.should == :foo
+          a2.arg1.should be(model)
+          a2.arg2.should == 'bar'
+          a2.block_arg.should == :bar
+        end
+      end
+    end
+
+    describe '#database' do
+      it 'should add databases' do
+        using_fake('Database', Fake::OneArg) do
+          model.database('Base') {|a| a.block_arg = :foo }
+          model.database('Base') {|a| a.block_arg = :bar }
+          model.databases.count.should be(2)
+          d1, d2 = model.databases
+          d1.arg1.should be(model)
+          d1.block_arg.should == :foo
+          d2.arg1.should be(model)
+          d2.block_arg.should == :bar
+        end
+      end
+
+      it 'should accept a nested class name' do
+        using_fake('Database', Fake) do
+          model.database('OneArg::Base')
+          model.databases.first.should be_an_instance_of Fake::OneArg::Base
+        end
+      end
+    end
+
+    describe '#store_with' do
+      it 'should add storages' do
+        using_fake('Storage', Fake::TwoArgs) do
+          model.store_with('Base', 'foo') {|a| a.block_arg = :foo }
+          model.store_with('Base', 'bar') {|a| a.block_arg = :bar }
+          model.storages.count.should be(2)
+          s1, s2 = model.storages
+          s1.arg1.should be(model)
+          s1.arg2.should == 'foo'
+          s1.block_arg.should == :foo
+          s2.arg1.should be(model)
+          s2.arg2.should == 'bar'
+          s2.block_arg.should == :bar
+        end
+      end
+
+      it 'should accept a nested class name' do
+        using_fake('Storage', Fake) do
+          model.store_with('TwoArgs::Base')
+          model.storages.first.should be_an_instance_of Fake::TwoArgs::Base
+        end
+      end
+    end
+
+    describe '#sync_with' do
+      it 'should add syncers' do
+        using_fake('Syncer', Fake::NoArg) do
+          model.sync_with('Base') {|a| a.block_arg = :foo }
+          model.sync_with('Base') {|a| a.block_arg = :bar }
+          model.syncers.count.should be(2)
+          s1, s2 = model.syncers
+          s1.block_arg.should == :foo
+          s2.block_arg.should == :bar
+        end
+      end
+
+      it 'should accept a nested class name' do
+        using_fake('Syncer', Fake) do
+          model.sync_with('NoArg::Base')
+          model.syncers.first.should be_an_instance_of Fake::NoArg::Base
+        end
+      end
+
+      it 'should warn user of change from RSync to RSync::Push' do
+        Backup::Logger.expects(:warn)
+        model.sync_with('Backup::Config::RSync')
+        model.syncers.first.should
+            be_an_instance_of Backup::Syncer::RSync::Push
+      end
+
+      it 'should warn user of change from S3 to Cloud::S3' do
+        Backup::Logger.expects(:warn)
+        model.sync_with('Backup::Config::S3')
+        model.syncers.first.should
+            be_an_instance_of Backup::Syncer::Cloud::S3
+      end
+
+      it 'should warn user of change from CloudFiles to Cloud::CloudFiles' do
+        Backup::Logger.expects(:warn)
+        model.sync_with('Backup::Config::CloudFiles')
+        model.syncers.first.should
+            be_an_instance_of Backup::Syncer::Cloud::CloudFiles
+      end
+    end
+
+    describe '#notify_by' do
+      it 'should add notifiers' do
+        using_fake('Notifier', Fake::OneArg) do
+          model.notify_by('Base') {|a| a.block_arg = :foo }
+          model.notify_by('Base') {|a| a.block_arg = :bar }
+          model.notifiers.count.should be(2)
+          n1, n2 = model.notifiers
+          n1.arg1.should be(model)
+          n1.block_arg.should == :foo
+          n2.arg1.should be(model)
+          n2.block_arg.should == :bar
+        end
+      end
+
+      it 'should accept a nested class name' do
+        using_fake('Notifier', Fake) do
+          model.notify_by('OneArg::Base')
+          model.notifiers.first.should be_an_instance_of Fake::OneArg::Base
+        end
+      end
+    end
+
+    describe '#encrypt_with' do
+      it 'should add an encryptor' do
+        using_fake('Encryptor', Fake::NoArg) do
+          model.encrypt_with('Base') {|a| a.block_arg = :foo }
+          model.encryptor.should be_an_instance_of Fake::NoArg::Base
+          model.encryptor.block_arg.should == :foo
+        end
+      end
+
+      it 'should accept a nested class name' do
+        using_fake('Encryptor', Fake) do
+          model.encrypt_with('NoArg::Base')
+          model.encryptor.should be_an_instance_of Fake::NoArg::Base
+        end
+      end
+    end
+
+    describe '#compress_with' do
+      it 'should add a compressor' do
+        using_fake('Compressor', Fake::NoArg) do
+          model.compress_with('Base') {|a| a.block_arg = :foo }
+          model.compressor.should be_an_instance_of Fake::NoArg::Base
+          model.compressor.block_arg.should == :foo
+        end
+      end
+
+      it 'should accept a nested class name' do
+        using_fake('Compressor', Fake) do
+          model.compress_with('NoArg::Base')
+          model.compressor.should be_an_instance_of Fake::NoArg::Base
+        end
+      end
+    end
+
+    describe '#split_into_chunks_of' do
+      it 'should add a splitter' do
+        using_fake('Splitter', Fake::TwoArgs::Base) do
+          model.split_into_chunks_of(123)
+          model.splitter.should be_an_instance_of Fake::TwoArgs::Base
+          model.splitter.arg1.should be(model)
+          model.splitter.arg2.should == 123
+        end
+      end
+
+      it 'should raise an error if chunk_size is not an Integer' do
+        expect do
+          model.split_into_chunks_of('345')
+        end.to raise_error {|err|
+          err.should be_an_instance_of Backup::Errors::Model::ConfigurationError
+          err.message.should match(/must be an Integer/)
+        }
+      end
+    end
+
+    describe "#before" do
+      it "should set before hook" do
+        b = lambda { }
+        model.before &b
+        model.hooks.should be_an_instance_of Backup::Hooks
+        model.hooks.before_proc.should == b
+      end
+    end
+
+    describe "#after" do
+      it "should set after hook" do
+        a = lambda { }
+        model.after &a
+        model.hooks.should be_an_instance_of Backup::Hooks
+        model.hooks.after_proc.should == a
+      end
+    end
+
+  end # describe 'DSL Methods'
+
+  describe '#prepare!' do
+    it 'should prepare for the backup' do
+      FileUtils.expects(:mkdir_p).with(
+        File.join(Backup::Config.data_path, 'test_trigger')
+      )
+      Backup::Cleaner.expects(:prepare).with(model)
+
+      model.prepare!
+    end
+  end
+
+  describe '#perform!' do
+    let(:procedure_a)   { lambda {} }
+    let(:procedure_b)   { mock }
+    let(:procedure_c)   { mock }
+    let(:procedure_d)   { lambda {} }
+    let(:procedure_e)   { lambda {} }
+    let(:procedure_f)   { mock }
+    let(:procedures) do
+      [ procedure_a, [procedure_b, procedure_c],
+        procedure_d, procedure_e, [procedure_f] ]
+    end
+    let(:syncer_a)      { mock }
+    let(:syncer_b)      { mock }
+    let(:syncers)       { [syncer_a, syncer_b] }
+    let(:notifier_a)    { mock }
+    let(:notifier_b)    { mock }
+    let(:notifiers)     { [notifier_a, notifier_b] }
+
+    it 'should set the @time and @started_at variables' do
+      Timecop.freeze(Time.now)
+      started_at = Time.now
+      time = started_at.strftime("%Y.%m.%d.%H.%M.%S")
+      model.expects(:log!).with(:started)
+      model.expects(:log!).with(:finished)
+
+      model.perform!
+      model.time.should == time
+      model.instance_variable_get(:@started_at).should == started_at
+    end
+
+    it 'should call before and after hooks' do
+      h = model.hooks
+      h.expects(:perform!).with(:before)
+      h.expects(:perform!).with(:after)
+
+      model.expects(:log!).with(:started)
+      model.expects(:log!).with(:finished)
+      model.perform!
+    end
+
+    context 'when no errors occur' do
+      before do
+        model.expects(:procedures).returns(procedures)
+        model.expects(:syncers).returns(syncers)
+        model.expects(:notifiers).returns(notifiers)
+      end
+
+      context 'when databases are configured' do
+        before do
+          model.instance_variable_set(:@databases, [true])
+        end
+
+        it 'should perform all procedures' do
+          model.expects(:log!).in_sequence(s).with(:started)
+
+          procedure_a.expects(:call).in_sequence(s)
+          procedure_b.expects(:perform!).in_sequence(s)
+          procedure_c.expects(:perform!).in_sequence(s)
+          procedure_d.expects(:call).in_sequence(s)
+          procedure_e.expects(:call).in_sequence(s)
+          procedure_f.expects(:perform!).in_sequence(s)
+
+          syncer_a.expects(:perform!).in_sequence(s)
+          syncer_b.expects(:perform!).in_sequence(s)
+
+          notifier_a.expects(:perform!).in_sequence(s)
+          notifier_b.expects(:perform!).in_sequence(s)
+
+          model.expects(:log!).in_sequence(s).with(:finished)
+
+          model.perform!
+        end
+      end
+
+      context 'when archives are configured' do
+        before do
+          model.instance_variable_set(:@archives, [true])
+        end
+
+        it 'should perform all procedures' do
+          model.expects(:log!).in_sequence(s).with(:started)
+
+          procedure_a.expects(:call).in_sequence(s)
+          procedure_b.expects(:perform!).in_sequence(s)
+          procedure_c.expects(:perform!).in_sequence(s)
+          procedure_d.expects(:call).in_sequence(s)
+          procedure_e.expects(:call).in_sequence(s)
+          procedure_f.expects(:perform!).in_sequence(s)
+
+          syncer_a.expects(:perform!).in_sequence(s)
+          syncer_b.expects(:perform!).in_sequence(s)
+
+          notifier_a.expects(:perform!).in_sequence(s)
+          notifier_b.expects(:perform!).in_sequence(s)
+
+          model.expects(:log!).in_sequence(s).with(:finished)
+
+          model.perform!
+        end
+      end
+
+    end # context 'when no errors occur'
+
+    # for the purposes of testing the error handling, we're just going to
+    # stub the first thing this method calls and raise an error
+    context 'when errors occur' do
+      let(:error_a)   { mock }
+      let(:error_b)   { mock }
+      let(:notifier)  { mock }
+
+      before do
+        error_a.stubs(:backtrace).returns(['many', 'backtrace', 'lines'])
+      end
+
+      it 'logs, notifies and continues if a StandardError is rescued' do
+        Time.stubs(:now).raises(StandardError, 'non-fatal error')
+
+        Backup::Errors::ModelError.expects(:wrap).in_sequence(s).with do |err, msg|
+          err.message.should == 'non-fatal error'
+          msg.should match(/Backup for test label \(test_trigger\) Failed!/)
+        end.returns(error_a)
+        Backup::Logger.expects(:error).in_sequence(s).with(error_a)
+        Backup::Logger.expects(:error).in_sequence(s).with(
+          "\nBacktrace:\n\s\smany\n\s\sbacktrace\n\s\slines\n\n"
+        )
+
+        Backup::Cleaner.expects(:warnings).in_sequence(s).with(model)
+
+        Backup::Errors::ModelError.expects(:new).in_sequence(s).with do |msg|
+          msg.should match(/Backup will now attempt to continue/)
+        end.returns(error_b)
+        Backup::Logger.expects(:message).in_sequence(s).with(error_b)
+
+        # notifiers called, but any Exception is ignored
+        notifier.expects(:perform!).with(true).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
+        Time.stubs(:now).raises(Exception, 'fatal error')
+
+        Backup::Errors::ModelError.expects(:wrap).in_sequence(s).with do |err, msg|
+          err.message.should == 'fatal error'
+          msg.should match(/Backup for test label \(test_trigger\) Failed!/)
+        end.returns(error_a)
+        Backup::Logger.expects(:error).in_sequence(s).with(error_a)
+        Backup::Logger.expects(:error).in_sequence(s).with(
+          "\nBacktrace:\n\s\smany\n\s\sbacktrace\n\s\slines\n\n"
+        )
+
+        Backup::Cleaner.expects(:warnings).in_sequence(s).with(model)
+
+        Backup::Errors::ModelError.expects(:new).in_sequence(s).with do |msg|
+          msg.should match(/Backup will now exit/)
+        end.returns(error_b)
+        Backup::Logger.expects(:error).in_sequence(s).with(error_b)
+
+        expect do
+          # notifiers called, but any Exception is ignored
+          notifier = mock
+          notifier.expects(:perform!).with(true).raises(Exception)
+          model.expects(:notifiers).returns([notifier])
+        end.not_to raise_error
+
+        expect do
+          model.perform!
+        end.to raise_error(SystemExit) {|exit| exit.status.should be(1) }
+      end
+
+    end # context 'when errors occur'
+
+  end # describe '#perform!'
+
+  describe '#package!' do
+    it 'should package the backup' do
+      Backup::Packager.expects(:package!).in_sequence(s).with(model)
+      Backup::Cleaner.expects(:remove_packaging).in_sequence(s).with(model)
+
+      model.send(:package!)
+      model.package.should be_an_instance_of Backup::Package
+    end
+  end
+
+  describe '#clean' do
+    it 'should remove the final packaged files' do
+      package = mock
+      model.instance_variable_set(:@package, package)
+      Backup::Cleaner.expects(:remove_package).with(package)
+
+      model.send(:clean!)
+    end
+  end
+
+  describe '#procedures' do
+    it 'should return an array of specific, ordered procedures' do
+      model.stubs(:databases).returns(:databases)
+      model.stubs(:archives).returns(:archives)
+      model.stubs(:package!).returns(:package)
+      model.stubs(:storages).returns(:storages)
+      model.stubs(:clean!).returns(:clean)
+
+      one, two, three, four, five = model.send(:procedures)
+      one.should == :databases
+      two.should == :archives
+      three.call.should == :package
+      four.should == :storages
+      five.call.should == :clean
+    end
+  end
+
+  describe '#procedure_instance_variables' do
+    # these are all set to an empty Array in #initialize
+    it 'should return an array of Array holding instance variables' do
+      model.send(:procedure_instance_variables).should ==
+          [:@databases, :@archives, :@storages, :@notifiers, :@syncers]
+    end
+  end
+
+  describe '#get_class_from_scope' do
+
+    module Fake
+      module TestScope
+        class TestKlass; end
+      end
+    end
+    module TestScope
+      module TestKlass; end
+    end
+
+    context 'when name is given as a string' do
+      it 'should return the constant for the given scope and name' do
+        model.send(
+          :get_class_from_scope,
+          Fake,
+          'TestScope'
+        ).should == Fake::TestScope
+      end
+
+      it 'should accept a nested class name' do
+        model.send(
+          :get_class_from_scope,
+          Fake,
+          'TestScope::TestKlass'
+        ).should == Fake::TestScope::TestKlass
+      end
+    end
+
+    context 'when name is given as a module' do
+      it 'should return the constant for the given scope and name' do
+        model.send(
+          :get_class_from_scope,
+          Fake,
+          TestScope
+        ).should == Fake::TestScope
+      end
+
+      it 'should accept a nested class name' do
+        model.send(
+          :get_class_from_scope,
+          Fake,
+          TestScope::TestKlass
+        ).should == Fake::TestScope::TestKlass
+      end
+    end
+
+    context 'when name is given as a module defined under Backup::Config' do
+      # this is necessary since the specs in spec/config_spec.rb
+      # remove all the constants from Backup::Config as part of those tests.
+      before(:all) do
+        module Backup::Config
+          module TestScope
+            module TestKlass; end
+          end
+        end
+      end
+
+      it 'should return the constant for the given scope and name' do
+        model.send(
+          :get_class_from_scope,
+          Fake,
+          Backup::Config::TestScope
+        ).should == Fake::TestScope
+      end
+
+      it 'should accept a nested class name' do
+        model.send(
+          :get_class_from_scope,
+          Fake,
+          Backup::Config::TestScope::TestKlass
+        ).should == Fake::TestScope::TestKlass
+      end
+    end
+
+  end # describe '#get_class_from_scope'
+
+  describe '#log!' do
+    context 'when action is :started' do
+      it 'should log that the backup has started with the version' do
+        Backup::Logger.expects(:message).with(
+          "Performing Backup for 'test label (test_trigger)'!\n" +
+          "[ backup #{ Backup::Version.current } : #{ RUBY_DESCRIPTION } ]"
+        )
+        model.send(:log!, :started)
+      end
+    end
+
+    context 'when action is :finished' do
+      before { model.expects(:elapsed_time).returns('01:02:03') }
+      context 'when warnings were issued' do
+        before { Backup::Logger.expects(:has_warnings?).returns(true) }
+        it 'should log a warning that the backup has finished with warnings' do
+          Backup::Logger.expects(:warn).with(
+            "Backup for 'test label (test_trigger)' " +
+            "Completed Successfully (with Warnings) in 01:02:03"
+          )
+          model.send(:log!, :finished)
+        end
+      end
+
+      context 'when no warnings were issued' do
+        it 'should log that the backup has finished with the elapsed time' do
+          Backup::Logger.expects(:message).with(
+            "Backup for 'test label (test_trigger)' " +
+            "Completed Successfully in 01:02:03"
+          )
+          model.send(:log!, :finished)
+        end
+      end
+    end
+  end # describe '#log!'
+
+  describe '#elapsed_time' do
+    it 'should return a string representing the elapsed time' do
+      Timecop.freeze(Time.now)
+      { 0       => '00:00:00', 1       => '00:00:01', 59      => '00:00:59',
+        60      => '00:01:00', 61      => '00:01:01', 119     => '00:01:59',
+        3540    => '00:59:00', 3541    => '00:59:01', 3599    => '00:59:59',
+        3600    => '01:00:00', 3601    => '01:00:01', 3659    => '01:00:59',
+        3660    => '01:01:00', 3661    => '01:01:01', 3719    => '01:01:59',
+        7140    => '01:59:00', 7141    => '01:59:01', 7199    => '01:59:59',
+        212400  => '59:00:00', 212401  => '59:00:01', 212459  => '59:00:59',
+        212460  => '59:01:00', 212461  => '59:01:01', 212519  => '59:01:59',
+        215940  => '59:59:00', 215941  => '59:59:01', 215999  => '59:59:59'
+      }.each do |duration, expected|
+        model.instance_variable_set(:@started_at, Time.now - duration)
+        model.send(:elapsed_time).should == expected
+      end
+    end
+  end
+
+end