smart_proxy_dhcp_infoblox 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 60402237d263b43dabb100b57d4125956e4b6a02
-  data.tar.gz: 99c055f097f298b41efac29c19a6301de2aa1aa7
+SHA256:
+  metadata.gz: ed4af7f2889b7259c13b0ed75d551ae139812fd086e56c40b724bddfaa46cf78
+  data.tar.gz: 7b1716d0ac19d220f26389221fe04793d14a34b4002a1a2c8e531a18e6b0d6a9
 SHA512:
-  metadata.gz: ef037dfe4489d9b0f74b6c59ab78d125709e56c8283bc5e8a546dee03c3a32fd630b7fdf5345dbc561d93732eab306b44cb893a794fe12a8a462301ecbeedb67
-  data.tar.gz: 7b39bfc1b031e3fd36c9b6c76149ea3bd1cf36d3456c1aef4958e4a935d39996549b936baa1718a48405a2e2a36763bbf9a9457c2183e11d3ec908992b7a544c
+  metadata.gz: 82d8cb3847b9cd9b801a3ce16cee9fb113122fba6e662a10da0f576a7ad6951b6b09d5b1a73a5cb5eedec60f722ecaa7a7089f4e2e2247fbbcbe4b3e525f4352
+  data.tar.gz: e56a98657864b67315907210d27b8c286386ce1dd62bdb78d3a4b0d8595cafb61fc534d7f4083322b530d129aad42b5e8f4cdd5ffc22758bbe3a9838fe14bde6

data/README.md

@@ -11,6 +11,19 @@ for how to install Smart Proxy plugins
 
 This plugin is compatible with Smart Proxy 1.11 or higher.
 
+Example installation command via foreman-installer:
+
+```
+# foreman-installer --enable-foreman-proxy-plugin-dhcp-infoblox \
+--foreman-proxy-dhcp-provider infoblox \
+--foreman-proxy-plugin-dhcp-infoblox-record-type host \
+--foreman-proxy-dhcp-server 192.168.201.2 \
+--foreman-proxy-plugin-dhcp-infoblox-username admin \
+--foreman-proxy-plugin-dhcp-infoblox-password infoblox \
+--foreman-proxy-plugin-dhcp-infoblox-network-view default \
+--foreman-proxy-plugin-dhcp-infoblox-dns-view default
+```
+
 When installing using "gem", make sure to install the bundle file:
 
     echo "gem 'smart_proxy_dhcp_infoblox'" > /usr/share/foreman-proxy/bundler.d/dhcp_infoblox.rb
@@ -34,6 +47,43 @@ The main difference between host and fixedaddress is that a host record already
 
 If you chose to use fixedaddress you'll need to use the infoblox dns smart proxy (https://github.com/theforeman/smart_proxy_dns_infoblox) if you want to manage dns records.
 
+## SSL
+
+The plugin enforces HTTPS server certificate verification. Follow a standard CA cert installation procedure for your operating system. It's possible to either download the server certificate from Infoblox web UI or use openssl command to extract it from server response. Here are example steps for Red Hat compatible systems:
+
+```
+# update-ca-trust enable
+# openssl s_client -showcerts -connect 192.168.201.2:443 </dev/null | openssl x509 -text >/etc/pki/ca-trust/source/anchors/infoblox.crt
+# update-ca-trust extract
+```
+
+For Debian-compatible systems:
+
+```
+# openssl s_client -showcerts -connect 192.168.201.2:443 </dev/null | openssl x509 -text >/usr/local/share/ca-certificates/infoblox.crt
+# update-ca-certificates
+```
+
+To test the CA certificate, a simple curl query can be used. This is a positive test:
+
+```
+# curl -u admin:infoblox https://192.168.201.2/wapi/v2.0/network
+[
+    {
+        "_ref": "network/ZG5zLm5ldHdvcmskMTkyLjE2OC4yMDIuMC8yNC8w:192.168.202.0/24/default",
+        "network": "192.168.202.0/24",
+        "network_view": "default"
+    }
+]
+```
+
+And a negative one:
+
+```
+# curl -u admin:infoblox https://192.168.201.2/wapi/v2.0/network
+curl: (60) SSL certificate problem: self signed certificate
+```
+
 ## Contributing
 
 Fork and send a Pull Request. Thanks!

