smart_proxy_dhcp_infoblox 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d3ff6b849368389cef25d7fbcc8b3f4072f29451
-  data.tar.gz: 11cb8b354e2917816c4bd4ca957d93f664ee2309
+  metadata.gz: 1a07a8c599733c506c451ce081884584dc9501eb
+  data.tar.gz: a07bed8a8a3b384a5670cff0c0c0f72005ebbc17
 SHA512:
-  metadata.gz: 985763eae34749aa8f78529476bee93b1ae55008d5f814184785b6365be50d00311e2bb16e214cd29977ea34c7517cb0a416d5d2cbc510f56916c396d62586b9
-  data.tar.gz: f7c85f678518194b307880a62eba5a0305a56467f784ada42822f398315df744fe300aaa8d50f5cfd53cdfa71ceebed1cf296c52689ed551d897fa201867cbe0
+  metadata.gz: b3156dbd4113a50c8c48a5305813ddd290336478ab5ab64dccc94b084a9972bd11e403e4c064970f11196400bedb1b2569856f9ae284defecd840173cad5db62
+  data.tar.gz: 99715f24471a04a0d0126e1f750ea23d66e88dbef2d5d956e5ca1cb2574ee34673fdbc636aa784fdcd83e05d35805bb852ada89b813dcf69f45b307dbfd15855

data/README.md

@@ -24,9 +24,9 @@ To enable this DHCP provider, edit `/etc/foreman-proxy/settings.d/dhcp.yml` and
 Configuration options for this plugin are in `/etc/foreman-proxy/settings.d/dhcp_infoblox.yml` and include:
 
 * username: API Username
-* passowrd: API Password
+* password: API Password
 * record_type: host / fixedaddress (see different record types chapter)
-* use_range: use infoblox ranges (true) or infoblox networks (false) to find the next free ip in your infoblox
+* use_ranges: use infoblox ranges (true) or infoblox networks (false) to find the next free ip in your infoblox
 
 ## Different record types
 The main difference between host and fixedaddress is that a host record already includes the dns records. It's an infoblox object that includes dhcp/a record/ptr records. If you use the host objects there is no need to use a dns smart proxy. Everything gets handled inside the dhcp smart proxy. This does however limit functionality. You can't delete conflicting records or you can't change dns names using foreman gui. Beware when editing host objects manually in infoblox, once you delete a host in foreman all associated host objects get deleted.

data/config/dhcp_infoblox.yml.example

@@ -8,10 +8,13 @@
 :username: "infoblox"
 :password: "infoblox"
 #
-# Record type to manage: can be "host" or "fixed_address"
+# Record type to manage: can be "host" or "fixedaddress"
 #
 :record_type: 'host'
 #
 # Use  pre-definded ranges in networks to find available IP's
 #
 :use_ranges: false
+
+#:dns_view: 'non-default'
+#:network_view: 'another-non-default'

data/lib/smart_proxy_dhcp_infoblox/dhcp_infoblox_main.rb

@@ -7,13 +7,14 @@ module Proxy::DHCP::Infoblox
     include Proxy::Util
     include IpAddressArithmetic
 
-    attr_reader :connection, :crud, :restart_grid, :unused_ips
+    attr_reader :connection, :crud, :restart_grid, :unused_ips, :network_view
 
-    def initialize(connection, crud, restart_grid, unused_ips, managed_subnets)
+    def initialize(connection, crud, restart_grid, unused_ips, managed_subnets, network_view)
       @connection = connection
       @crud = crud
       @restart_grid = restart_grid
       @unused_ips = unused_ips
+      @network_view = network_view
       super('infoblox', managed_subnets, nil)
     end
 
@@ -76,7 +77,8 @@ module Proxy::DHCP::Infoblox
     end
 
     def find_network(network_address)
-      network = ::Infoblox::Network.find(connection, 'network~' => network_address, '_max_results' => 1).first
+      network = ::Infoblox::Network.find(connection, 'network' => network_address, 'network_view' => network_view,
+                                         '_max_results' => 1).first
       raise "Subnet #{network_address} not found" if network.nil?
       network
     end

data/lib/smart_proxy_dhcp_infoblox/dhcp_infoblox_plugin.rb

@@ -2,7 +2,7 @@ module Proxy::DHCP::Infoblox
   class Plugin < ::Proxy::Provider
     plugin :dhcp_infoblox, ::Proxy::DHCP::Infoblox::VERSION
 
-    default_settings :record_type => 'host', :range => false
+    default_settings :record_type => 'host', :range => false, :dns_view => "default", :network_view => "default"
     validate_presence :username, :password
 
     requires :dhcp, '>= 1.13'

