backup 3.0.19 → 3.0.20

data/spec/notifier/twitter_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::Notifier::Twitter do
   let(:notifier) do
@@ -12,22 +12,22 @@ describe Backup::Notifier::Twitter do
     end
   end
 
-  it do
-    notifier.consumer_key.should       == 'consumer_key'
-    notifier.consumer_secret.should    == 'consumer_secret'
-    notifier.oauth_token.should        == 'oauth_token'
-    notifier.oauth_token_secret.should == 'oauth_token_secret'
+  describe '#initialize' do
+    it 'sets the correct defaults' do
+      notifier.consumer_key.should       == 'consumer_key'
+      notifier.consumer_secret.should    == 'consumer_secret'
+      notifier.oauth_token.should        == 'oauth_token'
+      notifier.oauth_token_secret.should == 'oauth_token_secret'
 
-    notifier.on_success.should == true
-    notifier.on_failure.should == true
-  end
+      notifier.on_success.should == true
+      notifier.on_warning.should == true
+      notifier.on_failure.should == true
+    end
 
-  describe 'defaults' do
-    it do
+    it 'uses and overrides configuration defaults' do
       Backup::Configuration::Notifier::Twitter.defaults do |twitter|
         twitter.consumer_key = 'new_consumer_key'
         twitter.on_success   = false
-        twitter.on_failure   = true
       end
       notifier = Backup::Notifier::Twitter.new do |twitter|
         twitter.consumer_key = 'my_own_consumer_key'
@@ -35,52 +35,117 @@ describe Backup::Notifier::Twitter do
 
       notifier.consumer_key.should   == 'my_own_consumer_key'
       notifier.on_success.should == false
+      notifier.on_warning.should == true
       notifier.on_failure.should == true
     end
-  end
 
-  describe '#initialize' do
-    it do
-      Backup::Notifier::Twitter.any_instance.expects(:set_defaults!)
-      Backup::Notifier::Twitter.new
+    it 'create a new Twitter::Client' do
+      notifier.twitter_client.should be_an_instance_of ::Twitter::Client
+      #notifier.twitter_client.credentials?.should be_true
+      options = ::Twitter.options # v1.7.1 API
+      options[:consumer_key].should       == notifier.consumer_key
+      options[:consumer_secret].should    == notifier.consumer_secret
+      options[:oauth_token].should        == notifier.oauth_token
+      options[:oauth_token_secret].should == notifier.oauth_token_secret
     end
   end
 
   describe '#perform!' do
-    let(:model) { Backup::Model.new('blah', 'blah') {} }
+    let(:model)   { Backup::Model.new('trigger', 'label') {} }
+    let(:message) { '[Backup::%s] label (trigger)' }
+
     before do
       notifier.on_success = false
+      notifier.on_warning = false
       notifier.on_failure = false
     end
 
-    context "when successful" do
-      it do
-        Backup::Logger.expects(:message).with("Backup::Notifier::Twitter started notifying about the process.")
-        notifier.expects("notify_success!")
-        notifier.on_success = true
-        notifier.perform!(model)
+    context 'success' do
+
+      context 'when on_success is true' do
+        before { notifier.on_success = true }
+
+        it 'sends success message' do
+          notifier.expects(:log!)
+          notifier.twitter_client.expects(:update).with(message % 'Success')
+
+          notifier.perform!(model)
+        end
       end
 
-      it do
-        notifier.expects("notify_success!").never
-        notifier.on_success = false
-        notifier.perform!(model)
+      context 'when on_success is false' do
+        it 'sends no message' do
+          notifier.expects(:log!).never
+          notifier.expects(:notify!).never
+          notifier.twitter_client.expects(:update).never
+
+          notifier.perform!(model)
+        end
       end
-    end
 