data/lib/smart_proxy_dhcp_infoblox/common_crud.rb

@@ -54,9 +54,9 @@ module ::Proxy::DHCP::Infoblox
     end
 
     def del_records_by_ip(ip_address)
-      found = find_hosts({'ipv4addr' => ip_address}, 2147483646)
+      found = find_hosts({ 'ipv4addr' => ip_address }, 2147483646)
       return if found.empty?
-      found.each {|record| record.delete}
+      found.each { |record| record.delete }
       nil
     end
 

data/lib/smart_proxy_dhcp_infoblox/dhcp_infoblox_main.rb

@@ -17,7 +17,7 @@ module Proxy::DHCP::Infoblox
       super('infoblox', managed_subnets, nil, unused_ips)
     end
 
-    def find_subnet(address);::Proxy::DHCP::Subnet.new(address, '255.255.255.0'); end
+    def find_subnet(address); ::Proxy::DHCP::Subnet.new(address, '255.255.255.0'); end
 
     def subnets
       ::Infoblox::Network.all(connection).map do |network|

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', :dns_view => "default", :network_view => "default", :blacklist_duration_minutes => 30*60
+    default_settings :record_type => 'host', :dns_view => "default", :network_view => "default", :blacklist_duration_minutes => 30 * 60
     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.13'
+      VERSION = '0.0.14'.freeze
     end
   end
 end

data/lib/smart_proxy_dhcp_infoblox/fixed_address_crud.rb

@@ -14,7 +14,7 @@ module ::Proxy::DHCP::Infoblox
     def all_hosts(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
+      network.map { |h| build_reservation(h.name, h, subnet_address) }.compact
     end
 
     def find_record_by_ip(subnet_address, ip_address)
@@ -24,9 +24,9 @@ module ::Proxy::DHCP::Infoblox
     end
 
     def find_records_by_ip(subnet_address, ip_address)
-      found = find_hosts({'ipv4addr' => ip_address}, 2147483646)
+      found = find_hosts({ 'ipv4addr' => ip_address }, 2147483646)
       return [] if found.empty?
-      to_return = found.map {|record| build_reservation(record.name, record, subnet_address)}
+      to_return = found.map { |record| build_reservation(record.name, record, subnet_address) }
       to_return.compact
     end
 

data/lib/smart_proxy_dhcp_infoblox/host_ipv4_address_crud.rb

@@ -16,37 +16,37 @@ module ::Proxy::DHCP::Infoblox
       address_range_regex = NetworkAddressesRegularExpressionGenerator.new.generate_regex(subnet_address)
 
       hosts = ::Infoblox::Host.find(
-          @connection,
+        @connection,
           'ipv4addr~' => address_range_regex,
           'view' => dns_view,
           '_max_results' => 2147483646)
 
       ip_addr_matcher = Regexp.new(address_range_regex) # pre-compile the regex
-      hosts.map {|host| build_reservation(host.name, host.ipv4addrs.find {|ip| ip_addr_matcher =~ ip.ipv4addr}, subnet_address)}.compact
+      hosts.map { |host| build_reservation(host.name, host.ipv4addrs.find { |ip| ip_addr_matcher =~ ip.ipv4addr }, subnet_address) }.compact
     end
 
     def find_record_by_ip(subnet_address, ip_address)
       found = find_hosts('ipv4addr' => ip_address).first
       return nil if found.nil?
-      build_reservation(found.name, found.ipv4addrs.find {|ip| ip.ipv4addr == ip_address}, subnet_address)
+      build_reservation(found.name, found.ipv4addrs.find { |ip| ip.ipv4addr == ip_address }, subnet_address)
     end
 
     def find_records_by_ip(subnet_address, ip_address)
-      found = find_hosts({'ipv4addr' => ip_address}, 2147483646)
+      found = find_hosts({ 'ipv4addr' => ip_address }, 2147483646)
       return [] if found.empty?
-      to_return = found.map {|record| build_reservation(record.name, record.ipv4addrs.find {|ip| ip.ipv4addr == ip_address}, subnet_address)}
+      to_return = found.map { |record| build_reservation(record.name, record.ipv4addrs.find { |ip| ip.ipv4addr == ip_address }, subnet_address) }
       to_return.compact
     end
 
     def find_record_by_mac(subnet_address, mac_address)
       found = find_hosts('mac' => mac_address).first
       return nil if found.nil?
-      build_reservation(found.name, found.ipv4addrs.find {|ip| ip.mac == mac_address}, subnet_address)
+      build_reservation(found.name, found.ipv4addrs.find { |ip| ip.mac == mac_address }, subnet_address)
     end
 
     def find_host_and_name_by_ip(ip_address)
       h = find_hosts('ipv4addr' => ip_address).first
-      h.nil? ? [nil, nil] : [h.name, h.ipv4addrs.find {|ip| ip.ipv4addr == ip_address}]
+      h.nil? ? [nil, nil] : [h.name, h.ipv4addrs.find { |ip| ip.ipv4addr == ip_address }]
     end
 
     def find_hosts(condition, max_results = 1)

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('.')
+      (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,7 @@ 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
 
@@ -31,18 +31,17 @@ 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 { |g| ((g.value != ['0?'] && current.value != ['0?']) || (current.value == ['0?'] && g.value == ['0?'])) && (g.children == current.children) }
           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
 
@@ -59,11 +58,11 @@ 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)
@@ -79,14 +78,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 +93,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 +110,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

@@ -11,34 +11,31 @@ module Proxy::DHCP::Infoblox
     end
 
     def load_dependency_injection_wirings(c, settings)
+      c.dependency :connection, (lambda {
+        ::Infoblox.wapi_version = '2.0'
+        ::Infoblox::Connection.new(:username => settings[:username], :password => settings[:password],
+                                   :host => settings[:server], :ssl_opts => { :verify => true },
+                                   :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.singleton_dependency :unused_ips, lambda {::Proxy::DHCP::FreeIps.new(settings[:blacklist_duration_minutes]) }
-
-      c.dependency :host_ipv4_crud, (lambda do
+      c.dependency :host_ipv4_crud, (lambda {
         ::Proxy::DHCP::Infoblox::HostIpv4AddressCRUD.new(c.get_dependency(:connection), settings[:dns_view])
-      end)
-      c.dependency :fixed_address_crud, (lambda do
+      })
+      c.dependency :fixed_address_crud, (lambda {
         ::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(
-                                        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],
-                                          settings[:network_view])
-                                      end)
+      })
+      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),
+          (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[:network_view])
+      })
     end
   end
 end
