backup 3.0.20 → 3.0.21

data/spec/storage/ninefold_spec.rb

@@ -3,181 +3,317 @@
 require File.expand_path('../../spec_helper.rb', __FILE__)
 
 describe Backup::Storage::Ninefold do
-
-  let(:ninefold) do
-    Backup::Storage::Ninefold.new do |nf|
-      nf.storage_token  = 'my_storage_token'
-      nf.storage_secret = 'my_storage_secret'
-      nf.path           = 'backups'
-      nf.keep           = 20
+  let(:model)   { Backup::Model.new(:test_trigger, 'test label') }
+  let(:storage) do
+    Backup::Storage::Ninefold.new(model) do |nf|
+      nf.storage_token    = 'my_token'
+      nf.storage_secret   = 'my_secret'
+      nf.keep             = 5
     end
   end
 
-  before do
-    Backup::Configuration::Storage::Ninefold.clear_defaults!
-  end
-
-  it 'should have defined the configuration properly' do
-    ninefold.storage_token.should  == 'my_storage_token'
-    ninefold.storage_secret.should == 'my_storage_secret'
-    ninefold.keep.should           == 20
-  end
+  describe '#initialize' do
+    it 'should set the correct values' do
+      storage.storage_token.should  == 'my_token'
+      storage.storage_secret.should == 'my_secret'
+      storage.path.should       == 'backups'
 
-  it 'should use the defaults if a particular attribute has not been defined' do
-    Backup::Configuration::Storage::Ninefold.defaults do |nf|
-      nf.storage_token = 'my_storage_token'
-      nf.keep          = 500
+      storage.storage_id.should be_nil
+      storage.keep.should       == 5
     end
 
-    ninefold = Backup::Storage::Ninefold.new do |nf|
-      nf.path = 'my/backups'
+    it 'should set a storage_id if given' do
+      nf = Backup::Storage::Ninefold.new(model, 'my storage_id')
+      nf.storage_id.should == 'my storage_id'
     end
 
-    ninefold.storage_token.should  == 'my_storage_token' # not defined, uses default
-    ninefold.storage_secret.should == nil                # not defined, no default
-    ninefold.path.should           == 'my/backups'       # overwritten from Backup::Storage::Ninefold
-    ninefold.keep.should           == 500                # comes from the default configuration
-  end
+    context 'when setting configuration defaults' do
+      after { Backup::Configuration::Storage::Ninefold.clear_defaults! }
 
-  describe '#provider' do
-    it 'should be Ninefold' do
-      ninefold.provider.should == 'Ninefold'
-    end
-  end
+      it 'should use the configured defaults' do
+        Backup::Configuration::Storage::Ninefold.defaults do |nf|
+          nf.storage_token    = 'some_token'
+          nf.storage_secret   = 'some_secret'
+          nf.path             = 'some_path'
+          nf.keep             = 15
+        end
+        storage = Backup::Storage::Ninefold.new(model)
+        storage.storage_token.should  == 'some_token'
+        storage.storage_secret.should == 'some_secret'
+        storage.path.should           == 'some_path'
+
+        storage.storage_id.should be_nil
+        storage.keep.should       == 15
+      end
+
+      it 'should override the configured defaults' do
+        Backup::Configuration::Storage::Ninefold.defaults do |nf|
+          nf.storage_token    = 'old_token'
+          nf.storage_secret   = 'old_secret'
+          nf.path             = 'old_path'
+          nf.keep             = 15
+        end
+        storage = Backup::Storage::Ninefold.new(model) do |nf|
+          nf.storage_token    = 'new_token'
+          nf.storage_secret   = 'new_secret'
+          nf.path             = 'new_path'
+          nf.keep             = 10
+        end
+
+        storage.storage_token.should  == 'new_token'
+        storage.storage_secret.should == 'new_secret'
+        storage.path.should           == 'new_path'
+
+        storage.storage_id.should be_nil
+        storage.keep.should       == 10
+      end
+    end # context 'when setting configuration defaults'
+
+  end # describe '#initialize'
 
