dop_common 0.13.0

data/spec/dop_common/plan_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+describe DopCommon::Plan do
+
+  describe '#name' do
+    it 'will return a hash if no name is defined' do
+      plan = DopCommon::Plan.new({})
+      if RUBY_VERSION <= '1.8.7'
+        expect(plan.name).to eq 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'
+      else
+        expect(plan.name).to eq '44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a'
+      end
+    end
+    it 'will return the correct value if name is defined' do
+      plan = DopCommon::Plan.new({:name => 'myplan'})
+      expect(plan.name).to eq 'myplan'
+      plan = DopCommon::Plan.new({:name => 'my-plan'})
+      expect(plan.name).to eq 'my-plan'
+    end
+    it 'will throw and exception if the value is not a String' do
+      plan = DopCommon::Plan.new({:name => 2})
+      expect{plan.name}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'will throw and exception if the value contais illegal chars' do
+      plan = DopCommon::Plan.new({:name => 'my(plan'})
+      expect{plan.name}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#infrastructures' do
+    it 'will throw and exception if the infrastructures key is not defined' do
+      plan = DopCommon::Plan.new({})
+      expect{plan.infrastructures}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'will throw and exception if the infrastructures value is not a Hash' do
+      plan = DopCommon::Plan.new({:infrastructures => 'foo'})
+      expect{plan.infrastructures}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'will throw and exception if the infrastructures hash is empty' do
+      plan = DopCommon::Plan.new({:infrastructures => {}})
+      expect{plan.infrastructures}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#nodes' do
+    it 'will return a list of nodes' do
+      plan = DopCommon::Plan.new({:infrastructures => {:management => {}}, :nodes => {'mynode{i}.example.com' =>{:range  => '1..10', :digits => 3}}})
+      expect(plan.nodes.length).to be 10
+      expect(plan.nodes[0].name).to eq 'mynode001.example.com'
+      expect(plan.nodes[9].name).to eq 'mynode010.example.com'
+    end
+    it 'will throw and exception if the nodes key is not defined' do
+      plan = DopCommon::Plan.new({})
+      expect{plan.nodes}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'will throw and exception if the nodes value is not a Hash' do
+      plan = DopCommon::Plan.new({:nodes => 'foo'})
+      expect{plan.nodes}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'will throw and exception if the nodes hash is empty' do
+      plan = DopCommon::Plan.new({:nodes => {}})
+      expect{plan.nodes}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#step_sets' do
+    it 'will return an empty array if the steps key is not defined' do
+      plan = DopCommon::Plan.new({})
+      expect(plan.step_sets).to eq([])
+    end
+    it 'will return a StepSet object if the stepset is specified correctly' do
+      plan = DopCommon::Plan.new({:steps => []})
+      expect(plan.step_sets.all?{|s| s.kind_of?(DopCommon::StepSet)}).to be true
+      plan = DopCommon::Plan.new({:steps => {'foo' => []}})
+      expect(plan.step_sets.all?{|s| s.kind_of?(DopCommon::StepSet)}).to be true
+    end
+    it 'will throw and exception if the value is not an Array or Hash' do
+      plan = DopCommon::Plan.new({:steps => 'foo'})
+      expect{plan.step_sets}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'will throw and exception if the hash is empty' do
+      plan = DopCommon::Plan.new({:steps => {}})
+      expect{plan.step_sets}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'will throw and exception if the hash is invalid' do
+      plan = DopCommon::Plan.new({:steps => {2 => {}}})
+      expect{plan.step_sets}.to raise_error DopCommon::PlanParsingError
+      plan = DopCommon::Plan.new({:steps => {'foo' => 2}})
+      expect{plan.step_sets}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#credentials' do
+    it 'will return an empty Hash of credentials if nothing is specified' do
+      plan = DopCommon::Plan.new({})
+      expect(plan.credentials).to eq({})
+    end
+    it 'will return a Hash of credentials if correctly specified' do
+      plan = DopCommon::Plan.new({:credentials => {'test' => {
+        :type     => :username_password,
+        :username => 'a',
+        :password => 'b'
+      }}})
+      expect(plan.credentials.key?('test')).to be true
+      expect(plan.credentials['test']).to be_a ::DopCommon::Credential
+    end
+    it 'will raise an exception if the the key is not valid' do
+      plan = DopCommon::Plan.new({:credentials => {2 => {}}})
+      expect{plan.credentials}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'will raise an exception if the value is not a hash' do
+      plan = DopCommon::Plan.new({:credentials => {'test' => 2}})
+      expect{plan.credentials}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#hooks' do
+    it 'will return hooks object if specified properly' do
+      plan = ::DopCommon::Plan.new({})
+      expect(plan.hooks).to be_a(::DopCommon::Hooks)
+      %w(create update destroy).each do |action|
+        %w(pre post).each do |prefix|
+          hook_name = "#{prefix}_#{action}_vm"
+          plan = ::DopCommon::Plan.new({'hooks' => {hook_name => []}})
+          expect(plan.hooks).to be_an_instance_of(::DopCommon::Hooks)
+        end
+      end
+    end
+    it 'will raise an error if not specified correctly' do
+      plan = ::DopCommon::Plan.new({'hooks' => {}})
+      expect { plan.hooks }.to raise_error ::DopCommon::PlanParsingError
+      plan = ::DopCommon::Plan.new({'hooks' => {'invalid' => ['/foo/bar/baz']}})
+      expect { plan.hooks }.to raise_error ::DopCommon::PlanParsingError
+    end
+  end
+end

