foreman_netbox 1.0.2

data/test/integration/foreman_netbox/sync_k8s_physical_host_test.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class SyncK8sPhysicalHostTest < ActiveSupport::TestCase
+  setup do
+    setup_netbox_integration_test
+  end
+
+  subject { ForemanNetbox::SyncHost::Organizer.call(host: host) }
+
+  let(:hostname) { 'k8s_physical_host' }
+  let(:file) { file_fixture("facts/#{hostname}.json").read }
+  let(:facts_json) { JSON.parse(file) }
+  let(:host) do
+    FactoryBot.build_stubbed(
+      :host,
+      hostname: "#{hostname}.tier.example.com",
+      owner: FactoryBot.build_stubbed(:usergroup, name: 'Owner'),
+      location: FactoryBot.build_stubbed(:location, name: 'Location'),
+      interfaces: [
+        FactoryBot.build_stubbed(
+          :nic_base,
+          identifier: 'eth0',
+          mac: 'C3:CD:63:54:21:60',
+          ip: '10.0.0.7',
+          subnet: FactoryBot.build_stubbed(:subnet_ipv4, organizations: [], locations: [])
+        ),
+        FactoryBot.build_stubbed(
+          :nic_base,
+          identifier: 'eth1',
+          mac: '45:E9:6A:83:02:20',
+          ip6: '1600:0:2d0:202::17',
+          subnet6: FactoryBot.build_stubbed(:subnet_ipv6, organizations: [], locations: [])
+        )
+      ]
+    ).tap do |host|
+      host.stubs(:ip).returns(host.interfaces.find(&:ip).ip)
+      host.stubs(:ip6).returns(host.interfaces.find(&:ip6).ip6)
+      host.stubs(:compute?).returns(false)
+      host.stubs(:facts).returns(facts_json)
+    end
+  end
+
+  test 'sync host' do
+    ForemanNetbox::NetboxFacet.any_instance.expects(:update).twice.returns(true)
+
+    assert subject.success?
+
+    assert_equal host.name,                         subject.device.name
+    assert_equal host.owner.netbox_tenant_name,     subject.device.tenant.name
+    assert_equal host.location.netbox_site_name,    subject.device.site.name
+    assert_equal host.facts['manufacturer'],        subject.device.device_type.manufacturer.name
+    assert_equal host.facts['productname'],         subject.device.device_type.model
+    assert_equal host.facts['serialnumber'],        subject.device.serial
+
+    assert_equal IPAddress.parse("#{host.ip}/24"),  subject.device.primary_ip4.address
+    assert_equal IPAddress.parse("#{host.ip6}/64"), subject.device.primary_ip6.address
+    host.interfaces.each do |h_interface|
+      nx_interface = subject.interfaces.find { |i| i.name == h_interface.identifier }
+
+      assert nx_interface.present?
+
+      h_interface.netbox_ips.each do |h_ip|
+        assert subject.ip_addresses.find { |nx_ip| nx_ip.interface.id == nx_interface.id && nx_ip.address == IPAddress.parse(h_ip) }.present?
+      end
+    end
+
+    expected_tags = ForemanNetbox::NetboxParameters::DEFAULT_TAGS
+    assert_equal expected_tags, subject.device.tags
+    assert_equal expected_tags, subject.device_type.tags
+    assert_equal expected_tags, subject.site.tags
+    assert_equal expected_tags, subject.tenant.tags
+    subject.interfaces.reload.each do |interface|
+      assert_equal expected_tags, interface.tags
+    end
+    subject.ip_addresses.reload.each do |interface|
+      assert_equal expected_tags, interface.tags
+    end
+  end
+end

