smart_proxy_dhcp_infoblox 0.0.4 → 0.0.5

data/test/host_and_fixedaddress_crud_test.rb

@@ -0,0 +1,169 @@
+require 'test_helper'
+require 'infoblox'
+require 'dhcp_common/dhcp_common'
+require 'dhcp_common/record/reservation'
+require 'smart_proxy_dhcp_infoblox/fixed_address_crud'
+require 'smart_proxy_dhcp_infoblox/host_ipv4_address_crud'
+
+module CommoncrudTests
+  def test_find_record_using_ip
+    @entity.expects(:find).with(@connection, 'ipv4addr' => '192.168.42.1', '_max_results' => 1).returns([@host])
+    assert_equal @reservation, @crud.find_record_by_ip('192.168.42.0/24', '192.168.42.1')
+  end
+
+  def test_find_record_using_ip_returns_nil_if_record_not_found
+    @entity.expects(:find).with(@connection, 'ipv4addr' => '192.168.42.1', '_max_results' => 1).returns([])
+    assert_nil @crud.find_record_by_ip('192.168.42.0/24', '192.168.42.1')
+  end
+
+  def test_find_record_using_mac
+    @entity.expects(:find).with(@connection, 'mac' => '00:01:02:03:05:06', '_max_results' => 1).returns([@host])
+    assert_equal @reservation, @crud.find_record_by_mac('192.168.42.0/24', '00:01:02:03:05:06')
+  end
+
+  def test_find_record_using_mac_returns_nil_if_record_not_found
+    @entity.expects(:find).with(@connection, 'mac' => '00:01:02:03:05:06', '_max_results' => 1).returns([])
+    assert_nil @crud.find_record_by_mac('192.168.42.0/24', '00:01:02:03:05:06')
+  end
+
+  def test_find_record_by_ip
+    @crud.expects(:find_record_by_ip).with('192.168.42.0/24', '192.168.42.1')
+    @crud.find_record('192.168.42.0/24', '192.168.42.1')
+  end
+
+  def test_find_record_by_mac
+    @crud.expects(:find_record_by_mac).with('192.168.42.0/24', '00:01:02:03:05:06')
+    @crud.find_record('192.168.42.0/24', '00:01:02:03:05:06')
+  end
+
+  def test_add_record
+    @crud.expects(:build_host).with(:ip => @ip, :mac => @mac, :hostname => @hostname).returns(@host)
+    @host.expects(:post)
+
+    @crud.add_record(:ip => @ip, :mac => @mac, :hostname => @hostname)
+  end
+
+  def test_add_record_with_already_existing_host
+    @crud.expects(:build_host).with(:ip => @ip, :mac => @mac, :hostname => @hostname).returns(@host)
+    @host.expects(:post).raises(Infoblox::Error.new("IB.Data.Conflict"))
+    @crud.expects(:find_host).with('ipv4addr' => @ip).returns(@host)
+
+    assert_raises(Proxy::DHCP::AlreadyExists) { @crud.add_record(:ip => @ip, :mac => @mac, :hostname => @hostname) }
+  end
+
+  def test_del_record
+    @crud.expects(:find_host).with('ipv4addr' => @ip).returns(@host)
+    @host.expects(:delete)
+    @crud.del_record('unused', @reservation)
+  end
+end
+
+class HostCrudTest < Test::Unit::TestCase
+  include CommoncrudTests
+
+  def setup
+    @connection = Object.new
+    @crud = ::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD.new(@connection)
+
+    @entity = ::Infoblox::Host
+
+    @hostname = 'test.test.com'
+    @mac = '00:01:02:03:05:06'
+    @nextserver = '192.168.42.1'
+    @filename = '/tftpboot.img'
+    @ip = '192.168.42.1'
+
+    @host = ::Infoblox::Host.new(
+        :name => @hostname,
+        :ipv4addrs => [{:ipv4addr => @ip, :mac => @mac, :nextserver => @nextserver, :use_nextserver => true,
+                        :bootfile => @filename, :use_bootfile => true, :configure_for_dhcp => true}])
+
+    @reservation = ::Proxy::DHCP::Reservation.new(
+        :hostname => @hostname, :mac => @mac, :ip => @ip, :nextServer => @nextserver,
+        :filename => @filename, :deleteable => true,
+        :subnet => ::Proxy::DHCP::Subnet.new('192.168.42.0', '255.255.255.0'))
+  end
+
+  def test_all_hosts
+    ::Infoblox::Host.expects(:find).with(@connection, 'ipv4addr~' => '192\.168\.42\..+', '_max_results' => 2147483646).returns([@host])
+    assert_equal @reservation, @crud.all_hosts('192.168.42.0/24').first
+  end
+
+  def test_build_host
+    built = @crud.build_host(:hostname => @hostname, :mac => @mac, :ip => @ip, :nextServer => @nextserver,
+                             :filename => @filename, :deleteable => true)
+
+    assert_equal @host.name, built.name
+    assert_equal @host.ipv4addrs.size, built.ipv4addrs.size
+
+    expected_addr = @host.ipv4addrs.first
+    actual_addr = built.ipv4addrs.first
+
+    assert_equal expected_addr.ipv4addr, actual_addr.ipv4addr
+    assert_equal expected_addr.mac, actual_addr.mac
+    assert expected_addr.nextserver, actual_addr.nextserver
+    assert actual_addr.use_nextserver
+    assert_equal expected_addr.bootfile, actual_addr.bootfile
+    assert actual_addr.use_bootfile
+    assert actual_addr.configure_for_dhcp
+  end
+
+  def test_add_record_with_collision
+    @crud.expects(:build_host).with(:ip => @ip, :mac => @mac, :hostname => @hostname).returns(@host)
+    @host.expects(:post).raises(Infoblox::Error.new("IB.Data.Conflict"))
+    @crud.expects(:find_host).with('ipv4addr' => @ip).returns(
+        ::Infoblox::Host.new(:name => @hostname, :ipv4addrs => [{:ipv4addr => @ip, :mac => '11:22:33:44:55:66', :configure_for_dhcp => true}]))
+
+    assert_raises(Proxy::DHCP::Collision) { @crud.add_record(:ip => @ip, :mac => @mac, :hostname => @hostname) }
+  end
+end
+
+class FixedaddressCrudTest < Test::Unit::TestCase
+  def setup
+    @connection = Object.new
+    @crud = ::Proxy::DHCP::Infoblox::FixedAddressCRUD.new(@connection)
+
+    @entity = ::Infoblox::Fixedaddress
+
+    @hostname = 'test.test.com'
+    @mac = '00:01:02:03:05:06'
+    @nextserver = '192.168.42.1'
+    @filename = '/tftpboot.img'
+    @ip = '192.168.42.1'
+
+    @host = ::Infoblox::Fixedaddress.new(
+        :name => @hostname,
+        :ipv4addr => @ip, :mac => @mac) # :ipv4addr => @ip, :mac => @mac) #
+
+    @reservation = ::Proxy::DHCP::Reservation.new(
+        :hostname => @hostname, :mac => @mac, :ip => @ip, :deleteable => true,
+        :subnet => ::Proxy::DHCP::Subnet.new('192.168.42.0', '255.255.255.0'))
+  end
+
+  def test_all_hosts
+    ::Infoblox::Fixedaddress.expects(:find).with(@connection, 'network' => '192.168.42.0/24', '_max_results' => 2147483646).returns([@host])
+    assert_equal @reservation, @crud.all_hosts('192.168.42.0/24').first
+  end
+
+  def test_build_host
+    built = @crud.build_host(:hostname => @hostname, :mac => @mac, :ip => @ip, :nextServer => @nextserver,
+                             :filename => @filename, :deleteable => true)
+
+    assert_equal @host.name, built.name
+    assert_equal @host.ipv4addr, built.ipv4addr
+    assert_equal @host.mac, built.mac
+#    assert @host.nextserver, built.nextserver
+#    assert built.use_nextserver
+#    assert_equal @host.bootfile, built.bootfile
+#    assert built.use_bootfile
+  end
+
+  def test_add_record_with_collision
+    @crud.expects(:build_host).with(:ip => @ip, :mac => @mac, :hostname => @hostname).returns(@host)
+    @host.expects(:post).raises(Infoblox::Error.new("IB.Data.Conflict"))
+    @crud.expects(:find_host).with('ipv4addr' => @ip).returns(
+        ::Infoblox::Fixedaddress.new(:name => @hostname, :ipv4addr => @ip, :mac => '11:22:33:44:55:66'))
+
+    assert_raises(Proxy::DHCP::Collision) { @crud.add_record(:ip => @ip, :mac => @mac, :hostname => @hostname) }
+  end
+end

