smart_proxy_dhcp_infoblox 0.0.5 → 0.0.18

data/test/integration_test.rb

@@ -0,0 +1,96 @@
+require "rack/test"
+require 'test_helper'
+require 'json'
+require 'dhcp_common/dhcp_common'
+require 'dhcp/dhcp'
+require 'dhcp/dependency_injection'
+require 'dhcp/dhcp_api'
+
+ENV['RACK_ENV'] = 'test'
+
+class IntegrationTest < ::Test::Unit::TestCase
+  include Rack::Test::Methods
+
+  def app
+    app = Proxy::DhcpApi.new
+    app.helpers.server = @server
+    app
+  end
+
+  def setup
+    @free_ips = ::Proxy::DHCP::FreeIps.new
+    @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" }
+  end
+
+  def test_get_subnets
+    @server.expects(:subnets).returns([])
+    get "/"
+    assert last_response.ok?, "Last response was not ok: #{last_response.status} #{last_response.body}"
+  end
+
+  def test_get_network
+    @server.expects(:all_hosts).with("10.0.0.0").returns([@expected_reservation])
+    @server.expects(:all_leases).with("10.0.0.0").returns([])
+
+    get "/10.0.0.0"
+
+    assert last_response.ok?, "Last response was not ok: #{last_response.status} #{last_response.body}"
+  end
+
+  def test_get_unused_ip
+    @server.expects(:get_subnet).with("10.0.0.0").returns(::Proxy::DHCP::Subnet.new("10.0.0.0", "255.255.255.0"))
+    @server.expects(:all_hosts).with("10.0.0.0").returns([@expected_reservation])
+    @server.expects(:all_leases).with("10.0.0.0").returns([])
+    @free_ips.expects(:find_free_ip).with("10.0.0.100", "10.0.0.200", [@expected_reservation]).returns("10.0.0.150")
+
+    get "/10.0.0.0/unused_ip?from=10.0.0.100&to=10.0.0.200"
+
+    assert last_response.ok?, "Last response was not ok: #{last_response.status} #{last_response.body}"
+    parsed_response = JSON.parse(last_response.body)
+    assert parsed_response.key?('ip')
+  end
+
+  def test_get_records_by_ip
+    @server.expects(:find_records_by_ip).with("10.0.0.0", "10.0.0.200").returns([@expected_reservation])
+    get "/10.0.0.0/ip/10.0.0.200"
+    assert last_response.ok?, "Last response was not ok: #{last_response.status} #{last_response.body}"
+    parsed_response = JSON.parse(last_response.body)
+    assert_equal 1, parsed_response.size
+    assert_equal @expected_reservation, parsed_response.first
+  end
+
+  def test_get_record_by_mac
+    @server.expects(:find_record_by_mac).with("10.0.0.0", "11:22:33:a9:61:09").returns(@expected_reservation)
+    get "/10.0.0.0/mac/11:22:33:a9:61:09"
+    assert last_response.ok?, "Last response was not ok: #{last_response.status} #{last_response.body}"
+    assert_equal @expected_reservation, JSON.parse(last_response.body)
+  end
+
+  def test_create_record
+    record = {
+      "hostname" => "test-02",
+        "ip"       => "10.0.0.250",
+        "mac"      => "10:10:10:10:10:10",
+        "network"  => "10.0.0.0",
+    }
+    @server.expects(:add_record).with(has_entries(record))
+    post "/10.0.0.0", record
+    assert last_response.ok?, "Last response was not ok: #{last_response.status} #{last_response.body}"
+  end
+
+  def test_delete_records_by_ip
+    @server.expects(:del_records_by_ip).with("10.0.0.0", "10.0.0.200")
+    delete "/10.0.0.0/ip/10.0.0.200"
+    assert last_response.ok?, "Last response was not ok: #{last_response.status} #{last_response.body}"
+  end
+
+  def test_delete_record_by_mac
+    @server.expects(:del_record_by_mac).with("10.0.0.0", "11:22:33:a9:61:09")
+    delete "/10.0.0.0/mac/11:22:33:a9:61:09"
+    assert last_response.ok?, "Last response was not ok: #{last_response.status} #{last_response.body}"
+  end
+end

data/test/plugin_configuration_test.rb

@@ -1,25 +1,34 @@
 require 'test_helper'
 require 'infoblox'
 require 'dhcp_common/dhcp_common'
+require 'dhcp_common/free_ips'
 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)