-    context "when failed" do
-      it do
-        Backup::Logger.expects(:message).with("Backup::Notifier::Twitter started notifying about the process.")
-        notifier.expects("notify_failure!")
-        notifier.on_failure = true
-        notifier.perform!(model, Exception.new)
+    end # context 'success'
+
+    context 'warning' do
+      before { Backup::Logger.stubs(:has_warnings?).returns(true) }
+
+      context 'when on_success is true' do
+        before { notifier.on_success = true }
+
+        it 'sends warning message' do
+          notifier.expects(:log!)
+          notifier.twitter_client.expects(:update).with(message % 'Warning')
+
+          notifier.perform!(model)
+        end
+      end
+
+      context 'when on_warning is true' do
+        before { notifier.on_warning = true }
+
+        it 'sends warning message' do
+          notifier.expects(:log!)
+          notifier.twitter_client.expects(:update).with(message % 'Warning')
+
+          notifier.perform!(model)
+        end
       end
 
-      it do
-        notifier.expects("notify_failure!").never
-        notifier.on_failure = false
-        notifier.perform!(model, Exception.new)
+      context 'when on_success and on_warning are false' do
+        it 'sends no message' do
+          notifier.expects(:log!).never
+          notifier.expects(:notify!).never
+          notifier.twitter_client.expects(:update).never
+
+          notifier.perform!(model)
+        end
       end
-    end
-  end
+
+    end # context 'warning'
+
+    context 'failure' do
+
+      context 'when on_failure is true' do
+        before { notifier.on_failure = true }
+
+        it 'sends failure message' do
+          notifier.expects(:log!)
+          notifier.twitter_client.expects(:update).with(message % 'Failure')
+
+          notifier.perform!(model, Exception.new)
+        end
+      end
+
+      context 'when on_failure is false' do
+        it 'sends no message' do
+          notifier.expects(:log!).never
+          notifier.expects(:notify!).never
+          notifier.twitter_client.expects(:update).never
+
+          notifier.perform!(model, Exception.new)
+        end
+      end
+
+    end # context 'failure'
+
+  end # describe '#perform!'
 end

data/spec/spec_helper.rb

@@ -1,11 +1,17 @@
 # encoding: utf-8
 
+##
+# Use Bundler
+require 'rubygems' if RUBY_VERSION < '1.9'
+require 'bundler/setup'
+
 ##
 # Load Backup
-require File.expand_path( '../../lib/backup', __FILE__ )
+require 'backup'
 
 ##
 # Use Mocha to mock with RSpec
+require 'rspec'
 RSpec.configure do |config|
   config.mock_with :mocha
   config.before(:each) do
@@ -26,5 +32,5 @@ module Backup
 end
 
 unless @_put_ruby_version
-  puts @_put_ruby_version = "\n\nRuby version: #{ENV['rvm_ruby_string']}\n\n"
+  puts @_put_ruby_version = "\n\nRuby version: #{RUBY_DESCRIPTION}\n\n"
 end

data/spec/splitter_spec.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe Backup::Splitter do
+  let(:model)    { mock("Backup::Model")       }
+  let(:splitter) { Backup::Splitter.new(model) }
+
+  before do
+    splitter.stubs(:chunks).returns([
+      "/some/file.tar.gz.enc-ad",
+      "/some/file.tar.gz.enc-ac",
+      "/some/file.tar.gz.enc-ab",
+      "/some/file.tar.gz.enc-aa",
+    ])
+  end
+
+  describe "#chunk_suffixes" do
+    it "should return an array of chunk suffixes (ordered in alphabetical order)" do
+      splitter.send(:chunk_suffixes).should == ["aa", "ab", "ac", "ad"]
+    end
+  end
+
+  describe "#bytes_representation_of" do
+    it "should convert megabytes to bytes" do
+      splitter.send(:bytes_representation_of, 50).should == 52428800
+    end
+  end
+
+  describe "#split!" do
+    before do
+      model.stubs(:file).returns("/some/file.tar.gz.enc")
+    end
+
+    [nil, true, false, "123", :sym].each do |value|
+      it "should not split: chunk_size must be an integer" do
+        model.stubs(:chunk_size).returns(value)
+
+        File.expects(:size).never
+        splitter.expects(:bytes_representation_of).never
+        splitter.expects(:run).never
+        splitter.split!
+      end
+    end
+
+    it "should not split: chunk size is 300mb, file is 300mb" do
+      File.expects(:size).with(model.file).returns(52428800) # 300mb
+      model.stubs(:chunk_size).returns(300)
+
+      splitter.expects(:run).never
+      splitter.split!
+    end
+
+    it "should not split: chunk size is 300mb, file size is 200mb" do
+      File.expects(:size).with(model.file).returns(209715200) # 200mb
+      model.stubs(:chunk_size).returns(300)
+
+      splitter.expects(:run).never
+      splitter.split!
+    end
+
+    it "should split: chunk size is 300mb, file size is 400mb" do
+      File.expects(:size).with(model.file).returns(419430400) # 400mb
+      model.stubs(:chunk_size).returns(300)
+
+      splitter.expects(:utility).with(:split).returns("split")
+      splitter.expects(:run).with("split -b 300m '/some/file.tar.gz.enc' '/some/file.tar.gz.enc-'")
+      splitter.split!
+    end
+  end
+end

