backup 2.4.5.1 → 3.0.0.build.0

data/spec/database/redis_spec.rb

@@ -0,0 +1,122 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Backup::Database::Redis do
+
+  before do
+    Backup::Database::Redis.any_instance.stubs(:load_defaults!)
+    Backup::Logger.stubs(:error)
+  end
+
+  let(:db) do
+    Backup::Database::Redis.new do |db|
+      db.name        = 'mydatabase'
+      db.path        = '/var/lib/redis/db/'
+      db.password    = 'secret'
+      db.host        =  'localhost'
+      db.port        = 123
+      db.socket      = '/redis.sock'
+      db.invoke_save = true
+
+      db.additional_options = ['--query']
+    end
+  end
+
+  describe '#new' do
+    it 'should read the adapter details correctly' do
+      db.name.should        == 'mydatabase'
+      db.password.should    == 'secret'
+      db.host.should        == 'localhost'
+      db.port.should        == 123
+      db.socket.should      == '/redis.sock'
+      db.invoke_save.should == true
+
+      db.additional_options.should == '--query'
+    end
+
+    it 'arrays should default to empty arrays when not specified' do
+      db = Backup::Database::Redis.new do |db|
+        db.name     = 'mydatabase'
+        db.password = 'secret'
+      end
+
+      db.additional_options.should == ""
+    end
+
+    it 'should ensure the directory is available' do
+      Backup::Database::Redis.any_instance.expects(:mkdir).with("#{Backup::TMP_PATH}/myapp/Redis")
+      Backup::Database::Redis.new {}
+    end
+  end
+
+  describe '#credential_options' do
+    it 'should return the mongo syntax for the credential options' do
+      db.credential_options.should == "-a 'secret'"
+    end
+  end
+
+  describe '#connectivity_options' do
+    it 'should return the redis syntax for the connectivity options' do
+      db.connectivity_options.should == "-h 'localhost' -p '123' -s '/redis.sock'"
+    end
+
+    it 'should return only the port' do
+      db = Backup::Database::Redis.new do |db|
+        db.host   = nil
+        db.port   = 123
+      end
+
+      db.connectivity_options.should == "-p '123'"
+    end
+  end
+
+  describe '#invoke_save!' do
+    it 'should return the full mongodump string' do
+      db.expects(:utility).with('redis-cli').returns('redis-cli')
+      db.expects(:run).with("redis-cli -a 'secret' -h 'localhost' -p '123' -s '/redis.sock' --query SAVE")
+      db.invoke_save!
+    end
+  end
+
+  describe '#copy!' do
+    it do
+      File.expects(:exist?).returns(true)
+      db.stubs(:utility).returns('cp')
+      db.expects(:run).with("cp '#{ File.join('/var/lib/redis/db/mydatabase.rdb') }' '#{ File.join(Backup::TMP_PATH, Backup::TRIGGER, 'Redis', 'mydatabase.rdb') }'")
+      db.copy!
+    end
+  end
+
+  describe '#perform!' do
+    before do
+      Backup::Logger.stubs(:message)
+      File.stubs(:exist?).returns(true)
+      db.stubs(:utility).returns('redis-cli')
+      db.stubs(:mkdir)
+      db.stubs(:run)
+    end
+
+    it 'should copy over without persisting (saving) first' do
+      db.invoke_save = nil
+      db.expects(:invoke_save!).never
+      db.expects(:copy!)
+
+      db.perform!
+    end
+
+    it 'should copy over after persisting (saving) the most recent updates' do
+      db.invoke_save = true
+      db.expects(:invoke_save!)
+      db.expects(:copy!)
+
+      db.perform!
+    end
+
+    it do
+      Backup::Logger.expects(:message).with("Backup::Database::Redis started dumping and archiving \"mydatabase\".")
+
+      db.perform!
+    end
+  end
+end

