backup 3.0.19 → 3.0.20

data/spec/storage/cloudfiles_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::CloudFiles do
 
@@ -45,16 +45,42 @@ describe Backup::Storage::CloudFiles do
     cf.path.should      == 'my/backups'
   end
 
+  describe '#perform' do
+    it 'should invoke transfer! and cycle!' do
+      cf.expects(:transfer!)
+      cf.expects(:cycle!)
+      cf.perform!
+    end
+  end
+
   describe '#connection' do
-    it 'should establish a connection to Rackspace Cloud Files. using the provided credentials' do
-      Fog::Storage.expects(:new).with({
-        :provider           => 'Rackspace',
-        :rackspace_username => 'my_username',
-        :rackspace_api_key  => 'my_api_key',
-        :rackspace_auth_url => 'lon.auth.api.rackspacecloud.com'
-      })
+    it 'should establish and re-use a connection to Rackspace Cloud Files' do
+      Fog::Storage.expects(:new).once.with({
+        :provider             => 'Rackspace',
+        :rackspace_username   => 'my_username',
+        :rackspace_api_key    => 'my_api_key',
+        :rackspace_auth_url   => 'lon.auth.api.rackspacecloud.com',
+        :rackspace_servicenet => false
+      }).returns(true)
 
       cf.send(:connection)
+      cf.send(:connection)
+    end
+
+    context 'with LAN (servicenet) enabled' do
+      it 'should establish and re-use a connection to Rackspace Cloud Files' do
+        Fog::Storage.expects(:new).once.with({
+          :provider             => 'Rackspace',
+          :rackspace_username   => 'my_username',
+          :rackspace_api_key    => 'my_api_key',
+          :rackspace_auth_url   => 'lon.auth.api.rackspacecloud.com',
+          :rackspace_servicenet => true
+        }).returns(true)
+
+        cf.servicenet = true
+        cf.send(:connection)
+        cf.send(:connection)
+      end
     end
   end
 
@@ -67,15 +93,14 @@ describe Backup::Storage::CloudFiles do
   describe '#transfer!' do
     let(:connection) { mock('Fog::Storage') }
     before do
-      Fog::Storage.stubs(:new).returns(connection)
+      Fog::Storage.expects(:new).once.returns(connection)
     end
 
     it 'should transfer the provided file to the container' do
       Backup::Model.new('blah', 'blah') {}
       file = mock("Backup::Storage::CloudFiles::File")
       File.expects(:open).with("#{File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER}")}.tar").returns(file)
-      cf.expects(:remote_file).returns("#{ Backup::TIME }.#{ Backup::TRIGGER }.tar").twice
-      connection.expects(:put_object).with('my_container', "backups/myapp/#{ Backup::TIME }.#{ Backup::TRIGGER }.tar", file)
+      connection.expects(:put_object).with('my_container', "backups/myapp/#{ Backup::TIME }/#{ Backup::TRIGGER }.tar", file)
       cf.send(:transfer!)
     end
   end
@@ -83,22 +108,13 @@ describe Backup::Storage::CloudFiles do
   describe '#remove!' do
     let(:connection) { mock('Fog::Storage') }
     before do
-      Fog::Storage.stubs(:new).returns(connection)
+      Fog::Storage.expects(:new).once.returns(connection)
     end
 
     it 'should remove the file from the container' do
-      cf.expects(:remote_file).returns("#{ Backup::TIME }.#{ Backup::TRIGGER }.tar")
-      connection.expects(:delete_object).with('my_container', "backups/myapp/#{ Backup::TIME }.#{ Backup::TRIGGER }.tar")
+      connection.expects(:delete_object).with('my_container', "backups/myapp/#{ Backup::TIME }/#{ Backup::TRIGGER }.tar")
       cf.send(:remove!)
     end
   end
 
-  describe '#perform' do
-    it 'should invoke transfer! and cycle!' do
-      cf.expects(:transfer!)
-      cf.expects(:cycle!)
-      cf.perform!
-    end
-  end
-
 end

data/spec/storage/dropbox_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::Dropbox do
 
@@ -54,28 +54,28 @@ describe Backup::Storage::Dropbox do
   end
 
   describe '#connection' do