+    assert_equal({ :record_type => 'fixedaddress',
+      :used_ips_search_type => "record_type",
+      :blacklist_duration_minutes => 30 * 60,
+      :wait_after_restart => 10,
+      :dns_view => "default",
+      :options => [],
+      :network_view => "default" },
+                 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']}
+    @network_view = "network_view"
+    @dns_view = "dns_view"
+    @settings = { :username => 'user', :password => 'password', :server => '127.0.0.1', :record_type => 'fixedaddress',
+                 :used_ips_search_type => 'record_type', :subnets => ['1.1.1.0/255.255.255.0'], :blacklist_duration_minutes => 300,
+                 :wait_after_restart => 1,: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
@@ -29,23 +38,25 @@ 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
-    free_ips = @container.get_dependency(:unused_ips)
-    assert_not_nil free_ips.connection
-    assert free_ips.use_ranges
+    unused_ips = @container.get_dependency(:unused_ips)
+    assert unused_ips
+    assert_equal 300, unused_ips.blacklist_interval
   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
@@ -57,15 +68,16 @@ class InfobloxDhcpProductionWiringTest < Test::Unit::TestCase
     provider = @container.get_dependency(:dhcp_provider)
     assert_not_nil provider.connection
     assert_not_nil provider.restart_grid
-    assert_not_nil provider.unused_ips
+    assert_not_nil provider.free_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)
+    assert provider.crud.instance_of?(::Proxy::DHCP::Infoblox::FixedAddressCRUD)
   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')
+      load_dependency_injection_wirings(@container, :username => 'user', :password => 'password', :server => '127.0.0.1',
+                                        :record_type => 'fixed_address', :used_ips_search_type => 'record_type')
 
     provider = @container.get_dependency(:dhcp_provider)
     assert provider.crud.instance_of?(::Proxy::DHCP::Infoblox::FixedAddressCRUD)

data/test/test_helper.rb

@@ -1,5 +1,5 @@
 require 'test/unit'
-require 'mocha/setup'
+require 'mocha/test_unit'
 
 require 'smart_proxy_for_testing'
 

data/test/unused_ip_test.rb

@@ -1,48 +1,58 @@
 require 'test_helper'
 require 'infoblox'
-require 'smart_proxy_dhcp_infoblox/unused_ips'
+require 'dhcp_common/free_ips'
+require 'smart_proxy_dhcp_infoblox/dhcp_infoblox_main'
+require 'ostruct'
 
 class UnusedIpTest < Test::Unit::TestCase
   def setup
     @connection = Object.new
-    @unused_ips = ::Proxy::DHCP::Infoblox::UnusedIps.new(@connection, false)
+    @crud = Object.new
+    @restart_grid = Object.new
+    @managed_subnets = nil
+    @network_view = "another"
+    @unused_ips = ::Proxy::DHCP::FreeIps.new
     @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')
+    @provider = Proxy::DHCP::Infoblox::Provider.new(@connection, @crud, @restart_grid,
+                                                    @unused_ips, @managed_subnets, @network_view)
   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_unused_network_ip
+    expected_ip = '1.1.1.1'
+    @provider.expects(:get_subnet).with('1.1.0.0').returns(::Proxy::DHCP::Subnet.new('1.1.0.0', '255.255.0.0'))
+    @provider.expects(:all_hosts).with('1.1.0.0').returns([host = Object.new])
+    @provider.expects(:all_leases).with('1.1.0.0').returns([lease = Object.new])
+    @unused_ips.expects(:find_free_ip).with('1.1.0.1', '1.1.255.254', [host, lease]).returns(expected_ip)
 
-  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
+    ip = @provider.unused_ip('1.1.0.0', nil, nil, nil)
 
-  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?
+    assert_equal expected_ip, ip
   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_network_ip_with_mac_address_present
+    expected_ip = '1.1.1.1'
+    mac_address = '00:01:02:03:04:05'
+    @provider.expects(:get_subnet).with('1.1.0.0').returns(subnet = ::Proxy::DHCP::Subnet.new('1.1.0.0', '255.255.0.0'))
+    @provider.expects(:find_ip_by_mac_address_and_range).with(subnet, mac_address, '1.1.0.1', '1.1.255.254').returns(expected_ip)
 
-  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
+    ip = @provider.unused_ip('1.1.0.0', mac_address, nil, nil)
 
-  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')
+    assert_equal expected_ip, ip
   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')
+  def test_unused_network_ip_with_mac_address_present_with_address_outside_range
+    expected_ip = '1.1.1.1'
+    start_range = '1.1.10.1'
+    end_range = '1.1.100.1'
+    mac_address = '00:01:02:03:04:05'
+    @provider.expects(:get_subnet).with('1.1.0.0').returns(subnet = ::Proxy::DHCP::Subnet.new('1.1.0.0', '255.255.0.0'))
+    @crud.expects(:find_record_by_mac).with('1.1.0.0/16', mac_address).returns(OpenStruct.new(:ip => '10.0.0.1'))
+    @provider.expects(:all_hosts).with('1.1.0.0').returns([host = Object.new])
+    @provider.expects(:all_leases).with('1.1.0.0').returns([lease = Object.new])
+    @unused_ips.expects(:find_free_ip).with(start_range, end_range, [host, lease]).returns(expected_ip)
+
+    ip = @provider.unused_ip('1.1.0.0', mac_address, start_range, end_range)
+
+    assert_equal expected_ip, ip
   end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_dhcp_infoblox
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.18
 platform: ruby
 authors:
 - Klaas Demter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-12 00:00:00.000000000 Z
-dependencies: []
+date: 2024-03-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: infoblox
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: Infoblox DHCP provider plugin for Foreman's smart proxy
 email:
 - demter@atix.de
@@ -32,18 +46,16 @@ files:
 - lib/smart_proxy_dhcp_infoblox/ip_address_arithmetic.rb
 - lib/smart_proxy_dhcp_infoblox/network_address_range_regex_generator.rb
 - lib/smart_proxy_dhcp_infoblox/plugin_configuration.rb
-- lib/smart_proxy_dhcp_infoblox/record_type_validator.rb
-- lib/smart_proxy_dhcp_infoblox/unused_ips.rb
 - test/host_and_fixedaddress_crud_test.rb
 - test/infoblox_provider_test.rb
+- test/integration_test.rb
 - test/plugin_configuration_test.rb
-- test/record_type_validator_test.rb
 - test/regex_generator_test.rb
 - test/test_helper.rb
 - test/unused_ip_test.rb
 homepage: https://github.com/theforeman/smart_proxy_dhcp_infoblox
 licenses:
-- GPLv3
+- GPL-3.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -53,23 +65,22 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.3.26
 signing_key: 
 specification_version: 4
 summary: Infoblox DHCP provider plugin for Foreman's smart proxy
 test_files:
 - test/host_and_fixedaddress_crud_test.rb
 - test/infoblox_provider_test.rb
+- test/integration_test.rb
 - test/plugin_configuration_test.rb
-- test/record_type_validator_test.rb
 - test/regex_generator_test.rb
 - test/test_helper.rb
 - test/unused_ip_test.rb

data/lib/smart_proxy_dhcp_infoblox/record_type_validator.rb

@@ -1,8 +0,0 @@
-module ::Proxy::DHCP::Infoblox
-  class RecordTypeValidator < ::Proxy::PluginValidators::Base
-    def validate!(settings)
-      return true if ['host', 'fixedaddress'].include?(settings[:record_type])
-      raise ::Proxy::Error::ConfigurationError, "Setting 'record_type' can be set to either 'host' or 'fixedaddress'"
-    end
-  end
-end

data/lib/smart_proxy_dhcp_infoblox/unused_ips.rb

@@ -1,47 +0,0 @@
-require 'ipaddr'
-require 'smart_proxy_dhcp_infoblox/ip_address_arithmetic'
-
-module Proxy::DHCP::Infoblox
-  class UnusedIps
-    include IpAddressArithmetic
-    attr_reader :connection, :use_ranges
-
-    def initialize(connection, use_ranges)
-      @connection = connection
-      @use_ranges = use_ranges
-    end
-
-    def unused_ip(network_address, from_ip_address, to_ip_address)
-      @use_ranges ? unused_range_ip(network_address, from_ip_address, to_ip_address) : unused_network_ip(network_address, from_ip_address, to_ip_address)
-    end
-
-    def unused_network_ip(network_address, from_ip_address, to_ip_address)
-      find_network(network_address).next_available_ip(1, excluded_ips(find_network(network_address).network, from_ip_address, to_ip_address)).first
-    end
-
-    def unused_range_ip(network_address, from_ip_address, to_ip_address)
-      find_range(network_address, from_ip_address, to_ip_address).next_available_ip(1).first
-    end
-
-    def excluded_ips(subnet_address, from, to)
-      return [] if from.nil? || to.nil?
-      (IPAddr.new(network_cidr_to_range(subnet_address).first)..IPAddr.new(network_cidr_to_range(subnet_address).last)).to_a.map(&:to_s) -
-          (IPAddr.new(from)..IPAddr.new(to)).to_a.map(&:to_s)
-    end
-
-    def find_range(network_address, from, to)
-      ranges = ::Infoblox::Range.find(@connection, 'network~' => network_address)
-      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
-    end
-
-    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
-      raise "Subnet #{network_address} not found" if @memoized_network.nil?
-      @memoized_network
-    end
-  end
-end

data/test/record_type_validator_test.rb

@@ -1,20 +0,0 @@
-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