backup_checksum 3.0.23

data/spec/storage/rsync_spec.rb

@@ -0,0 +1,345 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Backup::Storage::RSync do
+  let(:model)   { Backup::Model.new(:test_trigger, 'test label') }
+  let(:storage) do
+    Backup::Storage::RSync.new(model) do |rsync|
+      rsync.username  = 'my_username'
+      rsync.password  = 'my_password'
+      rsync.ip        = '123.45.678.90'
+      rsync.keep      = 5
+    end
+  end
+
+  describe '#initialize' do
+    it 'should set the correct values' do
+      storage.username.should == 'my_username'
+      storage.password.should == 'my_password'
+      storage.ip.should       == '123.45.678.90'
+      storage.port.should     == 22
+      storage.path.should     == 'backups'
+      storage.local.should    == false
+
+      storage.storage_id.should be_nil
+      storage.keep.should       == 5
+    end
+
+    it 'should set a storage_id if given' do
+      rsync = Backup::Storage::RSync.new(model, 'my storage_id')
+      rsync.storage_id.should == 'my storage_id'
+    end
+
+    it 'should remove any preceeding tilde and slash from the path' do
+      storage = Backup::Storage::RSync.new(model) do |rsync|
+        rsync.path = '~/my_backups/path'
+      end
+      storage.path.should == 'my_backups/path'
+    end
+
+    context 'when setting configuration defaults' do
+      after { Backup::Configuration::Storage::RSync.clear_defaults! }
+
+      it 'should use the configured defaults' do
+        Backup::Configuration::Storage::RSync.defaults do |rsync|
+          rsync.username  = 'some_username'
+          rsync.password  = 'some_password'
+          rsync.ip        = 'some_ip'
+          rsync.port      = 'some_port'
+          rsync.path      = 'some_path'
+          rsync.local     = 'some_local'
+          rsync.keep      = 'some_keep'
+        end
+        storage = Backup::Storage::RSync.new(model)
+        storage.username.should == 'some_username'
+        storage.password.should == 'some_password'
+        storage.ip.should       == 'some_ip'
+        storage.port.should     == 'some_port'
+        storage.path.should     == 'some_path'
+        storage.local.should    == 'some_local'
+
+        storage.storage_id.should be_nil
+        storage.keep.should       == 'some_keep'
+      end
+
+      it 'should override the configured defaults' do
+        Backup::Configuration::Storage::RSync.defaults do |rsync|
+          rsync.username  = 'old_username'
+          rsync.password  = 'old_password'
+          rsync.ip        = 'old_ip'
+          rsync.port      = 'old_port'
+          rsync.path      = 'old_path'
+          rsync.local     = 'old_local'
+          rsync.keep      = 'old_keep'
+        end
+        storage = Backup::Storage::RSync.new(model) do |rsync|
+          rsync.username  = 'new_username'
+          rsync.password  = 'new_password'
+          rsync.ip        = 'new_ip'
+          rsync.port      = 'new_port'
+          rsync.path      = 'new_path'
+          rsync.local     = 'new_local'
+          rsync.keep      = 'new_keep'
+        end
+
+        storage.username.should == 'new_username'
+        storage.password.should == 'new_password'
+        storage.ip.should       == 'new_ip'
+        storage.port.should     == 'new_port'
+        storage.path.should     == 'new_path'
+        storage.local.should    == 'new_local'
+
+        storage.storage_id.should be_nil
+        storage.keep.should       == 'new_keep'
+      end
+    end # context 'when setting configuration defaults'
+
+  end # describe '#initialize'
+
+  describe '#remote_path_for' do
+    let(:package) { mock }
+    before do
+      storage.instance_variable_set(:@package, package)
+      package.expects(:trigger).returns(model.trigger)
+    end
+
+    it 'should override superclass so the time folder is not used' do
+      storage.send(:remote_path_for, package).should ==
+          File.join('backups', 'test_trigger')
+    end
+  end
+
+  describe '#connection' do
+    let(:connection) { mock }
+    it 'should yield a Net::SSH connection' do
+      Net::SSH.expects(:start).with(
+        '123.45.678.90', 'my_username', :password => 'my_password', :port => 22
+      ).yields(connection)
+
+      storage.send(:connection) do |ssh|
+        ssh.should be(connection)
+      end
+    end
+  end
+
+  describe '#transfer!' do
+    let(:package) { mock }
+    let(:s) { sequence '' }
+
+    before do
+      storage.instance_variable_set(:@package, package)
+      storage.stubs(:storage_name).returns('Storage::RSync')
+      storage.stubs(:local_path).returns('/local/path')
+      storage.stubs(:rsync_options).returns(:rsync_options)
+      storage.stubs(:rsync_port).returns(:rsync_port)
+      storage.stubs(:rsync_password_file).returns(:rsync_password_file)
+      storage.expects(:utility).with(:rsync).times(0..2).returns('rsync')
+    end
+
+    context 'when @local is set to false' do
+      it 'should transfer the package files to the remote' do
+        storage.expects(:write_password_file!).in_sequence(s)
+
+        storage.expects(:remote_path_for).in_sequence(s).with(package).
+            returns('remote/path')
+
+        storage.expects(:create_remote_path!).in_sequence(s).with('remote/path')
+
+        storage.expects(:files_to_transfer_for).in_sequence(s).with(package).
+          multiple_yields(
+          ['2011.12.31.11.00.02.backup.tar.enc-aa', 'backup.tar.enc-aa'],
+          ['2011.12.31.11.00.02.backup.tar.enc-ab', 'backup.tar.enc-ab']
+        )
+        # first yield
+        Backup::Logger.expects(:message).in_sequence(s).with(
+          "Storage::RSync started transferring " +
+          "'2011.12.31.11.00.02.backup.tar.enc-aa' to '123.45.678.90'."
+        )
+        storage.expects(:run).in_sequence(s).with(
+          "rsync rsync_options rsync_port rsync_password_file " +
+          "'#{ File.join('/local/path', '2011.12.31.11.00.02.backup.tar.enc-aa') }' " +
+          "'my_username@123.45.678.90:#{ File.join('remote/path', 'backup.tar.enc-aa') }'"
+        )
+        # second yield
+        Backup::Logger.expects(:message).in_sequence(s).with(
+          "Storage::RSync started transferring " +
+          "'2011.12.31.11.00.02.backup.tar.enc-ab' to '123.45.678.90'."
+        )
+        storage.expects(:run).in_sequence(s).with(
+          "rsync rsync_options rsync_port rsync_password_file " +
+          "'#{ File.join('/local/path', '2011.12.31.11.00.02.backup.tar.enc-ab') }' " +
+          "'my_username@123.45.678.90:#{ File.join('remote/path', 'backup.tar.enc-ab') }'"
+        )
+
+        storage.expects(:remove_password_file!).in_sequence(s)
+
+        storage.send(:transfer!)
+      end
+
+      it 'should ensure password file removal' do
+        storage.expects(:write_password_file!).raises('error message')
+        storage.expects(:remove_password_file!)
+
+        expect do
+          storage.send(:transfer!)
+        end.to raise_error(RuntimeError, 'error message')
+      end
+    end # context 'when @local is set to false'
+
+    context 'when @local is set to true' do
+      before { storage.local = true }
+
+      it 'should transfer the package files locally' do
+        storage.expects(:write_password_file!).never
+
+        storage.expects(:remote_path_for).in_sequence(s).with(package).
+            returns('remote/path')
+
+        storage.expects(:create_remote_path!).in_sequence(s).with('remote/path')
+
+        storage.expects(:files_to_transfer_for).in_sequence(s).with(package).
+          multiple_yields(
+          ['2011.12.31.11.00.02.backup.tar.enc-aa', 'backup.tar.enc-aa'],
+          ['2011.12.31.11.00.02.backup.tar.enc-ab', 'backup.tar.enc-ab']
+        )
+        # first yield
+        Backup::Logger.expects(:message).in_sequence(s).with(
+          "Storage::RSync started transferring " +
+          "'2011.12.31.11.00.02.backup.tar.enc-aa' to 'remote/path'."
+        )
+        storage.expects(:run).in_sequence(s).with(
+          "rsync " +
+          "'#{ File.join('/local/path', '2011.12.31.11.00.02.backup.tar.enc-aa') }' " +
+          "'#{ File.join('remote/path', 'backup.tar.enc-aa') }'"
+        )
+        # second yield
+        Backup::Logger.expects(:message).in_sequence(s).with(
+          "Storage::RSync started transferring " +
+          "'2011.12.31.11.00.02.backup.tar.enc-ab' to 'remote/path'."
+        )
+        storage.expects(:run).in_sequence(s).with(
+          "rsync " +
+          "'#{ File.join('/local/path', '2011.12.31.11.00.02.backup.tar.enc-ab') }' " +
+          "'#{ File.join('remote/path', 'backup.tar.enc-ab') }'"
+        )
+
+        storage.expects(:remove_password_file!).never
+
+        storage.send(:transfer!)
+      end
+
+    end # context 'when @local is set to true'
+
+  end # describe '#transfer!'
+
+  ##
+  # Note: Storage::RSync doesn't cycle
+  describe '#remove!' do
+    it 'should never even be called' do
+      storage.send(:remove!).should be_nil
+    end
+  end
+
+  describe '#create_remote_path!' do
+    let(:connection) { mock }
+
+    context 'when @local is set to false' do
+      it 'should create the remote_path on the remote' do
+        FileUtils.expects(:mkdir_p).never
+
+        storage.expects(:connection).yields(connection)
+        connection.expects(:exec!).with("mkdir -p 'remote/path'")
+
+        storage.send(:create_remote_path!, 'remote/path')
+      end
+    end
+
+    context 'when @local is set to true' do
+      before { storage.local = true }
+      it 'should create the remote_path locally' do
+        storage.expects(:connection).never
+
+        FileUtils.expects(:mkdir_p).with('remote/path')
+
+        storage.send(:create_remote_path!, 'remote/path')
+      end
+    end
+  end
+
+  describe '#write_password_file!' do
+    let(:file) { mock }
+
+    context 'when a @password is set' do
+      it 'should write the password to file and set @password_file' do
+        Tempfile.expects(:new).with('backup-rsync-password').returns(file)
+        file.expects(:write).with('my_password')
+        file.expects(:close)
+
+        storage.send(:write_password_file!)
+        storage.instance_variable_get(:@password_file).should be(file)
+      end
+    end
+
+    context 'when a @password is not set' do
+      before { storage.password = nil }
+      it 'should do nothing' do
+        Tempfile.expects(:new).never
+
+        storage.send(:write_password_file!)
+        storage.instance_variable_get(:@password_file).should be_nil
+      end
+    end
+  end
+
+  describe '#remove_password_file!' do
+    let(:file) { mock }
+
+    context 'when @password_file is set' do
+      before { storage.instance_variable_set(:@password_file, file) }
+      it 'should delete the file and clear @password_file' do
+        file.expects(:delete)
+        storage.send(:remove_password_file!)
+        storage.instance_variable_get(:@password_file).should be_nil
+      end
+    end
+
+    context 'when @password_file is not set' do
+      it 'should do nothing' do
+        file.expects(:delete).never
+        storage.send(:remove_password_file!)
+      end
+    end
+  end
+
+  describe '#rsync_password_file' do
+    let(:file) { mock }
+
+    context 'when @password_file is set' do
+      before { storage.instance_variable_set(:@password_file, file) }
+      it 'should return the syntax for rsync to use the password file' do
+        file.expects(:path).returns('/path/to/file')
+        storage.send(:rsync_password_file).should == "--password-file='/path/to/file'"
+      end
+    end
+
+    context 'when @password_file is not set' do
+      it 'should return nil' do
+        storage.send(:rsync_password_file).should be_nil
+      end
+    end
+  end
+
+  describe '#rsync_port' do
+    it 'should return the syntax for rsync to set the port' do
+      storage.send(:rsync_port).should == "-e 'ssh -p 22'"
+    end
+  end
+
+  describe '#rsync_options' do
+    it 'should return the syntax for rsync to set other options' do
+      storage.send(:rsync_options).should == '-z'
+    end
+  end
+
+end