data/test/integration/foreman_netbox/sync_rhel_physical_host_test.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class SyncRhelPhysicalHostTest < ActiveSupport::TestCase
+  setup do
+    setup_netbox_integration_test
+  end
+
+  subject { ForemanNetbox::SyncHost::Organizer.call(host: host) }
+
+  let(:hostname) { 'rhel_physical_host' }
+  let(:file) { file_fixture("facts/#{hostname}.json").read }
+  let(:facts_json) { JSON.parse(file) }
+  let(:host) do
+    FactoryBot.build_stubbed(
+      :host,
+      hostname: "#{hostname}.tier.example.com",
+      owner: FactoryBot.build_stubbed(:usergroup, name: SecureRandom.hex(16)),
+      location: FactoryBot.build_stubbed(:location, name: 'Location'),
+      interfaces: [
+        FactoryBot.build_stubbed(
+          :nic_base,
+          identifier: 'eth0',
+          mac: 'C3:CD:63:54:21:61',
+          ip: '10.0.0.8',
+          subnet: FactoryBot.build_stubbed(:subnet_ipv4, organizations: [], locations: [])
+        ),
+        FactoryBot.build_stubbed(
+          :nic_base,
+          identifier: 'eth1',
+          mac: '45:E9:6A:83:02:21',
+          ip6: '1600:0:2d0:202::18',
+          subnet6: FactoryBot.build_stubbed(:subnet_ipv6, organizations: [], locations: [])
+        )
+      ]
+    ).tap do |host|
+      host.stubs(:ip).returns(host.interfaces.find(&:ip).ip)
+      host.stubs(:ip6).returns(host.interfaces.find(&:ip6).ip6)
+      host.stubs(:compute?).returns(false)
+      host.stubs(:facts).returns(facts_json)
+    end
+  end
+
+  test 'sync host' do
+    ForemanNetbox::NetboxFacet.any_instance.expects(:update).twice.returns(true)
+
+    assert subject.success?
+
+    assert_equal host.name,                         subject.device.name
+    assert_equal host.owner.netbox_tenant_name,     subject.device.tenant.name
+    assert_equal host.location.netbox_site_name,    subject.device.site.name
+    assert_equal host.facts['manufacturer'],        subject.device.device_type.manufacturer.name
+    assert_equal host.facts['productname'],         subject.device.device_type.model
+    assert_equal host.facts['serialnumber'],        subject.device.serial
+
+    assert_equal IPAddress.parse("#{host.ip}/24"),  subject.device.primary_ip4.address
+    assert_equal IPAddress.parse("#{host.ip6}/64"), subject.device.primary_ip6.address
+    host.interfaces.each do |h_interface|
+      nx_interface = subject.interfaces.find { |i| i.name == h_interface.identifier }
+
+      assert nx_interface.present?
+
+      h_interface.netbox_ips.each do |h_ip|
+        assert subject.ip_addresses.find { |nx_ip| nx_ip.interface.id == nx_interface.id && nx_ip.address == IPAddress.parse(h_ip) }.present?
+      end
+    end
+
+    expected_tags = ForemanNetbox::NetboxParameters::DEFAULT_TAGS
+    assert_equal expected_tags, subject.device.tags
+    assert_equal expected_tags, subject.device_type.tags
+    assert_equal expected_tags, subject.site.tags
+    assert_equal expected_tags, subject.tenant.tags
+    subject.interfaces.reload.each do |interface|
+      assert_equal expected_tags, interface.tags
+    end
+    subject.ip_addresses.reload.each do |interface|
+      assert_equal expected_tags, interface.tags
+    end
+  end
+end