-

data/test/host_and_fixedaddress_crud_test.rb

@@ -28,7 +28,7 @@ module CommoncrudTests
                                                                 :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])
+      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
 
@@ -74,7 +74,7 @@ module CommoncrudTests
   end
 
   def test_del_records_by_ip
-    @crud.expects(:find_hosts).with({'ipv4addr' => @ip}, 2147483646).returns([@host, @host1])
+    @crud.expects(:find_hosts).with({ 'ipv4addr' => @ip }, 2147483646).returns([@host, @host1])
     @host.expects(:delete)
     @host1.expects(:delete)
     @crud.del_records_by_ip(@ip)
@@ -105,15 +105,15 @@ class HostCrudTest < Test::Unit::TestCase
     @subnet_ip = '192.168.42.0'
 
     @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}])
+      :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}])
+      :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 }])
 
     @reservation = ::Proxy::DHCP::Reservation.new(@hostname, @ip, @mac, ::Proxy::DHCP::Subnet.new(@subnet_ip, '255.255.255.0'),
                                                   :hostname => @hostname, :nextServer => @nextserver, :filename => @filename,
@@ -150,13 +150,13 @@ class HostCrudTest < Test::Unit::TestCase
     @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)
+    { 'view' => @view }.merge(a_hash)
   end
 end
 
@@ -178,11 +178,11 @@ class FixedaddressCrudTest < Test::Unit::TestCase
     @subnet_ip = '192.168.42.0'
 
     @host = ::Infoblox::Fixedaddress.new(
-        :name => @hostname,
-        :ipv4addr => @ip, :mac => @mac, :network_view => @network_view)
+      :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)
+      :name => 'another.test.com',
+      :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)
@@ -212,13 +212,13 @@ class FixedaddressCrudTest < Test::Unit::TestCase
     @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',