-    context "when the session cache has not yet been written" do
-      before do
-        db.stubs(:gets)
-      end
+    before do
+      db.stubs(:gets)
+    end
 
+    context "when the session cache has not yet been written" do
       it do
         session = mock("Dropbox::Session")
         Dropbox::Session.expects(:new).with('my_api_key', 'my_secret').returns(session)
         session.expects(:mode=).with(:dropbox)
         session.expects(:authorize)
-        session.expects(:authorize_url)
         db.expects(:cache_exists?).returns(false)
         db.expects(:write_cache!).with(session)
+
+        template = Backup::Template.new(db.send(:binding))
+        Backup::Template.expects(:new).returns(template)
+
+        template.expects(:render).times(3)
         db.send(:connection)
       end
     end
 
     context "when the session cache has already been written" do
-      before do
-        db.stubs(:gets)
-      end
-
       it "should load the session from cache, instead of creating a new one" do
         db.expects(:cache_exists?).returns(true)
         File.expects(:read).with("#{ENV['HOME']}/Backup/.cache/my_api_keymy_secret").returns("foo")
@@ -107,14 +107,18 @@ describe Backup::Storage::Dropbox do
     end
 
     it do
-      Backup::Logger.expects(:message).with("Backup::Storage::Dropbox started transferring \"#{ Backup::TIME }.#{ Backup::TRIGGER }.tar\".")
+      Backup::Logger.expects(:message).with(
+        "Storage::Dropbox started transferring " +
+        "'#{ Backup::TIME }.#{ Backup::TRIGGER }.tar'."
+      )
       db.send(:transfer!)
     end
 
     it do
       connection.expects(:upload).with(
         File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar"),
-        File.join('backups', Backup::TRIGGER),
+        File.join('backups', Backup::TRIGGER, Backup::TIME),
+        :as      => "#{ Backup::TRIGGER }.tar",
         :timeout => db.timeout
       )
 