data/spec/dop_common/plan_store_spec.rb

@@ -0,0 +1,194 @@
+require 'spec_helper'
+
+describe DopCommon::PlanStore do
+
+  before :each do
+    @tmpdir = Dir.mktmpdir
+    @plan_store = DopCommon::PlanStore.new(@tmpdir)
+  end
+
+  after :each do
+    FileUtils.remove_entry_secure(@tmpdir)
+  end
+
+  let(:plan) { 'spec/fixtures/simple_plan.yaml' }
+  let(:plan_name) { 'simple_plan' }
+  let(:plan_dir) { File.join(@tmpdir, plan_name) }
+  let(:versions_dir) { File.join(plan_dir, 'versions') }
+
+  describe '#add' do
+    subject { @plan_store.add(plan) }
+
+    context 'The plan file is correct' do
+      it { is_expected.to eq('simple_plan') }
+      it { subject; expect(Dir[versions_dir + '/*.yaml'].length).to be 1 }
+    end
+    context 'The plan is in hash form' do
+      let(:plan) { YAML.load_file('spec/fixtures/simple_plan.yaml') }
+      it { is_expected.to eq('simple_plan') }
+      it { subject; expect(Dir[versions_dir + '/*.yaml'].length).to be 1 }
+    end
+    context 'The plan is invalid' do
+      let(:plan) { 'spec/fixtures/simple_plan_invalid.yaml' }
+      it { expect{subject}.to raise_error StandardError }
+    end
+    context 'The plan was already added' do
+      before { @plan_store.add(plan) }
+      it { expect{subject}.to raise_error StandardError }
+    end
+    context 'A node is already present' do
+      before { @plan_store.add('spec/fixtures/other_plan_same_nodes.yaml') }
+      it { expect{subject}.to raise_error StandardError }
+    end
+  end
+
+  describe '#update' do
+    before do |example|
+      @plan_store.add(plan) unless example.metadata[:skip_before]
+    end
+    subject { @plan_store.update(plan) }
+
+    context 'The plan file is correct' do
+      it { is_expected.to eq('simple_plan') }
+      it { subject; expect(Dir[versions_dir + '/*.yaml'].length).to be 2 }
+    end
+    context 'The plan is in hash form' do
+      let(:plan) { YAML.load_file('spec/fixtures/simple_plan.yaml') }
+      it { is_expected.to eq('simple_plan') }
+      it { subject; expect(Dir[versions_dir + '/*.yaml'].length).to be 2 }
+    end
+    context 'The plan is invalid' do
+      let(:invalid_plan) { 'spec/fixtures/simple_plan_invalid.yaml' }
+      subject { @plan_store.update(invalid_plan) }
+      it { expect{subject}.to raise_error StandardError }
+    end
+    context 'The plan was not already added', :skip_before => true do
+      it { expect{subject}.to raise_error StandardError }
+    end
+  end
+
+  describe '#remove' do
+    before :example do
+      @plan_store.add(plan)
+    end
+    let(:dopi_state) { File.join(plan_dir, 'dopi.yaml') }
+    let(:dopv_state) { File.join(plan_dir, 'dopv.yaml') }
+
+    context 'plan exists and default state remove options' do
+      subject { @plan_store.remove(plan_name) }
+      it { is_expected.to eq('simple_plan') }
+      it { subject; expect(File.exists?(versions_dir)).to be false }
+      it { subject; expect(File.exists?(dopi_state)).to be false }
+      it { subject; expect(File.exists?(dopv_state)).to be true }
+      it { subject; expect(File.exists?(plan_dir)).to be true }
+    end
+    context 'plan exists and keep dopi state' do
+      subject { @plan_store.remove(plan_name, false) }
+      it { is_expected.to eq('simple_plan') }
+      it { subject; expect(File.exists?(versions_dir)).to be false }
+      it { subject; expect(File.exists?(dopi_state)).to be true }
+      it { subject; expect(File.exists?(dopv_state)).to be true }
+      it { subject; expect(File.exists?(plan_dir)).to be true }
+    end
+    context 'plan exists and remove dopv state' do
+      subject { @plan_store.remove(plan_name, true, true) }
+      it { is_expected.to eq('simple_plan') }
+      it { subject; expect(File.exists?(versions_dir)).to be false }
+      it { subject; expect(File.exists?(dopi_state)).to be false }
+      it { subject; expect(File.exists?(dopv_state)).to be false }
+      it { subject; expect(File.exists?(plan_dir)).to be false }
+    end
+    context 'plan does not exist' do
+      let(:plan_name) { 'not_existing_plan' }
+      it { expect{subject}.to raise_error StandardError }
+    end
+  end
+
+  describe '#list' do
+    before { @plan_store.add(plan) }
+    subject { @plan_store.list }
+
+    context 'one plan is in the store' do
+      it { is_expected.to be_an Array }
+      it { is_expected.to have_exactly(1).items }
+      it { is_expected.to include plan_name }
+    end
+  end
+
+  describe '#show_versions' do
+    before do |example|
+      @plan_store.add(plan) unless example.metadata[:skip_before]
+    end
+    subject { @plan_store.show_versions(plan_name) }
+
+    context 'the plan is in the store' do
+      it { is_expected.to be_an Array }
+      it { is_expected.to have_exactly(1).items }
+    end
+    context 'the plan is not in the store', :skip_before => true do
+      it { expect{subject}.to raise_error StandardError }
+    end
+  end
+
+  describe '#get_plan_hash' do
+    before do |example|
+      @plan_store.add(plan) unless example.metadata[:skip_before]
+    end
+    subject { @plan_store.get_plan_hash(plan_name) }
+
+    context 'the plan is in the store' do
+      it { is_expected.to be_a Hash }
+      it { is_expected.to have_key 'name' }
+    end
+    context 'the plan is not in the store', :skip_before => true do
+      it { expect{subject}.to raise_error StandardError }
+    end
+  end
+
+  describe '#get_plan_hash_diff' do
+    before do |example|
+      unless example.metadata[:skip_before]
+        @plan_store.add(plan)
+        @plan_store.update('spec/fixtures/simple_plan_modified.yaml')
+      end
+    end
+    let(:old_version) { @plan_store.show_versions(plan_name).first }
+    subject { @plan_store.get_plan_hash_diff(plan_name, old_version) }
+
+    context 'the plan is in the store' do
+      it { is_expected.to be_an Array }
+    end
+    context 'the plan is not in the store', :skip_before => true do
+      it { expect{subject}.to raise_error StandardError }
+    end
+  end
+
+  describe '#get_plan' do
+    before do |example|
+      @plan_store.add(plan) unless example.metadata[:skip_before]
+    end
+    subject { @plan_store.get_plan(plan_name) }
+
+    context 'the plan is in the store' do
+      it { is_expected.to be_a DopCommon::Plan }
+      it { expect(subject.name).to eq(plan_name) }
+    end
+    context 'the plan is not in the store', :skip_before => true do
+      it { expect{subject}.to raise_error StandardError }
+    end
+  end
+
+  describe '#run_lock' do
+    pending
+  end
+
+  describe '#run_lock?' do
+    pending
+  end
+
+  describe '#state_store' do
+    pending
+  end
+
+end
+