data/spec/storage/base_spec.rb

@@ -1,29 +1,290 @@
 # encoding: utf-8
 
-require File.dirname(__FILE__) + '/../spec_helper'
+require File.expand_path('../../spec_helper.rb', __FILE__)
 
 describe Backup::Storage::Base do
-  let(:base) { Backup::Storage::Base.new }
-
-  it do
-    storage_object = mock
-    Backup::Storage::Object.expects(:new).with('Base').returns(storage_object)
-    storage_object.stubs(:load).returns([])
-    storage_object.expects(:write)
-    base.keep = 1
-    base.cycle!
+
+  describe '#initialize' do
+
+    after do
+      Backup::Configuration::Storage::Base.clear_defaults!
+    end
+
+    it 'should create a new storage object with default values' do
+      base = Backup::Storage::Base.new
+      base.keep.should be_nil
+      base.time.should == Backup::TIME
+    end
+
+    it 'should set configured defaults' do
+      Backup::Configuration::Storage::Base.defaults do |base|
+        base.keep = 5
+      end
+
+      base = Backup::Storage::Base.new
+      base.keep.should == 5
+      base.time.should == Backup::TIME
+    end
+
+    it 'should override the configuration defaults with the configure block' do
+      Backup::Configuration::Storage::Base.defaults do |base|
+        base.keep = 5
+      end
+
+      base = Backup::Storage::Base.new do |base|
+        base.keep = 10
+      end
+      base.keep.should == 10
+      base.time.should == Backup::TIME
+    end
+
+    it 'should store the configuration block' do
+      config_block = lambda {|base| base.keep = 10 }
+      base = Backup::Storage::Base.new(&config_block)
+
+      base.keep.should == 10
+      base.configure_block.should be config_block
+    end
+
+    it 'should set the storage_id using an optional block parameter' do
+      base = Backup::Storage::Base.new('my storage_id') do |base|
+        base.keep = 10
+      end
+      base.keep.should == 10
+      base.time.should == Backup::TIME
+      base.storage_id.should == 'my storage_id'
+    end
+
+  end # describe '#inititalize'
+
+  describe '#clean!' do
+
+    context 'when clearing instance variables for cycling' do
+      it 'version stamps the object' do
+        cycle_required_variables = %w[ @filename @time @chunk_suffixes ]
+        expected_variables = (cycle_required_variables + ['@version']).sort
+
+        base = Backup::Storage::Base.new do |config|
+          config.storage_id = 'bar_id'
+          config.keep = 3
+        end
+        base.time = Time.utc(2011, 12, 2)
+        base.chunk_suffixes = ['aa', 'ab']
+        base.instance_variable_set(:@filename, 'foo.tar')
+        base.version.should be_nil
+
+        base.send(:clean!)
+        base.instance_variables.map(&:to_s).sort.should == expected_variables
+        base.time.should == Time.utc(2011, 12, 2)
+        base.chunk_suffixes.should == ['aa', 'ab']
+        base.filename.should == 'foo.tar'
+        base.version.should == Backup::Version.current
+      end
+    end
+
   end
 
