backup 3.0.19 → 3.0.20

data/spec/storage/ninefold_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::Storage::Ninefold do
 
@@ -39,21 +39,30 @@ describe Backup::Storage::Ninefold do
     ninefold.keep.should           == 500                # comes from the default configuration
   end
 
+  describe '#provider' do
+    it 'should be Ninefold' do
+      ninefold.provider.should == 'Ninefold'
+    end
+  end
+
+  describe '#perform' do
+    it 'should invoke transfer! and cycle!' do
+      ninefold.expects(:transfer!)
+      ninefold.expects(:cycle!)
+      ninefold.perform!
+    end
+  end
+
   describe '#connection' do
-    it 'should establish a connection to Ninefold using the provided credentials' do
-      Fog::Storage.expects(:new).with({
+    it 'should establish and re-use a connection to Ninefold' do
+      Fog::Storage.expects(:new).once.with({
         :provider                => 'Ninefold',
         :ninefold_storage_token  => 'my_storage_token',
         :ninefold_storage_secret => 'my_storage_secret'
-      })
+      }).returns(true)
 
       ninefold.send(:connection)
-    end
-  end
-
-  describe '#provider' do
-    it 'should be Ninefold' do
-      ninefold.provider.should == 'Ninefold'
+      ninefold.send(:connection)
     end
   end
 
@@ -64,7 +73,7 @@ describe Backup::Storage::Ninefold do
     let(:files)       { mock('Fog::Storage::Ninefold::Files') }
 
     before do
-      Fog::Storage.stubs(:new).returns(connection)
+      Fog::Storage.expects(:new).once.returns(connection)
       connection.stubs(:directories).returns(directories)
       directory.stubs(:files).returns(files)
     end
@@ -74,11 +83,10 @@ describe Backup::Storage::Ninefold do
         Backup::Model.new('blah', 'blah') {}
         file = mock("Backup::Storage::Ninefold::File")
         File.expects(:open).with("#{File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER}")}.tar").returns(file)
-        ninefold.expects(:remote_file).returns("#{ Backup::TIME }.#{ Backup::TRIGGER }.tar").twice
 
-        directories.expects(:get).with('backups/myapp').returns(directory)
+        directories.expects(:get).with("backups/myapp/#{ Backup::TIME }").returns(directory)
         files.expects(:create) do |options|
-          options[:key].should == "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar"
+          options[:key].should == "#{ Backup::TRIGGER }.tar"
           options[:body].should == file
         end
 
@@ -91,15 +99,14 @@ describe Backup::Storage::Ninefold do
         Backup::Model.new('blah', 'blah') {}
         file = mock("Backup::Storage::Ninefold::File")
         File.expects(:open).with("#{File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER}")}.tar").returns(file)
-        ninefold.expects(:remote_file).returns("#{ Backup::TIME }.#{ Backup::TRIGGER }.tar").twice
 
-        directories.expects(:get).with('backups/myapp').returns(nil)
+        directories.expects(:get).with("backups/myapp/#{ Backup::TIME }").returns(nil)
         directories.expects(:create) { |options|
-          options[:key].should == 'backups/myapp'
+          options[:key].should == "backups/myapp/#{ Backup::TIME }"
         }.returns(directory)
 
         files.expects(:create) do |options|
-          options[:key].should == "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar"
+          options[:key].should == "#{ Backup::TRIGGER }.tar"
           options[:body].should == file
         end
 
@@ -116,27 +123,61 @@ describe Backup::Storage::Ninefold do
     let(:file)        { mock('Fog::Storage::Ninefold::File') }
 
     before do
-      Fog::Storage.stubs(:new).returns(connection)
+      Fog::Storage.expects(:new).once.returns(connection)
       connection.stubs(:directories).returns(directories)
       directory.stubs(:files).returns(files)
     end
 
     it 'should remove the file from the bucket' do
-      ninefold.expects(:remote_file).returns("#{ Backup::TIME }.#{ Backup::TRIGGER }.tar")
-
-      directories.expects(:get).with('backups/myapp').returns(directory)
-      files.expects(:get).with("#{ Backup::TIME }.#{ Backup::TRIGGER }.tar").returns(file)
+      directories.expects(:get).
+          with("backups/myapp/#{ Backup::TIME }").
+          returns(directory)
+      files.expects(:get).
+          with("#{ Backup::TRIGGER }.tar").
+          returns(file)
       file.expects(:destroy)
+      directory.expects(:destroy)
 
       ninefold.send(:remove!)
     end
-  end
 
