backup 3.0.20 → 3.0.21

data/spec/dependency_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require File.expand_path('../spec_helper.rb', __FILE__)
+
+describe Backup::Dependency do
+  before do
+    Backup::Dependency.stubs(:all).returns(
+      'net-sftp' => {
+        :require => 'net/sftp',
+        :version => '~> 2.0.5',
+        :for     => 'SFTP Protocol (SFTP Storage)'
+    })
+  end
+
+  describe ".load" do
+    it "should load and require given dependency" do
+      Backup::Dependency.expects(:gem).with("net-sftp", "~> 2.0.5")
+      Backup::Dependency.expects(:require).with("net/sftp")
+      Backup::Dependency.load("net-sftp")
+    end
+
+    context "on a missing dependency" do
+      before do
+        Backup::Dependency.stubs(:gem).raises(LoadError)
+      end
+
+      it "should display error message" do
+        Backup::Logger.expects(:error).with do |exception|
+          exception.message.should == "Dependency::LoadError: Dependency missing
+  Dependency required for:
+  SFTP Protocol (SFTP Storage)
+  To install the gem, issue the following command:
+  > gem install net-sftp -v '~> 2.0.5'
+  Please try again after installing the missing dependency."
+        end
+
+        expect do
+          Backup::Dependency.load("net-sftp")
+        end.to raise_error(SystemExit)
+      end
+
+      it "should exit with status code 1" do
+        expect do
+          Backup::Dependency.load("net-sftp")
+        end.to raise_error { |exit| exit.status.should be(1) }
+      end
+    end
+  end
+end

data/spec/encryptor/base_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe Backup::Encryptor::Base do
+  let(:base) { Backup::Encryptor::Base.new }
+
+  describe '#initialize' do
+    it 'should load defaults' do
+      Backup::Encryptor::Base.any_instance.expects(:load_defaults!)
+      base
+    end
+  end
+
+  describe '#encryptor_name' do
+    it 'should return class name with Backup namespace removed' do
+      base.send(:encryptor_name).should == 'Encryptor::Base'
+    end
+  end
+
+  describe '#log!' do
+    it 'should log a message' do
+      base.expects(:encryptor_name).returns('Encryptor Name')
+      Backup::Logger.expects(:message).with(
+        'Using Encryptor Name to encrypt the archive.'
+      )
+      base.send(:log!)
+    end
+  end
+end

data/spec/encryptor/gpg_spec.rb

@@ -3,12 +3,113 @@
 require File.expand_path('../../spec_helper.rb', __FILE__)
 
 describe Backup::Encryptor::GPG do
-
   let(:encryptor) do
     Backup::Encryptor::GPG.new do |e|