-  describe '#perform' do
-    it 'should invoke transfer! and cycle!' do
-      ninefold.expects(:transfer!)
-      ninefold.expects(:cycle!)
-      ninefold.perform!
+  describe '#provider' do
+    it 'should set the Fog provider' do
+      storage.send(:provider).should == 'Ninefold'
     end
   end
 
   describe '#connection' do
-    it 'should establish and re-use a connection to Ninefold' do
-      Fog::Storage.expects(:new).once.with({
+    let(:connection) { mock }
+
+    it 'should create a new connection' do
+      Fog::Storage.expects(:new).once.with(
         :provider                => 'Ninefold',
-        :ninefold_storage_token  => 'my_storage_token',
-        :ninefold_storage_secret => 'my_storage_secret'
-      }).returns(true)
+        :ninefold_storage_token  => 'my_token',
+        :ninefold_storage_secret => 'my_secret'
+      ).returns(connection)
+      storage.send(:connection).should == connection
+    end
 
-      ninefold.send(:connection)
-      ninefold.send(:connection)
+    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
+  end # describe '#connection'
 
-  describe '#transfer!' do
-    let(:connection)  { mock('Fog::Storage') }
-    let(:directories) { mock('Fog::Storage::Ninefold::Directories') }
-    let(:directory)   { mock('Fog::Storage::Ninefold::Directory') }
-    let(:files)       { mock('Fog::Storage::Ninefold::Files') }
+  describe '#directory_for' do
+    let(:connection)  { mock }
+    let(:directories) { mock }
+    let(:directory)   { mock }
 
     before do
-      Fog::Storage.expects(:new).once.returns(connection)
+      storage.stubs(:connection).returns(connection)
       connection.stubs(:directories).returns(directories)
-      directory.stubs(:files).returns(files)
     end
 
-    context 'directory already exists' do
-      it 'should transfer the provided file to the directory' 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)
-
-        directories.expects(:get).with("backups/myapp/#{ Backup::TIME }").returns(directory)
-        files.expects(:create) do |options|
-          options[:key].should == "#{ Backup::TRIGGER }.tar"
-          options[:body].should == file
-        end
-
-        ninefold.send(:transfer!)
+    context 'when the directory for the remote_path exists' do
+      it 'should return the directory' do
+        directories.expects(:get).with('remote_path').returns(directory)
+        storage.send(:directory_for, 'remote_path').should be(directory)
       end
     end
 
-    context 'directory does not yet exist' do
-      it 'should transfer the provided file to the directory' 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)
-
-        directories.expects(:get).with("backups/myapp/#{ Backup::TIME }").returns(nil)
-        directories.expects(:create) { |options|
-          options[:key].should == "backups/myapp/#{ Backup::TIME }"
-        }.returns(directory)
+    context 'when the directory for the remote_path does not exist' do
+      before do
+        directories.expects(:get).with('remote_path').returns(nil)
+      end
 
-        files.expects(:create) do |options|
-          options[:key].should == "#{ Backup::TRIGGER }.tar"
-          options[:body].should == file
+      context 'when create is set to false' do
+        it 'should return nil' do
+          storage.send(:directory_for, 'remote_path').should be_nil
         end
+      end
 
-        ninefold.send(:transfer!)
+      context 'when create is set to true' do
+        it 'should create and return the directory' do
+          directories.expects(:create).with(:key => 'remote_path').returns(directory)
+          storage.send(:directory_for, 'remote_path', true).should be(directory)
+        end
       end
     end
-  end
+  end # describe '#directory_for'
 
-  describe '#remove!' do
-    let(:connection)  { mock('Fog::Storage') }
-    let(:directories) { mock('Fog::Storage::Ninefold::Directories') }
-    let(:directory)   { mock('Fog::Storage::Ninefold::Directory') }
-    let(:files)       { mock('Fog::Storage::Ninefold::Files') }
-    let(:file)        { mock('Fog::Storage::Ninefold::File') }
+  describe '#remote_path_for' do
+    let(:package) { mock }
 
     before do
-      Fog::Storage.expects(:new).once.returns(connection)
-      connection.stubs(:directories).returns(directories)
-      directory.stubs(:files).returns(files)
+      # for superclass method
+      package.expects(:trigger).returns('trigger')
+      package.expects(:time).returns('time')
     end
 