-  describe '#perform' do
-    it 'should invoke transfer! and cycle!' do
-      ninefold.expects(:transfer!)
-      ninefold.expects(:cycle!)
-      ninefold.perform!
+    it 'should raise an error if remote_path does not exist' do
+      directories.expects(:get).
+          with("backups/myapp/#{ Backup::TIME }").
+          returns(nil)
+      files.expects(:get).never
+      file.expects(:destroy).never
+      directory.expects(:destroy).never
+
+      expect do
+        ninefold.send(:remove!)
+      end.to raise_error(
+        Backup::Errors::Storage::Ninefold::NotFoundError,
+        "Storage::Ninefold::NotFoundError: " +
+        "Directory at 'backups/myapp/#{Backup::TIME}' not found"
+      )
+
+    end
+
+    it 'should raise an error if remote_file does not exist' do
+      directories.expects(:get).
+          with("backups/myapp/#{ Backup::TIME }").
+          returns(directory)
+      files.expects(:get).
+          with("#{ Backup::TRIGGER }.tar").
+          returns(nil)
+      file.expects(:destroy).never
+      directory.expects(:destroy).never
+
+      expect do
+        ninefold.send(:remove!)
+      end.to raise_error(
+        Backup::Errors::Storage::Ninefold::NotFoundError,
+        "Storage::Ninefold::NotFoundError: " +
+        "'#{Backup::TRIGGER}.tar' not found in 'backups/myapp/#{Backup::TIME}'"
+      )
+
     end
   end
+
 end

data/spec/storage/object_spec.rb

@@ -1,74 +1,74 @@
 # encoding: utf-8
 
-require File.dirname(__FILE__) + '/../spec_helper'
+require File.expand_path('../../spec_helper.rb', __FILE__)
 
 describe Backup::Storage::Object do
-  let(:object) { Backup::Storage::Object.new(:s3) }
 
-  it do
-    object.storage_file.should == File.join(Backup::DATA_PATH, Backup::TRIGGER, 's3.yml')
+  describe '#initialize' do
+
+    it 'uses storage type only as YAML filename if no storage_id' do
+      [nil, '', ' '].each do |storage_id|
+        object = Backup::Storage::Object.new(:s3, storage_id)
+        object.storage_file.should == File.join(Backup::DATA_PATH, Backup::TRIGGER, 's3.yml')
+      end
+    end
+
+    it 'appends optional storage_id' do
+      object = Backup::Storage::Object.new(:s3, 'foo')
+      object.storage_file.should == File.join(Backup::DATA_PATH, Backup::TRIGGER, 's3-foo.yml')
+    end
+
+    it 'sanitizes user-defined storage_id for use as filename' do
+      [ ['Backup Server #1', 'Backup_Server__1'],
+        [' {Special} Storage ', '_Special__Storage'],
+        ['Cloud (!@$%^&*) #9', 'Cloud____________9'] ].each do |input, sanitized|
+        object = Backup::Storage::Object.new(:s3, input)
+        object.storage_file.should == File.join(Backup::DATA_PATH, Backup::TRIGGER, "s3-#{sanitized}.yml")
+      end
+    end
+
   end
 
   describe '#load' do
+    let(:storage_object) { Backup::Storage::Object.new(:s3, nil) }
+
     it 'should return an array with objects' do
+      loaded_objects = YAML.load([Backup::Storage::S3.new, Backup::Storage::S3.new].to_yaml)
+      sorted_objects = loaded_objects.sort {|a,b| b.time <=> a.time }
+
       File.expects(:exist?).returns(true)
       YAML.expects(:load_file).with(
         File.join(Backup::DATA_PATH, Backup::TRIGGER, 's3.yml')
-      ).returns(YAML.load([Backup::Storage::S3.new, Backup::Storage::S3.new].to_yaml))
+      ).returns(loaded_objects)
 
-      objects = object.load
+      objects = storage_object.load
       objects.should be_an(Array)
       objects.first.should be_an_instance_of(Backup::Storage::S3)
     end
 
-    describe 'loading them sorted by time descending (newest backup is first in the array)' do
-      it do
-        obj_1 = Backup::Storage::S3.new; obj_1.time = '2007.00.00.00.00.00'
-        obj_2 = Backup::Storage::S3.new; obj_2.time = '2009.00.00.00.00.00'
-        obj_3 = Backup::Storage::S3.new; obj_3.time = '2011.00.00.00.00.00'
+    it 'should load them sorted by time descending (newest backup is first in the array)' do
+      obj_1 = Backup::Storage::S3.new; obj_1.time = '2007.00.00.00.00.00'
+      obj_2 = Backup::Storage::S3.new; obj_2.time = '2009.00.00.00.00.00'
+      obj_3 = Backup::Storage::S3.new; obj_3.time = '2011.00.00.00.00.00'
 
