chef_backup 0.0.1.dev.1

data/spec/spec_helper.rb

@@ -0,0 +1,103 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'chef_backup'
+require 'bundler/setup'
+require 'json'
+require 'tempfile'
+require 'chef/mixin/deep_merge'
+
+# Merge attributes into existing running_config
+def private_chef(*args)
+  Chef::Mixin::DeepMerge.deep_merge!(*args, ChefBackup::Config['private_chef'])
+end
+
+# Overwrite config with given attributes
+def private_chef!(args = {})
+  ChefBackup::Config.config = args
+end
+
+# Merge attributes into existing cli_args
+def cli_args(*args)
+  Chef::Mixin::DeepMerge.deep_merge!(*args, ChefBackup::Config.config)
+end
+
+# Overwrite config with given CLI args
+def cli_args!(args)
+  ChefBackup::Config.config = args
+end
+
+def use_default_running_config
+  ChefBackup::Config.config = running_config
+end
+
+def use_default_cli_args
+  ChefBackup::Config.config = cli_args
+end
+
+def clear_config
+  ChefBackup::Config.config = {}
+end
+
+def set_common_variables
+  let(:backup_tarball) { '/tmp/chef-backup-2014-12-10-20-31-40.tgz' }
+  let(:backup_time) { '2014-08-21T23:10:57-07:00' }
+  let(:tmp_dir) { '/tmp/chef-backup' }
+  let(:strategy) { 'test' }
+  let(:export_dir) { '/mnt/chef-backups' }
+  let(:all_services) do
+    %w(nginx oc_bifrost oc_id opscode-erchef opscode-expander
+       opscode-expander-reindexer opscode-solr4 postgresql rabbitmq redis_lb
+    )
+  end
+  let(:enabled_services) { all_services }
+  let(:data_map) do
+    double(
+      'DataMap',
+      services: {
+        'postgresql' => {
+          'data_dir' => '/var/opt/opscode/postgresql_9.2/data'
+        },
+        'couchdb' => {
+          'data_dir' => '/var/opt/opscode/couchdb/data'
+        },
+        'rabbitmq' => {
+          'data_dir' => '/var/opt/opscode/rabbitdb/data'
+        }
+      },
+      configs: {
+        'opscode' => {
+          'data_dir' => '/etc/opscode'
+        },
+        'opscode-manage' => {
+          'data_dir' => '/etc/opscode-manage'
+        }
+      }
+    )
+  end
+end
+
+def running_config
+  @config ||= begin
+    f = File.expand_path('../fixtures/chef-server-running.json', __FILE__)
+    JSON.parse(File.read(f))
+  end
+  @config.dup
+end
+
+def cli_args
+  {
+    'tmp_dir' => '/tmp/chef_backup/tmp_dir',
+    'agree_to_cleanse' => nil,
+    'restore_arg' => '/tmp/chef_backup/backup.tgz',
+    'restore_dir' => File.join('/tmp/chef_backup/tmp_dir', 'restore_dir')
+  }
+end
+
+RSpec.configure do |rspec|
+  rspec.run_all_when_everything_filtered = true
+  rspec.filter_run :focus
+  rspec.order = 'random'
+  rspec.expect_with(:rspec) { |c| c.syntax = :expect }
+  rspec.before { allow($stdout).to receive(:write) }
+end

data/spec/unit/data_map_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe ChefBackup::DataMap do
+  set_common_variables
+
+  describe '.initialize' do
+    it 'yields a config block' do
+      expect { |b| described_class.new(&b) }.to yield_with_args
+    end
+  end
+
+  describe '.add_service' do
+    subject { described_class.new }
+
+    it 'adds a service' do
+      subject.add_service('bookshelf', '/bookshelf/path')
+      expect(subject.services.keys.count).to eq(1)
+      expect(subject.services['bookshelf']['data_dir']).to eq('/bookshelf/path')
+    end
+  end
+
+  describe '.add_config' do
+    subject { described_class.new }
+
+    it 'adds a config' do
+      subject.add_config('opscode-manage', '/opscode-manage/path')
+      expect(subject.configs.keys.count).to eq(1)
+      expect(subject.configs['opscode-manage']['data_dir'])
+        .to eq('/opscode-manage/path')
+    end
+  end
+
+  describe '.manifest' do
+    subject do
+      described_class.new do |dm|
+        dm.strategy = 'test'
+        dm.backup_time = backup_time
+        dm.add_config('somethingstrange', 'inthehood')
+        dm.add_service('whoyagonnacall', 'ghostbusters')
+      end
+    end
+
+    it 'includes the backup strategy type' do
+      expect(subject.manifest).to include('strategy' => 'test')
+    end
+
+    it 'includes the backup timestamp' do
+      expect(subject.manifest).to include('backup_time' => backup_time)
+    end
+
+    it 'includes the backup config' do
+      expect(subject.manifest).to include('configs' => subject.configs)
+    end
+
+    it 'includes the backup service' do
+      expect(subject.manifest).to include('services' => subject.services)
+    end
+  end
+end

