smart_proxy_dhcp_infoblox 0.0.5 → 0.0.18

data/lib/smart_proxy_dhcp_infoblox/ip_address_arithmetic.rb

@@ -1,20 +1,20 @@
 module ::Proxy::DHCP::Infoblox
   module IpAddressArithmetic
     def cidr_to_ip_mask(prefix_length)
-      bitmask = 0xFFFFFFFF ^ (2 ** (32-prefix_length) - 1)
-      (0..3).map {|i| (bitmask >> i*8) & 0xFF}.reverse.join('.')
+      bitmask = 0xFFFFFFFF ^ ((2**(32 - prefix_length)) - 1)
+      (0..3).map { |i| (bitmask >> (i * 8)) & 0xFF }.reverse.join('.')
     end
 
     def ipv4_to_i(an_address)
-      an_address.split('.').inject(0) {|a, c| (a << 8) + c.to_i}
+      an_address.split('.').inject(0) { |a, c| (a << 8) + c.to_i }
     end
 
-    def i_to_ipv4(i)
-      (0..3).inject([]) {|a, c| a.push((i >> (c * 8)) & 0xFF)}.reverse.join('.')
+    def i_to_ipv4(i) # rubocop:todo Naming/MethodParameterName
+      (0..3).inject([]) { |a, c| a.push((i >> (c * 8)) & 0xFF) }.reverse.join('.')
     end
 
     def cidr_to_bitmask(prefix_length)
-      0xFFFFFFFF ^ (2 ** (32-prefix_length) - 1)
+      0xFFFFFFFF ^ ((2**(32 - prefix_length)) - 1)
     end
 
     def cidr_to_i(an_address_with_cidr)

data/lib/smart_proxy_dhcp_infoblox/network_address_range_regex_generator.rb

@@ -12,7 +12,8 @@ module ::Proxy::DHCP::Infoblox
 
       def add_children(values)
         return if values.empty?
-        node = (found = children.find {|n| n.value == values.first}).nil? ? add_child(Node.new(values.first)) : found
+
+        node = (found = children.find { |n| n.value == values.first }).nil? ? add_child(Node.new(values.first)) : found
         node.add_children(values[1..-1])
       end
 
@@ -21,6 +22,7 @@ module ::Proxy::DHCP::Infoblox
         return 1 if other.value.to_s == '0?'
         return 0 if value == other.value
         return -1 if value < other.value
+
         1
       end
 
@@ -31,23 +33,27 @@ module ::Proxy::DHCP::Infoblox
       end
 
       def group_children
-        children.each {|n| n.group_children}
+        children.each { |n| n.group_children }
         return if children.size < 2
-        @children = children[1..-1].inject([MergedNode.new(children.first)]) do |grouped, to_group|
+
+        @children = children[1..-1].each_with_object([MergedNode.new(children.first)]) do |to_group, grouped|
           current = MergedNode.new(to_group)
-          found = grouped.find {|g| ((g.value != ['0?'] && current.value != ['0?']) || (current.value == ['0?'] && g.value == ['0?'])) && (g.children == current.children)}
+          found = grouped.find do |g|
+            ((g.value != ['0?'] && current.value != ['0?']) || (current.value == ['0?'] && g.value == ['0?'])) && \
+              (g.children == current.children)
+          end
           found.nil? ? grouped.push(current) : found.merge(current)
-          grouped
         end
       end
 
       def as_regex
-        children.empty? ? [value.to_s] : children.map {|c| c.as_regex.map {|r| value.to_s + r}}.flatten
+        children.empty? ? [value.to_s] : children.map { |c| c.as_regex.map { |r| value.to_s + r } }.flatten
       end
     end
 
     class MergedNode
       attr_accessor :value, :children
+
       def initialize(a_node)
         @value = [a_node.value].flatten
         @children = a_node.children
@@ -59,15 +65,16 @@ module ::Proxy::DHCP::Infoblox
       end
 
       def as_regex
-        children.empty? ? [value_as_regex] : children.map {|c| c.as_regex.map {|r| value_as_regex + r}}.flatten
+        children.empty? ? [value_as_regex] : children.map { |c| c.as_regex.map { |r| value_as_regex + r } }.flatten
       end
 
       def value_as_regex
-        value.size < 2 ? value.first.to_s : "[#{value.join('')}]"
+        (value.size < 2) ? value.first.to_s : "[#{value.join}]"
       end
 
       def ==(other)
         return false if self.class != other.class