@@ -125,7 +129,7 @@ describe Backup::Storage::Dropbox do
   describe '#remove!' do
     it do
       connection.expects(:delete).with(
-        File.join('backups', Backup::TRIGGER, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar")
+        File.join('backups', Backup::TRIGGER, Backup::TIME)
       )
 
       db.send(:remove!)

data/spec/storage/ftp_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::FTP do
 
@@ -55,89 +55,179 @@ describe Backup::Storage::FTP do
     ftp.passive_mode.should == false
   end
 
+  describe '#perform' do
+    it 'should invoke transfer! and cycle!' do
+      ftp.expects(:transfer!)
+      ftp.expects(:cycle!)
+      ftp.perform!
+    end
+  end
+
   describe '#connection' do
-    let(:connection) { mock('Fog::Storage') }
+    let(:connection) { mock }
 
-    it 'should establish a connection to the remote server using the provided ip address and credentials' do
-      Net::FTP.expects(:new).with('123.45.678.90', 'my_username', 'my_password')
-      ftp.send(:connection)
-    end
+    it 'should establish a connection to the remote server' do
+      Net::FTP.expects(:open).with(
+        '123.45.678.90', 'my_username', 'my_password'
+      ).yields(connection)
 
-    it 'should re-define the Net::FTP port' do
-      Net::FTP.stubs(:new)
-      ftp.port = 40
-      ftp.send(:connection)
-      Net::FTP::FTP_PORT.should == 40
+      ftp.send(:connection) do |conn|
+        conn.should be connection
+      end
     end
 
     it 'configures net/ftp to use passive mode if passive_mode set to true' do
       ftp.passive_mode = true
-      Net::FTP.stubs(:new).returns(connection)
+      Net::FTP.expects(:open).with(
+        '123.45.678.90', 'my_username', 'my_password'
+      ).yields(connection)
       connection.expects(:passive=).with(true)
-      ftp.send(:connection)
+
+      ftp.send(:connection) do |conn|
+        conn.should be connection
+      end
     end
-  end
+
+    context 'when re-defining the Net::FTP port' do
+
+      def reset_ftp_port
+        if defined? Net::FTP::FTP_PORT
+          Net::FTP.send(:remove_const, :FTP_PORT)
+        end; Net::FTP.send(:const_set, :FTP_PORT, 21)
+      end
+
+      before { reset_ftp_port }
+      after  { reset_ftp_port }
+
+      it 'should re-define Net::FTP::FTP_PORT' do
+        Net::FTP.stubs(:open)
+        ftp.port = 40
+        ftp.send(:connection)
+        Net::FTP::FTP_PORT.should == 40
+      end
+
+    end
+
+  end # describe '#connection'
 
   describe '#transfer!' do
-    let(:connection) { mock('Fog::Storage') }
+    let(:connection) { mock }
 
     before do
-      Net::FTP.stubs(:new).returns(connection)
-      ftp.stubs(:create_remote_directories!)
+      ftp.stubs(:storage_name).returns('Storage::FTP')
     end
 
-    it 'should transfer the provided file to the path' do
-      Backup::Model.new('blah', 'blah') {}
-      file = mock("Backup::Storage::FTP::File")
+    context 'when file chunking is not used' do
+      it 'should create remote paths and transfer using a single connection' do
+        local_file  = "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar"
+        remote_file = "#{ Backup::TRIGGER }.tar"
 
-      ftp.expects(:create_remote_directories!)
-      connection.expects(:put).with(
-        File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar"),
-        File.join('backups/myapp', "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar")
-      )
+        ftp.expects(:connection).yields(connection)
+        ftp.expects(:create_remote_directories).with(connection)
 
-      ftp.send(:transfer!)
-    end
-  end
+        Backup::Logger.expects(:message).with(
+          "Storage::FTP started transferring '#{local_file}' to '#{ftp.ip}'."
+        )
 
-  describe '#remove!' do
-    let(:connection) { mock('Net::FTP') }
+        connection.expects(:put).with(
+          File.join(Backup::TMP_PATH, local_file),
+          File.join('backups/myapp', Backup::TIME, remote_file)
+        )
 
-    before do
-      Net::FTP.stubs(:new).returns(connection)
+        ftp.send(:transfer!)
+      end
     end
 
-    it 'should remove the file from the remote server path' do
-      connection.expects(:delete).with("backups/myapp/#{ Backup::TIME }.#{ Backup::TRIGGER }.tar")
-      ftp.send(:remove!)
+    context 'when file chunking is used' do
+      it 'should transfer all the provided files using a single connection' do
+        s = sequence ''
+
+        ftp.expects(:connection).in_sequence(s).yields(connection)
+        ftp.expects(:create_remote_directories).in_sequence(s).with(connection)
+
+        ftp.expects(:files_to_transfer).in_sequence(s).multiple_yields(
+          ['local_file1', 'remote_file1'], ['local_file2', 'remote_file2']
+        )
+
+        Backup::Logger.expects(:message).in_sequence(s).with(
+          "Storage::FTP started transferring 'local_file1' to '#{ftp.ip}'."
+        )
+        connection.expects(:put).in_sequence(s).with(
+          File.join(Backup::TMP_PATH, 'local_file1'),
+          File.join('backups/myapp', Backup::TIME, 'remote_file1')
+        )
+
+        Backup::Logger.expects(:message).in_sequence(s).with(
+          "Storage::FTP started transferring 'local_file2' to '#{ftp.ip}'."
+        )
+        connection.expects(:put).in_sequence(s).with(
+          File.join(Backup::TMP_PATH, 'local_file2'),
+          File.join('backups/myapp', Backup::TIME, 'remote_file2')
+        )
+
+        ftp.send(:transfer!)
+      end
     end
-  end
+  end # describe '#transfer'
 
-  describe '#create_remote_directories!' do
-    let(:connection) { mock('Net::FTP') }
+  describe '#remove!' do
+    it 'should remove all remote files with a single FTP connection' do
+      s = sequence ''
+      connection = mock
+      remote_path = "backups/myapp/#{ Backup::TIME }"
+      ftp.stubs(:storage_name).returns('Storage::FTP')
 
-    before do
-      Net::FTP.stubs(:new).returns(connection)
-    end
+      ftp.expects(:connection).in_sequence(s).yields(connection)
+
+      ftp.expects(:transferred_files).in_sequence(s).multiple_yields(
+        ['local_file1', 'remote_file1'], ['local_file2', 'remote_file2']
+      )
+
+      Backup::Logger.expects(:message).in_sequence(s).with(
+        "Storage::FTP started removing 'local_file1' from '#{ftp.ip}'."
+      )
+      connection.expects(:delete).in_sequence(s).with(
+        File.join(remote_path, 'remote_file1')
+      )
 
-    it 'should properly create remote directories one by one' do
-      ftp.path = '~/backups/some_other_folder/another_folder'
+      Backup::Logger.expects(:message).in_sequence(s).with(
+        "Storage::FTP started removing 'local_file2' from '#{ftp.ip}'."
+      )
+      connection.expects(:delete).in_sequence(s).with(
+        File.join(remote_path, 'remote_file2')
+      )
 
-      connection.expects(:mkdir).with('~')
-      connection.expects(:mkdir).with('~/backups')
-      connection.expects(:mkdir).with('~/backups/some_other_folder')
-      connection.expects(:mkdir).with('~/backups/some_other_folder/another_folder')
-      connection.expects(:mkdir).with('~/backups/some_other_folder/another_folder/myapp')
+      connection.expects(:rmdir).in_sequence(s).with(remote_path)
 
-      ftp.send(:create_remote_directories!)
+      ftp.send(:remove!)
     end
-  end
+  end # describe '#remove!'
 
-  describe '#perform' do
-    it 'should invoke transfer! and cycle!' do
-      ftp.expects(:transfer!)
-      ftp.expects(:cycle!)
-      ftp.perform!
+  describe '#create_remote_directories!' do
+    let(:connection) { mock }
+
+    context 'while properly creating remote directories one by one' do
+      it 'should rescue any FTPPermErrors' do
+        s = sequence ''
+        ftp.path = '~/backups/some_other_folder/another_folder'
+
+        connection.expects(:mkdir).in_sequence(s).
+            with("~").raises(Net::FTPPermError)
+        connection.expects(:mkdir).in_sequence(s).
+            with("~/backups").raises(Net::FTPPermError)
+        connection.expects(:mkdir).in_sequence(s).
+            with("~/backups/some_other_folder")
+        connection.expects(:mkdir).in_sequence(s).
+            with("~/backups/some_other_folder/another_folder")
+        connection.expects(:mkdir).in_sequence(s).
+            with("~/backups/some_other_folder/another_folder/myapp")
+        connection.expects(:mkdir).in_sequence(s).
+            with("~/backups/some_other_folder/another_folder/myapp/#{ Backup::TIME }")
+
+        expect do
+          ftp.send(:create_remote_directories, connection)
+        end.not_to raise_error
+      end
     end
   end
 

data/spec/storage/local_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::Local do
 
@@ -16,7 +16,7 @@ describe Backup::Storage::Local do
   end
 
   it 'should have defined the configuration properly' do
-    local.path.should == "#{ENV['HOME']}/backups/"
+    local.path.should == "#{ENV['HOME']}/backups"
     local.keep.should == 20
   end
 
@@ -50,7 +50,7 @@ describe Backup::Storage::Local do
 
       FileUtils.expects(:cp).with(
         File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar"),
-        File.join("#{ENV['HOME']}/backups/myapp", "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar")
+        File.join("#{ENV['HOME']}/backups/myapp", Backup::TIME, "#{ Backup::TRIGGER }.tar")
       )
 
       local.send(:transfer!)
@@ -59,15 +59,15 @@ describe Backup::Storage::Local do
 
   describe '#remove!' do
     it 'should remove the file from the remote server path' do
-      FileUtils.expects(:rm).with("#{ENV['HOME']}/backups/myapp/#{ Backup::TIME }.#{ Backup::TRIGGER }.tar")
+      FileUtils.expects(:rm_r).with("#{ENV['HOME']}/backups/myapp/#{ Backup::TIME }")
       local.send(:remove!)
     end
   end
 
-  describe '#create_remote_directories!' do
+  describe '#create_local_directories!' do
     it 'should properly create remote directories one by one' do
       local.path = "#{ENV['HOME']}/backups/some_other_folder/another_folder"
-      FileUtils.expects(:mkdir_p).with("#{ENV['HOME']}/backups/some_other_folder/another_folder/myapp")
+      FileUtils.expects(:mkdir_p).with("#{ENV['HOME']}/backups/some_other_folder/another_folder/myapp/#{ Backup::TIME }")
       local.send(:create_local_directories!)
     end
   end