data/test/integration/foreman_netbox/sync_rhel_virtual_host_test.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class SyncRhelVirtualHostTest < ActiveSupport::TestCase
+  setup do
+    setup_netbox_integration_test
+  end
+
+  subject { ForemanNetbox::SyncHost::Organizer.call(host: host) }
+
+  let(:hostname) { 'rhel_virtual_host' }
+  let(:file) { file_fixture("facts/#{hostname}.json").read }
+  let(:facts_json) { JSON.parse(file) }
+  let(:host) do
+    FactoryBot.build_stubbed(
+      :host,
+      hostname: "#{hostname}.tier.example.com",
+      owner: FactoryBot.build_stubbed(:usergroup, name: 'Owner'),
+      interfaces: [
+        FactoryBot.build_stubbed(
+          :nic_base,
+          identifier: 'eth0',
+          mac: 'C3:CD:63:54:21:62',
+          ip: '10.0.0.9',
+          subnet: FactoryBot.build_stubbed(:subnet_ipv4, organizations: [], locations: [])
+        ),
+        FactoryBot.build_stubbed(
+          :nic_base,
+          identifier: 'eth1',
+          mac: '45:E9:6A:83:02:22',
+          ip6: '1600:0:2d0:202::19',
+          subnet6: FactoryBot.build_stubbed(:subnet_ipv6, organizations: [], locations: [])
+        )
+      ]
+    ).tap do |host|
+      host.stubs(:ip).returns(host.interfaces.find(&:ip).ip)
+      host.stubs(:ip6).returns(host.interfaces.find(&:ip6).ip6)
+      host.stubs(:compute?).returns(true)
+      host.stubs(:compute_resource).returns(
+        OpenStruct.new(type: 'Foreman::Model::Vmware')
+      )
+      host.stubs(:compute_object).returns(
+        OpenStruct.new(
+          cluster: 'CLUSTER',
+          cpus: 1,
+          memory_mb: 1024,
+          volumes: [
+            OpenStruct.new(size_gb: 120)
+          ]
+        )
+      )
+      host.stubs(:facts).returns(facts_json)
+    end
+  end
+
+  test 'sync host' do
+    ForemanNetbox::NetboxFacet.any_instance.expects(:update).twice.returns(true)
+
+    assert subject.success?
+
+    assert_equal host.name,                                 subject.virtual_machine.name
+    assert_equal host.owner.netbox_tenant_name,             subject.virtual_machine.tenant.name
+    assert_equal host.compute_object.cpus,                  subject.virtual_machine.vcpus
+    assert_equal host.compute_object.memory_mb,             subject.virtual_machine.memory
+    assert_equal host.compute_object.volumes.first.size_gb, subject.virtual_machine.disk
+    assert_equal host.compute_object.cluster,               subject.virtual_machine.cluster.name
+    assert_equal 'VMware ESXi',                             subject.cluster_type.name
+
+    assert_equal IPAddress.parse("#{host.ip}/24"),  subject.virtual_machine.primary_ip4.address
+    assert_equal IPAddress.parse("#{host.ip6}/64"), subject.virtual_machine.primary_ip6.address
+    host.interfaces.each do |h_interface|
+      nx_interface = subject.interfaces.find { |i| i.name == h_interface.identifier }
+
+      assert nx_interface.present?
+
+      h_interface.netbox_ips.each do |h_ip|
+        assert subject.ip_addresses.find { |nx_ip| nx_ip.interface.id == nx_interface.id && nx_ip.address == IPAddress.parse(h_ip) }.present?
+      end
+    end
+
+    expected_tags = ForemanNetbox::NetboxParameters::DEFAULT_TAGS
+    assert_equal expected_tags, subject.virtual_machine.tags
+    assert_equal expected_tags, subject.tenant.tags
+    assert_equal expected_tags, subject.cluster.tags
+    subject.interfaces.reload.each do |interface|
+      assert_equal expected_tags, interface.tags
+    end
+    subject.ip_addresses.reload.each do |interface|
+      assert_equal expected_tags, interface.tags
+    end
+  end
+end

data/test/interactors/foreman_netbox/sync_host/organizer_test.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class SyncHostOrganizerTest < ActiveSupport::TestCase
+  subject { ForemanNetbox::SyncHost::Organizer.call(host: host) }
+
+  let(:host) do
+    FactoryBot.create(:host).tap do |host|
+      host.stubs(:interfaces).returns([])
+      host.stubs(:facts).returns({ serialnumber: 'abc123' })
+    end
+  end
+  let(:tags) { ForemanNetbox::NetboxParameters::DEFAULT_TAGS }
+
+  setup do
+    setup_default_netbox_settings
+    # rubocop:disable Layout/FirstArrayElementIndentation
+    stub_get_netbox_request('tenancy/tenants.json?limit=50&slug=admin-user', results: [
+      { id: 1, name: host.owner.name, slug: host.owner.name.parameterize, tags: tags }
+    ])
+    stub_get_netbox_request('dcim/sites.json?limit=50&slug=location-1', results: [
+      { id: 1, name: host.location.netbox_site_name, slug: host.location.netbox_site_slug, tags: tags }
+    ])
+    stub_get_netbox_request('dcim/device-roles.json?limit=50&slug=server', results: [
+      { id: 1, name: 'Device Role', slug: 'server' }
+    ])
+    stub_get_netbox_request('dcim/manufacturers.json?limit=50&slug=unknown', results: [
+      { id: 1, name: 'Unknown', slug: 'unknown' }
+    ])
+    stub_get_netbox_request('dcim/device-types.json?limit=50&slug=unknown', results: [
+      { id: 1, name: 'Unknown', slug: 'unknown', tags: tags }
+    ])
+    stub_get_netbox_request("dcim/devices.json?limit=50&serial=#{host.facts[:serialnumber]}", results: [
+      { id: 1, name: host.name, serial: host.facts[:serialnumber], tags: tags }
+    ])
+    stub_get_netbox_request('dcim/interfaces.json?device_id=1&limit=50', results: [])
+    stub_get_netbox_request('ipam/ip-addresses.json?device_id=1&limit=50', results: [])
+    # rubocop:enable Layout/FirstArrayElementIndentation
+  end
+
+  test 'save synchronization status when it succeeds' do
+    stub_request(:patch, "#{Setting::Netbox[:netbox_url]}/api/dcim/devices/1.json").to_return(
+      status: 200, headers: { 'Content-Type': 'application/json' },
+      body: { id: 1 }.to_json
+    )
+    subject
+    host.reload
+
+    assert_not_nil host.netbox_facet.synchronized_at
+    assert_equal "#{Setting::Netbox[:netbox_url]}/dcim/devices/1", host.netbox_facet.url
+    assert_nil host.netbox_facet.synchronization_error
+  end
+
+  test 'save synchronization status when it fails' do
+    stub_request(:patch, "#{Setting::Netbox[:netbox_url]}/api/dcim/devices/1.json").to_return(
+      status: 500, headers: { 'Content-Type': 'application/json' }
+    )
+    subject
+    host.reload
+
+    assert_not_nil host.netbox_facet.synchronized_at
+    assert_nil host.netbox_facet.url
+    assert_equal 'ForemanNetbox::SyncHost::SyncDevice::Update: 500 Remote Error', host.netbox_facet.synchronization_error
+  end
+
+  private
+
+  def stub_get_netbox_request(path, results:)
+    stub_request(:get, "#{Setting::Netbox[:netbox_url]}/api/#{path}").to_return(
+      status: 200, headers: { 'Content-Type': 'application/json' },
+      body: {
+        count: 1,
+        results: results
+      }.to_json
+    )
+  end
+end