+
         value == other.value
       end
     end
@@ -79,14 +86,14 @@ module ::Proxy::DHCP::Infoblox
 
       def as_regex
         group_children
-        "(%s)" % children.map {|c| c.as_regex}.join('|')
+        "(%s)" % children.map { |c| c.as_regex }.join('|')
       end
 
       def digits(a_number)
         to_return = []
         begin
           to_return.push(a_number % 10)
-          a_number = a_number / 10
+          a_number /= 10
         end while a_number != 0
         to_return.reverse
       end
@@ -94,7 +101,7 @@ module ::Proxy::DHCP::Infoblox
 
     def range_regex(range_start, range_end)
       root = Root.new(nil)
-      (range_start..range_end).to_a.each {|i| root.add_number(i)}
+      (range_start..range_end).to_a.each { |i| root.add_number(i) }
       root.as_regex
     end
   end
@@ -111,7 +118,7 @@ module ::Proxy::DHCP::Infoblox
       range_start_octets = range.first.split('.').map(&:to_i)
       range_end_octets = range.last.split('.').map(&:to_i)
 
-      (0..3).map {|i| [range_start_octets[i], range_end_octets[i]]}
+      (0..3).map { |i| [range_start_octets[i], range_end_octets[i]] }
     end
 
     def range_to_regex(range)

data/lib/smart_proxy_dhcp_infoblox/plugin_configuration.rb

@@ -3,35 +3,46 @@ module Proxy::DHCP::Infoblox
     def load_classes
       require 'infoblox'
       require 'dhcp_common/dhcp_common'
+      require 'dhcp_common/free_ips'
       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'
     end
 
-    def load_dependency_injection_wirings(c, settings)
+    def load_dependency_injection_wirings(c, settings) # rubocop:todo Naming/MethodParameterName
+      c.dependency :connection, (lambda {
+        ::Infoblox.wapi_version = '2.0'
+        ::Infoblox::Connection.new(:username => settings[:username], :password => settings[:password],
+                                   :host => settings[:server],
+                                   :ssl_opts => { :verify => !ENV['FOREMAN_INFOBLOX_NOSSLVERIFY'] },
+                                   :logger => ::Proxy::LogBuffer::Decorator.instance)
+      })
 
+      c.singleton_dependency :unused_ips, lambda { ::Proxy::DHCP::FreeIps.new(settings[:blacklist_duration_minutes]) }
 
-      c.dependency :connection, (lambda do
-                                  ::Infoblox.wapi_version = '2.0'
-                                  ::Infoblox::Connection.new(:username => settings[:username] ,:password => settings[:password],
-                                                             :host => settings[:server], :ssl_opts => {:verify => false})
-                                end)
-
-
-      c.dependency :unused_ips, lambda { ::Proxy::DHCP::Infoblox::UnusedIps.new(c.get_dependency(:connection), settings[:use_ranges])}
-      c.dependency :host_ipv4_crud, lambda { ::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD.new(c.get_dependency(:connection))}
-      c.dependency :fixed_address_crud, lambda { ::Proxy::DHCP::Infoblox::FixedAddressCRUD.new(c.get_dependency(:connection))}
-      c.dependency :grid_restart, lambda { ::Proxy::DHCP::Infoblox::GridRestart.new(c.get_dependency(:connection))}
-      c.dependency :dhcp_provider, (lambda do
-                                      ::Proxy::DHCP::Infoblox::Provider.new(
-                                        c.get_dependency(:connection),
-                                        settings[:record_type] == 'host' ? c.get_dependency(:host_ipv4_crud) : c.get_dependency(:fixed_address_crud),
-                                        c.get_dependency(:grid_restart),
-                                        c.get_dependency(:unused_ips),
-                                        settings[:subnets])
-                                      end)
+      c.dependency :host_ipv4_crud, (lambda {
+        ::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD.new(
+          c.get_dependency(:connection),
+          settings[:dns_view],
+          settings[:used_ips_search_type])
+      })
+      c.dependency :fixed_address_crud, (lambda {
+        ::Proxy::DHCP::Infoblox::FixedAddressCRUD.new(
+          c.get_dependency(:connection),
+          settings[:network_view],
+          settings[:used_ips_search_type])
+      })
+      c.dependency :grid_restart, lambda { ::Proxy::DHCP::Infoblox::GridRestart.new(c.get_dependency(:connection)) }
+      c.dependency :dhcp_provider, (lambda {
+        ::Proxy::DHCP::Infoblox::Provider.new(
+          c.get_dependency(:connection),
+          c.get_dependency(settings[:record_type] == 'host' ? :host_ipv4_crud : :fixed_address_crud),
+          c.get_dependency(:grid_restart),
+          c.get_dependency(:unused_ips),
+          settings[:subnets],
+          settings[:network_view])
+      })
     end
   end
 end