-      e.key = <<-KEY
+      e.key = 'gpg_key'
+    end
+  end
+
+  describe '#initialize' do
+    it 'should read the adapter details correctly' do
+      encryptor.key.should == 'gpg_key'
+    end
+
+    context 'when options are not set' do
+      it 'should use default values' do
+        encryptor = Backup::Encryptor::GPG.new
+        encryptor.key.should be_nil
+      end
+    end
+
+    context 'when configuration defaults have been set' do
+      after { Backup::Configuration::Encryptor::GPG.clear_defaults! }
+
+      it 'should use configuration defaults' do
+        Backup::Configuration::Encryptor::GPG.defaults do |encryptor|
+          encryptor.key = 'my_key'
+        end
+
+        encryptor = Backup::Encryptor::GPG.new
+        encryptor.key.should == 'my_key'
+      end
+    end
+  end # describe '#initialize'
+
+  describe '#encrypt_with' do
+    it 'should yield the encryption command and extension' do
+      encryptor.expects(:log!)
+      encryptor.expects(:extract_encryption_key_email!)
+      encryptor.expects(:utility).with(:gpg).returns('gpg')
+      encryptor.expects(:options).returns('command options')
+
+      encryptor.encrypt_with do |command, ext|
+        command.should == 'gpg command options'
+        ext.should == '.gpg'
+      end
+    end
+  end
+
+  describe '#extract_encryption_key_email!' do
+    it 'should extract the encryption_key_email' do
+      encryptor.expects(:utility).with(:gpg).returns('gpg')
+      encryptor.expects(:with_tmp_key_file).yields('/path/to/tmpfile')
+      encryptor.expects(:run).with("gpg --import '/path/to/tmpfile' 2>&1").
+        returns('gpg: key A1B2C3D4: "User Name (Comment) <user@host>" not changed')
+
+      encryptor.send(:extract_encryption_key_email!)
+      encryptor.instance_variable_get(:@encryption_key_email).should == 'user@host'
+    end
+
+    it 'should use the cached key email if already extracted' do
+      encryptor.instance_variable_set(:@encryption_key_email, 'foo@host')
+      encryptor.expects(:utility).never
+      encryptor.expects(:with_tmp_key_file).never
+      encryptor.expects(:run).never
+
+      encryptor.send(:extract_encryption_key_email!)
+    end
+  end
+
+  describe '#options' do
+    it 'should return the option string for the gpg command' do
+      encryptor.instance_variable_set(:@encryption_key_email, 'user@host')
+      encryptor.send(:options).should == "-e --trust-model always -r 'user@host'"
+    end
+  end
+
+  describe '#with_tmp_key_file' do
+    let(:tmp_file) { mock }
+    let(:s) { sequence '' }
+
+    before do
+      tmp_file.stubs(:path).returns('/path/to/tmp_file')
+      encryptor.stubs(:encryption_key).returns('provided key')
+    end
+
+    it 'should provide a tempfile with the provided key' do
+      Tempfile.expects(:new).in_sequence(s).
+          with('backup.pub').
+          returns(tmp_file)
+      FileUtils.expects(:chown).in_sequence(s).
+          with(Backup::Config.user, nil, '/path/to/tmp_file')
+      FileUtils.expects(:chmod).in_sequence(s).
+          with(0600, '/path/to/tmp_file')
+      tmp_file.expects(:write).in_sequence(s).
+          with('provided key')
+      tmp_file.expects(:close).in_sequence(s)
+      tmp_file.expects(:delete).in_sequence(s)
+
+      encryptor.send(:with_tmp_key_file) do |tmp_file|
+        tmp_file.should == '/path/to/tmp_file'
+      end
+    end
+  end
+
+  describe '#encryption_key' do
+    it 'should strip leading whitespace from the given key' do
+      encryptor.key = <<-KEY
         -----BEGIN PGP PUBLIC KEY BLOCK-----
-        Version: GnuPG v1.4.11 (Darwin)
+        \tVersion: GnuPG v1.4.11 (Darwin)
 
         mQENBE12G/8BCAC4mnlSMYMBwBYTHe5zURcnYYNCORPWOr0iXGiLWuKxYtrDQyLm
         X2Nws44Iz7Wp7AuJRAjkitf1cRBgXyDu8wuogXO7JqPmtsUdBCABz9w5NH6IQjgR
@@ -16,12 +117,8 @@ describe Backup::Encryptor::GPG do
         =Yvhg
         -----END PGP PUBLIC KEY BLOCK-----
       KEY
-    end
-  end
 
-  context "when a block is provided" do
-    it "should strip initial whitespace from key lines" do
-      key = <<-KEY
+      encryptor.send(:encryption_key).should == <<-KEY
 -----BEGIN PGP PUBLIC KEY BLOCK-----
 Version: GnuPG v1.4.11 (Darwin)
 
@@ -31,27 +128,7 @@ WNa3g2n0nokA7Zr5FA4GXoEaYivfbvGiyNpd6P4okH+//G2p+3FIryu5xz+89D1b
 =Yvhg
 -----END PGP PUBLIC KEY BLOCK-----
       KEY
-
-      encryptor.key.should == key
     end
   end
 
-  describe '#options' do
-    it do
-      encryptor.expects(:encryption_key_id).returns('secret')
-      encryptor.send(:options).should == "-e --trust-model always -r 'secret'"
-    end
-  end
-
-  describe '#write_tmp_file!' do
-    it do
-      tmp_file = Tempfile.new("foo")
-      Tempfile.expects(:new).returns(tmp_file)
-      tmp_file.expects(:write).with('secret')
-      tmp_file.expects(:close)
-
-      encryptor.key = 'secret'
-      encryptor.send(:write_tmp_file!)
-    end
-  end
 end

