backup 3.0.2 → 3.0.3.build.0

data/spec/database/redis_spec.rb

@@ -1,122 +0,0 @@
-# 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

@@ -1,57 +0,0 @@
-# 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

@@ -1,102 +0,0 @@
-# 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

@@ -1,37 +0,0 @@
-# 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

@@ -1,236 +0,0 @@
-# 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