data/test/infoblox_provider_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+require 'infoblox'
+require 'dhcp_common/dhcp_common'
+require 'dhcp_common/subnet'
+require 'smart_proxy_dhcp_infoblox/dhcp_infoblox_main'
+
+class InfobloxProviderTest < Test::Unit::TestCase
+  def setup
+    @connection = Object.new
+    @crud = Object.new
+    @restart_grid = Object.new
+    @unused_ips = Object.new
+    @managed_subnets = nil
+
+    @network = Infoblox::Network.new(:network => '192.168.42.0/24')
+    @subnet = ::Proxy::DHCP::Subnet.new('192.168.42.0', '255.255.255.0')
+
+
+    @network_2 = Infoblox::Network.new(:network => '192.168.43.0/24')
+    @provider = Proxy::DHCP::Infoblox::Provider.new(@connection, @crud, @restart_grid, @unused_ips, @managed_subnets)
+  end
+
+  def test_subnets
+    Infoblox::Network.expects(:all).with(@connection).returns([@network])
+    assert_equal [@subnet], @provider.subnets
+  end
+
+  def test_subnets_returns_managed_subnets_only
+    provider = Proxy::DHCP::Infoblox::Provider.new(@connection, @crud, @restart_grid, @unused_ips, ['192.168.42.0/255.255.255.0'])
+    Infoblox::Network.expects(:all).with(@connection).returns([@network, @network_2])
+    assert_equal [@subnet], provider.subnets
+  end
+
+  def test_find_subnet
+    ::Infoblox::Network.expects(:find).with(@connection, 'network~' => '192.168.42.0', '_max_results' => 1).returns([@network])
+    assert_equal @network, @provider.find_network('192.168.42.0')
+  end
+
+  def test_find_subnet_raises_exception_when_network_not_found
+    ::Infoblox::Network.expects(:find).with(@connection, 'network~' => '192.168.42.0', '_max_results' => 1).returns([])
+    assert_raises(RuntimeError) { @provider.find_network('192.168.42.0') }
+  end
+
+  def test_add_record_restarts_grid
+    @crud.stubs(:add_record)
+    @provider.stubs(:full_network_address)
+    @restart_grid.expects(:try_restart)
+    @provider.add_record({})
+  end
+
+  def test_del_record_restarts_grid
+    @crud.stubs(:del_record)
+    @provider.stubs(:full_network_address)
+    @restart_grid.expects(:try_restart)
+    @provider.del_record(@subnet,
+                         ::Proxy::DHCP::Record.new(:name => 'test',
+                                                   :ip => '192.168.42.1',
+                                                   :mac => '00:01:02:03:04:05',
+                                                   :subnet => ::Proxy::DHCP::Subnet.new('192.168.42.0', '255.255.255.0')))
+  end
+end