data/test/interactors/foreman_netbox/sync_host/sync_device/create_test.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class CreateDeviceTest < ActiveSupport::TestCase
+  subject do
+    ForemanNetbox::SyncHost::SyncDevice::Create.call(
+      host: host,
+      netbox_params: host.netbox_facet.netbox_params,
+      device_type: device_type,
+      device_role: device_role,
+      site: site,
+      tenant: tenant,
+      device: device
+    )
+  end
+
+  let(:device_id) { 1 }
+  let(:host) do
+    FactoryBot.build_stubbed(:host, hostname: 'host.dev.example.com').tap do |host|
+      host.stubs(:facts).returns({ 'serialnumber' => 'abc123' })
+    end
+  end
+  let(:device_type) { OpenStruct.new(id: 1) }
+  let(:device_role) { OpenStruct.new(id: 1) }
+  let(:site) { OpenStruct.new(id: 1) }
+  let(:tenant) { OpenStruct.new(id: 1) }
+  let(:netbox_device_params) { host.netbox_facet.netbox_params.fetch(:device) }
+
+  setup do
+    setup_default_netbox_settings
+  end
+
+  context 'when device is not assigned to the context' do
+    let(:device) { nil }
+
+    it 'creates a device' do
+      stub_post = stub_request(:post, "#{Setting[:netbox_url]}/api/dcim/devices/").with(
+        body: {
+          name: netbox_device_params[:name],
+          serial: netbox_device_params[:serial],
+          tags: netbox_device_params[:tags],
+          device_type: device_type.id,
+          device_role: device_role.id,
+          site: site.id,
+          tenant: tenant.id
+        }.to_json
+      ).to_return(
+        status: 201, headers: { 'Content-Type': 'application/json' },
+        body: { id: device_id }.to_json
+      )
+
+      assert_equal device_id, subject.device.id
+      assert_requested(stub_post)
+    end
+  end
+
+  context 'when device is already assigned to the context' do
+    let(:device) { OpenStruct.new(id: device_id) }
+
+    it 'does not create a device' do
+      assert_equal device_id, subject.device.id
+    end
+  end
+end

