alg-backup 3.0.10

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

data/spec/notifier/mail_spec.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Backup::Notifier::Mail do
+  let(:notifier) do
+    Backup::Notifier::Mail.new do |mail|
+      mail.from                 = 'my.sender.email@gmail.com'
+      mail.to                   = 'my.receiver.email@gmail.com'
+      mail.address              = 'smtp.gmail.com'
+      mail.port                 = 587
+      mail.domain               = 'your.host.name'
+      mail.user_name            = 'user'
+      mail.password             = 'secret'
+      mail.authentication       = 'plain'
+      mail.enable_starttls_auto = true
+    end
+  end
+
+  it do
+    notifier.from.should                 == 'my.sender.email@gmail.com'
+    notifier.to.should                   == 'my.receiver.email@gmail.com'
+    notifier.address.should              == 'smtp.gmail.com'
+    notifier.port.should                 == 587
+    notifier.domain.should               == 'your.host.name'
+    notifier.user_name.should            == 'user'
+    notifier.password.should             == 'secret'
+    notifier.authentication.should       == 'plain'
+    notifier.enable_starttls_auto.should == true
+
+    notifier.on_success.should == true
+    notifier.on_failure.should == true
+  end
+
+  describe 'defaults' do
+    it do
+      Backup::Configuration::Notifier::Mail.defaults do |mail|
+        mail.to         = 'some.receiver.email@gmail.com'
+        mail.on_success = false
+        mail.on_failure = true
+      end
+      notifier = Backup::Notifier::Mail.new do |mail|
+        mail.from = 'my.sender.email@gmail.com'
+      end
+
+      notifier.to.should   == 'some.receiver.email@gmail.com'
+      notifier.from.should == 'my.sender.email@gmail.com'
+      notifier.on_success.should == false
+      notifier.on_failure.should == true
+    end
+  end
+
+  describe '#initialize' do
+    it do
+      Backup::Notifier::Mail.any_instance.expects(:set_defaults!)
+      Backup::Notifier::Mail.new
+    end
+  end
+
+  describe '#perform!' do
+    let(:model) { Backup::Model.new('blah', 'blah') {} }
+    before do
+      notifier.on_success = false
+      notifier.on_failure = false
+    end
+
+    context "when successful" do
+      it do
+        Backup::Logger.expects(:message).with("Backup::Notifier::Mail started notifying about the process.")
+        notifier.expects("notify_success!")
+        notifier.on_success = true
+        notifier.perform!(model)
+      end
+
+      it do
+        notifier.expects("notify_success!").never
+        notifier.on_success = false
+        notifier.perform!(model)
+      end
+    end
+
+    context "when failed" do
+      it do
+        Backup::Logger.expects(:message).with("Backup::Notifier::Mail started notifying about the process.")
+        notifier.expects("notify_failure!")
+        notifier.on_failure = true
+        notifier.perform!(model, Exception.new)
+      end
+
+      it do
+        notifier.expects("notify_failure!").never
+        notifier.on_failure = false
+        notifier.perform!(model, Exception.new)
+      end
+    end
+  end
+end

data/spec/notifier/twitter_spec.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Backup::Notifier::Twitter do
+  let(:notifier) do
+    Backup::Notifier::Twitter.new do |twitter|
+      twitter.consumer_key       = 'consumer_key'
+      twitter.consumer_secret    = 'consumer_secret'
+      twitter.oauth_token        = 'oauth_token'
+      twitter.oauth_token_secret = 'oauth_token_secret'
+    end
+  end
+
+  it do
+    notifier.consumer_key.should       == 'consumer_key'
+    notifier.consumer_secret.should    == 'consumer_secret'
+    notifier.oauth_token.should        == 'oauth_token'
+    notifier.oauth_token_secret.should == 'oauth_token_secret'
+
+    notifier.on_success.should == true
+    notifier.on_failure.should == true
+  end
+
+  describe 'defaults' do
+    it do
+      Backup::Configuration::Notifier::Twitter.defaults do |twitter|
+        twitter.consumer_key = 'new_consumer_key'
+        twitter.on_success   = false
+        twitter.on_failure   = true
+      end
+      notifier = Backup::Notifier::Twitter.new do |twitter|
+        twitter.consumer_key = 'my_own_consumer_key'
+      end
+
+      notifier.consumer_key.should   == 'my_own_consumer_key'
+      notifier.on_success.should == false
+      notifier.on_failure.should == true
+    end
+  end
+
+  describe '#initialize' do
+    it do
+      Backup::Notifier::Twitter.any_instance.expects(:set_defaults!)
+      Backup::Notifier::Twitter.new
+    end
+  end
+
+  describe '#perform!' do
+    let(:model) { Backup::Model.new('blah', 'blah') {} }
+    before do
+      notifier.on_success = false
+      notifier.on_failure = false
+    end
+
+    context "when successful" do
+      it do
+        Backup::Logger.expects(:message).with("Backup::Notifier::Twitter started notifying about the process.")
+        notifier.expects("notify_success!")
+        notifier.on_success = true
+        notifier.perform!(model)
+      end
+
+      it do
+        notifier.expects("notify_success!").never
+        notifier.on_success = false
+        notifier.perform!(model)
+      end
+    end
+
+    context "when failed" do
+      it do
+        Backup::Logger.expects(:message).with("Backup::Notifier::Twitter started notifying about the process.")
+        notifier.expects("notify_failure!")
+        notifier.on_failure = true
+        notifier.perform!(model, Exception.new)
+      end
+
+      it do
+        notifier.expects("notify_failure!").never
+        notifier.on_failure = false
+        notifier.perform!(model, Exception.new)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+##
+# Load Backup
+require File.expand_path( '../../lib/backup', __FILE__ )
+
+##
+# Use Mocha to mock with RSpec
+RSpec.configure do |config|
+  config.mock_with :mocha
+end
+
+# FIXTURES_PATH = File.join( File.dirname(__FILE__), 'fixtures' )
+
+Backup.send(:remove_const, :TRIGGER) if defined? Backup::TRIGGER
+Backup.send(:remove_const, :TIME) if defined? Backup::TIME
+
+module Backup
+  TRIGGER = 'myapp'
+  TIME = Time.now.strftime("%Y.%m.%d.%H.%M.%S")
+end

data/spec/storage/base_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Backup::Storage::Base do
+  let(:base) { Backup::Storage::Base.new }
+
+  before do
+    Backup::Logger.stubs(:message)
+  end
+
+  it do
+    storage_object = mock
+    Backup::Storage::Object.expects(:new).with('Base').returns(storage_object)
+    storage_object.stubs(:load).returns([])
+    storage_object.expects(:write)
+    base.keep = 1
+    base.cycle!
+  end
+
+  it do
+    base.keep = 3
+    storage_object = mock
+    objects = %w[1 2 3 4].map { Backup::Storage::Base.new }
+
+    Backup::Storage::Object.expects(:new).with('Base').returns(storage_object)
+    storage_object.stubs(:load).returns(objects)
+    storage_object.expects(:write)
+    Backup::Storage::Base.any_instance.expects(:remove!).times(2)
+
+    base.cycle!
+  end
+end