dop_common 0.13.0

data/spec/dop_common/hash_parser_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+describe DopCommon::HashParser do
+
+  describe '#key_aliases' do
+    it 'should set the proper keys' do
+      hash = {'my_key' => 'test'}
+      aliases = ['my_key', :my_keys, 'my_keys']
+      DopCommon::HashParser.key_aliases(hash, :my_key, aliases)
+      expect(hash[:my_key]).to eq 'test'
+      # Make sure we can execute it again
+      DopCommon::HashParser.key_aliases(hash, :my_key, aliases)
+      expect(hash[:my_key]).to eq 'test'
+    end
+    it 'raises an exception if more than one alias/key is already set' do
+      hash = {'my_key' => 'test', :my_key => 'test2'}
+      aliases = ['my_key', :my_keys, 'my_keys']
+      expect{DopCommon::HashParser.key_aliases(hash, :my_key, aliases)}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#symbolize_keys' do
+    subject { DopCommon::HashParser.symbolize_keys(
+      hash = {'a' => [{'aa' => 1, 'bb' => 2}], 'b' => 3}
+    )}
+    it { is_expected.to eq({:a => [{'aa' => 1, 'bb' => 2}], :b => 3}) }
+  end
+
+  describe '#deep_symbolize_keys' do
+    context 'simple nested hash' do
+      subject { DopCommon::HashParser.deep_symbolize_keys(
+        hash = {'a' => [{'aa' => '1', 'bb' => 2}], 'b' => 3}
+      )}
+      it { is_expected.to eq({:a => [{:aa => '1', :bb => 2}], :b => 3}) }
+    end
+    context 'nested hash with loops' do
+      subject {
+        hash = {'a' => [{'aa' => 1, 'bb' => 2}], 'b' => 3}
+        hash['a'] << hash
+        DopCommon::HashParser.deep_symbolize_keys(hash)
+      }
+      it { is_expected.to be_a Hash }
+    end
+  end
+
+  describe '#represents_regexp?' do
+    context 'valid regexp' do
+      subject {DopCommon::HashParser.represents_regexp?('/valid/')}
+      it { is_expected.to be true }
+    end
+    context 'invalid regexp' do
+      subject {DopCommon::HashParser.represents_regexp?('noregex')}
+      it { is_expected.to be false }
+    end
+  end
+
+  describe '#is_valid_regexp?' do
+    context 'valid regexp' do
+      subject {DopCommon::HashParser.is_valid_regexp?('/valid/')}
+      it { is_expected.to be true }
+    end
+    context 'invalid regexp' do
+      subject {DopCommon::HashParser.is_valid_regexp?('/][/')}
+      it { is_expected.to be false }
+    end
+  end
+
+  describe '#pattern_list_valid?' do
+    it 'returns true if the hash is correctly specified' do
+      hash = {'my_key' => :all}
+      expect(DopCommon::HashParser.pattern_list_valid?(hash, 'my_key')).to be(true)
+      hash = {'my_key' => 'foo'}
+      expect(DopCommon::HashParser.pattern_list_valid?(hash, 'my_key')).to be(true)
+      hash = {'my_key' => ['foo', '/foo/']}
+      expect(DopCommon::HashParser.pattern_list_valid?(hash, 'my_key')).to be(true)
+    end
+    it 'returns false if the key is missing but optional' do
+      hash = {}
+      expect(DopCommon::HashParser.pattern_list_valid?(hash, 'my_key')).to be(false)
+    end
+    it 'raises an error if the key is missing and not optional' do
+      hash = {}
+      expect{DopCommon::HashParser.pattern_list_valid?(hash, 'my_key', false)}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'raises an error if a value in the array is not a string' do
+      hash = {'my_key' => [2]}
+      expect{DopCommon::HashParser.pattern_list_valid?(hash, 'my_key')}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'raises an error if a regexp in the array is not valid' do
+      hash = {'my_key' => ['/][/']}
+      expect{DopCommon::HashParser.pattern_list_valid?(hash, 'my_key')}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#hash_of_pattern_lists_valid?' do
+    it 'returns true if the hash is correctly specified' do
+      hash = {'my_key' => {'list_1' => '/foo/', 'list_2' => ['foo', '/foo/']}}
+      expect(DopCommon::HashParser.hash_of_pattern_lists_valid?(hash, 'my_key')).to be(true)
+    end
+    it 'returns false if the key is missing but optional' do
+      hash = {}
+      expect(DopCommon::HashParser.hash_of_pattern_lists_valid?(hash, 'my_key')).to be(false)
+    end
+    it 'raises an error if the key is missing and not optional' do
+      hash = {}
+      expect{DopCommon::HashParser.hash_of_pattern_lists_valid?(hash, 'my_key', false)}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'raises an error if the value is not a hash' do
+      hash = {'my_key' => 2}
+      expect{DopCommon::HashParser.pattern_list_valid?(hash, 'my_key')}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'raises an error if a key is not a string' do
+      hash = {'my_key' => { 2 => 'foo' }}
+      expect{DopCommon::HashParser.pattern_list_valid?(hash, 'my_key')}.to raise_error DopCommon::PlanParsingError
+    end
+    it 'raises an error if a list is not valid' do
+      hash = {'my_key' => { 'list_1' => 2 }}
+      expect{DopCommon::HashParser.pattern_list_valid?(hash, 'my_key')}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#parse_pattern_list' do
+    pending
+  end
+
+  describe '#parse_hash_of_pattern_lists' do
+    pending
+  end
+
+  describe 'load_content' do
+    it 'successfully returns the content from a string' do
+      value = 'Some simple string'
+      expect{DopCommon::HashParser.load_content_valid?(value)}.to_not raise_error
+      expect(DopCommon::HashParser.load_content(value)).to eq('Some simple string')
+    end
+
+    it 'successfully retrieve content from a file' do
+      secret = SecureRandom.hex
+      key_file = Tempfile.new('secret_file', ENV['HOME'])
+      key_file.write(secret)
+      key_file.close
+      value = {:file => key_file.path}
+      expect{DopCommon::HashParser.load_content_valid?(value)}.to_not raise_error
+      expect(DopCommon::HashParser.load_content(value)).to eq(secret)
+      key_file.delete
+    end
+
+    it 'successfully retrieve content from an executable' do
+      secret = SecureRandom.hex
+      key_exec = Tempfile.new('secret_exec', ENV['HOME'])
+      key_exec.write("#!/bin/sh\necho \"#{secret}\"")
+      key_exec.close
+      FileUtils.chmod(0700, key_exec.path)
+      value = {:exec => [key_exec.path]}
+      expect{DopCommon::HashParser.load_content_valid?(value)}.to_not raise_error
+      expect(DopCommon::HashParser.load_content(value)).to eq(secret)
+      key_exec.delete
+    end
+
+    it 'successfully retrieve content from an executable with parameters' do
+      secret = SecureRandom.hex
+      key_exec = Tempfile.new('secret_exec', ENV['HOME'])
+      key_exec.write("#!/bin/sh\necho $2")
+      key_exec.close
+      FileUtils.chmod(0700, key_exec.path)
+      value = {:exec => [key_exec.path, '--secret', secret]}
+      expect{DopCommon::HashParser.load_content_valid?(value)}.to_not raise_error
+      expect(DopCommon::HashParser.load_content(value)).to eq(secret)
+      key_exec.delete
+    end
+
+    it "raises an exeption if the file does not exist" do
+      file_name = SecureRandom.hex
+      value = {:file => File.join('/tmp', file_name)}
+      expect{DopCommon::HashParser.load_content_valid?(value)}.to raise_error DopCommon::PlanParsingError
+      value = {:exec => File.join('/tmp', file_name)}
+      expect{DopCommon::HashParser.load_content_valid?(value)}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+end