-                                      :network_view => @network_view)])
+      [::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)
+    { 'network_view' => @network_view }.merge(a_hash)
   end
 end

data/test/infoblox_provider_test.rb

@@ -16,7 +16,6 @@ class InfobloxProviderTest < Test::Unit::TestCase
     @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, @network_view)

data/test/integration_test.rb

@@ -22,11 +22,10 @@ class IntegrationTest < ::Test::Unit::TestCase
     @server = ::Proxy::DHCP::Infoblox::Provider.new(nil, Object.new, Object.new, @free_ips, [],
                                                     "default")
 
-    @expected_reservation = {"name" => "testing-01", "ip" => "10.0.0.200", "mac" => "11:22:33:a9:61:09",
-                             "subnet" => "10.0.0.0/255.255.255.0", "hostname" => "testing-01"}
+    @expected_reservation = { "name" => "testing-01", "ip" => "10.0.0.200", "mac" => "11:22:33:a9:61:09",
+                             "subnet" => "10.0.0.0/255.255.255.0", "hostname" => "testing-01" }
   end
 
-
   def test_get_subnets
     @server.expects(:subnets).returns([])
     get "/"
@@ -73,7 +72,7 @@ class IntegrationTest < ::Test::Unit::TestCase
 
   def test_create_record
     record = {
-        "hostname" => "test-02",
+      "hostname" => "test-02",
         "ip"       => "10.0.0.250",
         "mac"      => "10:10:10:10:10:10",
         "network"  => "10.0.0.0",

data/test/plugin_configuration_test.rb

@@ -12,7 +12,7 @@ require 'smart_proxy_dhcp_infoblox/dhcp_infoblox_main'
 
 class PluginDefaultConfigurationTest < Test::Unit::TestCase
   def test_default_settings
-    assert_equal({:record_type => 'host', :blacklist_duration_minutes => 30*60, :dns_view => "default", :network_view => "default"},
+    assert_equal({ :record_type => 'host', :blacklist_duration_minutes => 30 * 60, :dns_view => "default", :network_view => "default" },
                  Proxy::DHCP::Infoblox::Plugin.default_settings)
   end
 end
@@ -21,9 +21,9 @@ 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',
+    @settings = { :username => 'user', :password => 'password', :server => '127.0.0.1', :record_type => 'host',
                  :subnets => ['1.1.1.0/255.255.255.0'], :blacklist_duration_minutes => 300,
-                 :dns_view => @dns_view, :network_view => @network_view}
+                 :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
@@ -33,7 +33,7 @@ class InfobloxDhcpProductionWiringTest < Test::Unit::TestCase
     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)
+    assert_equal({ :verify => true }, connection.ssl_opts)
   end
 
   def test_unused_ips_configuration
@@ -71,7 +71,7 @@ class InfobloxDhcpProductionWiringTest < Test::Unit::TestCase
 
   def test_provider_configuration_with_fixedaddress_crud
     Proxy::DHCP::Infoblox::PluginConfiguration.new.
-        load_dependency_injection_wirings(@container, :username => 'user', :password => 'password',
+      load_dependency_injection_wirings(@container, :username => 'user', :password => 'password',
                                           :server => '127.0.0.1', :record_type => 'fixed_address')
 
     provider = @container.get_dependency(:dhcp_provider)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dhcp_infoblox
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - Klaas Demter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-27 00:00:00.000000000 Z
+date: 2018-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: infoblox
@@ -30,6 +30,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.4
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.50.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.50.0
 description: Infoblox DHCP provider plugin for Foreman's smart proxy
 email:
 - demter@atix.de
@@ -81,16 +95,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Infoblox DHCP provider plugin for Foreman's smart proxy
 test_files:
-- test/integration_test.rb
-- test/infoblox_provider_test.rb
-- test/plugin_configuration_test.rb
-- test/regex_generator_test.rb
 - test/record_type_validator_test.rb
+- test/regex_generator_test.rb
 - test/test_helper.rb
 - test/unused_ip_test.rb
 - test/host_and_fixedaddress_crud_test.rb
+- test/integration_test.rb
+- test/plugin_configuration_test.rb
+- test/infoblox_provider_test.rb