data/lib/smart_proxy_dhcp_infoblox.rb

@@ -5,6 +5,5 @@ module Proxy
 end
 
 require 'smart_proxy_dhcp_infoblox/plugin_configuration'
-require 'smart_proxy_dhcp_infoblox/record_type_validator'
 require 'smart_proxy_dhcp_infoblox/dhcp_infoblox_version'
 require 'smart_proxy_dhcp_infoblox/dhcp_infoblox_plugin'

data/test/host_and_fixedaddress_crud_test.rb

@@ -1,4 +1,5 @@
 require 'test_helper'
+require 'ostruct'
 require 'infoblox'
 require 'dhcp_common/dhcp_common'
 require 'dhcp_common/record/reservation'
@@ -7,22 +8,37 @@ 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])
+    @entity.expects(:find).with(@connection, search_condition('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([])
+    @entity.expects(:find).with(@connection, search_condition('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_records_using_ip_returns_empty_arrays_if_records_not_found
+    @entity.expects(:find).with(@connection, search_condition('ipv4addr' => '192.168.42.1', '_max_results' => 2147483646)).returns([])
+    assert @crud.find_records_by_ip('192.168.42.0/24', '192.168.42.1').empty?
+  end
+
+  def test_find_records_by_ip_returns_empty_array_when_host_has_no_dhcp_record
+    found_record = OpenStruct.new(:name => 'testing',
+                                  :ipv4addrs => [OpenStruct.new(:ipv4addr => '192.168.42.1',
+                                                                :mac => '00:01:02:03:04:05',
+                                                                :configure_for_dhcp => false)])
+    @entity.expects(:find).
+      with(@connection, search_condition('ipv4addr' => '192.168.42.1', '_max_results' => 2147483646)).returns([found_record])
+    assert @crud.find_records_by_ip('192.168.42.0/24', '192.168.42.1').empty?
+  end
+
   def test_find_record_using_mac
-    @entity.expects(:find).with(@connection, 'mac' => '00:01:02:03:05:06', '_max_results' => 1).returns([@host])
+    @entity.expects(:find).with(@connection, search_condition('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([])
+    @entity.expects(:find).with(@connection, search_condition('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
 
@@ -46,16 +62,29 @@ module CommoncrudTests
   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)
+    @crud.expects(:find_hosts).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)
+    @crud.expects(:find_hosts).with('ipv4addr' => @ip).returns([@host])
     @host.expects(:delete)
     @crud.del_record('unused', @reservation)
   end
+
+  def test_del_records_by_ip
+    @crud.expects(:find_hosts).with({ 'ipv4addr' => @ip }, 2147483646).returns([@host, @host1])
+    @host.expects(:delete)
+    @host1.expects(:delete)
+    @crud.del_records_by_ip(@ip)
+  end
+
+  def test_del_record_by_mac
+    @crud.expects(:find_hosts).with('mac' => @mac).returns([@host])
+    @host.expects(:delete)
+    @crud.del_record_by_mac(@mac)
+  end
 end
 
 class HostCrudTest < Test::Unit::TestCase
@@ -63,7 +92,8 @@ class HostCrudTest < Test::Unit::TestCase
 
   def setup
     @connection = Object.new
-    @crud = ::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD.new(@connection)
+    @view = "something"
+    @crud = ::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD.new(@connection, @view, 'record_type')
 
     @entity = ::Infoblox::Host
 
@@ -72,23 +102,63 @@ class HostCrudTest < Test::Unit::TestCase
     @nextserver = '192.168.42.1'
     @filename = '/tftpboot.img'
     @ip = '192.168.42.1'
+    @subnet_ip = '192.168.42.0'
 
     @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'))
+      :name => @hostname,
+      :view => @view,
+      :ipv4addrs => [{ :ipv4addr => @ip, :mac => @mac, :nextserver => @nextserver, :use_nextserver => true,
+                      :bootfile => @filename, :use_bootfile => true, :configure_for_dhcp => true }])
+    @host1 = ::Infoblox::Host.new(
+      :name => 'another.test.com',
+      :view => @view,
+      :ipv4addrs => [{ :ipv4addr => @ip, :mac => '00:01:02:03:05:07', :nextserver => @nextserver, :use_nextserver => true,
+                      :bootfile => @filename, :use_bootfile => true, :configure_for_dhcp => true }])
+
+    @ipv4address = ::Infoblox::Ipv4address.new(
+      :names => [@hostname],
+      :ip_address => @ip,
+      :mac_address => @mac
+    )
+
+    @ipv4address_dnsonly = ::Infoblox::Ipv4address.new(
+      :names => ['dnsonly.test.com'],
+      :ip_address => '192.168.42.2',
+      :mac_address => ''
+    )
+
+    @reservation = ::Proxy::DHCP::Reservation.new(@hostname, @ip, @mac, ::Proxy::DHCP::Subnet.new(@subnet_ip, '255.255.255.0'),
+                                                  :hostname => @hostname, :nextServer => @nextserver, :filename => @filename,
+                                                  :deleteable => true)
+
+    @reservation_without_opts = ::Proxy::DHCP::Reservation.new(@hostname, @ip, @mac, ::Proxy::DHCP::Subnet.new(@subnet_ip, '255.255.255.0'),
+                                                             :hostname => @hostname, :deleteable => true)
+
+    @reservation_dnsonly = ::Proxy::DHCP::Reservation.new('dnsonly.test.com', '192.168.42.2', '00:00:00:00:00:00',
+                                                        ::Proxy::DHCP::Subnet.new(@subnet_ip, '255.255.255.0'),
+                                                        :hostname => 'dnsonly.test.com', :deleteable => true)
   end
 
-  def test_all_hosts
-    ::Infoblox::Host.expects(:find).with(@connection, 'ipv4addr~' => '192\.168\.42\..+', '_max_results' => 2147483646).returns([@host])
+  def test_all_hosts_with_find_by_record_type
+    ::Infoblox::Host.expects(:find).with(@connection, 'ipv4addr~' => '192\.168\.42\..+', 'view' => @view,
+                                         '_max_results' => 2147483646).returns([@host])
     assert_equal @reservation, @crud.all_hosts('192.168.42.0/24').first
   end
 
+  def test_all_hosts_with_find_by_used
+    @crud_used = ::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD.new(@connection, @view, 'used')
+    ::Infoblox::Ipv4address.expects(:find).with(@connection, 'network' => '192.168.42.0/24', 'status' => 'USED',
+                                         '_max_results' => 2147483646).returns([@ipv4address])
+    assert_equal @reservation_without_opts, @crud_used.all_hosts('192.168.42.0/24').first
+  end
+
+  def test_all_hosts_with_find_by_used_dns_record_creates_reservation
+    @crud_dnsonly = ::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD.new(@connection, @view, 'used')
+    ::Infoblox::Ipv4address.expects(:find).with(@connection, 'network' => '192.168.42.0/24', 'status' => 'USED',
+                                                '_max_results' => 2147483646).returns([@ipv4address_dnsonly])
+    assert_equal @reservation_dnsonly, @crud_dnsonly.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)
@@ -106,22 +176,30 @@ class HostCrudTest < Test::Unit::TestCase
     assert_equal expected_addr.bootfile, actual_addr.bootfile
     assert actual_addr.use_bootfile
     assert actual_addr.configure_for_dhcp
+    assert_equal @view, built.view
   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}]))
