interu-backup 3.0.16

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,58 @@
+# 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
+
+  context 'when logging silent messages' do
+    it do
+      Backup::Logger.expects(:puts).never
+      File.expects(:open).with(File.join(Backup::LOG_PATH, 'backup.log'), 'a')
+
+      Backup::Logger.silent "This has been logged."
+    end
+  end
+
+  context 'when quieted' do
+    it do
+      Backup::Logger.send(:const_set, :QUIET, true)
+      Backup::Logger.expects(:puts).never
+
+      Backup::Logger.message "This has been logged."
+      Backup::Logger.error   "This has been logged."
+      Backup::Logger.warn    "This has been logged."
+      Backup::Logger.normal  "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 -f '#{ File.join( Backup::TMP_PATH, "#{ Backup::TIME }.#{ Backup::TRIGGER }.tar" ) }' -C '#{ Backup::TMP_PATH }' '#{ Backup::TRIGGER }'|)
+      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/campfire_spec.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Backup::Notifier::Campfire do
+  let(:notifier) do
+    Backup::Notifier::Campfire.new do |campfire|
+      campfire.api_token = 'token'
+      campfire.subdomain = 'subdomain'
+      campfire.room_id   = 'room_id'
+    end
+  end
+
+  it do
+    notifier.api_token.should == 'token'
+    notifier.subdomain.should == 'subdomain'
+    notifier.room_id.should   == 'room_id'
+
+    notifier.on_success.should == true
+    notifier.on_failure.should == true
+  end
+
+  describe 'defaults' do
+    it do
+      Backup::Configuration::Notifier::Campfire.defaults do |campfire|
+        campfire.api_token  = 'old_token'
+        campfire.on_success = false
+        campfire.on_failure = true
+      end
+        notifier           = Backup::Notifier::Campfire.new do |campfire|
+        campfire.api_token = 'new_token'
+      end
+
+      notifier.api_token.should  == 'new_token'
+      notifier.on_success.should == false
+      notifier.on_failure.should == true
+    end
+  end
+
+  describe '#initialize' do
+    it do
+      Backup::Notifier::Campfire.any_instance.expects(:set_defaults!)
+      Backup::Notifier::Campfire.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::Campfire 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::Campfire 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
+
+  describe Backup::Notifier::Campfire::Interface do
+    let(:room) do
+      Backup::Notifier::Campfire::Room.new('room_id', 'subdomain', 'token')
+    end
+
+    it do
+      room.api_token.should == 'token'
+      room.subdomain.should == 'subdomain'
+      room.room_id.should   == 'room_id'
+    end
+  end
+end