data/test/plugin_configuration_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+require 'infoblox'
+require 'dhcp_common/dhcp_common'
+require 'smart_proxy_dhcp_infoblox/plugin_configuration'
+require 'smart_proxy_dhcp_infoblox/record_type_validator'
+require 'smart_proxy_dhcp_infoblox/dhcp_infoblox_plugin'
+require 'smart_proxy_dhcp_infoblox/host_ipv4_address_crud'
+require 'smart_proxy_dhcp_infoblox/fixed_address_crud'
+require 'smart_proxy_dhcp_infoblox/grid_restart'
+require 'smart_proxy_dhcp_infoblox/unused_ips'
+require 'smart_proxy_dhcp_infoblox/dhcp_infoblox_main'
+
+class PluginDefaultConfigurationTest < Test::Unit::TestCase
+  def test_default_settings
+    assert_equal({:record_type => 'host', :range => false}, Proxy::DHCP::Infoblox::Plugin.default_settings)
+  end
+end
+
+class InfobloxDhcpProductionWiringTest < Test::Unit::TestCase
+  def setup
+    @settings = {:username => 'user', :password => 'password', :server => '127.0.0.1', :record_type => 'host',
+                 :use_ranges => true, :subnets => ['1.1.1.0/255.255.255.0']}
+    @container = ::Proxy::DependencyInjection::Container.new
+    Proxy::DHCP::Infoblox::PluginConfiguration.new.load_dependency_injection_wirings(@container, @settings)
+  end
+
+  def test_connection_initialization
+    connection = @container.get_dependency(:connection)
+    assert_equal 'https://127.0.0.1', connection.host
+    assert_equal 'user', connection.username
+    assert_equal 'password', connection.password
+    assert_equal({:verify => false}, connection.ssl_opts)
+  end
+
+  def test_unused_ips_configuration
+    free_ips = @container.get_dependency(:unused_ips)
+    assert_not_nil free_ips.connection
+    assert free_ips.use_ranges
+  end
+
+  def test_host_ipv4_crud_configuration
+    host = @container.get_dependency(:host_ipv4_crud)
+    assert_not_nil host.connection
+  end
+
+  def test_fixed_address_crud_configuration
+    fixed_address = @container.get_dependency(:fixed_address_crud)
+    assert_not_nil fixed_address.connection
+  end
+
+  def test_grid_restart_configuration
+    grid_restart = @container.get_dependency(:grid_restart)
+    assert_not_nil grid_restart.connection
+  end
+
+  def test_provider_configuration_with_host_crud
+    provider = @container.get_dependency(:dhcp_provider)
+    assert_not_nil provider.connection
+    assert_not_nil provider.restart_grid
+    assert_not_nil provider.unused_ips
+    assert provider.managed_subnets.include?('1.1.1.0/255.255.255.0')
+    assert provider.crud.instance_of?(::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD)
+  end
+
+  def test_provider_configuration_with_fixedaddress_crud
+    Proxy::DHCP::Infoblox::PluginConfiguration.new.
+        load_dependency_injection_wirings(@container, :username => 'user', :password => 'password',
+                                          :server => '127.0.0.1', :record_type => 'fixed_address')
+
+    provider = @container.get_dependency(:dhcp_provider)
+    assert provider.crud.instance_of?(::Proxy::DHCP::Infoblox::FixedAddressCRUD)
+  end
+end

