dop_common 0.13.0

data/spec/dop_common/interface_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+describe DopCommon::Interface do
+  before(:each) do
+    @networks = {
+      :valid_defgw => [DopCommon::Network.new(
+        'valid_defgw', {
+          'ip_pool'    => {'from' => '192.168.1.100', 'to' => '192.168.1.200'},
+          'ip_netmask' => '255.255.255.0',
+          'ip_defgw'   => '192.168.1.254'
+        }
+      )],
+      :valid_nodefgw => [DopCommon::Network.new(
+        'valid_nodefgw', {
+          'ip_pool'    => {'from' => '192.168.1.100', 'to' => '192.168.1.200'},
+          'ip_netmask' => '255.255.255.0',
+          'ip_defgw'   => false
+        }
+      )]
+    }
+  end
+
+  describe '#network' do
+    it 'will return a network name in case it is defined in networks hash' do
+      interface = DopCommon::Interface.new(
+        'eth0',
+        {'network' => 'valid_defgw'},
+        {:parsed_networks => @networks[:valid_defgw]}
+      )
+      expect(interface.network).to eq @networks[:valid_defgw].first.name
+    end
+    it "will raise an error if network name is invalid" do
+      [nil, [], {}, "", 1].each do |n|
+        interface = DopCommon::Interface.new(
+          'eth0',
+          {'network' => n},
+          {:parsed_networks => @networks[:valid_defgw]}
+        )
+        expect{interface.network}.to raise_error DopCommon::PlanParsingError
+      end
+    end
+    it "will raise an error if the network points to invalid network definition" do
+      interface = DopCommon::Interface.new(
+        'eth0',
+        {'network' => 'invalid definition', 'ip' => '192.168.1.101'},
+        {:parsed_networks => @networks[:valid_defgw]}
+      )
+      expect{interface.network}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#ip' do
+    it "will return :dhcp if 'dhcp' is specified" do
+      interface = DopCommon::Interface.new('eth0', {:ip => 'dhcp'})
+      expect(interface.ip).to eq(:dhcp)
+    end
+    it "will return 'none' if none is specified" do
+      interface = DopCommon::Interface.new('eth0', {:ip => 'none'})
+      expect(interface.ip).to eq(:none)
+    end
+    it 'will return an IP if specified correctly' do
+      interface = DopCommon::Interface.new(
+        'eth0',
+        {'network' => 'valid_defgw', 'ip' => '192.168.1.101'},
+        {:parsed_networks => @networks[:valid_defgw]}
+      )
+      expect(interface.ip).to eq('192.168.1.101')
+    end
+    it 'will raise an error if the ip is not valid' do
+      interface = DopCommon::Interface.new('eth0', {'ip' => 'not valid ip'})
+      expect{interface.ip}.to raise_error DopCommon::PlanParsingError
+      interface = DopCommon::Interface.new('eth0', {'ip' => 2})
+      expect{interface.ip}.to raise_error DopCommon::PlanParsingError
+      interface = DopCommon::Interface.new('eth0', {'ip' => '300.0.0.0'})
+      expect{interface.ip}.to raise_error DopCommon::PlanParsingError
+      %w(192.168.1.202 192.168.1.254).each do |ip|
+        interface = DopCommon::Interface.new(
+          'eth0',
+          {'network' => 'valid_defgw', 'ip' => ip},
+          {:parsed_networks => @networks[:valid_defgw]}
+        )
+        expect{interface.ip}.to raise_error DopCommon::PlanParsingError
+      end
+    end
+  end
+
+  describe '#netmask' do
+    it 'will return a netmask if specified correctly' do
+      interface = DopCommon::Interface.new(
+        'eth0',
+        {'network' => 'valid_defgw', 'ip' => '192.168.1.101'},
+        {:parsed_networks => @networks[:valid_defgw]}
+      )
+      netmask = @networks[:valid_defgw].first.ip_netmask.to_s
+      expect(interface.netmask).to eq(netmask)
+    end
+  end
+
+  describe '#gateway' do
+    it 'will return a gateway if specified correctly' do
+      %w(valid_defgw valid_nodefgw).each do |n|
+        interface = DopCommon::Interface.new(
+          'eth0',
+          {'network' => n, 'ip' => '192.168.1.101'},
+          {:parsed_networks => @networks[n.to_sym]}
+        )
+        gateway = @networks[n.to_sym].first.ip_defgw.to_s
+        expect(interface.gateway.to_s).to eq(gateway)
+      end
+    end
+  end
+
+  describe '#set_gateway?' do
+    it 'will return true if not specified and network definition contains a default gateway' do
+      interface = DopCommon::Interface.new(
+        'eth0',
+        {'network' => 'valid_defgw', 'ip' => '192.168.1.101'},
+        {:parsed_networks => @networks[:valid_defgw]}
+      )
+      expect(interface.set_gateway?).to eq(true)
+    end
+    [true, false].each do |v|
+      it "will return #{v} if specified and network definition contains a default gateway" do
+        interface = DopCommon::Interface.new(
+          'eth0',
+          {'network' => 'valid_defgw', 'ip' => '192.168.1.101', 'set_gateway' => v},
+          {:parsed_networks => @networks[:valid_defgw]}
+        )
+        expect(interface.set_gateway?).to eq(v)
+      end
+    end
+    it 'will return false if not specified and network definition does not contain a default gateway' do
+      interface = DopCommon::Interface.new(
+        'eth0',
+        {'network' => 'valid_nodefgw', 'ip' => '192.168.1.101'},
+        {:parsed_networks => @networks[:valid_nodefgw]}
+      )
+      expect(interface.set_gateway?).to eq(false)
+    end
+    it 'will raise an error if not specified correctly' do
+      [[], {}, 0, 1, 'foo'].each do |v|
+        interface = DopCommon::Interface.new(
+          'eth0',
+          {'network' => 'valid_defgw', 'ip' => '192.168.1.101', 'set_gateway' => v},
+          {:parsed_networks => @networks[:valid_defgw]}
+        )
+        expect{interface.set_gateway?}.to raise_error DopCommon::PlanParsingError
+      end
+    end
+    it "will raise an error if set to 'true' and network definition does not contain a default gateway" do
+      interface = DopCommon::Interface.new(
+        'eth0',
+        {'network' => 'valid_nodefgw', 'ip' => '192.168.1.101', 'set_gateway' => true},
+        {:parsed_networks => @networks[:valid_nodefgw]}
+      )
+      expect{interface.set_gateway?}.to raise_error DopCommon::PlanParsingError
+    end
+  end
+  describe '#virtual_switch' do
+    it 'will return a virtual switch name if specified correctly' do
+      ['foo', 'foo123', '123', 'foo bar', 'foo-bar', nil].each do |s|
+        interface = DopCommon::Interface.new('eth0', {'virtual_switch' => s})
+        expect(interface.virtual_switch).to be_a_kind_of(s.class)
+        expect(interface.virtual_switch).to eq s
+      end
+    end
+    it "will raise an error if the virtual switch definition isn't valid" do
+      [123, {}, [], ""].each do |s|
+        interface = DopCommon::Interface.new('eth0', {'virtual_switch' => s})
+        expect{interface.virtual_switch}.to raise_error DopCommon::PlanParsingError
+      end
+    end
+  end
+
+  describe '#floating_network' do
+    it 'will return nil if not specified' do
+      interface = DopCommon::Interface.new('eth0', {})
+      expect(interface.floating_network).to eq(nil)
+    end
+    it 'will return an IP network if specified properly' do
+      interface = DopCommon::Interface.new('eth0', {'floating_network' => 'floating-network'})
+      expect(interface.floating_network).to eq('floating-network')
+    end
+    it 'will raise an error if not specified correctly' do
+      [{}, [], '', 1].each do |n|
+        interface = DopCommon::Interface.new('eth0', {'floating_network' => n})
+        expect{interface.floating_network}.to raise_error DopCommon::PlanParsingError
+      end
+    end
+  end
+end
+