data/lib/smart_proxy_dhcp_infoblox/dhcp_infoblox_version.rb

@@ -1,7 +1,7 @@
 module Proxy
   module DHCP
     module Infoblox
-      VERSION = '0.0.7'
+      VERSION = '0.0.8'
     end
   end
 end

data/lib/smart_proxy_dhcp_infoblox/fixed_address_crud.rb

@@ -2,14 +2,18 @@ require 'smart_proxy_dhcp_infoblox/common_crud'
 
 module ::Proxy::DHCP::Infoblox
   class FixedAddressCRUD < CommonCRUD
-    def initialize(connection)
+    attr_reader :network_view
+
+    def initialize(connection, network_view)
       @memoized_hosts = []
       @memoized_condition = nil
-      super
+      @network_view = network_view
+      super(connection)
     end
 
     def all_hosts(subnet_address)
-      network = ::Infoblox::Fixedaddress.find(@connection, 'network' => subnet_address, '_max_results' => 2147483646) #2**(32-cidr_to_i(subnet_address)))
+      network = ::Infoblox::Fixedaddress.find(@connection, 'network' => subnet_address, 'network_view' => network_view,
+                                              '_max_results' => 2147483646) #2**(32-cidr_to_i(subnet_address)))
       network.map {|h| build_reservation(h.name, h, subnet_address)}.compact
     end
 
@@ -32,9 +36,10 @@ module ::Proxy::DHCP::Infoblox
     end
 
     def find_hosts(condition, max_results = 1)
-      return @memoized_hosts if (!@memoized_hosts.empty? && @memoized_condition == condition)
+      return @memoized_hosts if (!@memoized_hosts.empty? && @memoized_condition = condition)
       @memoized_condition = condition
-      @memoized_hosts = ::Infoblox::Fixedaddress.find(@connection, condition.merge('_max_results' => max_results))
+      @memoized_hosts = ::Infoblox::Fixedaddress.find(@connection, condition.merge('_max_results' => max_results,
+                                                                                   'network_view' => network_view))
     end
 
     def find_host_and_name_by_ip(ip_address)
@@ -51,6 +56,7 @@ module ::Proxy::DHCP::Infoblox
       host.use_nextserver = true
       host.bootfile = options[:filename]
       host.use_bootfile = true
+      host.network_view = network_view
       host
     end
   end

data/lib/smart_proxy_dhcp_infoblox/host_ipv4_address_crud.rb

@@ -3,10 +3,13 @@ require 'smart_proxy_dhcp_infoblox/network_address_range_regex_generator'
 
 module ::Proxy::DHCP::Infoblox
   class HostIpv4AddressCRUD < CommonCRUD
-    def initialize(connection)
+    attr_reader :dns_view
+
+    def initialize(connection, dns_view)
       @memoized_hosts = []
       @memoized_condition = nil
-      super
+      @dns_view = dns_view
+      super(connection)
     end
 
     def all_hosts(subnet_address)
@@ -15,6 +18,7 @@ module ::Proxy::DHCP::Infoblox
       hosts = ::Infoblox::Host.find(
           @connection,
           'ipv4addr~' => address_range_regex,
+          'view' => dns_view,
           '_max_results' => 2147483646)
 
       ip_addr_matcher = Regexp.new(address_range_regex) # pre-compile the regex
@@ -47,7 +51,8 @@ module ::Proxy::DHCP::Infoblox
     def find_hosts(condition, max_results = 1)
       return @memoized_hosts if (!@memoized_hosts.empty? && @memoized_condition == condition)
       @memoized_condition = condition
-      @memoized_hosts = ::Infoblox::Host.find(@connection, condition.merge('_max_results' => max_results))
+      @memoized_hosts = ::Infoblox::Host.find(@connection, condition.merge('view' => dns_view,
+                                                                           '_max_results' => max_results))
     end
 
     def build_host(options)
@@ -60,6 +65,7 @@ module ::Proxy::DHCP::Infoblox
       host_addr.use_nextserver = true
       host_addr.bootfile = options[:filename]
       host_addr.use_bootfile = true
+      host.view = dns_view
       host
     end
   end

data/lib/smart_proxy_dhcp_infoblox/plugin_configuration.rb