data/spec/dop_common/hooks_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe DopCommon::Hooks do
+  %w(create update).each do |a|
+    %w(pre post).each do |p|
+      hook = :"#{p}_#{a}_vm"
+      describe "##{hook}" do
+        it "will return an empty array if given hook isn't specified" do
+          hooks = ::DopCommon::Hooks.new({})
+          expect(hooks.send(hook)).to eq([])
+        end
+        it "will return an array of hooks if specified correctly" do
+          hooks = ::DopCommon::Hooks.new({ hook => ['spec/data/fake_hook_file_valid'] })
+          expect(hooks.send(hook)).to eq(['spec/data/fake_hook_file_valid'])
+        end
+        [nil, {}, [], 1].each do |v|
+          it "will raise an error if hook isn't specified properly" do
+            hooks = ::DopCommon::Hooks.new({ hook => v })
+            expect { hooks.send(hook) }.to raise_error ::DopCommon::PlanParsingError
+          end
+        end
+        it "will raise an error if hook isn't a file" do
+          hooks = ::DopCommon::Hooks.new({ hook => '/' })
+          expect { hooks.send(hook) }.to raise_error ::DopCommon::PlanParsingError
+        end
+        it "will raise an error if hook isn't an executable file" do
+          hooks = ::DopCommon::Hooks.new({ hook => 'spec/data/fake_hook_file_invalid' })
+          expect { hooks.send(hook) }.to raise_error ::DopCommon::PlanParsingError
+        end
+      end
+    end
+  end
+end