data/spec/dop_common/network_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe DopCommon::Network do
+
+  good_ip_defgw = '192.168.1.1'
+  good_ip_netmask = '255.255.255.0'
+  good_net = {
+    'ip_defgw' => good_ip_defgw,
+    'ip_netmask' => good_ip_netmask
+  }
+
+  describe '#ip_defgw' do
+    it 'will return a netmask object if the default gateway is correct' do
+      network = DopCommon::Network.new('dummy', {})
+      expect(network.ip_defgw).to be_nil
+      network = DopCommon::Network.new('dummy', good_net)
+      expect(network.ip_defgw.to_s).to eq(good_net['ip_defgw'])
+    end
+    it 'will return a netmask object if the default gateway is nil' do
+      network = DopCommon::Network.new('dummy', good_net.merge('ip_defgw' => false))
+      expect(network.ip_defgw).to be_falsey
+    end
+    it 'will raise an error in case of invalid default gateway IP' do
+      network = DopCommon::Network.new('dummy', {'ip_defgw' => :invalid})
+      expect { network.ip_defgw }.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+
+  describe '#ip_netmask' do
+    it 'will return a netmask object if the netmask is correct' do
+      network = DopCommon::Network.new('dummy', {})
+      expect(network.ip_netmask).to eq(nil)
+      network = DopCommon::Network.new('dummy', {'ip_netmask' => good_ip_netmask})
+      expect(network.ip_netmask.to_s).to eq(good_ip_netmask)
+    end
+    it 'will raise an error in case of invalid netmask' do
+      network = DopCommon::Network.new('dummy', {'ip_netmask' => :invalid})
+      expect { network.ip_netmask }.to raise_error DopCommon::PlanParsingError
+    end
+  end
+
+  describe '#ip_pool' do
+    good_ip_from = '192.168.1.11'
+    good_ip_to = '192.168.1.249'
+
+    it 'will return an empty hash if "ip_pool" is unspecified' do
+      network = DopCommon::Network.new('dummy', {})
+      expect(network.ip_pool).to eq({})
+    end
+
+    it 'will return a hash with "from" and "to" if network is specified properly' do
+      network = DopCommon::Network.new('dummy', good_net.merge('ip_pool' => {'from' => good_ip_from, 'to' => good_ip_to}))
+      expect(network.ip_pool[:from].to_s).to eq(good_ip_from)
+      expect(network.ip_pool[:to].to_s).to eq(good_ip_to)
+    end
+
+    it 'will raise an error if ip_pool is not a hash and any of "from" or "to" is not defined' do
+      network = DopCommon::Network.new('dummy', good_net.merge('ip_pool' => :invalid))
+      expect { network.ip_pool }.to raise_error DopCommon::PlanParsingError
+      network = DopCommon::Network.new('dummy', good_net.merge('ip_pool' => {'to' => good_ip_to}))
+      expect { network.ip_pool }.to raise_error DopCommon::PlanParsingError
+      network = DopCommon::Network.new('dummy', good_net.merge('ip_pool' => {'from' => good_ip_from}))
+      expect { network.ip_pool }.to raise_error DopCommon::PlanParsingError
+    end
+
+    it 'will raise an error in case "from" is an invalid IP' do
+      network = DopCommon::Network.new('dummy', good_net.merge('ip_pool' => {'from' => :invalid, 'to' => good_ip_to}))
+      expect { network.ip_pool }.to raise_error DopCommon::PlanParsingError
+    end
+
+    it 'will raise an error in case "to" is an invalid IP' do
+      network = DopCommon::Network.new('dummy', good_net.merge('ip_pool' => {'from' => good_ip_from, 'to' => :invalid}))
+      expect { network.ip_pool }.to raise_error DopCommon::PlanParsingError
+    end
+
+    it 'will raise an error in case of invalid ip_pool specification (from > to)' do
+      network = DopCommon::Network.new('dummy', good_net.merge('ip_pool' => {'from' => good_ip_to, 'to' => good_ip_from}))
+      expect { network.ip_pool }.to raise_error DopCommon::PlanParsingError
+    end
+
+    it 'will raise an error if the IP of default gateway is within IP pool range' do
+      bad_net = {
+        'ip_defgw' => good_ip_from,
+        'ip_netmask' => good_net['ip_netmask']
+      }
+      network = DopCommon::Network.new('dummy', bad_net.merge('ip_pool' => {'from' => good_ip_to, 'to' => good_ip_from}))
+      expect { network.ip_pool }.to raise_error DopCommon::PlanParsingError
+    end
+  end
+end
+

