chef_backup 0.0.1.dev.2 → 0.1.1

data/spec/spec_helper.rb

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

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

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

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

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