-  it do
-    base.keep = 3
-    storage_object = mock
-    objects = %w[1 2 3 4].map { Backup::Storage::Base.new }
+  describe '#update!' do
+
+    it 'updates the storage object with the given configure_block' do
+      base_a = Backup::Storage::Base.new do |config|
+        config.storage_id = 'foo_id'
+        config.keep = 5
+      end
+      base_b = Backup::Storage::Base.new do |config|
+        config.storage_id = 'bar_id'
+        config.keep = 3
+      end
+      base_b.expects(:upgrade_if_needed!)
+
+      base_b.send(:update!, base_a.configure_block)
+      base_b.storage_id.should == 'foo_id'
+      base_b.keep.should == 5
+    end
+
+    it 'updates YAML loaded objects, which were `cleaned` for cycling' do
+      base = Backup::Storage::Base.new do |config|
+        config.storage_id = 'foo_id'
+        config.keep = 5
+      end
+      base.time.should == Backup::TIME
+
+      loaded = Backup::Storage::Base.new do |config|
+        config.storage_id = 'bar_id'
+        config.keep = 3
+      end
+      loaded.time = Time.utc(2011, 12, 2)
+      loaded.chunk_suffixes = ['aa', 'ab']
+      loaded.instance_variable_set(:@filename, 'foo.tar')
+
+      loaded.send(:clean!)
+      loaded.storage_id.should == nil
+      loaded.keep.should == nil
+      loaded.version.should == Backup::Version.current
+
+      loaded.send(:update!, base.configure_block)
+      loaded.storage_id.should == 'foo_id'
+      loaded.keep.should == 5
+      loaded.time.should == Time.utc(2011, 12, 2)
+      loaded.chunk_suffixes.should == ['aa', 'ab']
+      loaded.filename.should == 'foo.tar'
+      loaded.version.should == Backup::Version.current
+    end
+
+  end # describe '#update!'
+
+  describe '#upgrade_if_needed!' do
+
+    it 'upgrades <= 3.0.19' do
+      v_3_0_19_yaml = <<-EOF.gsub(/^\s+/,'  ').gsub(/^  -/,'-')
+        ---
+        !ruby/object:Backup::Storage::SCP
+        username: a_user
+        password: a_password
+        ip: an_address
+        port: a_port
+        path: a_path
+        keep: a_few
+        time: 2011.11.01.01.02.03
+        local_file: 2011.11.01.01.02.03.a_backup.tar
+        remote_file: 2011.11.01.01.02.03.a_backup.tar
+      EOF
+      loaded = YAML.load(v_3_0_19_yaml)
+      cycle_required_variables = %w[ @filename @time @chunk_suffixes ]
+      expected_variables = (cycle_required_variables + ['@version']).sort
+
+      loaded.send(:upgrade_if_needed!)
+      loaded.instance_variables.map(&:to_s).sort.should == expected_variables
+      loaded.filename.should == '2011.11.01.01.02.03.a_backup.tar'
+      loaded.time.should == '2011.11.01.01.02.03'
+      loaded.chunk_suffixes.should == []
+      loaded.version.should == Backup::Version.current
+    end
+
+  end # describe '#upgrade_if_needed!'
+
+  describe '#cycle!' do
+    let(:base) { Backup::Storage::Base.new {} }
+
+    it 'updates loaded objects and adds current object' do
+      s = sequence ''
+      storage_object = mock
+      loaded_object = mock
+
+      Backup::Storage::Object.expects(:new).in_sequence(s).
+          with('Base', nil).returns(storage_object)
+      storage_object.expects(:load).in_sequence(s).
+          returns([loaded_object])
+      loaded_object.expects(:update!).in_sequence(s).
+          with(base.configure_block)
+      objects = [base, loaded_object]
+      objects.each {|object| object.expects(:clean!).in_sequence(s) }
+      storage_object.expects(:write).in_sequence(s).
+          with(objects)
+
+      base.keep = 2
+      base.send(:cycle!)
+    end
+
+    context 'when removing old stored objects' do
+
+      it 'should warn and continue on errors' do
+        num_to_load = 6
+        num_to_keep = 3
+        obj_to_fail = 2 # we're removing 3, so fail the 2nd one.
+
+        s = sequence ''
+        storage_object = mock
+        raised_error = StandardError.new
+        loaded_objects = []
+        (1..num_to_load).each do |n|
+          instance_eval <<-EOS
+            loaded_object#{n} = mock
+            loaded_object#{n}.stubs(:filename).returns("file#{n}")
+            loaded_objects << loaded_object#{n}
+          EOS
+        end
+
+        Backup::Storage::Object.expects(:new).in_sequence(s).
+            with('Base', nil).returns(storage_object)
+        storage_object.expects(:load).in_sequence(s).
+            returns(loaded_objects)
+        loaded_objects.each do |loaded_object|
+          loaded_object.expects(:update!).in_sequence(s).
+              with(base.configure_block)
+        end
+        objects = [base] + loaded_objects
+
+        objects_to_remove = objects[num_to_keep..-1]
+        objects_to_remove.each_with_index do |object_to_remove, i|
+          Backup::Logger.expects(:message).in_sequence(s).
+              with {|msg| msg.include?(object_to_remove.filename) }
+          if i == obj_to_fail
+            object_to_remove.expects(:remove!).in_sequence(s).
+                raises(raised_error)
+            Backup::Errors::Storage::CycleError.expects(:wrap).in_sequence(s).
+                with(raised_error, "#{base.storage_name} failed to remove " +
+                    "'#{object_to_remove.filename}'").
+                returns(:wrapped_error)
+            Backup::Logger.expects(:warn).in_sequence(s).
+                with(:wrapped_error)
+          else
+            object_to_remove.expects(:remove!).in_sequence(s)
+          end
+        end
+
+        objects = objects - objects_to_remove
+        objects.each {|object| object.expects(:clean!).in_sequence(s) }
+        storage_object.expects(:write).in_sequence(s).
+            with(objects)
+
+        base.keep = num_to_keep
+        base.send(:cycle!)
+      end
+
+    end
+
+  end
+
+  describe '#chunks' do
+
+    it 'returns sorted filenames for chunk_suffixes' do
+      base = Backup::Storage::Base.new
+      base.chunk_suffixes = ["aa", "ad", "ae", "ab", "ac"]
+      base.stubs(:filename).returns("file.tar")
+      base.chunks.should == [
+        "#{base.filename}-aa",
+        "#{base.filename}-ab",
+        "#{base.filename}-ac",
+        "#{base.filename}-ad",
+        "#{base.filename}-ae",
+      ]
+
+      base.chunk_suffixes.should == ["aa", "ad", "ae", "ab", "ac"]
+    end
+
+  end
+
+  describe '#storage_name' do
+    let(:s3) { Backup::Storage::S3.new {} }
+
+    describe 'returns storage class name with the Backup:: namespace removed' do
+
+      context 'when storage_id is set' do
+        before { s3.storage_id = 'my storage' }
+
+        it 'appends the storage_id' do
+          s3.storage_name.should == 'Storage::S3 (my storage)'
+        end
+      end
+
+      context 'when storage_id is not set' do
+        it 'does not append the storage_id' do
+          s3.storage_name.should == 'Storage::S3'
+        end
+      end
 
-    Backup::Storage::Object.expects(:new).with('Base').returns(storage_object)
-    storage_object.stubs(:load).returns(objects)
-    storage_object.expects(:write)
-    Backup::Storage::Base.any_instance.expects(:remove!).times(2)
+    end
 
-    base.cycle!
   end
 end