+    @crud.expects(:find_hosts).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
+
+  def search_condition(a_hash)
+    { 'view' => @view }.merge(a_hash)
+  end
 end
 
 class FixedaddressCrudTest < Test::Unit::TestCase
+  include CommoncrudTests
+
   def setup
     @connection = Object.new
-    @crud = ::Proxy::DHCP::Infoblox::FixedAddressCRUD.new(@connection)
+    @network_view = "something"
+    @crud = ::Proxy::DHCP::Infoblox::FixedAddressCRUD.new(@connection, @network_view, 'record_type')
 
     @entity = ::Infoblox::Fixedaddress
 
@@ -130,21 +208,58 @@ class FixedaddressCrudTest < Test::Unit::TestCase
     @nextserver = '192.168.42.1'
     @filename = '/tftpboot.img'
     @ip = '192.168.42.1'
+    @subnet_ip = '192.168.42.0'
 
     @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'))
+      :name => @hostname,
+      :ipv4addr => @ip, :mac => @mac, :network_view => @network_view)
+    @host1 = ::Infoblox::Fixedaddress.new(
+      :name => 'another.test.com',
+      :ipv4addr => @ip, :mac => '00:01:02:03:05:07', :network_view => @network_view)
+
+    @ipv4address = ::Infoblox::Ipv4address.new(
+      :names => [@hostname],
+      :ip_address => @ip,
+      :mac_address => @mac
+    )
+
+    @ipv4address_dnsonly = ::Infoblox::Ipv4address.new(
+      :names => ['dnsonly.test.com'],
+      :ip_address => '192.168.42.2',
+      :mac_address => ''
+    )
+
+    @reservation = ::Proxy::DHCP::Reservation.new(@hostname, @ip, @mac, ::Proxy::DHCP::Subnet.new(@subnet_ip, '255.255.255.0'),
+                                                  :deleteable => true, :hostname => @hostname)
+
+    @reservation_without_opts = ::Proxy::DHCP::Reservation.new(@hostname, @ip, @mac, ::Proxy::DHCP::Subnet.new(@subnet_ip, '255.255.255.0'),
+                                                             :hostname => @hostname, :deleteable => true)
+
+    @reservation_dnsonly = ::Proxy::DHCP::Reservation.new('dnsonly.test.com', '192.168.42.2', '00:00:00:00:00:00',
+                                                        ::Proxy::DHCP::Subnet.new(@subnet_ip, '255.255.255.0'),
+                                                        :hostname => 'dnsonly.test.com', :deleteable => true)
   end
 