data/spec/dop_common/pre_processor_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe DopCommon::PreProcessor do
+
+  describe '#load_plan' do
+    subject{ DopCommon::PreProcessor.load_plan(file) }
+
+    context 'All the include files are present and correct' do
+      let(:file) { 'spec/fixtures/simple_include.yaml' }
+      it{ is_expected.to be_a String }
+      it do
+        expect(YAML.load(subject)).to eq({
+          'name'          => 'simple_include_test',
+          'some_root_key' => 'some_value',
+          'some_key'      => ['an_item', 'another_item'],
+        })
+      end
+    end
+
+    context 'Included files are missing' do
+      let(:file) { 'spec/fixtures/simple_include_with_errors.yaml' }
+      it{ expect{subject}.to raise_error DopCommon::PlanParsingError }
+    end
+  end
+
+end
+

data/spec/dop_common/run_options_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+class RunOptionsTestKlass
+  include DopCommon::RunOptions
+  def initialize(hash); @hash = hash; end
+end
+
+describe DopCommon::RunOptions do
+
+  describe '#max_in_flight' do
+    it 'will return nil if max_in_flight is not defined' do
+      run_options = RunOptionsTestKlass.new({})
+      expect(run_options.max_in_flight).to be nil
+    end
+    it 'will return the correct value if max_in_flight is defined' do
+      run_options = RunOptionsTestKlass.new({:max_in_flight => 10})
+      expect(run_options.max_in_flight).to be 10
+    end
+    it 'will throw and exception if the value is not a Fixnum' do
+      run_options = RunOptionsTestKlass.new({:max_in_flight => 'foo'})
+      expect{run_options.max_in_flight}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'will throw and exception if the value is < -1' do
+      run_options = RunOptionsTestKlass.new({:max_in_flight => -2})
+      expect{run_options.max_in_flight}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#max_per_role' do
+    it 'will return nil if max_per_role is not defined' do
+      run_options = RunOptionsTestKlass.new({})
+      expect(run_options.max_per_role).to be nil
+    end
+    it 'will return the correct value if max_per_role is defined' do
+      run_options = RunOptionsTestKlass.new({:max_per_role => 10})
+      expect(run_options.max_per_role).to be 10
+    end
+    it 'will throw and exception if the value is not a Fixnum' do
+      run_options = RunOptionsTestKlass.new({:max_per_role => 'foo'})
+      expect{run_options.max_per_role}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'will throw and exception if the value is < -1' do
+      run_options = RunOptionsTestKlass.new({:max_per_role => -2})
+      expect{run_options.max_per_role}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#canary_host' do
+    it 'returns false if the key is missing' do
+      run_options = RunOptionsTestKlass.new({})
+      expect(run_options.canary_host).to eq false
+    end
+    it 'returns the correct result if the key is set' do
+      run_options = RunOptionsTestKlass.new({:canary_host => true})
+      expect(run_options.canary_host).to eq true
+      run_options = RunOptionsTestKlass.new({:canary_host => false})
+      expect(run_options.canary_host).to eq false
+    end
+    it 'throws an exception if the value is not a boolean' do
+      run_options = RunOptionsTestKlass.new({:canary_host => 'foo'})
+      expect{run_options.canary_host}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+end

