smart_proxy_efficient_ip 0.0.12

data/test/api_test.rb

@@ -0,0 +1,179 @@
+require 'test_helper'
+require 'SOLIDserver'
+require 'smart_proxy_efficient_ip/api'
+
+class ApiTest < Test::Unit::TestCase
+  def setup
+    @connection = ::SOLIDserver::SOLIDserver.new('10.10.10.10', 'username', 'password')
+    @api = ::Proxy::DHCP::EfficientIp::Api.new(@connection)
+  end
+
+  def test_find_subnet
+    network_address = '192.168.45.0'
+    subnet = { 'subnet_id' => '142', 'subnet_size' => '256' }
+    server_response = stub(body: [subnet].to_json)
+
+    @connection
+      .expects(:ip_subnet_list)
+      .with(where: "start_hostaddr='#{network_address}' and is_terminal='1'", limit: 1)
+      .returns(server_response)
+
+    assert_equal @api.find_subnet(network_address), subnet
+  end
+
+  def test_find_subnets
+    subnets = [
+      { 'subnet_id' => '142', 'subnet_size' => '256' },
+      { 'subnet_id' => '182', 'subnet_size' => '256' },
+      { 'subnet_id' => '108', 'subnet_size' => '256' },
+    ]
+    server_response = stub(body: subnets.to_json)
+
+    @connection
+      .expects(:ip_subnet_list)
+      .with(where: "is_terminal='1' and start_hostaddr!='0.0.0.0'")
+      .returns(server_response)
+
+    assert_equal @api.subnets, subnets
+  end
+
+  def test_find_free
+    network_address = '192.168.45.0'
+    start_ip = '192.168.45.5'
+    end_ip = '192.168.45.25'
+    subnet = { 'subnet_id' => '142', 'subnet_size' => '256' }
+    free_address = { 'hostaddr' => '192.168.45.11' }
+    subnet_response = stub(body: [subnet].to_json)
+    server_response = stub(body: [free_address].to_json)
+
+    @connection
+      .expects(:ip_subnet_list)
+      .with(where: "start_hostaddr='#{network_address}' and is_terminal='1'", limit: 1)
+      .returns(subnet_response)
+    @connection
+      .expects(:ip_address_find_free)
+      .with(subnet_id: subnet['subnet_id'], begin_addr: start_ip, end_addr: end_ip, max_find: 1)
+      .returns(server_response)
+
+    assert_equal @api.find_free(network_address, start_ip, end_ip), free_address
+  end
+
+  def test_find_record
+    address = '192.168.45.92'
+    record = { 'name' => 'Vincent', 'hostaddr' => address }
+    server_response = stub(body: [record].to_json)
+
+    @connection
+      .expects(:ip_address_list)
+      .with(where: "type='ip' and (hostaddr='#{address}' or mac_addr='#{address}')", limit: 1)
+      .returns(server_response)
+
+    assert_equal @api.find_record(address), record
+  end
+
+  def test_find_records
+    address = '192.168.45.92'
+    records = [
+      { 'name' => 'Vincent', 'hostaddr' => address },
+      { 'name' => 'Tom', 'hostaddr' => address },
+    ]
+    server_response = stub(body: records.to_json)
+
+    @connection
+      .expects(:ip_address_list)
+      .with(where: "type='ip' and (hostaddr='#{address}' or mac_addr='#{address}')")
+      .returns(server_response)
+
+    assert_equal @api.find_records(address), records
+  end
+
+  def test_hosts
+    network_address = '192.168.45.0'
+    hosts = [
+      { 'name' => 'Vincent', 'hostaddr' => '192.168.45.101' },
+      { 'name' => 'Tom', 'hostaddr' => '192.168.45.94' },
+    ]
+    subnet = { 'subnet_id' => '192', 'subnet_size' => '256', 'start_hostaddr' => network_address }
+    subnet_response = stub(body: [subnet].to_json)
+    server_response = stub(body: hosts.to_json)
+
+    @connection
+      .expects(:ip_subnet_list)
+      .with(where: "start_hostaddr='#{network_address}' and is_terminal='1'", limit: 1)
+      .returns(subnet_response)
+    @connection
+      .expects(:ip_address_list)
+      .with(where: "subnet_id=#{subnet['subnet_id']} and dhcphost_id > 0")
+      .returns(server_response)
+
+    assert_equal @api.hosts(network_address), hosts
+  end
+
+  def test_leases
+    network_address = '192.168.47.0'
+    addresses = [
+      { 'dhcplease_id' => '78' },
+      { 'dhcplease_id' => '21' },
+    ]
+    leases = [
+      { 'dhcplease_id' => '78', 'dhcplease_name' => 'ABC' },
+      { 'dhcplease_id' => '21', 'dhcplease_name' => 'CBD' },
+    ]
+    subnet = { 'subnet_id' => '192', 'subnet_size' => '256', 'start_hostaddr' => network_address }
+    subnet_response = stub(body: [subnet].to_json)
+    server_response = stub(body: addresses.to_json)
+    leases_resposne = stub(body: leases.to_json)
+    ids = addresses.map { |addr| addr['dhcplease_id'] }
+
+    @connection
+      .expects(:ip_subnet_list)
+      .with(where: "start_hostaddr='#{network_address}' and is_terminal='1'", limit: 1)
+      .returns(subnet_response)
+    @connection
+      .expects(:ip_address_list)
+      .with(where: "subnet_id=#{subnet['subnet_id']} and dhcplease_id > 0")
+      .returns(server_response)
+    @connection
+      .expects(:dhcp_lease_list)
+      .with(where: "dhcplease_id IN (#{ids})")
+      .returns(leases_resposne)
+
+    assert_equal @api.leases(network_address), leases
+  end
+
+  def test_add_record
+    network_address = '192.168.45.0'
+    params = { 'ip' => '192.168.45.65', 'mac' => '1f:83:ea:ee:53:67', 'name' => 'Makita', 'network' => network_address }
+    subnet = { 'subnet_id' => '192', 'site_name' => 'Houston', 'start_hostaddr' => network_address }
+    subnet_response = stub(body: [subnet].to_json)
+
+    @connection
+      .expects(:ip_subnet_list)
+      .with(where: "start_hostaddr='#{network_address}' and is_terminal='1'", limit: 1)
+      .returns(subnet_response)
+    @connection
+      .expects(:ip_address_add)
+      .with(site_name: subnet['site_name'], ip_addr: params['ip'], mac_addr: params['mac'], name: params['name'])
+      .once
+
+    @api.add_record(params)
+  end
+
+  def test_delete_record
+    subnet_params = { 'subnet_id' => '192', 'site_name' => 'Houston' }
+    subnet = stub(network: '192.168.45.0')
+    record = stub(subnet: subnet, ip: '192.168.45.65')
+    subnet_response = stub(body: [subnet_params].to_json)
+
+    @connection
+      .expects(:ip_subnet_list)
+      .with(where: "start_hostaddr='#{subnet.network}' and is_terminal='1'", limit: 1)
+      .returns(subnet_response)
+    @connection
+      .expects(:ip_address_delete)
+      .with(site_name: subnet_params['site_name'], hostaddr: record.ip)
+      .once
+
+    @api.delete_record(record)
+  end
+end