@@ -20,9 +20,16 @@ module Proxy::DHCP::Infoblox
                                 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 :unused_ips, (lambda do
+        ::Proxy::DHCP::Infoblox::UnusedIps.new(c.get_dependency(:connection), settings[:use_ranges],
+                                             settings[:network_view])
+      end)
+      c.dependency :host_ipv4_crud, (lambda do
+        ::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD.new(c.get_dependency(:connection), settings[:dns_view])
+      end)
+      c.dependency :fixed_address_crud, (lambda do
+        ::Proxy::DHCP::Infoblox::FixedAddressCRUD.new(c.get_dependency(:connection), settings[:network_view])
+      end)
       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(
@@ -30,8 +37,10 @@ module Proxy::DHCP::Infoblox
                                         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])
+                                        settings[:subnets],
+                                          settings[:network_view])
                                       end)
     end
   end
 end
+

data/lib/smart_proxy_dhcp_infoblox/unused_ips.rb

@@ -4,12 +4,13 @@ require 'smart_proxy_dhcp_infoblox/ip_address_arithmetic'
 module Proxy::DHCP::Infoblox
   class UnusedIps
     include IpAddressArithmetic
-    attr_reader :connection, :use_ranges
+    attr_reader :connection, :use_ranges, :network_view
 
-    def initialize(connection, use_ranges)
+    def initialize(connection, use_ranges, network_view)
       @connection = connection
       @use_ranges = use_ranges
       @memoized_network = nil
+      @network_view = network_view
     end
 
     def unused_ip(network_address, from_ip_address, to_ip_address)
@@ -31,7 +32,7 @@ module Proxy::DHCP::Infoblox
     end
 
     def find_range(network_address, from, to)
-      ranges = ::Infoblox::Range.find(@connection, 'network~' => network_address)
+      ranges = ::Infoblox::Range.find(@connection, 'network' => network_address, 'network_view' => network_view)
       range = (from.nil? || to.nil?) ? ranges.first : ranges.find {|r| r.start_addr == from && r.end_addr == to}
       raise "No Ranges found for #{network_address} network" if range.nil?
       range
@@ -40,7 +41,8 @@ module Proxy::DHCP::Infoblox
     def find_network(network_address)
       return @memoized_network if !@memoized_network.nil? && @memoized_address == network_address
       @memoized_address = network_address
-      @memoized_network = ::Infoblox::Network.find(@connection, 'network~' => network_address, '_max_results' => 1).first
+      @memoized_network = ::Infoblox::Network.find(@connection, 'network' => network_address, 'network_view' => network_view,
+                                                   '_max_results' => 1).first
       raise "Subnet #{network_address} not found" if @memoized_network.nil?
       @memoized_network
     end

data/test/host_and_fixedaddress_crud_test.rb

@@ -7,27 +7,27 @@ 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, 'ipv4addr' => '192.168.42.1', '_max_results' => 2147483646).returns([])
+    @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_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
 
@@ -81,7 +81,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)
 
     @entity = ::Infoblox::Host
 
@@ -94,10 +95,12 @@ class HostCrudTest < Test::Unit::TestCase
 
     @host = ::Infoblox::Host.new(
         :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}])
 
@@ -107,7 +110,8 @@ class HostCrudTest < Test::Unit::TestCase
   end
 
   def test_all_hosts
-    ::Infoblox::Host.expects(:find).with(@connection, 'ipv4addr~' => '192\.168\.42\..+', '_max_results' => 2147483646).returns([@host])
+    ::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
 
@@ -128,22 +132,28 @@ 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_hosts).with('ipv4addr' => @ip).returns(
-        [::Infoblox::Host.new(:name => @hostname, :ipv4addrs => [{:ipv4addr => @ip, :mac => '11:22:33:44:55:66', :configure_for_dhcp => true}])])
+        [::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
   def setup
     @connection = Object.new
-    @crud = ::Proxy::DHCP::Infoblox::FixedAddressCRUD.new(@connection)
+    @network_view = "something"
+    @crud = ::Proxy::DHCP::Infoblox::FixedAddressCRUD.new(@connection, @network_view)
 
     @entity = ::Infoblox::Fixedaddress
 
@@ -156,17 +166,18 @@ class FixedaddressCrudTest < Test::Unit::TestCase
 
     @host = ::Infoblox::Fixedaddress.new(
         :name => @hostname,
-        :ipv4addr => @ip, :mac => @mac) # :ipv4addr => @ip, :mac => @mac) #
+        :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')
+        :ipv4addr => @ip, :mac => '00:01:02:03:05:07', :network_view => @network_view)
 
     @reservation = ::Proxy::DHCP::Reservation.new(@hostname, @ip, @mac, ::Proxy::DHCP::Subnet.new(@subnet_ip, '255.255.255.0'),
                                                   :deleteable => true, :hostname => @hostname)
   end
 
   def test_all_hosts
