backup_checksum 3.0.23

data/spec/storage/dropbox_spec.rb

@@ -0,0 +1,370 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Backup::Storage::Dropbox do
+  let(:model)   { Backup::Model.new(:test_trigger, 'test label') }
+  let(:storage) do
+    Backup::Storage::Dropbox.new(model) do |db|
+      db.api_key      = 'my_api_key'
+      db.api_secret   = 'my_api_secret'
+      db.keep         = 5
+    end
+  end
+
+  describe '#initialize' do
+    it 'should set the correct values' do
+      storage.api_key.should      == 'my_api_key'
+      storage.api_secret.should   == 'my_api_secret'
+      storage.access_type.should  == :app_folder
+      storage.path.should         == 'backups'
+
+      storage.storage_id.should be_nil
+      storage.keep.should       == 5
+    end
+
+    it 'should set a storage_id if given' do
+      db = Backup::Storage::Dropbox.new(model, 'my storage_id')
+      db.storage_id.should == 'my storage_id'
+    end
+
+    context 'when setting configuration defaults' do
+      after { Backup::Configuration::Storage::Dropbox.clear_defaults! }
+
+      it 'should use the configured defaults' do
+        Backup::Configuration::Storage::Dropbox.defaults do |db|
+          db.api_key      = 'some_api_key'
+          db.api_secret   = 'some_api_secret'
+          db.access_type  = 'some_access_type'
+          db.path         = 'some_path'
+          db.keep         = 15
+        end
+        storage = Backup::Storage::Dropbox.new(model)
+        storage.api_key.should      == 'some_api_key'
+        storage.api_secret.should   == 'some_api_secret'
+        storage.access_type.should  == 'some_access_type'
+        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::Dropbox.defaults do |db|
+          db.api_key      = 'old_api_key'
+          db.api_secret   = 'old_api_secret'
+          db.access_type  = 'old_access_type'
+          db.path         = 'old_path'
+          db.keep         = 15
+        end
+        storage = Backup::Storage::Dropbox.new(model) do |db|
+          db.api_key      = 'new_api_key'
+          db.api_secret   = 'new_api_secret'
+          db.access_type  = 'new_access_type'
+          db.path         = 'new_path'
+          db.keep         = 10
+        end
+
+        storage.api_key.should      == 'new_api_key'
+        storage.api_secret.should   == 'new_api_secret'
+        storage.access_type.should  == 'new_access_type'
+        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 '#connection' do
+    let(:session)     { mock }
+    let(:client)      { mock }
+    let(:s)           { sequence '' }
+
+    context 'when a cached session exists' do
+      before do
+        storage.expects(:cached_session).in_sequence(s).returns(session)
+        storage.expects(:create_write_and_return_new_session!).never
+        DropboxClient.expects(:new).in_sequence(s).
+            with(session, :app_folder).returns(client)
+      end
+
+      it 'should use the cached session to create the client' do
+        storage.send(:connection).should be(client)
+      end
+
+      it 'should return an already existing client' do
+        storage.send(:connection).should be(client)
+        storage.send(:connection).should be(client)
+      end
+    end
+
+    context 'when a cached session does not exist' do
+      before do
+        storage.expects(:cached_session).in_sequence(s).returns(false)
+        Backup::Logger.expects(:message).in_sequence(s).with(
+          'Creating a new session!'
+        )
+        storage.expects(:create_write_and_return_new_session!).in_sequence(s).
+            returns(session)
+        DropboxClient.expects(:new).in_sequence(s).
+            with(session, :app_folder).returns(client)
+      end
+
+      it 'should create a new session and return the client' do
+        storage.send(:connection).should be(client)
+      end
+
+      it 'should return an already existing client' do
+        storage.send(:connection).should be(client)
+        storage.send(:connection).should be(client)
+      end
+    end
+
+    context 'when an error is raised creating a client for the session' do
+      it 'should wrap and raise the error' do
+        storage.stubs(:cached_session).returns(true)
+        DropboxClient.expects(:new).raises('error')
+
+        expect do
+          storage.send(:connection)
+        end.to raise_error {|err|
+          err.should be_an_instance_of(
+            Backup::Errors::Storage::Dropbox::ConnectionError
+          )
+          err.message.should ==
+              'Storage::Dropbox::ConnectionError: RuntimeError: error'
+        }
+      end
+    end
+
+  end # describe '#connection'
+
+  describe '#cached_session' do
+    let(:session) { mock }
+
+    context 'when a cached session file exists' do
+      before do
+        storage.expects(:cache_exists?).returns(true)
+        storage.expects(:cached_file).returns('cached_file')
+        File.expects(:read).with('cached_file').returns('yaml_data')
+      end
+
+      context 'when the cached session is successfully loaded' do
+        it 'should return the sesssion' do
+          DropboxSession.expects(:deserialize).with('yaml_data').
+              returns(session)
+          Backup::Logger.expects(:message).with(
+            'Session data loaded from cache!'
+          )
+
+          storage.send(:cached_session).should be(session)
+        end
+      end
+
+      context 'when errors occur loading the session' do
+        it 'should log a warning and return false' do
+          DropboxSession.expects(:deserialize).with('yaml_data').
+              raises('error message')
+          Backup::Logger.expects(:warn).with do |err|
+            err.should be_an_instance_of(
+              Backup::Errors::Storage::Dropbox::CacheError
+            )
+            err.message.should == 'Storage::Dropbox::CacheError: ' +
+                "Could not read session data from cache.\n" +
+                "  Cache data might be corrupt.\n" +
+                "  Reason: RuntimeError\n" +
+                "  error message"
+          end
+
+          expect do
+            storage.send(:cached_session).should be_false
+          end.not_to raise_error
+        end
+      end
+    end
+
+    context 'when a cached session file does not exist' do
+      before { storage.stubs(:cache_exists?).returns(false) }
+      it 'should return false' do
+        storage.send(:cached_session).should be_false
+      end
+    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::Dropbox')
+      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')
+      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::Dropbox 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)
+      connection.expects(:put_file).in_sequence(s).with(
+        File.join('remote/path', 'backup.tar.enc-aa'), file
+      )
+      # second yield
+      Backup::Logger.expects(:message).in_sequence(s).with(
+        "Storage::Dropbox 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)
+      connection.expects(:put_file).in_sequence(s).with(
+        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::Dropbox')
+      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')
+      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']
+      )
+      # after both yields
+      Backup::Logger.expects(:message).in_sequence(s).with(
+        "Storage::Dropbox started removing " +
+        "'2011.12.31.11.00.02.backup.tar.enc-aa' from Dropbox.\n" +
+        "Storage::Dropbox started removing " +
+        "'2011.12.31.11.00.02.backup.tar.enc-ab' from Dropbox."
+      )
+      connection.expects(:file_delete).in_sequence(s).with('remote/path')
+
+      storage.send(:remove!, package)
+    end
+  end # describe '#remove!'
+
+  describe '#cached_file' do
+    it 'should return the path to the cache file' do
+      storage.send(:cached_file).should ==
+          File.join(Backup::Config.cache_path, 'my_api_keymy_api_secret')
+    end
+  end
+
+  describe '#cache_exists?' do
+    it 'should check if #cached_file exists' do
+      storage.expects(:cached_file).returns('/path/to/cache_file')
+      File.expects(:exist?).with('/path/to/cache_file')
+
+      storage.send(:cache_exists?)
+    end
+  end
+
+  describe '#write_cache!' do
+    let(:session)     { mock }
+    let(:cache_file)  { mock }
+
+    it 'should write a serialized session to file' do
+      storage.expects(:cached_file).returns('/path/to/cache_file')
+      session.expects(:serialize).returns('serialized_data')
+
+      File.expects(:open).with('/path/to/cache_file', 'w').yields(cache_file)
+      cache_file.expects(:write).with('serialized_data')
+
+      storage.send(:write_cache!, session)
+    end
+  end
+
+  describe '#create_write_and_return_new_session!' do
+    let(:session)   { mock }
+    let(:template)  { mock }
+    let(:s)         { sequence '' }
+
+    before do
+      storage.stubs(:cached_file).returns('/path/to/cache_file')
+
+      DropboxSession.expects(:new).in_sequence(s).
+          with('my_api_key', 'my_api_secret').returns(session)
+      session.expects(:get_request_token).in_sequence(s)
+      Backup::Template.expects(:new).in_sequence(s).with(
+        {:session => session, :cached_file => '/path/to/cache_file'}
+      ).returns(template)
+      template.expects(:render).in_sequence(s).with(
+        'storage/dropbox/authorization_url.erb'
+      )
+      Timeout.expects(:timeout).in_sequence(s).with(180).yields
+      STDIN.expects(:gets).in_sequence(s)
+    end
+
+    context 'when session is authenticated' do
+      before do
+        session.expects(:get_access_token).in_sequence(s)
+      end
+
+      it 'should cache and return the new session' do
+        template.expects(:render).in_sequence(s).with(
+          'storage/dropbox/authorized.erb'
+        )
+        storage.expects(:write_cache!).in_sequence(s).with(session)
+        template.expects(:render).in_sequence(s).with(
+          'storage/dropbox/cache_file_written.erb'
+        )
+
+        storage.send(:create_write_and_return_new_session!).should be(session)
+      end
+    end
+
+    context 'when session is not authenticated' do
+      before do
+        session.expects(:get_access_token).in_sequence(s).raises('error message')
+      end
+
+      it 'should wrap and re-raise the error' do
+        template.expects(:render).with('storage/dropbox/authorized.erb').never
+        storage.expects(:write_cache!).never
+        template.expects(:render).with('storage/dropbox/cache_file_written.erb').never
+
+        expect do
+          storage.send(:create_write_and_return_new_session!)
+        end.to raise_error {|err|
+          err.should be_an_instance_of(
+            Backup::Errors::Storage::Dropbox::AuthenticationError
+          )
+          err.message.should == 'Storage::Dropbox::AuthenticationError: ' +
+              "Could not create or authenticate a new session\n" +
+              "  Reason: RuntimeError\n" +
+              "  error message"
+        }
+      end
+    end
+  end
+
+end

data/spec/storage/ftp_spec.rb

@@ -0,0 +1,247 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Backup::Storage::FTP do
+  let(:model)   { Backup::Model.new(:test_trigger, 'test label') }
+  let(:storage) do
+    Backup::Storage::FTP.new(model) do |ftp|
+      ftp.username     = 'my_username'
+      ftp.password     = 'my_password'
+      ftp.ip           = '123.45.678.90'
+      ftp.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         == 21
+      storage.path.should         == 'backups'
+      storage.passive_mode.should == false
+
+      storage.storage_id.should be_nil
+      storage.keep.should       == 5
+    end
+
+    it 'should set a storage_id if given' do
+      ftp = Backup::Storage::FTP.new(model, 'my storage_id')
+      ftp.storage_id.should == 'my storage_id'
+    end
+
+    it 'should remove any preceeding tilde and slash from the path' do
+      storage = Backup::Storage::FTP.new(model) do |ftp|
+        ftp.path = '~/my_backups/path'
+      end
+      storage.path.should == 'my_backups/path'
+    end
+
+    context 'when setting configuration defaults' do
+      after { Backup::Configuration::Storage::FTP.clear_defaults! }
+
+      it 'should use the configured defaults' do
+        Backup::Configuration::Storage::FTP.defaults do |ftp|
+          ftp.username     = 'some_username'
+          ftp.password     = 'some_password'
+          ftp.ip           = 'some_ip'
+          ftp.port         = 'some_port'
+          ftp.path         = 'some_path'
+          ftp.passive_mode = 'some_passive_mode'
+          ftp.keep         = 'some_keep'
+        end
+        storage = Backup::Storage::FTP.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.passive_mode.should == 'some_passive_mode'
+
+        storage.storage_id.should be_nil
+        storage.keep.should       == 'some_keep'
+      end
+
+      it 'should override the configured defaults' do
+        Backup::Configuration::Storage::FTP.defaults do |ftp|
+          ftp.username     = 'old_username'
+          ftp.password     = 'old_password'
+          ftp.ip           = 'old_ip'
+          ftp.port         = 'old_port'
+          ftp.path         = 'old_path'
+          ftp.passive_mode = 'old_passive_mode'
+          ftp.keep         = 'old_keep'
+        end
+        storage = Backup::Storage::FTP.new(model) do |ftp|
+          ftp.username     = 'new_username'
+          ftp.password     = 'new_password'
+          ftp.ip           = 'new_ip'
+          ftp.port         = 'new_port'
+          ftp.path         = 'new_path'
+          ftp.passive_mode = 'new_passive_mode'
+          ftp.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.passive_mode.should == 'new_passive_mode'
+
+        storage.storage_id.should be_nil
+        storage.keep.should       == 'new_keep'
+      end
+    end # context 'when setting configuration defaults'
+
+  end # describe '#initialize'
+
+  describe '#connection' do
+    let(:connection) { mock }
+
+    it 'should yield a connection to the remote server' do
+      Net::FTP.expects(:open).with(
+        '123.45.678.90', 'my_username', 'my_password'
+      ).yields(connection)
+
+      storage.send(:connection) do |ftp|
+        ftp.should be(connection)
+      end
+    end
+
+    it 'should set passive mode if @passive_mode is true' do
+      storage.passive_mode = true
+      Net::FTP.expects(:open).with(
+        '123.45.678.90', 'my_username', 'my_password'
+      ).yields(connection)
+      connection.expects(:passive=).with(true)
+
+      storage.send(:connection) do |ftp|
+        ftp.should be(connection)
+      end
+    end
+
+    it 'should set the Net::FTP_PORT constant' do
+      storage.port = 40
+      Net::FTP.expects(:const_defined?).with(:FTP_PORT).returns(true)
+      Net::FTP.expects(:send).with(:remove_const, :FTP_PORT)
+      Net::FTP.expects(:send).with(:const_set, :FTP_PORT, 40)
+
+      Net::FTP.expects(:open)
+      storage.send(:connection)
+    end
+
+  end # describe '#connection'
+
+  describe '#transfer!' do
+    let(:connection) { mock }
+    let(:package) { mock }
+    let(:s) { sequence '' }
+
+    before do
+      storage.instance_variable_set(:@package, package)
+      storage.stubs(:storage_name).returns('Storage::FTP')
+      storage.stubs(:local_path).returns('/local/path')
+      storage.stubs(:connection).yields(connection)
+    end
+
+    it 'should transfer the package files' do
+      storage.expects(:remote_path_for).in_sequence(s).with(package).
+          returns('remote/path')
+      storage.expects(:create_remote_path).in_sequence(s).with(
+        'remote/path', connection
+      )
+
+      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::FTP started transferring " +
+        "'2011.12.31.11.00.02.backup.tar.enc-aa' to '123.45.678.90'."
+      )
+      connection.expects(:put).in_sequence(s).with(
+        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::FTP started transferring " +
+        "'2011.12.31.11.00.02.backup.tar.enc-ab' to '123.45.678.90'."
+      )
+      connection.expects(:put).in_sequence(s).with(
+        File.join('/local/path', '2011.12.31.11.00.02.backup.tar.enc-ab'),
+        File.join('remote/path', 'backup.tar.enc-ab')
+      )
+
+      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::FTP')
+      storage.stubs(:connection).yields(connection)
+    end
+
+    it 'should remove the package files' do
+      storage.expects(:remote_path_for).in_sequence(s).with(package).
+          returns('remote/path')
+
+      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::FTP started removing " +
+        "'2011.12.31.11.00.02.backup.tar.enc-aa' from '123.45.678.90'."
+      )
+      connection.expects(:delete).in_sequence(s).with(
+        File.join('remote/path', 'backup.tar.enc-aa')
+      )
+      # second yield
+      Backup::Logger.expects(:message).in_sequence(s).with(
+        "Storage::FTP started removing " +
+        "'2011.12.31.11.00.02.backup.tar.enc-ab' from '123.45.678.90'."
+      )
+      connection.expects(:delete).in_sequence(s).with(
+        File.join('remote/path', 'backup.tar.enc-ab')
+      )
+
+      connection.expects(:rmdir).with('remote/path').in_sequence(s)
+
+      storage.send(:remove!, package)
+    end
+  end # describe '#remove!'
+
+  describe '#create_remote_path' do
+    let(:connection)  { mock }
+    let(:remote_path) { 'backups/folder/another_folder' }
+    let(:s) { sequence '' }
+
+    context 'while properly creating remote directories one by one' do
+      it 'should rescue any FTPPermErrors and continue' do
+        connection.expects(:mkdir).in_sequence(s).
+            with("backups").raises(Net::FTPPermError)
+        connection.expects(:mkdir).in_sequence(s).
+            with("backups/folder")
+        connection.expects(:mkdir).in_sequence(s).
+            with("backups/folder/another_folder")
+
+        expect do
+          storage.send(:create_remote_path, remote_path, connection)
+        end.not_to raise_error
+      end
+    end
+  end
+
+end