-  def test_all_hosts
-    ::Infoblox::Fixedaddress.expects(:find).with(@connection, 'network' => '192.168.42.0/24', '_max_results' => 2147483646).returns([@host])
+  def test_all_hosts_with_find_by_record_type
+    ::Infoblox::Fixedaddress.expects(:find).with(@connection, 'network' => '192.168.42.0/24', 'network_view' => @network_view,
+                                                 '_max_results' => 2147483646).returns([@host])
     assert_equal @reservation, @crud.all_hosts('192.168.42.0/24').first
   end
 
+  def test_all_hosts_with_find_by_used
+    @crud_used = ::Proxy::DHCP::Infoblox::FixedAddressCRUD.new(@connection, @network_view, 'used')
+    ::Infoblox::Ipv4address.expects(:find).with(@connection, 'network' => '192.168.42.0/24', 'status' => 'USED',
+                                                '_max_results' => 2147483646).returns([@ipv4address])
+    assert_equal @reservation_without_opts, @crud_used.all_hosts('192.168.42.0/24').first
+  end
+
+  def test_all_hosts_with_find_by_used_dns_record_creates_reservation
+    @crud_dnsonly = ::Proxy::DHCP::Infoblox::FixedAddressCRUD.new(@connection, @network_view, 'used')
+    ::Infoblox::Ipv4address.expects(:find).with(@connection, 'network' => '192.168.42.0/24', 'status' => 'USED',
+                                                '_max_results' => 2147483646).returns([@ipv4address_dnsonly])
+    assert_equal @reservation_dnsonly, @crud_dnsonly.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)
@@ -152,18 +267,35 @@ class FixedaddressCrudTest < Test::Unit::TestCase
     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
+    assert_equal @nextserver, built.nextserver
+    assert built.use_nextserver
+    assert_equal @filename, built.bootfile
+    assert built.use_bootfile
+    assert_equal @network_view, built.network_view
+  end
+
+  def test_build_host_with_options
+    begin
+      Proxy::DHCP::Infoblox::Plugin.settings.options = [{"name" => "xyz"}]
+
+      host = @crud.build_host(:ip => @ip, :mac => @mac, :hostname => @hostname)
+      assert_equal [{"name" => "xyz"}], host.instance_variable_get("@options")
+    ensure
+      Proxy::DHCP::Infoblox::Plugin.settings.options = []
+    end
   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'))
+    @crud.expects(:find_hosts).with('ipv4addr' => @ip).returns(
+      [::Infoblox::Fixedaddress.new(:name => @hostname, :ipv4addr => @ip, :mac => '11:22:33:44:55:66',
+                                    :network_view => @network_view)])
 
     assert_raises(Proxy::DHCP::Collision) { @crud.add_record(:ip => @ip, :mac => @mac, :hostname => @hostname) }
   end
+
+  def search_condition(a_hash)
+    { 'network_view' => @network_view }.merge(a_hash)
+  end
 end

data/test/infoblox_provider_test.rb