data/spec/encryptor/gpg_spec.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Backup::Encryptor::GPG do
+
+  let(:encryptor) do
+    Backup::Encryptor::GPG.new do |e|
+      e.key = <<-KEY
+        -----BEGIN PGP PUBLIC KEY BLOCK-----
+        Version: GnuPG v1.4.11 (Darwin)
+
+        mQENBE12G/8BCAC4mnlSMYMBwBYTHe5zURcnYYNCORPWOr0iXGiLWuKxYtrDQyLm
+        X2Nws44Iz7Wp7AuJRAjkitf1cRBgXyDu8wuogXO7JqPmtsUdBCABz9w5NH6IQjgR
+        WNa3g2n0nokA7Zr5FA4GXoEaYivfbvGiyNpd6P4okH+//G2p+3FIryu5xz+89D1b
+        =Yvhg
+        -----END PGP PUBLIC KEY BLOCK-----
+      KEY
+    end
+  end
+
+  context "when a block is provided" do
+    it do
+      key = <<-KEY
+        -----BEGIN PGP PUBLIC KEY BLOCK-----
+        Version: GnuPG v1.4.11 (Darwin)
+
+        mQENBE12G/8BCAC4mnlSMYMBwBYTHe5zURcnYYNCORPWOr0iXGiLWuKxYtrDQyLm
+        X2Nws44Iz7Wp7AuJRAjkitf1cRBgXyDu8wuogXO7JqPmtsUdBCABz9w5NH6IQjgR
+        WNa3g2n0nokA7Zr5FA4GXoEaYivfbvGiyNpd6P4okH+//G2p+3FIryu5xz+89D1b
+        =Yvhg
+        -----END PGP PUBLIC KEY BLOCK-----
+      KEY
+
+      encryptor.key.should == key.gsub(/^(\s|\t)+/, '')
+    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 = mock('TmpFile')
+      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

@@ -0,0 +1,102 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+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 == []
+    end
+
+    it do
+      encryptor.send(:options).should == "aes-256-cbc"
+    end
+  end
+
+  context "when a block is provided" do
+    let(:encryptor) do
+      Backup::Encryptor::OpenSSL.new do |e|
+        e.password = "my_secret_password"
+        e.salt     = true
+        e.base64   = 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']
+    end
+
+    it do
+      encryptor.send(:options).should == "aes-256-cbc -base64 -salt"
+    end
+  end
+
+  describe '#perform!' do
+    let(:encryptor) { Backup::Encryptor::OpenSSL.new }
+    before do
+      Backup::Model.extension = 'tar'
+      Backup::Logger.stubs(:message)
+      [: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 -in '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar") }' -out '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar.enc") }' -k ''")
+      encryptor.perform!
+    end
+
+    it do
+      encryptor = Backup::Encryptor::OpenSSL.new do |e|
+        e.password = "my_secret_password"
+        e.salt     = true
+        e.base64   = true
+      end
+      encryptor.stubs(:utility).returns(:openssl)
+      encryptor.expects(:run).with("openssl aes-256-cbc -base64 -salt -in '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar") }' -out '#{ File.join(Backup::TMP_PATH, "#{Backup::TIME}.#{Backup::TRIGGER}.tar.enc") }' -k 'my_secret_password'")
+      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
+
+    it do
+      encryptor.expects(:utility).with(:openssl)
+      encryptor.perform!
+    end
+
+    it do
+      Backup::Logger.expects(:message).with("Backup::Encryptor::OpenSSL started encrypting the archive.")
+      encryptor.perform!
+    end
+
+    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