data/test/configuration_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+require 'SOLIDserver'
+require 'dhcp_common/dhcp_common'
+require 'smart_proxy_efficient_ip/api'
+require 'smart_proxy_efficient_ip/main'
+require 'smart_proxy_efficient_ip/configuration'
+
+class ConfigurationTest < Test::Unit::TestCase
+  def setup
+    @settings = {
+      username: 'user',
+      password: 'password',
+      server_id: '10.10.10.10'
+    }
+    @container = ::Proxy::DependencyInjection::Container.new
+    Proxy::DHCP::EfficientIp::Configuration.new.load_dependency_injection_wirings(@container, @settings)
+  end
+
+  def test_connection
+    connection = @container.get_dependency(:connection)
+
+    assert_instance_of ::SOLIDserver::SOLIDserver, connection
+  end
+
+  def test_api
+    api = @container.get_dependency(:api)
+
+    assert_instance_of ::Proxy::DHCP::EfficientIp::Api, api
+  end
+
+  def test_provider
+    provider = @container.get_dependency(:dhcp_provider)
+
+    assert_instance_of ::Proxy::DHCP::EfficientIp::Provider, provider
+  end
+end
+
+

data/test/provider_test.rb

@@ -0,0 +1,142 @@
+require 'test_helper'
+require 'SOLIDserver'
+require 'smart_proxy_efficient_ip/main'
+require 'smart_proxy_efficient_ip/const'
+
+SIZE_TO_MASK = ::Proxy::DHCP::EfficientIp::SIZE_TO_MASK
+
+class ProviderTest < Test::Unit::TestCase
+  def setup
+    @connection = ::SOLIDserver::SOLIDserver.new('10.10.10.10', 'username', 'password')
+    @api = ::Proxy::DHCP::EfficientIp::Api.new(@connection)
+    @provider = ::Proxy::DHCP::EfficientIp::Provider.new(@api, nil)
+  end
+
+  def test_find_subnet
+    network_address = '192.168.45.0'
+    subnet_params = { 'subnet_id' => '106', 'subnet_size' => '256' }
+
+    @api.expects(:find_subnet).with(network_address).returns(subnet_params)
+
+    result = @provider.find_subnet(network_address)
+
+    assert_instance_of ::Proxy::DHCP::Subnet, result
+    assert_equal result.network, network_address
+    assert_equal result.netmask, ::Proxy::DHCP::EfficientIp::SIZE_TO_MASK[subnet_params['subnet_size'].to_i]
+  end
+
+  def test_find_subnets
+    network_address = '192.168.45.0'
+    subnets_params = [
+      { 'subnet_id' => '106', 'start_hostaddr' => '192.168.84.0', 'subnet_size' => '256' },
+      { 'subnet_id' => '125', 'start_hostaddr' => '192.168.88.0', 'subnet_size' => '128' },
+    ]
+
+    @api.expects(:subnets).returns(subnets_params)
+
+    result = @provider.subnets
+    assert_instance_of ::Proxy::DHCP::Subnet, result[0]
+    assert_instance_of ::Proxy::DHCP::Subnet, result[1]
+    assert_equal result[0].network, subnets_params[0]['start_hostaddr']
+    assert_equal result[1].network, subnets_params[1]['start_hostaddr']
+    assert_equal result[0].netmask, SIZE_TO_MASK[subnets_params[0]['subnet_size'].to_i]
+    assert_equal result[1].netmask, SIZE_TO_MASK[subnets_params[1]['subnet_size'].to_i]
+  end
+
+  def test_all_hosts
+    network_address = '192.168.75.0'
+    subnet = { 'subnet_id' => '106', 'subnet_size' => '256' }
+    hosts = [
+      { 'name' => 'Rick', 'hostaddr' => '192.168.75.23', 'mac_addr' => '8a:9c:3e:c3:5a:6b' },
+      { 'name' => 'Morty', 'hostaddr' => '192.168.75.67', 'mac_addr' => 'af:94:2d:6d:7e:7e' }
+    ]
+
+
+    @api.expects(:hosts).with(network_address).returns(hosts)
+    @api.expects(:find_subnet).with(network_address).returns(subnet)
+
+    result = @provider.all_hosts(network_address)
+
+    assert_instance_of ::Proxy::DHCP::Reservation, result[0]
+    assert_instance_of ::Proxy::DHCP::Reservation, result[1]
+    assert_equal result[0].name, hosts[0]['name']
+    assert_equal result[1].name, hosts[1]['name']
+    assert_equal result[0].ip, hosts[0]['hostaddr']
+    assert_equal result[1].ip, hosts[1]['hostaddr']
+    assert_equal result[0].mac, hosts[0]['mac_addr']
+    assert_equal result[1].mac, hosts[1]['mac_addr']
+  end
+
+  def test_all_leases
+    network_address = '192.168.85.0'
+    subnet = { 'subnet_id' => '106', 'subnet_size' => '256' }
+    real_mac_address_1 = '8a:9c:3e:c3:5a:6b'
+    real_mac_address_2 = 'af:94:2d:6d:7e:7e'
+    leases = [
+      {
+        'dhcplease_id' => '78',
+        'dhcplease_name' => 'Nick',
+        'dhcplease_addr' => '192.168.75.23',
+        'dhcplease_mac_addr' => "0a:#{real_mac_address_1}",
+        'dhcplease_first_time' => '1617021896',
+        'dhcplease_end_time' => '1617066741',
+        'time_to_expire' => '54632'
+      },
+      {
+        'dhcplease_id' => '31',
+        'dhcplease_name' => 'Jack',
+        'dhcplease_addr' => '192.168.75.67',
+        'dhcplease_mac_addr' => "0a:#{real_mac_address_2}",
+        'dhcplease_first_time' => '1617021396',
+        'dhcplease_end_time' => '1617066421',
+        'time_to_expire' => '631'
+      }
+    ]
+
+
+    @api.expects(:leases).with(network_address).returns(leases)
+    @api.expects(:find_subnet).with(network_address).returns(subnet)
+
+    result = @provider.all_leases(network_address)
+
+    assert_instance_of ::Proxy::DHCP::Lease, result[0]
+    assert_instance_of ::Proxy::DHCP::Lease, result[1]
+    assert_equal result[0].name, leases[0]['dhcplease_name']
+    assert_equal result[1].name, leases[1]['dhcplease_name']
+    assert_equal result[0].ip, leases[0]['dhcplease_addr']
+    assert_equal result[1].ip, leases[1]['dhcplease_addr']
+    assert_equal result[0].mac, real_mac_address_1
+    assert_equal result[1].mac, real_mac_address_2
+  end
+
+  def test_unused_ip
+    network_address = '192.168.85.0'
+    free_ip = '192.168.85.64'
+    start_ip = '192.168.85.12'
+    end_ip = '192.168.85.112'
+    server_response = { 'hostaddr' => free_ip }
+
+    @api.expects(:find_free).with(network_address, start_ip, end_ip).returns(server_response)
+
+    result = @provider.unused_ip(network_address, nil, start_ip, end_ip)
+
+    assert_equal result, free_ip
+  end
+
+  def test_find_record
+    network_address = '192.168.95.0'
+    ip = '192.168.95.23'
+    record_params = { 'hostaddr' => ip, 'mac_addr' => 'e1:2c:07:c1:46:7b', 'name' => 'First' }
+    subnet_params = { 'subnet_id' => '577', 'subnet_size' => '256' }
+
+    @api.expects(:find_subnet).with(network_address).returns(subnet_params)
+    @api.expects(:find_record).with(ip).returns(record_params)
+
+    result = @provider.find_record(network_address, ip)
+
+    assert_instance_of Proxy::DHCP::Reservation, result
+    assert_equal result.ip, record_params['hostaddr']
+    assert_equal result.mac, record_params['mac_addr']
+    assert_equal result.name, record_params['name']
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'test/unit'
+require 'mocha/test_unit'
+require 'smart_proxy_for_testing'

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: smart_proxy_efficient_ip
+version: !ruby/object:Gem::Version
+  version: 0.0.12
+platform: ruby
+authors:
+- Michal Olejniczak
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-06-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: SOLIDserver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.11
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+description: Plugin for integration Foreman's smart proxy with EfficientIP
+email:
+- michal.olejniczak@ironin.pl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bundler.d/efficient_ip.rb
+- config/dhcp_efficient_ip.yml.example
+- config/docker_smart-proxy_settings/settings.d/dhcp.yml
+- config/docker_smart-proxy_settings/settings.d/dhcp_efficient_ip.yml.example
+- config/docker_smart-proxy_settings/settings.yml
+- lib/smart_proxy_efficient_ip.rb
+- lib/smart_proxy_efficient_ip/api.rb
+- lib/smart_proxy_efficient_ip/configuration.rb
+- lib/smart_proxy_efficient_ip/const.rb
+- lib/smart_proxy_efficient_ip/main.rb
+- lib/smart_proxy_efficient_ip/plugin.rb
+- lib/smart_proxy_efficient_ip/version.rb
+- test/api_test.rb
+- test/configuration_test.rb
+- test/provider_test.rb
+- test/test_helper.rb
+homepage: https://gitlab.ironin.it/efficient-ip/smart-proxy-dhcp
+licenses:
+- GPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Smart proxy plugin for EfficientIP
+test_files:
+- test/api_test.rb
+- test/configuration_test.rb
+- test/provider_test.rb
+- test/test_helper.rb