data/spec/storage/s3_spec.rb

@@ -0,0 +1,221 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+##
+# available S3 regions:
+# eu-west-1, us-east-1, ap-southeast-1, us-west-1
+describe Backup::Storage::S3 do
+  let(:model)   { Backup::Model.new(:test_trigger, 'test label') }
+  let(:storage) do
+    Backup::Storage::S3.new(model) do |s3|
+      s3.access_key_id      = 'my_access_key_id'
+      s3.secret_access_key  = 'my_secret_access_key'
+      s3.bucket             = 'my-bucket'
+      s3.region             = 'us-east-1'
+      s3.keep               = 5
+    end
+  end
+
+  describe '#initialize' do
+    it 'should set the correct values' do
+      storage.access_key_id.should      == 'my_access_key_id'
+      storage.secret_access_key.should  == 'my_secret_access_key'
+      storage.bucket.should             == 'my-bucket'
+      storage.path.should               == 'backups'
+      storage.region.should             == 'us-east-1'
+
+      storage.storage_id.should be_nil
+      storage.keep.should       == 5
+    end
+
+    it 'should set a storage_id if given' do
+      s3 = Backup::Storage::S3.new(model, 'my storage_id')
+      s3.storage_id.should == 'my storage_id'
+    end
+
+    context 'when setting configuration defaults' do
+      after { Backup::Configuration::Storage::S3.clear_defaults! }
+
+      it 'should use the configured defaults' do
+        Backup::Configuration::Storage::S3.defaults do |s3|
+          s3.access_key_id      = 'some_access_key_id'
+          s3.secret_access_key  = 'some_secret_access_key'
+          s3.bucket             = 'some-bucket'
+          s3.path               = 'some_path'
+          s3.region             = 'some_region'
+          s3.keep               = 15
+        end
+        storage = Backup::Storage::S3.new(model)
+        storage.access_key_id.should      == 'some_access_key_id'
+        storage.secret_access_key.should  == 'some_secret_access_key'
+        storage.bucket.should             == 'some-bucket'
+        storage.path.should               == 'some_path'
+        storage.region.should             == 'some_region'
+
+        storage.storage_id.should be_nil
+        storage.keep.should       == 15
+      end
+
+      it 'should override the configured defaults' do
+        Backup::Configuration::Storage::S3.defaults do |s3|
+          s3.access_key_id      = 'old_access_key_id'
+          s3.secret_access_key  = 'old_secret_access_key'
+          s3.bucket             = 'old-bucket'
+          s3.path               = 'old_path'
+          s3.region             = 'old_region'
+          s3.keep               = 15
+        end
+        storage = Backup::Storage::S3.new(model) do |s3|
+          s3.access_key_id      = 'new_access_key_id'
+          s3.secret_access_key  = 'new_secret_access_key'
+          s3.bucket             = 'new-bucket'
+          s3.path               = 'new_path'
+          s3.region             = 'new_region'
+          s3.keep               = 10
+        end
+
+        storage.access_key_id.should      == 'new_access_key_id'
+        storage.secret_access_key.should  == 'new_secret_access_key'
+        storage.bucket.should             == 'new-bucket'
+        storage.path.should               == 'new_path'
+        storage.region.should             == 'new_region'
+
+        storage.storage_id.should be_nil
+        storage.keep.should       == 10
+      end
+    end # context 'when setting configuration defaults'
+
+  end # describe '#initialize'
+
+  describe '#provider' do
+    it 'should set the Fog provider' do
+      storage.send(:provider).should == 'AWS'
+    end
+  end
+
+  describe '#connection' do
+    let(:connection) { mock }
+
+    it 'should create a new connection' do
+      Fog::Storage.expects(:new).once.with(
+        :provider               => 'AWS',
+        :aws_access_key_id      => 'my_access_key_id',
+        :aws_secret_access_key  => 'my_secret_access_key',
+        :region                 => 'us-east-1'
+      ).returns(connection)
+      storage.send(:connection).should == connection
+    end
+
+    it 'should return an existing connection' do
+      Fog::Storage.expects(:new).once.returns(connection)
+      storage.send(:connection).should == connection
+      storage.send(:connection).should == connection
+    end
+  end # describe '#connection'
+
+  describe '#remote_path_for' do
+    let(:package) { mock }
+
+    before do
+      # for superclass method
+      package.expects(:trigger).returns('trigger')
+      package.expects(:time).returns('time')
+    end
+
+    it 'should remove any preceeding slash from the remote path' do
+      storage.path = '/backups'
+      storage.send(:remote_path_for, package).should == 'backups/trigger/time'
+    end
+  end
+
+  describe '#transfer!' do
+    let(:connection) { mock }
+    let(:package) { mock }
+    let(:file) { mock }
+    let(:s) { sequence '' }
+
+    before do
+      storage.instance_variable_set(:@package, package)
+      storage.stubs(:storage_name).returns('Storage::S3')
+      storage.stubs(:local_path).returns('/local/path')
+      storage.stubs(:connection).returns(connection)
+    end
+
+    it 'should transfer the package files' do
+      storage.expects(:remote_path_for).in_sequence(s).with(package).
+          returns('remote/path')
+      connection.expects(:sync_clock).in_sequence(s)
+      storage.expects(:files_to_transfer_for).in_sequence(s).with(package).
+        multiple_yields(
+        ['2011.12.31.11.00.02.backup.tar.enc-aa', 'backup.tar.enc-aa'],
+        ['2011.12.31.11.00.02.backup.tar.enc-ab', 'backup.tar.enc-ab']
+      )
+      # first yield
+      Backup::Logger.expects(:message).in_sequence(s).with(
+        "Storage::S3 started transferring " +
+        "'2011.12.31.11.00.02.backup.tar.enc-aa' to bucket 'my-bucket'."
+      )
+      File.expects(:open).in_sequence(s).with(
+        File.join('/local/path', '2011.12.31.11.00.02.backup.tar.enc-aa'), 'r'
+      ).yields(file)
+      connection.expects(:put_object).in_sequence(s).with(
+        'my-bucket', File.join('remote/path', 'backup.tar.enc-aa'), file
+      )
+      # second yield
+      Backup::Logger.expects(:message).in_sequence(s).with(
+        "Storage::S3 started transferring " +
+        "'2011.12.31.11.00.02.backup.tar.enc-ab' to bucket 'my-bucket'."
+      )
+      File.expects(:open).in_sequence(s).with(
+        File.join('/local/path', '2011.12.31.11.00.02.backup.tar.enc-ab'), 'r'
+      ).yields(file)
+      connection.expects(:put_object).in_sequence(s).with(
+        'my-bucket', File.join('remote/path', 'backup.tar.enc-ab'), file
+      )
+
+      storage.send(:transfer!)
+    end
+  end # describe '#transfer!'
+
+  describe '#remove!' do
+    let(:package) { mock }
+    let(:connection) { mock }
+    let(:s) { sequence '' }
+
+    before do
+      storage.stubs(:storage_name).returns('Storage::S3')
+      storage.stubs(:connection).returns(connection)
+    end
+
+    it 'should remove the package files' do
+      storage.expects(:remote_path_for).in_sequence(s).with(package).
+          returns('remote/path')
+      connection.expects(:sync_clock).in_sequence(s)
+      storage.expects(:transferred_files_for).in_sequence(s).with(package).
+        multiple_yields(
+        ['2011.12.31.11.00.02.backup.tar.enc-aa', 'backup.tar.enc-aa'],
+        ['2011.12.31.11.00.02.backup.tar.enc-ab', 'backup.tar.enc-ab']
+      )
+      # first yield
+      Backup::Logger.expects(:message).in_sequence(s).with(
+        "Storage::S3 started removing " +
+        "'2011.12.31.11.00.02.backup.tar.enc-aa' from bucket 'my-bucket'."
+      )
+      connection.expects(:delete_object).in_sequence(s).with(
+        'my-bucket', File.join('remote/path', 'backup.tar.enc-aa')
+      )
+      # second yield
+      Backup::Logger.expects(:message).in_sequence(s).with(
+        "Storage::S3 started removing " +
+        "'2011.12.31.11.00.02.backup.tar.enc-ab' from bucket 'my-bucket'."
+      )
+      connection.expects(:delete_object).in_sequence(s).with(
+        'my-bucket', File.join('remote/path', 'backup.tar.enc-ab')
+      )
+
+      storage.send(:remove!, package)
+    end
+  end # describe '#remove!'
+
+end