data/spec/logger_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/spec_helper'
+require 'timecop'
+
+describe Backup::Logger do
+  before do
+    Timecop.freeze( Time.now )
+  end
+
+  context 'when logging regular messages' do
+    it do
+      Backup::Logger.expects(:puts).with("[#{ Time.now.strftime("%Y/%m/%d %H:%M:%S") }][\e[32mmessage\e[0m] This has been logged.")
+      File.expects(:open).with(File.join(Backup::LOG_PATH, 'backup.log'), 'a')
+
+      Backup::Logger.message "This has been logged."
+    end
+  end
+
+  context 'when logging error messages' do
+    it do
+      Backup::Logger.expects(:puts).with("[#{ Time.now.strftime("%Y/%m/%d %H:%M:%S") }][\e[31merror\e[0m] This has been logged.")
+      File.expects(:open).with(File.join(Backup::LOG_PATH, 'backup.log'), 'a')
+
+      Backup::Logger.error "This has been logged."
+    end
+  end
+
+  context 'when logging warn messages' do
+    it do
+      Backup::Logger.expects(:puts).with("[#{ Time.now.strftime("%Y/%m/%d %H:%M:%S") }][\e[33mwarning\e[0m] This has been logged.")
+      File.expects(:open).with(File.join(Backup::LOG_PATH, 'backup.log'), 'a')
+
+      Backup::Logger.warn "This has been logged."
+    end
+  end
+end

data/spec/model_spec.rb