-        File.expects(:exist?).returns(true)
-        YAML.expects(:load_file).with(
-          File.join(Backup::DATA_PATH, Backup::TRIGGER, 's3.yml')
-        ).returns(YAML.load([obj_1, obj_2, obj_3].to_yaml))
+      File.stubs(:exist?).returns(true)
+      File.stubs(:zero?).returns(false)
 
-        objects = object.load
-        objects[0].time.should == '2011.00.00.00.00.00'
-        objects[1].time.should == '2009.00.00.00.00.00'
-        objects[2].time.should == '2007.00.00.00.00.00'
-      end
-
-      it do
-        obj_3 = Backup::Storage::S3.new; obj_3.time = '2007.00.00.00.00.00'
-        obj_2 = Backup::Storage::S3.new; obj_2.time = '2009.00.00.00.00.00'
-        obj_1 = Backup::Storage::S3.new; obj_1.time = '2011.00.00.00.00.00'
-
-        File.expects(:exist?).returns(true)
-        YAML.expects(:load_file).with(
-          File.join(Backup::DATA_PATH, Backup::TRIGGER, 's3.yml')
-        ).returns(YAML.load([obj_1, obj_2, obj_3].to_yaml))
-
-        objects = object.load
-        objects[0].time.should == '2011.00.00.00.00.00'
-        objects[1].time.should == '2009.00.00.00.00.00'
-        objects[2].time.should == '2007.00.00.00.00.00'
-      end
+      [obj_1, obj_2, obj_3].permutation.each do |perm|
+        loaded_objects = YAML.load(perm.to_yaml)
+        sorted_objects = loaded_objects.sort {|a,b| b.time <=> a.time }
 
-      it do
-        obj_3 = Backup::Storage::S3.new; obj_3.time = '2007.00.00.00.00.00'
-        obj_1 = Backup::Storage::S3.new; obj_1.time = '2009.00.00.00.00.00'
-        obj_2 = Backup::Storage::S3.new; obj_2.time = '2011.00.00.00.00.00'
-
-        File.expects(:exist?).at_least_once.returns(true)
         YAML.expects(:load_file).with(
           File.join(Backup::DATA_PATH, Backup::TRIGGER, 's3.yml')
-        ).returns(YAML.load([obj_1, obj_2, obj_3].to_yaml))
+        ).returns(loaded_objects)
 
-        objects = object.load
+        objects = storage_object.load
         objects[0].time.should == '2011.00.00.00.00.00'
         objects[1].time.should == '2009.00.00.00.00.00'
         objects[2].time.should == '2007.00.00.00.00.00'
       end
     end
+
   end
+
 end

data/spec/storage/rsync_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::Storage::RSync do
 
@@ -19,13 +19,12 @@ describe Backup::Storage::RSync do
   end
 
   it 'should have defined the configuration properly' do
-    rsync.username.should        == 'my_username'
-    rsync.send(:password).should =~ /backup-rsync-password/
-    rsync.ip.should              == '123.45.678.90'
-    rsync.port.should            == "-e 'ssh -p 22'"
-    rsync.path.should            == 'backups/'
-
-    File.read(rsync.instance_variable_get('@password_file').path).should == 'my_password'
+    rsync.username.should == 'my_username'
+    rsync.password.should == 'my_password'
+    rsync.ip.should       == '123.45.678.90'
+    rsync.port.should     == 22
+    rsync.path.should     == 'backups/'
+    rsync.send(:rsync_port).should == "-e 'ssh -p 22'"
   end
 
   it 'should use the defaults if a particular attribute has not been defined' do
@@ -40,101 +39,225 @@ describe Backup::Storage::RSync do
       rsync.ip       = '123.45.678.90'
     end
 
-    rsync.username.should        == 'my_default_username'
-    rsync.send(:password).should =~ /backup-rsync-password/
-    rsync.ip.should              == '123.45.678.90'
-    rsync.port.should            == "-e 'ssh -p 22'"
-
-    File.read(rsync.instance_variable_get('@password_file').path).should == 'my_password'
+    rsync.username.should == 'my_default_username'
+    rsync.password.should == 'my_password'
+    rsync.ip.should       == '123.45.678.90'
+    rsync.port.should     == 22
+    rsync.send(:rsync_port).should == "-e 'ssh -p 22'"
   end
 
   it 'should have its own defaults' do
     rsync = Backup::Storage::RSync.new