-    it 'should remove the file from the bucket' do
-      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)
+    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(:package) { mock }
+    let(:directory)       { mock }
+    let(:directory_files) { mock }
+    let(:file) { mock }
+    let(:s) { sequence '' }
 
-      ninefold.send(:remove!)
+    before do
+      storage.instance_variable_set(:@package, package)
+      storage.stubs(:storage_name).returns('Storage::Ninefold')
+      storage.stubs(:local_path).returns('/local/path')
+      directory.stubs(:files).returns(directory_files)
     end
 
-    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
+    it 'should transfer the package files' do
+      storage.expects(:remote_path_for).in_sequence(s).with(package).
+          returns('remote/path')
+      storage.expects(:directory_for).with('remote/path', true).returns(directory)
 
-      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"
+      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::Ninefold started transferring " +
+        "'2011.12.31.11.00.02.backup.tar.enc-aa'."
+      )
+      File.expects(:open).in_sequence(s).with(
+        File.join('/local/path', '2011.12.31.11.00.02.backup.tar.enc-aa'), 'r'
+      ).yields(file)
+      directory_files.expects(:create).in_sequence(s).with(
+        :key => 'backup.tar.enc-aa', :body => file
+      )
+      # second yield
+      Backup::Logger.expects(:message).in_sequence(s).with(
+        "Storage::Ninefold started transferring " +
+        "'2011.12.31.11.00.02.backup.tar.enc-ab'."
+      )
+      File.expects(:open).in_sequence(s).with(
+        File.join('/local/path', '2011.12.31.11.00.02.backup.tar.enc-ab'), 'r'
+      ).yields(file)
+      directory_files.expects(:create).in_sequence(s).with(
+        :key => 'backup.tar.enc-ab', :body => file
       )
 
+      storage.send(:transfer!)
     end
+  end # describe '#transfer!'
 
-    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
+  describe '#remove!' do
+    let(:package) { mock }
+    let(:directory)       { mock }
+    let(:directory_files) { mock }
+    let(:file) { mock }
+    let(:s) { sequence '' }
 
-      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}'"
+    before do
+      storage.stubs(:storage_name).returns('Storage::Ninefold')
+      directory.stubs(:files).returns(directory_files)
+    end
+
+    it 'should remove the package files' do
+      storage.expects(:remote_path_for).in_sequence(s).with(package).
+          returns('remote/path')
+      storage.expects(:directory_for).with('remote/path').returns(directory)
+
+      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::Ninefold started removing " +
+        "'2011.12.31.11.00.02.backup.tar.enc-aa' from Ninefold."
+      )
+      directory_files.expects(:get).in_sequence(s).
+          with('backup.tar.enc-aa').returns(file)
+      file.expects(:destroy).in_sequence(s)
+      # second yield
+      Backup::Logger.expects(:message).in_sequence(s).with(
+        "Storage::Ninefold started removing " +
+        "'2011.12.31.11.00.02.backup.tar.enc-ab' from Ninefold."
+      )
+      directory_files.expects(:get).in_sequence(s).
+          with('backup.tar.enc-ab').returns(file)
+      file.expects(:destroy).in_sequence(s)
 
+      directory.expects(:destroy).in_sequence(s)
+
+      expect do
+        storage.send(:remove!, package)
+      end.not_to raise_error
     end