data/test/record_type_validator_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+require 'smart_proxy_dhcp_infoblox/record_type_validator'
+
+class RecordTypeValidatorTest < Test::Unit::TestCase
+  def setup
+    @validator = ::Proxy::DHCP::Infoblox::RecordTypeValidator.new(:dhcp_infoblox, :record_type, nil, nil)
+  end
+
+  def test_should_pass_when_record_type_is_host
+    assert @validator.validate!(:record_type => 'host')
+  end
+
+  def test_should_pass_when_record_type_is_fixedaddress
+    assert @validator.validate!(:record_type => 'fixedaddress')
+  end
+
+  def test_should_raise_exception_when_record_type_is_unrecognised
+    assert_raises(::Proxy::Error::ConfigurationError) { @validator.validate!(:record_type => '') }
+  end
+end

data/test/regex_generator_test.rb

@@ -0,0 +1,86 @@
+require 'test_helper'
+require 'smart_proxy_dhcp_infoblox/network_address_range_regex_generator'
+
+class RangeRegExGeneratorTest < Test::Unit::TestCase
+  def setup
+    @generator = ::Proxy::DHCP::Infoblox::RangeRegularExpressionGenerator.new
+  end
+
+  def test_full_range_single_digit
+    assert_equal "(0?0?[0123456789])", @generator.range_regex(0, 9)
+  end
+
+  def test_single_digits_range
+    assert_equal "(0?0?[34567])", @generator.range_regex(3, 7)
+  end
+
+  def test_neighbour_numbers_single_digits_range
+    assert_equal "(0?0?[12])", @generator.range_regex(1, 2)
+  end
+
+  def test_full_range_double_digits
+    assert_equal "(0?[123456789][0123456789])", @generator.range_regex(10, 99)
+  end
+
+  def test_range_double_digits
+    assert_equal "(0?3[3456789]|0?[456][0123456789]|0?7[01234567])", @generator.range_regex(33, 77)
+  end
+
+  def test_neighbour_numbers_double_digits_range
+    assert_equal "(0?5[56])", @generator.range_regex(55, 56)
+  end
+
+  def test_single_and_double_digit_full_range
+    assert_equal "(0?0?[0123456789]|0?[123456789][0123456789])", @generator.range_regex(0, 99)
+  end
+
+  def test_full_range_triple_digits
+    assert_equal "([123456789][0123456789][0123456789])", @generator.range_regex(100, 999)
+  end
+
+  def test_range_triple_digits
+    assert_equal "(12[56789]|1[3456789][0123456789]|[23456][0123456789][0123456789]|7[012][0123456789]|73[01234])", @generator.range_regex(125, 734)
+  end
+
+  def test_neighbour_numbers_triple_digits_range
+    assert_equal "(34[56])", @generator.range_regex(345, 346)
+  end
+
+  def test_single_double_and_triple_digit_full_range
+    assert_equal "(0?0?[0123456789]|0?[123456789][0123456789]|[123456789][0123456789][0123456789])", @generator.range_regex(0, 999)
+  end
+end
+
+class NetworkAddressesRegularExpressionGeneratorTest < Test::Unit::TestCase
+  def setup
+    @generator = ::Proxy::DHCP::Infoblox::NetworkAddressesRegularExpressionGenerator.new
+  end
+
+  def test_ranges_with_cidrs_of_multiples_of_8bit
+    assert_equal [[1, 1], [0, 255], [0, 255], [0, 255]], @generator.network_cidr_range_octets('1.0.0.0/8')
+    assert_equal [[10, 10], [10, 10], [0, 255], [0, 255]], @generator.network_cidr_range_octets('10.10.0.0/16')
+    assert_equal [[33, 33], [34, 34], [35, 35], [0, 255]], @generator.network_cidr_range_octets('33.34.35.0/24')
+  end
+
+  def test_ranges_with_cidrs_non_multiples_of_8bits
+    assert_equal [[240, 255], [0, 255], [0, 255], [0, 255]], @generator.network_cidr_range_octets('240.0.0.0/4')
+    assert_equal [[10, 10], [128, 255], [0, 255], [0, 255]], @generator.network_cidr_range_octets('10.128.0.0/9')
+    assert_equal [[192, 192], [168, 168], [42, 42], [64, 127]], @generator.network_cidr_range_octets('192.168.42.64/26')
+  end
+
+  def test_cidr16_range_to_regex
+    assert_equal '10\.10\..+\..+', @generator.range_to_regex([[10, 10], [10, 10], [0, 255], [0, 255]])
+  end
+
+  def test_cidr9_range_to_regex
+    assert_equal '10\.(129|1[3456789][0123456789]|2[01234][0123456789]|25[01234])\..+\..+', @generator.range_to_regex([[10, 10], [128, 255], [0, 255], [0, 255]])
+  end
+
+  def test_cidr26_range_to_regex
+    assert_equal '192\.168\.42\.(0?6[56789]|0?[789][0123456789]|1[01][0123456789]|12[0123456])', @generator.range_to_regex([[192, 192], [168, 168], [42, 42], [64, 127]])
+  end
+
+  def test_generate_regex
+    assert_equal '192\.168\.42\.(0?6[56789]|0?7[012345678])', @generator.generate_regex('192.168.42.64/28')
+  end
+end