-    rsync.port.should  == "-e 'ssh -p 22'"
+    rsync.port.should  == 22
     rsync.path.should  == 'backups'
     rsync.local.should == false
+    rsync.send(:rsync_port).should == "-e 'ssh -p 22'"
+  end
+
+  describe '#perform' do
+    it 'should invoke transfer!' do
+      s = sequence ''
+      rsync.expects(:write_password_file!).in_sequence(s)
+      rsync.expects(:transfer!).in_sequence(s)
+      rsync.expects(:remove_password_file!).in_sequence(s)
+
+      rsync.perform!
+    end
+
+    it 'should ensure any password file is removed' do
+      s = sequence ''
+      rsync.expects(:write_password_file!).in_sequence(s)
+      rsync.expects(:transfer!).in_sequence(s).raises(Exception)
+      rsync.expects(:remove_password_file!).in_sequence(s)
+
+      expect do
+        rsync.perform!
+      end.to raise_error
+    end
   end
 
   describe '#connection' do
-    it 'should establish a connection to the remote server using the provided ip address and credentials' do
-      Net::SSH.expects(:start).with('123.45.678.90', 'my_username', :password => 'my_password', :port => 22)
-      rsync.send(:connection)
+    it 'should establish a connection to the remote server' do
+      connection = mock
+      Net::SSH.expects(:start).with(
+        '123.45.678.90',
+        'my_username',
+        :password => 'my_password',
+        :port => 22
+      ).yields(connection)
+
+      rsync.send(:connection) do |ssh|
+        ssh.should be connection
+      end
     end
   end
 
   describe '#transfer!' do
-    let(:connection) { mock('Net::SCP') }
+    let(:local_file)  { File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar") }
+    let(:remote_file) { "#{ Backup::TRIGGER }/#{ Backup::TRIGGER }.tar" }
+    let(:pwdfile)     { stub(:path => 'path/to/password/file') }
 
     before do
-      Net::SSH.stubs(:start).returns(connection)
-      rsync.stubs(:create_remote_directories!)
+      rsync.expects(:create_remote_directories!)
+      rsync.expects(:utility).returns('rsync')
+      Backup::Logger.expects(:message).with(
+        "Storage::RSync started transferring '#{rsync.filename}' to '#{rsync.ip}'."
+      )
     end
 
-    it 'should transfer the provided file to the path' do
-      Backup::Model.new('blah', 'blah') {}
-      file = mock("Backup::Storage::RSync::File")
+    context 'when performing a remote transfer' do
+      context 'when a password is set' do
+        before do
+          rsync.stubs(:write_password_file!)
+          rsync.instance_variable_set(:@password_file, pwdfile)
+        end
 
-      rsync.expects(:create_remote_directories!)
-      rsync.expects(:utility).returns('rsync')
-      rsync.expects(:run).with("rsync -z -e 'ssh -p 22' --password-file='#{rsync.instance_variable_get('@password_file').path}' '#{ File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar") }' 'my_username@123.45.678.90:backups/#{ Backup::TRIGGER }/#{ Backup::TRIGGER }.tar'")
+        it 'should transfer the provided file to the path' do
+          rsync.expects(:run).with(
+            "rsync -z -e 'ssh -p 22' --password-file='path/to/password/file' " +
+            "'#{local_file}' " +
+            "'my_username@123.45.678.90:backups/#{remote_file}'"
+          )
 
-      rsync.send(:transfer!)
-    end
+          rsync.send(:transfer!)
+        end
+      end
 
-    it 'should not provide the --password-file option' do
-      Backup::Model.new('blah', 'blah') {}
-      file = mock("Backup::Storage::RSync::File")
+      context 'when no password is set' do
+        before { rsync.password = nil }
 
-      rsync.password = nil
-      rsync.expects(:create_remote_directories!)
-      rsync.expects(:utility).returns('rsync')
-      rsync.expects(:run).with("rsync -z -e 'ssh -p 22'  '#{ File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar") }' 'my_username@123.45.678.90:backups/#{ Backup::TRIGGER }/#{ Backup::TRIGGER }.tar'")
+        it 'should not provide the --password-file option' do
+          rsync.expects(:run).with(
+            "rsync -z -e 'ssh -p 22'  " +
+            "'#{local_file}' " +
+            "'my_username@123.45.678.90:backups/#{remote_file}'"
+          )
 
-      rsync.send(:transfer!)
-    end
+          rsync.send(:transfer!)
+        end
+      end
+
+    end # context 'when performing a remote transfer'
+
+    context 'when performing a local transfer' do
+      before { rsync.local = true }
+
+      it 'should save a local copy of backups' do
+        rsync.expects(:run).with(
+          "rsync '#{local_file}' 'backups/#{remote_file}'"
+        )
+        rsync.send(:transfer!)
+      end
+    end # context 'when performing a local transfer'
   end
 
   describe '#remove!' do