data/spec/dop_common/node_filter_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+class NodeFilterTest
+  include DopCommon::NodeFilter
+end
+
+describe DopCommon::NodeFilter do
+  describe '#filter_nodes' do
+    subject { NodeFilterTest.new.filter_nodes(nodes, filters) }
+
+    context 'include only specified nodes' do
+      let(:nodes) {[
+        instance_double(DopCommon::Node, :has_name? => true),
+        instance_double(DopCommon::Node, :has_name? => false)
+      ]}
+      let(:filters){OpenStruct.new({:nodes => '/foo/'})}
+
+      it { is_expected.to include(nodes[0]) }
+      it { is_expected.to_not include(nodes[1]) }
+    end
+
+    context 'exclude specified nodes' do
+      let(:nodes) {[
+        instance_double(DopCommon::Node, :has_name? => true),
+        instance_double(DopCommon::Node, :has_name? => false)
+      ]}
+      let(:filters){OpenStruct.new({:nodes => :all, :exclude_nodes => '/foo/'})}
+
+      it { is_expected.to include(nodes[1]) }
+      it { is_expected.to_not include(nodes[0]) }
+    end
+
+    context 'include only specified roles' do
+      let(:nodes) {[
+        instance_double(DopCommon::Node, :has_role? => true),
+        instance_double(DopCommon::Node, :has_role? => false)
+      ]}
+      let(:filters){OpenStruct.new({:roles => :all, :exclude_roles => '/foo/'})}
+
+      it { is_expected.to include(nodes[1]) }
+      it { is_expected.to_not include(nodes[0]) }
+    end
+
+    context 'exclude specified roles' do
+      let(:nodes) {[
+        instance_double(DopCommon::Node, :has_role? => true),
+        instance_double(DopCommon::Node, :has_role? => false)
+      ]}
+      let(:filters){OpenStruct.new({:roles => '/foo/'})}
+
+      it { is_expected.to include(nodes[0]) }
+      it { is_expected.to_not include(nodes[1]) }
+    end
+
+    context 'include only specified nodes by config' do
+      let(:nodes) {[
+        instance_double(DopCommon::Node, :config_includes? => true),
+        instance_double(DopCommon::Node, :config_includes? => false)
+      ]}
+      let(:filters){OpenStruct.new({:nodes_by_config => {'foo' => '/foo/'}})}
+
+      it { is_expected.to include(nodes[0]) }
+      it { is_expected.to_not include(nodes[1]) }
+    end
+
+
+  end
+end
+
+