-  end
+
+    context 'when the remote directory does not exist' do
+      it 'should raise an error' do
+        storage.expects(:remote_path_for).in_sequence(s).with(package).
+            returns('remote/path')
+        storage.expects(:directory_for).with('remote/path').returns(nil)
+
+        storage.expects(:transferred_files_for).never
+        directory_files.expects(:get).never
+        file.expects(:destroy).never
+        directory.expects(:destroy).never
+
+        expect do
+          storage.send(:remove!, package)
+        end.to raise_error {|err|
+          err.should be_an_instance_of Backup::Errors::Storage::Ninefold::NotFoundError
+          err.message.should == 'Storage::Ninefold::NotFoundError: ' +
+              "Directory at 'remote/path' not found"
+        }
+      end
+    end
+
+    context 'when remote files do not exist' do
+      it 'should collect their names and raise an error after proceeding' do
+        storage.expects(:remote_path_for).in_sequence(s).with(package).
+            returns('remote/path')
+        storage.expects(:directory_for).with('remote/path').returns(directory)
+
+        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'],
+          ['2011.12.31.11.00.02.backup.tar.enc-ac', 'backup.tar.enc-ac']
+        )
+        # first yield (file not found)
+        Backup::Logger.expects(:message).in_sequence(s).with(
+          "Storage::Ninefold started removing " +
+          "'2011.12.31.11.00.02.backup.tar.enc-aa' from Ninefold."
+        )
+        directory_files.expects(:get).in_sequence(s).
+            with('backup.tar.enc-aa').returns(nil)
+        # second yield (file found and removed)
+        Backup::Logger.expects(:message).in_sequence(s).with(
+          "Storage::Ninefold started removing " +
+          "'2011.12.31.11.00.02.backup.tar.enc-ab' from Ninefold."
+        )
+        directory_files.expects(:get).in_sequence(s).
+            with('backup.tar.enc-ab').returns(file)
+        file.expects(:destroy).in_sequence(s)
+        # third yield (file not found)
+        Backup::Logger.expects(:message).in_sequence(s).with(
+          "Storage::Ninefold started removing " +
+          "'2011.12.31.11.00.02.backup.tar.enc-ac' from Ninefold."
+        )
+        directory_files.expects(:get).in_sequence(s).
+            with('backup.tar.enc-ac').returns(nil)
+
+        # directory removed
+        directory.expects(:destroy).in_sequence(s)
+
+        expect do
+          storage.send(:remove!, package)
+        end.to raise_error {|err|
+          err.should be_an_instance_of Backup::Errors::Storage::Ninefold::NotFoundError
+          err.message.should == 'Storage::Ninefold::NotFoundError: ' +
+              "The following file(s) were not found in 'remote/path'\n" +
+              "  backup.tar.enc-aa\n  backup.tar.enc-ac"
+        }
+      end
+    end
+  end # describe '#remove!'
 
 end

data/spec/storage/rsync_spec.rb

@@ -3,261 +3,342 @@
 require File.expand_path('../../spec_helper.rb', __FILE__)
 
 describe Backup::Storage::RSync do
-
-  let(:rsync) do
-    Backup::Storage::RSync.new do |rsync|
+  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.port      = 22
-      rsync.path      = '~/backups/'
+      rsync.keep      = 5
     end
   end
 
-  before do
-    Backup::Configuration::Storage::RSync.clear_defaults!
-  end
-
-  it 'should have defined the configuration properly' do
-    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
+  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 use the defaults if a particular attribute has not been defined' do
-    Backup::Configuration::Storage::RSync.defaults do |rsync|
-      rsync.username = 'my_default_username'
-      rsync.password = 'my_default_password'
-      rsync.path     = '~/backups'
+    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
 
-    rsync = Backup::Storage::RSync.new do |rsync|
-      rsync.password = 'my_password'
-      rsync.ip       = '123.45.678.90'
+    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
 
-    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
+    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 have its own defaults' do
-    rsync = Backup::Storage::RSync.new
-    rsync.port.should  == 22
-    rsync.path.should  == 'backups'
-    rsync.local.should == false
-    rsync.send(:rsync_port).should == "-e 'ssh -p 22'"
-  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
 
-  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)
+        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'
 
-      rsync.perform!
-    end
+        storage.storage_id.should be_nil
+        storage.keep.should       == 'new_keep'
+      end
+    end # context 'when setting configuration defaults'
+
+  end # describe '#initialize'
 
-    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)
+  describe '#remote_path_for' do
+    let(:package) { mock }
+    before do
+      storage.instance_variable_set(:@package, package)
+      package.expects(:trigger).returns(model.trigger)
+    end
 
-      expect do
-        rsync.perform!
-      end.to raise_error
+    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
-    it 'should establish a connection to the remote server' do
-      connection = mock
+    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
+        '123.45.678.90', 'my_username', :password => 'my_password', :port => 22
       ).yields(connection)
 
-      rsync.send(:connection) do |ssh|
-        ssh.should be connection
+      storage.send(:connection) do |ssh|
+        ssh.should be(connection)
       end
     end
   end
 
   describe '#transfer!' do