data/spec/unit/helpers_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require_relative 'shared_examples/helpers'
+
+describe ChefBackup::Helpers do
+  let(:tmp_dir_path) { '/tmp/chef_backup/tmp_dir' }
+
+  before do
+    # Test class to include our helpers methods
+    class HelperTest; include ChefBackup::Helpers; end
+  end
+
+  after do
+    Object.send(:remove_const, :HelperTest)
+  end
+
+  subject { HelperTest.new }
+
+  describe '.tmp_dir' do
+    context 'with CLI args' do
+      before { private_chef!('tmp_dir' => tmp_dir_path) }
+
+      context 'when the directory exists' do
+        before do
+          allow(File)
+            .to receive(:directory?).with(tmp_dir_path).and_return(true)
+        end
+
+        it_behaves_like '.tmp_dir with an existing specified directory'
+      end
+
+      context 'when the directory does not exist' do
+        before do
+          allow(File)
+            .to receive(:directory?).with(tmp_dir_path).and_return(false)
+          allow(FileUtils)
+            .to receive(:mkdir_p).with(tmp_dir_path).and_return([tmp_dir_path])
+        end
+
+        it_behaves_like '.tmp_dir with a nonexisting specified directory'
+      end
+    end
+
+    context 'with running_config args' do
+      before { private_chef!('tmp_dir' => tmp_dir_path) }
+
+      context 'when the directory exists' do
+        before do
+          allow(File)
+            .to receive(:directory?).with(tmp_dir_path).and_return(true)
+        end
+
+        it_behaves_like '.tmp_dir with an existing specified directory'
+      end
+
+      context 'when the directory does not exist' do
+        before do
+          allow(File)
+            .to receive(:directory?).with(tmp_dir_path).and_return(false)
+          allow(FileUtils)
+            .to receive(:mkdir_p).with(tmp_dir_path).and_return([tmp_dir_path])
+        end
+
+        it_behaves_like '.tmp_dir with a nonexisting specified directory'
+      end
+    end
+
+    context 'when no args are passed' do
+      before do
+        clear_config
+        allow(Dir).to receive(:mktmpdir).with('chef_backup')
+      end
+
+      it_behaves_like '.tmp_dir without a specified directory'
+    end
+  end
+
+  describe '.cleanup' do
+    before do
+      allow(subject).to receive(:tmp_dir).and_return(tmp_dir_path)
+      allow(FileUtils).to receive(:rm_r).with(tmp_dir_path)
+    end
+
+    it 'cleans up all items in the temp directory' do
+      expect(FileUtils).to receive(:rm_r).with(tmp_dir_path)
+      subject.cleanup
+    end
+  end
+end