data/spec/encryptor/open_ssl_spec.rb

@@ -3,156 +3,127 @@
 require File.expand_path('../../spec_helper.rb', __FILE__)
 
 describe Backup::Encryptor::OpenSSL do
-
-  context "when no block is provided" do
-    let(:encryptor) { Backup::Encryptor::OpenSSL.new }
-
-    it do
-      encryptor.password.should == nil
-    end
-
-    it do
-      encryptor.send(:base64).should == []
-    end
-
-    it do
-      encryptor.send(:salt).should == []
+  let(:encryptor) do
+    Backup::Encryptor::OpenSSL.new do |e|
+      e.password      = 'mypassword'
+      e.password_file = '/my/password/file'
+      e.base64        = true
+      e.salt          = true
     end
+  end
 
-    it do
-      encryptor.send(:pass).should == ["-k ''"]
+  describe '#initialize' do
+    it 'should read the adapter details correctly' do
+      encryptor.password.should       == 'mypassword'
+      encryptor.password_file.should  == '/my/password/file'
+      encryptor.base64.should         == true
+      encryptor.salt.should           == true
     end
 
-    it do
-      encryptor.send(:options).should == "aes-256-cbc -k ''"
+    context 'when options are not set' do
+      it 'should use default values' do
+        encryptor = Backup::Encryptor::OpenSSL.new
+        encryptor.password.should       be_nil
+        encryptor.password_file.should  be_nil
+        encryptor.base64.should         be_false
+        encryptor.salt.should           be_true
+      end
     end
-  end
 
-  context "when a block is provided" do
+    context 'when configuration defaults have been set' do
+      after { Backup::Configuration::Encryptor::OpenSSL.clear_defaults! }
 
-    context "with a password" do
-      let(:encryptor) do
-        Backup::Encryptor::OpenSSL.new do |e|
-          e.password = "my_secret_password"
-          e.salt     = true
-          e.base64   = true
+      it 'should use configuration defaults' do
+        Backup::Configuration::Encryptor::OpenSSL.defaults do |encryptor|
+          encryptor.password      = 'my_password'
+          encryptor.password_file = '/my_password/file'
+          encryptor.base64        = true
+          encryptor.salt          = true
         end
-      end
-
-      it do
-        encryptor.password.should == "my_secret_password"
-      end
-
-      it do
-        encryptor.send(:salt).should == ['-salt']
-      end
 
-      it do
-        encryptor.send(:base64).should == ['-base64']
+        encryptor = Backup::Encryptor::OpenSSL.new
+        encryptor.password.should       == 'my_password'
+        encryptor.password_file.should  == '/my_password/file'
+        encryptor.base64.should         == true
+        encryptor.salt.should           == true
       end
+    end
+  end # describe '#initialize'
 
-      it do
-        encryptor.send(:pass).should == ["-k 'my_secret_password'"]
-      end
+  describe '#encrypt_with' do
+    it 'should yield the encryption command and extension' do
+      encryptor.expects(:log!)
+      encryptor.expects(:utility).with(:openssl).returns('openssl_cmd')
+      encryptor.expects(:options).returns('cmd_options')
 
-      it do
-        encryptor.send(:options).should == "aes-256-cbc -base64 -salt -k 'my_secret_password'"
+      encryptor.encrypt_with do |command, ext|
+        command.should == 'openssl_cmd cmd_options'
+        ext.should == '.enc'
       end
     end
+  end
 
-    context "with a password file" do
-      let(:encryptor) do
-        Backup::Encryptor::OpenSSL.new do |e|
-          e.password_file = "/path/to/password/file"
-          e.salt     = true
-          e.base64   = true
-        end
-      end
+  describe '#options' do
+    let(:encryptor) { Backup::Encryptor::OpenSSL.new }
 
-      it do
-        encryptor.password.should == nil
-      end
+    before do
+      # salt is true by default
+      encryptor.salt = false
+    end
 