data/spec/dop_common/infrastructure_properties_spec.rb

@@ -0,0 +1,224 @@
+require 'spec_helper'
+
+describe DopCommon::InfrastructureProperties do
+
+  providers = %w(ovirt vsphere openstack)
+  infrastructure = Hash[
+    providers.collect { |p| [p, DopCommon::Infrastructure.new(p, {'type' => p})] }
+  ]
+
+  describe '#affinity_groups' do
+    it 'will return an array of affinity group if input is valid' do
+      ags = ['ag1', 'ag2', 'ag3']
+      infrastructure_properties = DopCommon::InfrastructureProperties.new({}, nil)
+      expect(infrastructure_properties.affinity_groups).to eq []
+      infrastructure_properties = DopCommon::InfrastructureProperties.new({'affinity_groups' => ags}, nil)
+      expect(infrastructure_properties.affinity_groups).to eq ags
+    end
+
+    it 'will raise an error if input affinity groups point to a non-empty array' do
+      [[], 'invalid'].each do |val|
+        infrastructure_properties = DopCommon::InfrastructureProperties.new({'affinity_groups' => val}, nil)
+        expect { infrastructure_properties.affinity_groups }.to raise_error DopCommon::PlanParsingError
+      end
+    end
+
+    it 'will raise an error if input affinity groups array contains invalid entries' do
+      [[:ag1, "ag2", 2], ["ag1", 2, "ag3"], ["ag1", "ag2", ""]].each do |ag|
+        infrastructure_properties = DopCommon::InfrastructureProperties.new({'affinity_groups' => ag}, nil)
+        expect { infrastructure_properties.affinity_groups }.to raise_error DopCommon::PlanParsingError
+      end
+    end
+  end
+
+  describe '#keep_ha?' do
+    it "will return 'true' if not specified in input hash" do
+      infrastructure_properties = DopCommon::InfrastructureProperties.new({}, infrastructure['ovirt'])
+      expect(infrastructure_properties.keep_ha?).to eq true
+    end
+
+    it "will return 'true' or 'false' if specified in input hash properly" do
+      [true, false].each do |val|
+        infrastructure_properties = DopCommon::InfrastructureProperties.new({'keep_ha' => val}, infrastructure['ovirt'])
+        expect(infrastructure_properties.keep_ha?).to eq val
+      end
+    end
+
+    it 'will raise an exception if used for non-openstack provider' do
+      infrastructure_properties = DopCommon::InfrastructureProperties.new({'keep_ha' => true}, infrastructure['vsphere'])
+      expect { infrastructure_properties.keep_ha? }.to raise_error DopCommon::PlanParsingError
+    end
+    it 'will raise an exception if not specified properly in input hash' do
+      ['true', 'false', 1, 0, :invalid, {}].each do |val|
+        infrastructure_properties = DopCommon::InfrastructureProperties.new({'keep_ha' => val}, infrastructure['ovirt'])
+        expect { infrastructure_properties.keep_ha? }.to raise_error DopCommon::PlanParsingError
+      end
+    end
+  end
+
+  %w(datacenter cluster).each do |prop_name|
+    describe "##{prop_name}" do
+      providers.each do |p|
+        it "will return the '#{prop_name}' name if specified correctly" do
+          prop_val = "prop-val-#{p}"
+          infrastructure_properties = DopCommon::InfrastructureProperties.new(
+            {prop_name => prop_val},
+            infrastructure[p]
+          )
+          expect(infrastructure_properties.send(prop_name.to_sym)).to eq(p == 'openstack' ? nil : prop_val)
+        end
+
+        it "will raise an exception if '#{prop_name}' is not specified properly" do
+          unless p == 'openstack'
+            [{}, :invalid, ""].each do |prop_val|
+              infrastructure_properties = DopCommon::InfrastructureProperties.new(
+                {prop_name => prop_val},
+                infrastructure[p]
+              )
+              expect { infrastructure_properties.send(prop_name.to_sym) }.to raise_error DopCommon::PlanParsingError
+            end
+          end
+        end
+      end
+    end
+  end
+
+  %w(default_pool dest_folder).each do |method_name|
+    describe "##{method_name}" do
+      it "will return 'nil' if not specified in input hash" do
+        infrastructure_properties = DopCommon::InfrastructureProperties.new({}, nil)
+        expect(infrastructure_properties.send(method_name.to_sym)).to eq nil
+      end
+
+      it "will return '#{method_name}' if specified properly in input hash" do
+        infrastructure_properties = DopCommon::InfrastructureProperties.new({method_name => "foo-#{method_name}"}, nil)
+        expect(infrastructure_properties.send(method_name.to_sym)).to eq "foo-#{method_name}"
+      end
+
+      it "will raise an exception if not specified properly in input hash" do
+        ["", :invalid].each do |val|
+          infrastructure_properties = DopCommon::InfrastructureProperties.new({method_name => val}, nil)
+          expect { infrastructure_properties.send(method_name.to_sym) }.to raise_error DopCommon::PlanParsingError
+        end
+      end
+    end
+  end
+
+  describe '#tenant' do
+    providers.each do |p|
+      it "will return the 'tenant' name if specified properly" do
+        tenant = "tenant_#{p}"
+        infrastructure_properties = DopCommon::InfrastructureProperties.new({'tenant' => tenant}, infrastructure[p])
+        expect(infrastructure_properties.tenant).to eq(p == 'openstack' ? tenant : nil)
+      end
+    end
+
+    it "will raise an exception if provider is 'openstack' and 'tenant' is undefined" do
+      [nil, :invalid, ""].each do |prop_val|
+        infrastructure_properties = DopCommon::InfrastructureProperties.new({'tenant' => prop_val}, infrastructure['openstack'])
+        expect { infrastructure_properties.tenant }.to raise_error DopCommon::PlanParsingError
+      end
+    end
+  end
+
+  describe '#use_config_drive?' do
+    it "will return false if not specified in input hash" do
+      infrastructure_properties = DopCommon::InfrastructureProperties.new({}, nil)
+      expect(infrastructure_properties.use_config_drive?).to eq false
+    end
+
+    it "will return true or false if specified in input hash properly" do
+      [true, false].each do |val|
+        infrastructure_properties = DopCommon::InfrastructureProperties.new({'use_config_drive' => val}, infrastructure['openstack'])
+        expect(infrastructure_properties.use_config_drive?).to eq val
+      end
+    end
+
+    it 'will raise an exception if used for non-openstack provider' do
+      infrastructure_properties = DopCommon::InfrastructureProperties.new({'use_config_drive' => true}, infrastructure['ovirt'])
+      expect { infrastructure_properties.use_config_drive? }.to raise_error DopCommon::PlanParsingError
+    end
+    it 'will raise an exception if not specified properly in input hash' do
+      ['true', 'false', 1, 0, :invalid, {}].each do |val|
+        infrastructure_properties = DopCommon::InfrastructureProperties.new({'use_config_drive' => val}, infrastructure['openstack'])
+        expect { infrastructure_properties.use_config_drive? }.to raise_error DopCommon::PlanParsingError
+      end
+    end
+  end
+
+  describe '#security_groups' do
+    infra = DopCommon::Infrastructure.new('openstack', {'type' => 'openstack', 'default_security_groups' => ['sg1', 'sg2']})
+    it 'will return the default_security_groups if nothing is specified' do
+      infrastructure_properties = DopCommon::InfrastructureProperties.new({}, infra)
+      expect(infrastructure_properties.security_groups).to eq(['sg1', 'sg2'])
+    end
+    it 'will return the security_groups array if security_groups is specified' do
+      infrastructure_properties = DopCommon::InfrastructureProperties.new({'security_groups' => ['sg3']}, infra)
+      expect(infrastructure_properties.security_groups).to eq(['sg3'])
+    end
+    it 'will return a merged array of defaults and additional_security_groups if additional_security_groups is defined' do
+      infrastructure_properties = DopCommon::InfrastructureProperties.new({'additional_security_groups' => ['sg3']}, infra)
+      expect(infrastructure_properties.security_groups).to eq(['sg1', 'sg2', 'sg3'])
+    end
+    it 'will raise an error if security_groups is not properly specified' do
+      infrastructure_properties = DopCommon::InfrastructureProperties.new({'security_groups' => 'sg3'}, infra)
+      expect { infrastructure_properties.security_groups }.to raise_error DopCommon::PlanParsingError
+      infrastructure_properties = DopCommon::InfrastructureProperties.new({'security_groups' => [1, 2]}, infra)
+      expect { infrastructure_properties.security_groups }.to raise_error DopCommon::PlanParsingError
+    end
+    it 'will raise an error if additional_security_groups is not properly specified' do
+      infrastructure_properties = DopCommon::InfrastructureProperties.new({'additional_security_groups' => 'sg3'}, infra)
+      expect { infrastructure_properties.security_groups }.to raise_error DopCommon::PlanParsingError
+      infrastructure_properties = DopCommon::InfrastructureProperties.new({'additional_security_groups' => [1, 2]}, infra)
+      expect { infrastructure_properties.security_groups }.to raise_error DopCommon::PlanParsingError
+    end
+    it 'will raise an error if both security_groups and additional_security_groups are specified' do
+      infrastructure_properties = DopCommon::InfrastructureProperties.new({'additional_security_groups' => ['sg3'], 'security_groups' => ['sg3']}, infra)
+      expect { infrastructure_properties.security_groups }.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#domain_id' do
+    providers.each do |p|
+      it "will return the 'domain_id' name if specified properly" do
+        domain_id = "domain_id_#{p}"
+        infrastructure_properties = DopCommon::InfrastructureProperties.new({'domain_id' => domain_id}, infrastructure[p])
+        expect(infrastructure_properties.domain_id).to eq(p == 'openstack' ? domain_id : nil)
+      end
+    end
+    it "will return the 'default' if domain_id name isn't specified " do
+      infrastructure_properties = DopCommon::InfrastructureProperties.new({}, infrastructure['openstack'])
+      expect(infrastructure_properties.domain_id).to eq 'default'
+    end
+
+    it "will raise an exception if provider is 'openstack' and 'domain_id' is not a non-empty string" do
+      [1, :invalid, "", {}, []].each do |prop_val|
+        infrastructure_properties = DopCommon::InfrastructureProperties.new({'domain_id' => prop_val}, infrastructure['openstack'])
+        expect { infrastructure_properties.domain_id }.to raise_error DopCommon::PlanParsingError
+      end
+    end
+  end
+
+  describe '#endpoint_type' do
+    providers.each do |p|
+      %w(publicURL internalURL adminURL).each do |endpoint_type|
+        it "will return the 'endpoint_type' name if specified properly" do
+          infrastructure_properties = DopCommon::InfrastructureProperties.new({'endpoint_type' => endpoint_type}, infrastructure[p])
+          expect(infrastructure_properties.endpoint_type).to eq(p == 'openstack' ? endpoint_type : nil)
+        end
+      end
+    end
+    it "will return the 'publicURL' if endpoint_type name isn't specified " do
+      infrastructure_properties = DopCommon::InfrastructureProperties.new({}, infrastructure['openstack'])
+      expect(infrastructure_properties.endpoint_type).to eq 'publicURL'
+    end
+
+    it "will raise an exception if provider is 'openstack' and 'endpoint_type' is not publicURL, internalURL or adminURL literal " do
+      [1, :invalid, "", {}, [], 'foo'].each do |prop_val|
+        infrastructure_properties = DopCommon::InfrastructureProperties.new({'endpoint_type' => prop_val}, infrastructure['openstack'])
+        expect { infrastructure_properties.endpoint_type }.to raise_error DopCommon::PlanParsingError
+      end
+    end
+  end
+end
+