data/spec/unit/runner_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+describe ChefBackup::Runner do
+  let(:test_strategy) { double('TestBackup', backup: true, restore: true) }
+  let(:backup_tarball) { '/tmp/chef-backup-2014-12-10-20-31-40.tgz' }
+  let(:backup_name) { 'chef-backup-2014-12-10-20-31-40' }
+  let(:restore_dir) { ChefBackup::Config['restore_dir'] }
+  let(:manifest_json) { "#{restore_dir}/manifest.json" }
+  let(:manifest) { { 'strategy' => 'test_strategy' } }
+  let(:json) { '{"some":{"nested":{"hash":1}}}' }
+  let(:runner_config) do
+    {
+      'tmp_dir' => '/tmp/runner_spec_tmp_dir',
+      'restore_param' => backup_tarball,
+      'agree_to_cleanse' => 'yes',
+      'private_chef' => { 'backup' => { 'strategy' => 'test' } }
+    }
+  end
+
+  subject { described_class.new(runner_config) }
+
+  describe '.backup' do
+    it 'initializes a ChefBackup::Strategy and calls .backup' do
+      allow(ChefBackup::Strategy)
+        .to receive(:backup)
+        .with('test')
+        .and_return(test_strategy)
+
+      expect(test_strategy).to receive(:backup).once
+      subject.backup
+    end
+  end
+
+  describe '.restore' do
+    it 'initializes a ChefBackup::Strategy and calls .restore' do
+      allow(subject).to receive(:restore_strategy).and_return('test')
+      allow(ChefBackup::Strategy)
+        .to receive(:restore)
+        .with('test', backup_tarball)
+        .and_return(test_strategy)
+
+      expect(test_strategy).to receive(:restore).once
+      subject.restore
+    end
+  end
+
+  describe '.manifest' do
+    before do
+      allow(subject).to receive(:restore_directory).and_return(restore_dir)
+      allow(subject).to receive(:ensure_file!).and_return(true)
+      allow(File).to receive(:read).with(manifest_json).and_return(json)
+    end
+
+    it 'verifies that the file exists' do
+      expect(subject).to receive(:ensure_file!)
+      subject.manifest
+    end
+
+    it 'parses the manifest.json' do
+      expect(subject.manifest).to eq(JSON.parse(json).to_h)
+    end
+  end
+
+  describe '.restore_directory' do
+    let(:rest_dir) do
+      ChefBackup::Config['tmp_dir'] = '/tmp/chef_backup'
+      File.join(ChefBackup::Config['tmp_dir'], backup_name)
+    end
+
+    before(:each) do
+      ChefBackup::Config['tmp_dir'] = '/tmp/chef_backup'
+      allow(subject).to receive(:backup_name).and_return(backup_name)
+    end
+
+    context 'when the restore directory already exists' do
+      before do
+        allow(File).to receive(:directory?).and_return(true)
+        allow(Dir).to receive(:glob).and_return(%w(a b c))
+        allow(FileUtils).to receive(:rm_r).and_return(true)
+      end
+
+      it 'cleans the restore directory' do
+        # The directory needs to exist but has not been set in the config
+        ChefBackup::Config['restore_dir'] = nil
+        expect(FileUtils).to receive(:rm_r).with(%w(a b c))
+        subject.restore_directory
+      end
+
+      it 'does not create a new directory' do
+        ChefBackup::Config['restore_dir'] = '/tmp/restore_dir'
+        subject.restore_directory
+        expect(ChefBackup::Config['restore_dir']).to eq(restore_dir)
+      end
+    end
+
+    context 'when the restore directory does not exist' do
+      before do
+        allow(File).to receive(:directory?).and_return(false)
+        allow(FileUtils).to receive(:rm_r).and_return(true)
+        allow(FileUtils).to receive(:mkdir_p).and_return(true)
+      end
+
+      it 'creates a restore directory in the runner tmp_dir' do
+        ChefBackup::Config['restore_dir'] = nil
+        expect(FileUtils).to receive(:mkdir_p).with(rest_dir)
+        subject.restore_directory
+      end
+
+      it 'updates the config with the restore dir' do
+        ChefBackup::Config['restore_dir'] = nil
+        subject.restore_directory
+        expect(ChefBackup::Config['restore_dir']).to eq(restore_dir)
+      end
+    end
+  end
+
+  describe '.unpack_tarball' do
+    before do
+      allow(subject).to receive(:restore_param).and_return(backup_tarball)
+      allow(subject).to receive(:restore_directory).and_return(restore_dir)
+      allow(subject).to receive(:shell_out!).and_return(true)
+    end
+
+    it 'raises an error if the tarball is invalid' do
+      allow(File)
+        .to receive(:exist?).with(backup_tarball).and_return(false)
+      expect { subject.unpack_tarball }
+        .to raise_error(ChefBackup::Exceptions::InvalidTarball,
+                        "#{backup_tarball} not found")
+    end
+
+    it 'explodes the tarball into the restore directory' do
+      allow(subject).to receive(:ensure_file!).and_return(true)
+
+      cmd = "tar zxf #{backup_tarball} -C #{restore_dir}"
+      expect(subject).to receive(:shell_out!).with(cmd)
+      subject.unpack_tarball
+    end
+  end
+
+  describe '.restore_strategy' do
+    context 'when the restore param is a tarball' do
+      before do
+        allow(subject).to receive(:tarball?).and_return(true)
+        allow(subject).to receive(:unpack_tarball).and_return(true)
+        allow(subject).to receive(:manifest).and_return(manifest)
+      end
+
+      it 'unpacks the tarball' do
+        expect(subject).to receive(:unpack_tarball)
+        subject.restore_strategy
+      end
+
+      it 'returns the strategy from the manifest' do
+        expect(subject.restore_strategy).to eq('test_strategy')
+        subject.restore_strategy
+      end
+    end
+
+    context 'when the restore param is an ebs snapshot' do
+      before do
+        allow(subject).to receive(:tarball?).and_return(false)
+        allow(subject).to receive(:ebs_snapshot?).and_return(true)
+      end
+
+      it 'returns "ebs" as the strategy' do
+        expect(subject.restore_strategy).to eq('ebs')
+      end
+    end
+
+    context 'when the restore param is not valid' do
+      before do
+        allow(subject).to receive(:tarball?).and_return(false)
+        allow(subject).to receive(:ebs_snapshot?).and_return(false)
+        allow(subject).to receive(:restore_param).and_return('invalid_param')
+      end
+
+      it 'raises an exception' do
+        expect { subject.restore_strategy }
+          .to raise_error(ChefBackup::Exceptions::InvalidStrategy,
+                          'invalid_param is not a valid backup')
+      end
+    end
+  end
+end

data/spec/unit/shared_examples/helpers.rb

@@ -0,0 +1,20 @@
+shared_examples '.tmp_dir with a nonexisting specified directory' do
+  it 'uses the specified directory' do
+    expect(FileUtils).to receive(:mkdir_p).with(tmp_dir_path)
+    expect(subject.tmp_dir).to eq(tmp_dir_path)
+  end
+end
+
+shared_examples '.tmp_dir with an existing specified directory' do
+  it 'does not create a directory' do
+    expect(FileUtils).to_not receive(:anything)
+    expect(subject.tmp_dir).to eq(tmp_dir_path)
+  end
+end
+
+shared_examples '.tmp_dir without a specified directory' do
+  it 'creates a temp directory' do
+    expect(Dir).to receive(:mktmpdir).with('chef_backup')
+    subject.tmp_dir
+  end
+end