data/test/test_helper.rb

@@ -1,7 +1,5 @@
 require 'test/unit'
 require 'mocha/setup'
-require 'json'
-require 'ostruct'
 
 require 'smart_proxy_for_testing'
 

data/test/unused_ip_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+require 'infoblox'
+require 'smart_proxy_dhcp_infoblox/unused_ips'
+
+class UnusedIpTest < Test::Unit::TestCase
+  def setup
+    @connection = Object.new
+    @unused_ips = ::Proxy::DHCP::Infoblox::UnusedIps.new(@connection, false)
+    @network = Infoblox::Network.new(:network => '1.1.1.0/24')
+    @range = Infoblox::Range.new(:start_addr => '1.1.1.0', :end_addr => '1.1.1.253')
+  end
+
+  def test_excluded_ips
+    assert_equal ['192.168.42.254', '192.168.42.255'], @unused_ips.excluded_ips('192.168.42.0/24', '192.168.42.0', '192.168.42.253')
+  end
+
+  def test_excluded_ips_is_empty_when_range_start_is_nil
+    assert @unused_ips.excluded_ips('192.168.42.0/24', nil, '192.168.42.253').empty?
+  end
+
+  def test_excluded_ips_is_empty_when_range_end_is_nil
+    assert @unused_ips.excluded_ips('192.168.42.0/24', '192.168.42.250', nil).empty?
+  end
+
+  def test_unused_network_ip
+    ::Infoblox::Network.expects(:find).with(@connection, 'network~' => '1.1.1.0', '_max_results' => 1).returns([@network])
+    @network.expects(:next_available_ip).with(1, ['1.1.1.254', '1.1.1.255']).returns(['1.1.1.1'])
+    assert_equal '1.1.1.1', @unused_ips.unused_network_ip('1.1.1.0', '1.1.1.0', '1.1.1.253')
+  end
+
+  def test_unused_range_ip
+    ::Infoblox::Range.expects(:find).with(@connection, 'network~' => '1.1.1.0').returns([@range])
+    @range.expects(:next_available_ip).with(1).returns(['1.1.1.1'])
+    assert_equal '1.1.1.1', @unused_ips.unused_range_ip('1.1.1.0', '1.1.1.0', '1.1.1.253')
+  end
+
+  def test_unused_ip_uses_network_api_when_use_ranges_is_false
+    unused_ips = ::Proxy::DHCP::Infoblox::UnusedIps.new(@connection, false)
+    unused_ips.expects(:unused_network_ip).with('1.1.1.0', '1.1.1.0', '1.1.1.253')
+    unused_ips.unused_ip('1.1.1.0', '1.1.1.0', '1.1.1.253')
+  end
+
+  def test_unused_ip_uses_range_api_when_use_ranges_is_true
+    unused_ips = ::Proxy::DHCP::Infoblox::UnusedIps.new(@connection, true)
+    unused_ips.expects(:unused_range_ip).with('1.1.1.0', '1.1.1.0', '1.1.1.253')
+    unused_ips.unused_ip('1.1.1.0', '1.1.1.0', '1.1.1.253')
+  end
+end