data/spec/dop_common/infrastructure_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe DopCommon::Infrastructure do
+
+  describe '#provider' do
+    it 'will set and return the infrastructure type of infrastructure if specified correctly' do
+      infrastructure = ::DopCommon::Infrastructure.new('dummy', {'type' => 'rhev'})
+      expect(infrastructure.provider).to eq(:rhev)
+    end
+    it 'will raise an error if the type is missing' do
+      infrastructure = ::DopCommon::Infrastructure.new('dummy', {})
+      expect { infrastructure.provider }.to raise_error ::DopCommon::PlanParsingError
+    end
+    it 'will raise an error ig the infrastructure provider type is invalid' do
+      infrastructure = ::DopCommon::Infrastructure.new('dummy', {'type' => 'invalid'})
+      expect { infrastructure.provider }.to raise_error ::DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#endpoint' do
+    it 'will set and return an URL object of infrastructure endpoint if specified correctly' do
+      infrastructure = ::DopCommon::Infrastructure.new('dummy', {'type' => 'baremetal'})
+      expect(infrastructure.endpoint.to_s).to eq('')
+      infrastructure = ::DopCommon::Infrastructure.new('dummy', {'type' => 'rhev', 'endpoint' => 'https://foo.bar/baz'})
+      expect(infrastructure.endpoint.to_s).to eq('https://foo.bar/baz')
+    end
+    it 'will raise an error if endpoint is unspecified and the cloud provider is not of baremetal type' do
+      infrastructure = ::DopCommon::Infrastructure.new('dummy', {'type' => 'rhev'})
+      expect { infrastructure.endpoint }.to raise_error ::DopCommon::PlanParsingError
+    end
+    it 'will raise an error if the endpoint specification is invalid' do
+      infrastructure = ::DopCommon::Infrastructure.new('dummy', {'type' => 'rhev', 'endpoint' => nil})
+      expect { infrastructure.endpoint }.to raise_error ::DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#networks' do
+    it 'will set and return networks if specified correctly' do
+      infrastructure = ::DopCommon::Infrastructure.new('dummy', {'type' => 'baremetal'})
+      expect(infrastructure.networks).to eq([])
+      infrastructure = ::DopCommon::Infrastructure.new('dummy', {'type' => 'rhev', 'networks' => {'net1' => {}}})
+      expect(infrastructure.networks.find { |n| n.name == 'net1' }).to be_a ::DopCommon::Network
+    end
+    it 'will raise an error if network specification is invalid' do
+      infrastructure = ::DopCommon::Infrastructure.new('dummy', {'type' => 'rhev'})
+      expect { infrastructure.networks }.to raise_error ::DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#affinity_groups' do
+    it 'will set and return affinity groups if specified correctly' do
+      infrastructure = ::DopCommon::Infrastructure.new('dummy', {'type' => 'rhev', 'affinity_groups' => {}})
+      expect(infrastructure.affinity_groups).to eq([])
+    end
+    it 'will raise an error in case of invalid specification of affinity groups' do
+      infrastructure = ::DopCommon::Infrastructure.new('dummy', {'type' => 'rhev', 'affinity_groups' => :invalid})
+      expect { infrastructure.affinity_groups }.to raise_error ::DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#default_security_groups' do
+    it 'will return an empty array if not defined' do
+      infrastructure = ::DopCommon::Infrastructure.new('dummy', {'type' => 'rhev'})
+      expect(infrastructure.default_security_groups).to eq([])
+    end
+    it 'will return an array of security groups if specified correctly' do
+      infrastructure = ::DopCommon::Infrastructure.new('dummy', {'type' => 'rhev', 'default_security_groups' => ['sg1', 'sg2']})
+      expect(infrastructure.default_security_groups).to eq(['sg1', 'sg2'])
+    end
+    it 'will raise an error if the security groups is not specified correctly' do
+      infrastructure = ::DopCommon::Infrastructure.new('dummy', {'type' => 'rhev', 'default_security_groups' => 1})
+      expect { infrastructure.default_security_groups }.to raise_error ::DopCommon::PlanParsingError
+      infrastructure = ::DopCommon::Infrastructure.new('dummy', {'type' => 'rhev', 'default_security_groups' => [ 1, 2 ]})
+      expect { infrastructure.default_security_groups }.to raise_error ::DopCommon::PlanParsingError
+    end
+  end
+end