data/test/interactors/foreman_netbox/sync_host/sync_device/find_test.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class FindDeviceTest < ActiveSupport::TestCase
+  subject { ForemanNetbox::SyncHost::SyncDevice::Find.call(host: host, netbox_params: host.netbox_facet.netbox_params) }
+
+  let(:host) do
+    FactoryBot.build_stubbed(:host).tap do |host|
+      host.stubs(:mac).returns('C3:CD:63:54:21:62')
+      host.stubs(:facts).returns({ 'serialnumber' => 'abc123' })
+    end
+  end
+
+  setup do
+    setup_default_netbox_settings
+  end
+
+  context 'when device already exists in Netbox' do
+    test 'find device by host name' do
+      stub_get_by_serial = stub_request(:get, "#{Setting[:netbox_url]}/api/dcim/devices.json").with(
+        query: { limit: 50, serial: host.netbox_facet.netbox_params.dig(:device, :serial) }
+      ).to_return(
+        status: 200, headers: { 'Content-Type': 'application/json' },
+        body: { count: 0, results: [] }.to_json
+      )
+      stub_get_by_mac_addres = stub_request(:get, "#{Setting[:netbox_url]}/api/dcim/devices.json").with(
+        query: { limit: 50, mac_address: host.mac }
+      ).to_return(
+        status: 200, headers: { 'Content-Type': 'application/json' },
+        body: { count: 0, results: [] }.to_json
+      )
+      stub_get_by_name = stub_request(:get, "#{Setting[:netbox_url]}/api/dcim/devices.json").with(
+        query: { limit: 50, name: host.name }
+      ).to_return(
+        status: 200, headers: { 'Content-Type': 'application/json' },
+        body: { count: 1, results: [{ id: 1, name: host.name }] }.to_json
+      )
+
+      assert_equal 1, subject.device.id
+      assert_requested(stub_get_by_serial)
+      assert_requested(stub_get_by_mac_addres)
+      assert_requested(stub_get_by_name)
+    end
+
+    test 'find device by mac address' do
+      stub_get_by_serial = stub_request(:get, "#{Setting[:netbox_url]}/api/dcim/devices.json").with(
+        query: { limit: 50, serial: host.netbox_facet.netbox_params.dig(:device, :serial) }
+      ).to_return(
+        status: 200, headers: { 'Content-Type': 'application/json' },
+        body: { count: 0, results: [] }.to_json
+      )
+      stub_get_by_mac_addres = stub_request(:get, "#{Setting[:netbox_url]}/api/dcim/devices.json").with(
+        query: { limit: 50, mac_address: host.mac }
+      ).to_return(
+        status: 200, headers: { 'Content-Type': 'application/json' },
+        body: { count: 1, results: [{ id: 1, name: host.netbox_facet.netbox_params.dig(:device, :name) }] }.to_json
+      )
+
+      assert_equal 1, subject.device.id
+      assert_requested(stub_get_by_serial)
+      assert_requested(stub_get_by_mac_addres)
+    end
+
+    test 'find device by serial number' do
+      stub_get_by_serial = stub_request(:get, "#{Setting[:netbox_url]}/api/dcim/devices.json").with(
+        query: { limit: 50, serial: host.netbox_facet.netbox_params.dig(:device, :serial) }
+      ).to_return(
+        status: 200, headers: { 'Content-Type': 'application/json' },
+        body: { count: 1, results: [{ id: 1, name: host.name }] }.to_json
+      )
+
+      assert_equal 1, subject.device.id
+      assert_requested(stub_get_by_serial)
+    end
+  end
+
+  context 'when device does not exist in NetBox' do
+    it 'does not assign device to context' do
+      stub_get_by_serial = stub_request(:get, "#{Setting[:netbox_url]}/api/dcim/devices.json").with(
+        query: { limit: 50, serial: host.netbox_facet.netbox_params.dig(:device, :serial) }
+      ).to_return(
+        status: 200, headers: { 'Content-Type': 'application/json' },
+        body: { count: 0, results: [] }.to_json
+      )
+      stub_get_by_mac_addres = stub_request(:get, "#{Setting[:netbox_url]}/api/dcim/devices.json").with(
+        query: { limit: 50, mac_address: host.mac }
+      ).to_return(
+        status: 200, headers: { 'Content-Type': 'application/json' },
+        body: { count: 0, results: [] }.to_json
+      )
+      stub_get_by_name = stub_request(:get, "#{Setting[:netbox_url]}/api/dcim/devices.json").with(
+        query: { limit: 50, name: host.netbox_facet.netbox_params.dig(:device, :name) }
+      ).to_return(
+        status: 200, headers: { 'Content-Type': 'application/json' },
+        body: { count: 0, results: [] }.to_json
+      )
+
+      assert_nil subject.site
+      assert_requested(stub_get_by_serial)
+      assert_requested(stub_get_by_mac_addres)
+      assert_requested(stub_get_by_name)
+    end
+  end
+end