data/spec/dop_common/signal_handler_spec.rb

@@ -0,0 +1,31 @@
+#
+# Test the SignalHandler class
+#
+# This test was created with the help of the very useful blog post at
+# http://timuruski.net/blog/2014/testing-signal-handlers/
+#
+require 'spec_helper'
+
+describe DopCommon::SignalHandler do
+
+  it 'receives the signal, executes the block and then exits' do
+    pipe_reader, pipe_writer = IO.pipe
+
+    ruby = fork do
+      pipe_reader.close
+      DopCommon::SignalHandler.new.handle_signals(:INT) do
+        pipe_writer.puts('received')
+        raise 'signal received'
+      end
+    end
+
+    pipe_writer.close
+    sleep(0.1)
+    Process.kill(:INT, ruby)
+    expect(pipe_reader.gets).to eq("received\n")
+    pid, status = Process.waitpid2(ruby)
+    expect(status.success?).to be true
+  end
+
+end
+

data/spec/dop_common/step_set_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe DopCommon::StepSet do
+
+  describe '#steps' do
+    it 'will return an array of steps if correctly specified' do
+      step_set = DopCommon::StepSet.new('foo', [{:name => 'foo'}])
+      expect(step_set.steps).to be_a Array
+      expect(step_set.steps.first).to be_a ::DopCommon::Step
+    end
+    it 'will raise an error if the array is empty' do
+      step_set = DopCommon::StepSet.new('foo', [])
+      expect{step_set.steps}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'will raise an error if the array contains something other than hashes' do
+      step_set = DopCommon::StepSet.new('foo', [{}, 1])
+      expect{step_set.steps}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+end