-    ::Infoblox::Fixedaddress.expects(:find).with(@connection, 'network' => '192.168.42.0/24', '_max_results' => 2147483646).returns([@host])
+    ::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
 
@@ -181,14 +192,20 @@ class FixedaddressCrudTest < Test::Unit::TestCase
     assert built.use_nextserver
     assert_equal @filename, built.bootfile
     assert built.use_bootfile
+    assert_equal @network_view, built.network_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_hosts).with('ipv4addr' => @ip).returns(
-        [::Infoblox::Fixedaddress.new(:name => @hostname, :ipv4addr => @ip, :mac => '11:22:33:44:55:66')])
+        [::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,15 @@ class InfobloxProviderTest < Test::Unit::TestCase
     @restart_grid = Object.new
     @unused_ips = Object.new
     @managed_subnets = nil
+    @network_view = "another"
 
     @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)
+    @provider = Proxy::DHCP::Infoblox::Provider.new(@connection, @crud, @restart_grid,
+                                                    @unused_ips, @managed_subnets, @network_view)
   end
 
   def test_subnets
@@ -26,18 +28,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'])
+    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_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])
+    ::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
 

data/test/plugin_configuration_test.rb

@@ -12,14 +12,18 @@ 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)
+    assert_equal({:record_type => 'host', :range => false, :dns_view => "default", :network_view => "default"},
+                 Proxy::DHCP::Infoblox::Plugin.default_settings)
   end
 end
 
 class InfobloxDhcpProductionWiringTest < Test::Unit::TestCase
   def setup
+    @network_view = "network_view"
+    @dns_view = "dns_view"
     @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']}
+                 :use_ranges => true, :subnets => ['1.1.1.0/255.255.255.0'],
+                 :dns_view => @dns_view, :network_view => @network_view}
     @container = ::Proxy::DependencyInjection::Container.new
     Proxy::DHCP::Infoblox::PluginConfiguration.new.load_dependency_injection_wirings(@container, @settings)
   end
@@ -36,16 +40,19 @@ class InfobloxDhcpProductionWiringTest < Test::Unit::TestCase
     free_ips = @container.get_dependency(:unused_ips)
     assert_not_nil free_ips.connection
     assert free_ips.use_ranges
+    assert_equal @network_view, free_ips.network_view
   end
 
   def test_host_ipv4_crud_configuration
     host = @container.get_dependency(:host_ipv4_crud)
     assert_not_nil host.connection
+    assert_equal @dns_view, host.dns_view
   end
 
   def test_fixed_address_crud_configuration
     fixed_address = @container.get_dependency(:fixed_address_crud)
     assert_not_nil fixed_address.connection
+    assert_equal @network_view, fixed_address.network_view
   end
 
   def test_grid_restart_configuration
@@ -58,6 +65,7 @@ class InfobloxDhcpProductionWiringTest < Test::Unit::TestCase
     assert_not_nil provider.connection
     assert_not_nil provider.restart_grid
     assert_not_nil provider.unused_ips
+    assert_equal @network_view, provider.network_view
     assert provider.managed_subnets.include?('1.1.1.0/255.255.255.0')
     assert provider.crud.instance_of?(::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD)
   end

data/test/unused_ip_test.rb

@@ -5,7 +5,8 @@ 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_view = "another"
+    @unused_ips = ::Proxy::DHCP::Infoblox::UnusedIps.new(@connection, false, @network_view)
     @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
@@ -23,25 +24,26 @@ class UnusedIpTest < Test::Unit::TestCase
   end
 
   def test_unused_network_ip
-    ::Infoblox::Network.expects(:find).with(@connection, 'network~' => '1.1.1.0', '_max_results' => 1).returns([@network])
+    ::Infoblox::Network.expects(:find).with(@connection, 'network' => '1.1.1.0',
+                                            '_max_results' => 1, 'network_view' => @network_view).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])
+    ::Infoblox::Range.expects(:find).with(@connection, 'network' => '1.1.1.0', 'network_view' => @network_view).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 = ::Proxy::DHCP::Infoblox::UnusedIps.new(@connection, false, @network_view)
     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 = ::Proxy::DHCP::Infoblox::UnusedIps.new(@connection, true, @network_view)
     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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dhcp_infoblox
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Klaas Demter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-07 00:00:00.000000000 Z
+date: 2017-09-22 00:00:00.000000000 Z
 dependencies: []
 description: Infoblox DHCP provider plugin for Foreman's smart proxy
 email:
@@ -51,17 +51,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: Infoblox DHCP provider plugin for Foreman's smart proxy