-    let(:connection) { mock('Net::SCP') }
+    it 'should return nil' do
+      rsync.send(:remove!).should == nil
+    end
+  end
 
-    before do
-      Net::SSH.stubs(:start).returns(connection)
+  describe '#create_remote_directories!' do
+
+    context 'when rsync.local is false' do
+      it 'should create directories on the remote server' do
+        ssh = mock
+        rsync.expects(:mkdir).never
+        rsync.expects(:connection).yields(ssh)
+        ssh.expects(:exec!).with("mkdir -p '#{rsync.remote_path}'")
+
+        rsync.send(:create_remote_directories!)
+      end
     end
 
-    it 'should remove the file from the remote server path' do
-      connection.expects(:exec!).with("rm backups/myapp/#{ Backup::TIME }.#{ Backup::TRIGGER }.tar")
-      rsync.send(:remove!)
+    context 'when rsync.local is true' do
+      before { rsync.local = true }
+      it 'should create directories locally' do
+        rsync.expects(:mkdir).with(rsync.remote_path)
+        rsync.expects(:connection).never
+
+        rsync.send(:create_remote_directories!)
+      end
     end
+
   end
 
-  describe '#create_remote_directories!' do
-    let(:connection) { mock('Net::SSH') }
+  describe '#write_password_file!' do
 
     before do
-      Net::SSH.stubs(:start).returns(connection)
+      rsync.instance_variable_defined?(:@password_file).should be_false
     end
 
-    it 'should properly create remote directories one by one' do
-      rsync.path = 'backups/some_other_folder/another_folder'
-      connection.expects(:exec!).with("mkdir -p 'backups/some_other_folder/another_folder/myapp'")
-      rsync.send(:create_remote_directories!)
+    context 'when a password is set' do
+      it 'should write the password file' do
+        rsync.send(:write_password_file!)
+        password_file = rsync.instance_variable_get(:@password_file)
+        password_file.should respond_to(:path)
+        File.read(password_file.path).should == 'my_password'
+      end
     end
-  end
 
-  describe '#perform' do
-    it 'should invoke transfer!' do
-      rsync.expects(:transfer!)
-      rsync.perform!
+    context 'when a password is not set' do
+      before { rsync.password = nil }
+      it 'should return nil' do
+        rsync.send(:write_password_file!).should be_nil
+      end
+    end
+
+  end # describe '#write_password_file!'
+
+  describe '#remove_password_file!' do
+    let(:pwdfile) { mock }
+
+    context 'when @password_file is set' do
+      before do
+        rsync.instance_variable_set(:@password_file, pwdfile)
+      end
+
+      it 'should remove the password file' do
+        pwdfile.expects(:delete)
+        rsync.send(:remove_password_file!)
+      end
+    end
+
+    context 'when @password_file is not set' do
+      it 'should return nil' do
+        rsync.send(:remove_password_file!).should be_nil
+      end
+    end
+
+  end # describe '#remove_password_file!'
+
+  describe '#rsync_password_file' do
+    let(:pwdfile) { stub(:path => 'path/to/password/file') }
+
+    context 'when @password_file is set' do
+      before do
+        rsync.instance_variable_set(:@password_file, pwdfile)
+      end
+
+      it 'should return the password file string for the rsync command' do
+        rsync.send(:rsync_password_file).should == "--password-file='path/to/password/file'"
+      end
+    end
+
+    context 'when a password is not set' do
+      it 'should return nil' do
+        rsync.send(:rsync_password_file).should be_nil
+      end
+    end
+
+  end # describe '#password_file'
+
+  describe '#rsync_port' do
+    it 'should return the port string for the rsync command' do
+      rsync.send(:rsync_port).should == "-e 'ssh -p 22'"
     end
   end
 
-  describe '#local backups' do
-    it 'should save a local copy of backups' do
-      rsync.expects(:create_remote_directories!)
-      rsync.local = true
-      rsync.expects(:utility).returns('rsync')
-      rsync.expects(:run).with("rsync '#{ File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar") }' 'backups/#{ Backup::TRIGGER }/#{ Backup::TIME }.#{ Backup::TRIGGER }.tar'")
-      rsync.send(:transfer!)
+  describe '#rsync_options' do
+    it 'should return the options string for the rsync command' do
+      rsync.send(:rsync_options).should == "-z"
     end
   end