-      it do
-        encryptor.password_file.should == "/path/to/password/file"
+    context 'with no options given' do
+      it 'should always include cipher command' do
+        encryptor.send(:options).should match(/^aes-256-cbc\s.*$/)
       end
 
-      it do
-        encryptor.send(:salt).should == ['-salt']
+      it 'should add #password option whenever #password_file not given' do
+        encryptor.send(:options).should ==
+            "aes-256-cbc -k ''"
       end
+    end
 
-      it do
-        encryptor.send(:base64).should == ['-base64']
-      end
+    context 'when #password_file is given' do
+      before { encryptor.password_file = 'password_file' }
 
-      it do
-        encryptor.send(:pass).should == ['-pass file:/path/to/password/file']
+      it 'should add #password_file option' do
+        encryptor.send(:options).should ==
+            'aes-256-cbc -pass file:password_file'
       end
 
-      it do
-        encryptor.send(:options).should == "aes-256-cbc -base64 -salt -pass file:/path/to/password/file"
+      it 'should add #password_file option even when #password given' do
+        encryptor.password = 'password'
+        encryptor.send(:options).should ==
+            'aes-256-cbc -pass file:password_file'
       end
     end
 
-  end
-
-  describe '#perform!' do
-    let(:encryptor) { Backup::Encryptor::OpenSSL.new }
-    before do
-      Backup::Model.extension = 'tar'
-      [:utility, :run, :rm].each { |method| encryptor.stubs(method) }
-    end
-
-    it do
-      encryptor = Backup::Encryptor::OpenSSL.new
-      encryptor.expects(:utility).returns(:openssl)
-      encryptor.expects(:run).with("openssl aes-256-cbc -k '' -in '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar") }' -out '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar.enc") }'")
-      encryptor.perform!
-    end
+    context 'when #password is given (without #password_file given)' do
+      before { encryptor.password = 'password' }
 
-    it do
-      encryptor = Backup::Encryptor::OpenSSL.new do |e|
-        e.password = "my_secret_password"
-        e.salt     = true
-        e.base64   = true
+      it 'should include the given password in the #password option' do
+        encryptor.send(:options).should ==
+            "aes-256-cbc -k 'password'"
       end
-      encryptor.stubs(:utility).returns(:openssl)
-      encryptor.expects(:run).with("openssl aes-256-cbc -base64 -salt -k 'my_secret_password' -in '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar") }' -out '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar.enc") }'")
-      encryptor.perform!
     end
 
-    it do
-      encryptor = Backup::Encryptor::OpenSSL.new do |e|
-        e.password_file = "/path/to/password/file"
-        e.salt     = true
-        e.base64   = true
+    context 'when #base64 is true' do
+      before { encryptor.base64 = true }
+
+      it 'should add the option' do
+        encryptor.send(:options).should ==
+            "aes-256-cbc -base64 -k ''"
       end
-      encryptor.stubs(:utility).returns(:openssl)
-      encryptor.expects(:run).with("openssl aes-256-cbc -base64 -salt -pass file:/path/to/password/file -in '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar") }' -out '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar.enc") }'")
-      encryptor.perform!
     end
 
-    it 'should append the .enc extension after the encryption' do
-      Backup::Model.extension.should == 'tar'
-      encryptor.perform!
-      Backup::Model.extension.should == 'tar.enc'
-    end
+    context 'when #salt is true' do
+      before { encryptor.salt = true }
 
-    it do
-      encryptor.expects(:utility).with(:openssl)
-      encryptor.perform!
+      it 'should add the option' do
+        encryptor.send(:options).should ==
+            "aes-256-cbc -salt -k ''"
+      end
     end
 
-    it do
-      Backup::Logger.expects(:message).with("Backup::Encryptor::OpenSSL started encrypting the archive.")
-      encryptor.perform!
-    end
+  end # describe '#options'
 
-    context "after encrypting the file (which creates a new file)" do
-      it 'should remove the non-encrypted file' do
-        encryptor.expects(:rm).with(Backup::Model.file)
-        encryptor.perform!
-      end
-    end
-  end
 end