@@ -11,13 +11,55 @@ class InfobloxProviderTest < Test::Unit::TestCase
     @restart_grid = Object.new
     @unused_ips = Object.new
     @managed_subnets = nil
+    @network_view = "another"
+    @used_ips_search_type = 'record_type'
 
     @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.32.0/19')
+    @subnet_2 = ::Proxy::DHCP::Subnet.new('192.168.32.0', '255.255.224.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)
+    @network_3 = Infoblox::Network.new(:network => '192.168.43.0/24')
+
+    @provider = Proxy::DHCP::Infoblox::Provider.new(@connection, @crud, @restart_grid,
+                                                    @unused_ips, @managed_subnets, @network_view)
+
+    @lease = Infoblox::Lease.new(:address => '192.168.43.127',
+                                 :binding_state => 'active',
+                                 :client_hostname => 'example',
+                                 :hardware => 'ba:be:fa:ce:ca:fe',
+                                 :network => @subnet.network,
+                                 :starts => nil,
+                                 :ends => nil)
+
+    @lease_2 = Infoblox::Lease.new(:address => '192.168.60.121',
+                                   :binding_state => 'active',
+                                   :client_hostname => 'example',
+                                   :hardware => 'c0:fe:fe:f0:01:bb',
+                                   :network => @subnet_2.network,
+                                   :starts => nil,
+                                   :ends => nil)
+  end
+
+  def test_leases
+    @crud = ::Proxy::DHCP::Infoblox::CommonCRUD.new(@connection, @used_ips_search_type)
+    @provider = Proxy::DHCP::Infoblox::Provider.new(@connection, @crud, @restart_grid,
+                                                    @unused_ips, @managed_subnets, @network_view)
+
+    @provider.expects(:full_network_address).with(@subnet.network).returns(@network.network)
+    Infoblox::Lease.expects(:find).with(@connection, 'address~' => "192\\.168\\.42\\..+").returns([@lease])
+    assert_equal @lease.hardware, @provider.all_leases(@subnet.network).first.mac
+  end
+
+  def test_nonclass_leases
+    @crud = ::Proxy::DHCP::Infoblox::CommonCRUD.new(@connection,@used_ips_search_type)
+    @provider = Proxy::DHCP::Infoblox::Provider.new(@connection, @crud, @restart_grid,
+                                                    @unused_ips, @managed_subnets, @network_view)
+
+    @provider.expects(:full_network_address).with(@subnet_2.network).returns(@network_2.network)
+    Infoblox::Lease.expects(:find).with(@connection, 'address~' => "192\\.168\\.(0?3[3456789]|0?[45][0123456789]|0?6[012])\\..+").returns([@lease_2])
+    assert_equal @lease_2.hardware, @provider.all_leases(@subnet_2.network).first.mac
   end
 
   def test_subnets
@@ -26,18 +68,21 @@ class InfobloxProviderTest < Test::Unit::TestCase
   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])
+    provider = Proxy::DHCP::Infoblox::Provider.new(@connection, @crud, @restart_grid,
+                                                   @unused_ips, ['192.168.42.0/255.255.255.0'], @network_view)
+    Infoblox::Network.expects(:all).with(@connection).returns([@network, @network_3])
     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])
+    ::Infoblox::Network.expects(:find).with(@connection, 'network' => '192.168.42.0',
+                                            '_max_results' => 1, 'network_view' => @network_view).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([])
+    ::Infoblox::Network.expects(:find).with(@connection, 'network' => '192.168.42.0',
+                                            'network_view' => @network_view, '_max_results' => 1).returns([])
     assert_raises(RuntimeError) { @provider.find_network('192.168.42.0') }
   end
 
@@ -52,10 +97,19 @@ class InfobloxProviderTest < Test::Unit::TestCase
     @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')))
+    @provider.del_record(::Proxy::DHCP::Record.new('192.168.42.1', '00:01:02:03:04:05',
+                                                   ::Proxy::DHCP::Subnet.new('192.168.42.0', '255.255.255.0')))
+  end
+
+  def test_del_record_by_mac_restarts_grid
+    @crud.stubs(:del_record_by_mac)
+    @restart_grid.expects(:try_restart)
+    @provider.del_record_by_mac(@subnet.network, '00:01:02:03:04:05')
+  end
+
+  def test_del_record_by_ip_restarts_grid
+    @crud.stubs(:del_records_by_ip)
+    @restart_grid.expects(:try_restart)
+    @provider.del_records_by_ip(@subnet.network, '192.168.42.1')
   end
 end