data/spec/dop_common/step_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+describe DopCommon::Step do
+
+  describe '#name' do
+    it 'returns the name if it is specified correctly' do
+      step = DopCommon::Step.new({:name => 'foo'})
+      expect(step.name).to eq 'foo'
+    end
+    it 'throws an exception if the key is missing' do
+      step = DopCommon::Step.new({})
+      expect{step.name}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+
+  [:nodes, :exclude_nodes, :roles, :exclude_roles].each do |method_name|
+    describe '#' + method_name.to_s do
+      it 'returns an array with entries if correctly specified' do
+        step = DopCommon::Step.new({:name => 'foo', method_name => ['foo']})
+        expect(step.send(method_name)).to eq(['foo'])
+      end
+      it 'returns an empty array if the key is missing' do
+        step = DopCommon::Step.new({:name => 'foo'})
+        expect(step.send(method_name)).to eq([])
+      end
+      it 'returns an array with one element if the value is a string' do
+        step = DopCommon::Step.new({:name => 'foo', method_name => 'foo'})
+        expect(step.send(method_name)).to eq(['foo'])
+      end
+      it 'throws an exception if the value is something other than an array or a string' do
+        step = DopCommon::Step.new({:name => 'foo', method_name => 1})
+        expect{step.send(method_name)}.to raise_error DopCommon::PlanParsingError
+      end
+      it 'throws an exception if the array contains something other than a string' do
+        step = DopCommon::Step.new({:name => 'foo', method_name => ['foo', 1]})
+        expect{step.send(method_name)}.to raise_error DopCommon::PlanParsingError
+      end
+      it 'throws an exception if the array contains an invalid regexp' do
+        step = DopCommon::Step.new({:name => 'foo', method_name => ['/][/']})
+        expect{step.send(method_name)}.to raise_error DopCommon::PlanParsingError
+      end
+    end
+  end
+
+  [:nodes_by_config, :exclude_nodes_by_config].each do |method_name|
+    describe '#' + method_name.to_s do
+      it 'returns a Hash if correctly specified' do
+        step = DopCommon::Step.new({:name => 'foo', method_name => {'my_alias' => 'foo'}})
+        expect(step.send(method_name)).to eq({'my_alias' => ['foo']})
+      end
+      it 'returns an empty hash if the key is missing' do
+        step = DopCommon::Step.new({:name => 'foo'})
+        expect(step.send(method_name)).to eq({})
+      end
+      it 'throws an exception if the value is something other than a hash' do
+        step = DopCommon::Step.new({:name => 'foo', method_name => 1})
+        expect{step.send(method_name)}.to raise_error DopCommon::PlanParsingError
+      end
+      it 'throws an exception if the hash contains something other than a string as a key' do
+        step = DopCommon::Step.new({:name => 'foo', method_name => {1 => 'foo'}})
+        expect{step.send(method_name)}.to raise_error DopCommon::PlanParsingError
+      end
+      it 'throws an exception if the hash contains something other than a string as a value' do
+        step = DopCommon::Step.new({:name => 'foo', method_name => {'my_alias' => 1}})
+        expect{step.send(method_name)}.to raise_error DopCommon::PlanParsingError
+      end
+      it 'throws an exception if the hash contains an invalid regexp' do
+        step = DopCommon::Step.new({:name => 'foo', method_name => {'my_alias' => '/][/'}})
+        expect{step.send(method_name)}.to raise_error DopCommon::PlanParsingError
+      end
+    end
+  end
+
+  describe '#commands' do
+    it 'returns the command objects if a command hash is specified' do
+      step = DopCommon::Step.new({:name => 'foo', :command => {:plugin => 'dummy'}})
+      expect(step.commands).to be_an Array
+      expect(step.commands.all?{|c| c.kind_of?(DopCommon::Command)}).to be true
+    end
+    it 'returns the command objects if a command hash is specified' do
+      step = DopCommon::Step.new({:name => 'foo', :commands => [{:plugin => 'dummy'}, 'dummy']})
+      expect(step.commands).to be_an Array
+      expect(step.commands.all?{|c| c.kind_of?(DopCommon::Command)}).to be true
+    end
+    it 'throws an exception if the command is not specified' do
+      step = DopCommon::Step.new({:name => 'foo'})
+      expect{step.commands}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'throws an exception if the value for command is something other than a String or a Hash' do
+      step = DopCommon::Step.new({:name => 'foo', :command => 1})
+      expect{step.commands}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#set_plugin_defaults' do
+    it 'returns an Array if correctly specified (normal plugin string)' do
+      step = DopCommon::Step.new({:name => 'foo', :set_plugin_defaults => [{ :plugin => 'ssh/custom', :credentials => 'my_cred'}]})
+      expect(step.set_plugin_defaults).to eq([{:plugins => ['ssh/custom'], :credentials => 'my_cred'}])
+    end
+    it 'returns an Array if correctly specified (plugins :all)' do
+      step = DopCommon::Step.new({:name => 'foo', :set_plugin_defaults => [{ :plugins => :all, :credentials => 'my_cred'}]})
+      expect(step.set_plugin_defaults).to eq([{:plugins => :all, :credentials => 'my_cred'}])
+    end
+    it 'returns an Array if correctly specified (plugins array)' do
+      step = DopCommon::Step.new({:name => 'foo', :set_plugin_defaults => [{ :plugins => ['ssh/custom', 'ssh/something'], :credentials => 'my_cred'}]})
+      expect(step.set_plugin_defaults).to eq([{:plugins => ['ssh/custom', 'ssh/something'], :credentials => 'my_cred'}])
+    end
+    it 'returns an Array if correctly specified (plugins array)' do
+      step = DopCommon::Step.new({:name => 'foo', :set_plugin_defaults => [{ :plugins => '/^ssh/', :credentials => 'my_cred'}]})
+      expect(step.set_plugin_defaults).to eq([{:plugins => [Regexp.new('^ssh')], :credentials => 'my_cred'}])
+    end
+    it 'returns an empty Array if the key is missing' do
+      step = DopCommon::Step.new({:name => 'foo'})
+      expect(step.set_plugin_defaults).to eq([])
+    end
+    it 'throws an exception if the value is something other than an array' do
+      step = DopCommon::Step.new({:name => 'foo', :set_plugin_defaults => 1})
+      expect{step.set_plugin_defaults}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'throws an exception if an entry is not a hash' do
+      step = DopCommon::Step.new({:name => 'foo', :set_plugin_defaults => [1]})
+      expect{step.set_plugin_defaults}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'throws an exception if no plugins key is present' do
+      step = DopCommon::Step.new({:name => 'foo', :set_plugin_defaults => {}})
+      expect{step.set_plugin_defaults}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'throws an exception if the plugins value is not valid' do
+      step = DopCommon::Step.new({:name => 'foo', :set_plugin_defaults => {:plugins => 1}})
+      expect{step.set_plugin_defaults}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'throws an exception if the plugins value is an invalid Regexp' do
+      step = DopCommon::Step.new({:name => 'foo', :set_plugin_defaults => {:plugins => '/][/'}})
+      expect{step.set_plugin_defaults}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'throws an exception if one of the keys is not a string or symbol' do
+      step = DopCommon::Step.new({:name => 'foo', :set_plugin_defaults => {:plugins => 'ssh/custom', 1 => 2}})
+      expect{step.set_plugin_defaults}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#delete_plugin_defaults' do
+    it 'returns an Array if correctly specified (normal plugin string)' do
+      step = DopCommon::Step.new({:name => 'foo', :delete_plugin_defaults => [{:plugin => 'ssh/custom', :delete_keys => ['credentials']}]})
+      expect(step.delete_plugin_defaults).to eq([{:plugins => ['ssh/custom'], :delete_keys => ['credentials']}])
+    end
+    it 'returns an Array if correctly specified (singular)' do
+      step = DopCommon::Step.new({:name => 'foo', :delete_plugin_defaults => [{:plugin => 'ssh/custom', :delete_key => 'credentials'}]})
+      expect(step.delete_plugin_defaults).to eq([{:plugins => ['ssh/custom'], :delete_keys => ['credentials']}])
+    end
+    it 'returns an Array if correctly specified (delete all for plugin)' do
+      step = DopCommon::Step.new({:name => 'foo', :delete_plugin_defaults => [{:plugin => 'ssh/custom', :delete_keys => :all}]})
+      expect(step.delete_plugin_defaults).to eq([{:plugins => ['ssh/custom'], :delete_keys => :all}])
+    end
+    it 'returns :all if correctly specified (delete all)' do
+      step = DopCommon::Step.new({:name => 'foo', :delete_plugin_defaults => :all})
+      expect(step.delete_plugin_defaults).to eq(:all)
+    end
+    it 'returns an empty Array if the key is missing' do
+      step = DopCommon::Step.new({:name => 'foo'})
+      expect(step.delete_plugin_defaults).to eq([])
+    end
+    it 'throws an exception if the delete_keys is invalid' do
+      step = DopCommon::Step.new({:name => 'foo', :delete_plugin_defaults => [{:plugin => 'ssh/custom', :delete_keys => 2}]})
+      expect{step.delete_plugin_defaults}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'throws an exception if an element in delete_keys is invalid' do
+      step = DopCommon::Step.new({:name => 'foo', :delete_plugin_defaults => [{:plugin => 'ssh/custom', :delete_keys => ['foo', 2]}]})
+      expect{step.delete_plugin_defaults}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+end
+

data/spec/dop_common/utils_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe DopCommon::Utils::DataSize do
+  describe '#size' do
+    {
+      1000     => 1000,
+      '1000K'  => 1000*1024,
+      '512M'   => 512*1024*1024,
+      '1000G'  => 1000*1024*1024*1024,
+      '1KB'    => 1000,
+      '1000MB' => 1000*1000*1000,
+      '2500GB' => 2500*1000*1000*1000,
+    }.each do |k, v|
+      it 'will return size in bytes if specified properly' do
+        size = DopCommon::Utils::DataSize.new(k)
+        expect(size).to be_an_instance_of(DopCommon::Utils::DataSize)
+        expect(size.bytes).to eq v
+      end
+    end
+    [nil, [], 2.4, '2500m', '1000'].each do |input|
+      it 'will raise an exception if not specified properly' do
+        size = DopCommon::Utils::DataSize.new(input)
+        expect{size.bytes}.to raise_error DopCommon::PlanParsingError
+      end
+    end
+  end
+end