@@ -0,0 +1,236 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Backup::Model do
+
+  before do
+    class Backup::Database::TestDatabase
+      def initialize(&block); end
+    end
+    class Backup::Storage::TestStorage
+      def initialize(&block); end
+    end
+    class Backup::Archive
+      def initialize(name, &block); end
+    end
+    class Backup::Compressor::Gzip
+      def initialize(&block); end
+    end
+    class Backup::Compressor::SevenZip
+      def initialize(&block); end
+    end
+    class Backup::Encryptor::OpenSSL
+      def initialize(&block); end
+    end
+    class Backup::Encryptor::GPG
+      def initialize(&block); end
+    end
+    class Backup::Notifier::TestMail
+      def initialize(&block); end
+    end
+  end
+
+  let(:model) { Backup::Model.new('mysql-s3', 'MySQL S3 Backup for MyApp') {} }
+
+  it do
+    Backup::Model.extension.should == 'tar'
+  end
+
+  it do
+    Backup::Model.new('foo', 'bar') {}
+    Backup::Model.extension.should == 'tar'
+  end
+
+  before do
+    Backup::Model.extension = 'tar'
+  end
+
+  it do
+    Backup::Model.new('blah', 'blah') {}
+    Backup::Model.extension.should == 'tar'
+  end
+
+  it do
+    Backup::Model.new('blah', 'blah') {}
+    Backup::Model.file.should == "#{ File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar") }"
+  end
+
+  it do
+    Backup::Model.new('blah', 'blah') {}
+    File.basename(Backup::Model.file).should == "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar"
+  end
+
+  it do
+    Backup::Model.new('blah', 'blah') {}
+    Backup::Model.tmp_path.should == File.join(Backup::TMP_PATH, Backup::TRIGGER)
+  end
+
+  it 'should create a new model with a trigger and label' do
+    model = Backup::Model.new('mysql-s3', 'MySQL S3 Backup for MyApp') {}
+    model.trigger.should == 'mysql-s3'
+    model.label.should == 'MySQL S3 Backup for MyApp'
+  end
+
+  it 'should have the time logged in the object' do
+    model = Backup::Model.new('mysql-s3', 'MySQL S3 Backup for MyApp') {}
+    model.time.should == Backup::TIME
+  end
+
+  describe '#extension' do
+    it 'should start out with just .tar before compression occurs' do
+      Backup::Model.extension.should == 'tar'
+    end
+  end
+
+  describe 'databases' do
+    it 'should add the mysql adapter to the array of databases to invoke' do
+      model = Backup::Model.new('mysql-s3', 'MySQL S3 Backup for MyApp') do
+        database('TestDatabase')
+      end
+
+      model.databases.count.should == 1
+    end
+
+    it 'should add 2 mysql adapters to the array of adapters to invoke' do
+      model = Backup::Model.new('mysql-s3', 'MySQL S3 Backup for MyApp') do
+        database('TestDatabase')
+        database('TestDatabase')
+      end
+
+      model.databases.count.should == 2
+    end
+  end
+
+  describe 'storages' do
+    it 'should add a storage to the array of storages to use' do
+      model = Backup::Model.new('mysql-s3', 'MySQL S3 Backup for MyApp') do
+        store_with('TestStorage')
+      end
+
+      model.storages.count.should == 1
+    end
+
+    it 'should add a storage to the array of storages to use' do
+      model = Backup::Model.new('mysql-s3', 'MySQL S3 Backup for MyApp') do
+        store_with('TestStorage')
+        store_with('TestStorage')
+      end
+
+      model.storages.count.should == 2
+    end
+  end
+
+  describe 'archives' do
+    it 'should add an archive to the array of archives to use' do
+      model = Backup::Model.new('mysql-s3', 'MySQL S3 Backup for MyApp') do
+        archive('my_archive')
+      end
+
+      model.archives.count.should == 1
+    end
+
+    it 'should add a storage to the array of storages to use' do
+      model = Backup::Model.new('mysql-s3', 'MySQL S3 Backup for MyApp') do
+        archive('TestStorage')
+        archive('TestStorage')
+      end
+
+      model.archives.count.should == 2
+    end
+  end
+
+  describe '#compress_with' do
+    it 'should add a compressor to the array of compressors to use' do
+      model = Backup::Model.new('mysql-s3', 'MySQL S3 Backup for MyApp') do
+        compress_with('Gzip')
+      end
+
+      model.compressors.count.should == 1
+    end
+
+    it 'should add a compressor to the array of compressors to use' do
+      model = Backup::Model.new('mysql-s3', 'MySQL S3 Backup for MyApp') do
+        compress_with('Gzip')
+        compress_with('SevenZip')
+      end
+
+      model.compressors.count.should == 2
+    end
+  end
+
+  describe '#encrypt_with' do
+    it 'should add a encryptor to the array of encryptors to use' do
+      model = Backup::Model.new('mysql-s3', 'MySQL S3 Backup for MyApp') do
+        encrypt_with('OpenSSL')
+      end
+
+      model.encryptors.count.should == 1
+    end
+
+    it 'should add a encryptor to the array of encryptors to use' do
+      model = Backup::Model.new('mysql-s3', 'MySQL S3 Backup for MyApp') do
+        encrypt_with('OpenSSL')
+        encrypt_with('GPG')
+      end
+
+      model.encryptors.count.should == 2
+    end
+  end
+
+  describe '#notify_by' do
+    it 'should add a notifier to the array of notifiers to use' do
+      model = Backup::Model.new('mysql-s3', 'MySQL S3 Backup for MyApp') do
+        notify_by('TestMail')
+      end
+
+      model.notifiers.count.should == 1
+    end
+
+    it 'should add a notifier to the array of notifiers to use' do
+      model = Backup::Model.new('mysql-s3', 'MySQL S3 Backup for MyApp') do
+        notify_by('TestMail')
+        notify_by('TestMail')
+      end
+
+      model.notifiers.count.should == 2
+    end
+  end
+
+  describe '#package!' do
+    before do
+      [:utility, :run].each { |method| model.stubs(method) }
+      Backup::Logger.stubs(:message)
+    end
+
+    it 'should package the folder' do
+      model.expects(:utility).with(:tar).returns(:tar)
+      model.expects(:run).with("tar -c -C '#{ Backup::TMP_PATH }' '#{ Backup::TRIGGER }' > '#{ File.join( Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar" ) }'")
+      model.send(:package!)
+    end
+
+    it 'should log' do
+      Backup::Logger.expects(:message).with("Backup started packaging everything to a single archive file.")
+      model.send(:package!)
+    end
+  end
+
+  describe '#clean!' do
+    before do
+      [:utility, :run, :rm].each { |method| model.stubs(method) }
+      Backup::Logger.stubs(:message)
+    end
+
+    it 'should remove the temporary files and folders that were created' do
+      model.expects(:utility).with(:rm).returns(:rm)
+      model.expects(:run).with("rm -rf '#{ File.join(Backup::TMP_PATH, Backup::TRIGGER) }' '#{ File.join(Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar") }'")
+      model.send(:clean!)
+    end
+
+    it do
+      Backup::Logger.expects(:message).with("Backup started cleaning up the temporary files.")
+      model.send(:clean!)
+    end
+  end
+
+end