-    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') }
+    let(:package) { mock }
+    let(:s) { sequence '' }
 
     before do
-      rsync.expects(:create_remote_directories!)
-      rsync.expects(:utility).returns('rsync')
-      Backup::Logger.expects(:message).with(
-        "Storage::RSync started transferring '#{rsync.filename}' to '#{rsync.ip}'."
-      )
+      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 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
+    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)
 
-        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}'"
-          )
+        storage.expects(:remote_path_for).in_sequence(s).with(package).
+            returns('remote/path')
 
-          rsync.send(:transfer!)
-        end
-      end
+        storage.expects(:create_remote_path!).in_sequence(s).with('remote/path')
 
-      context 'when no password is set' do
-        before { rsync.password = nil }
+        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') }'"
+        )
 
-        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}'"
-          )
+        storage.expects(:remove_password_file!).in_sequence(s)
 
-          rsync.send(:transfer!)
-        end
+        storage.send(:transfer!)
       end
 
-    end # context 'when performing a remote transfer'
+      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
 
-    context 'when performing a local transfer' do
-      before { rsync.local = true }
+        storage.expects(:remote_path_for).in_sequence(s).with(package).
+            returns('remote/path')
 
-      it 'should save a local copy of backups' do
-        rsync.expects(:run).with(
-          "rsync '#{local_file}' 'backups/#{remote_file}'"
+        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'."
         )
-        rsync.send(:transfer!)
+        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 performing a local transfer'
-  end
 
+    end # context 'when @local is set to true'
+
+  end # describe '#transfer!'
+
+  ##
+  # Note: Storage::RSync doesn't cycle
   describe '#remove!' do
-    it 'should return nil' do
-      rsync.send(:remove!).should == nil
+    it 'should never even be called' do
+      storage.send(:remove!).should be_nil
     end
   end
 
-  describe '#create_remote_directories!' do
+  describe '#create_remote_path!' do
+    let(:connection) { mock }
 
-    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}'")
+    context 'when @local is set to false' do
+      it 'should create the remote_path on the remote' do
+        FileUtils.expects(:mkdir_p).never
 
-        rsync.send(:create_remote_directories!)
+        storage.expects(:connection).yields(connection)
+        connection.expects(:exec!).with("mkdir -p 'remote/path'")
+
+        storage.send(:create_remote_path!, 'remote/path')
       end
     end
 
-    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
+    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')
 
-        rsync.send(:create_remote_directories!)
+        storage.send(:create_remote_path!, 'remote/path')
       end
     end
-
   end
 
   describe '#write_password_file!' do
+    let(:file) { mock }
 
-    before do
-      rsync.instance_variable_defined?(:@password_file).should be_false
-    end
+    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)
 
-    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'
+        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 { rsync.password = nil }
-      it 'should return nil' do
-        rsync.send(:write_password_file!).should be_nil
+    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 '#write_password_file!'
+  end
 
   describe '#remove_password_file!' do
-    let(:pwdfile) { mock }
+    let(:file) { 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!)
+      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 return nil' do
-        rsync.send(:remove_password_file!).should be_nil
+      it 'should do nothing' do
+        file.expects(:delete).never
+        storage.send(:remove_password_file!)
       end
     end
-
-  end # describe '#remove_password_file!'
+  end
 
   describe '#rsync_password_file' do
-    let(:pwdfile) { stub(:path => 'path/to/password/file') }
+    let(:file) { mock }
 
     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'"
+      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 a password is not set' do
+    context 'when @password_file is not set' do
       it 'should return nil' do
-        rsync.send(:rsync_password_file).should be_nil
+        storage.send(:rsync_password_file).should be_nil
       end
     end
-
-  end # describe '#password_file'
+  end
 
   describe '#rsync_port' do
-    it 'should return the port string for the rsync command' do
-      rsync.send(:rsync_port).should == "-e 'ssh -p 22'"
+    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 options string for the rsync command' do
-      rsync.send(:rsync_options).should == "-z"
+    it 'should return the syntax for rsync to set other options' do
+      storage.send(:rsync_options).should == '-z'
     end
   end