foreman_netbox 1.0.2

data/test/interactors/foreman_netbox/sync_host/sync_virtual_machine/sync_interfaces/update_test.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class UpdateVirtualMachineInterfacesTest < ActiveSupport::TestCase
+  subject do
+    ForemanNetbox::SyncHost::SyncVirtualMachine::SyncInterfaces::Update.call(
+      interfaces: interfaces,
+      host: host,
+      netbox_params: host.netbox_facet.netbox_params
+    )
+  end
+
+  let(:interfaces) { ForemanNetbox::API.client::Virtualization::Interfaces.new }
+  let(:old_mac) { 'FE:13:C6:44:29:22' }
+  let(:host) do
+    FactoryBot.build_stubbed(
+      :host,
+      interfaces: [
+        FactoryBot.build_stubbed(:nic_base, mac: old_mac)
+      ]
+    )
+  end
+
+  setup do
+    setup_default_netbox_settings
+  end
+
+  context 'if the interface has been updated since the last synchronization' do
+    let(:new_mac) { 'FE:13:C6:44:29:24' }
+
+    it 'updates interface in Netbox' do
+      get_stub = stub_request(:get, "#{Setting[:netbox_url]}/api/virtualization/interfaces.json").with(
+        query: { limit: 50 }
+      ).to_return(
+        status: 200, headers: { 'Content-Type': 'application/json' },
+        body: {
+          count: 1,
+          results: [
+            {
+              id: 1,
+              name: host.interfaces.first.netbox_name,
+              mac_address: new_mac,
+              tags: []
+            }
+          ]
+        }.to_json
+      )
+      stub_patch = stub_request(:patch, "#{Setting[:netbox_url]}/api/virtualization/interfaces/1.json").with(
+        body: {
+          mac_address: host.interfaces.first.mac,
+          tags: ForemanNetbox::NetboxParameters::DEFAULT_TAGS
+        }.to_json
+      ).to_return(
+        status: 200, headers: { 'Content-Type': 'application/json' },
+        body: { id: 1 }.to_json
+      )
+
+      subject
+      assert_requested(get_stub)
+      assert_requested(stub_patch)
+    end
+  end
+
+  context 'if the interface has not been updated since the last synchronization' do
+    it 'does not update interface on Netbox' do
+      get_stub = stub_request(:get, "#{Setting[:netbox_url]}/api/virtualization/interfaces.json").with(
+        query: { limit: 50 }
+      ).to_return(
+        status: 200, headers: { 'Content-Type': 'application/json' },
+        body: {
+          count: 1,
+          results: [
+            {
+              id: 1,
+              name: host.interfaces.first.netbox_name,
+              mac_address: old_mac,
+              tags: ForemanNetbox::NetboxParameters::DEFAULT_TAGS
+            }
+          ]
+        }.to_json
+      )
+
+      subject
+      assert_requested(get_stub)
+    end
+  end
+end

data/test/interactors/foreman_netbox/sync_host/sync_virtual_machine/update_test.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class UpdateVirtualMachineTest < ActiveSupport::TestCase
+  subject do
+    ForemanNetbox::SyncHost::SyncVirtualMachine::Update.call(
+      virtual_machine: virtual_machine,
+      host: host,
+      netbox_params: host.netbox_facet.netbox_params,
+      cluster: cluster,
+      tenant: tenant,
+      ip_addresses: ip_addresses
+    )
+  end
+
+  let(:virtual_machine) do
+    ForemanNetbox::API.client::Virtualization::VirtualMachine.new(id: 1).tap do |virtual_machine|
+      virtual_machine.instance_variable_set(
+        :@data,
+        {
+          'id' => 1,
+          'name' => virtual_machine_name,
+          'cluster' => { 'id' => 1 },
+          'tenant' => { 'id' => 1 },
+          'vcpus' => 2,
+          'memory' => 128,
+          'disk' => 512,
+          'primary_ip4' => {
+            'id' => 1,
+            'family' => 4,
+            'address' => '10.0.0.1/24'
+          },
+          'primary_ip6' => {
+            'id' => 2,
+            'family' => 6,
+            'address' => '1600:0:2d0:201::18/64'
+          },
+          'tags' => virtual_machine_tags
+        }
+      )
+    end
+  end
+
+  let(:virtual_machine_name) { 'name.example.com' }
+  let(:virtual_machine_tags) { ['tag'] }
+  let(:virtual_machine_data) { virtual_machine.instance_variable_get(:@data).deep_symbolize_keys }
+  let(:cluster) { OpenStruct.new(id: virtual_machine_data.dig(:cluster, :id)) }
+  let(:tenant) { OpenStruct.new(id: virtual_machine_data.dig(:tenant, :id)) }
+  let(:primary_ip4) do
+    OpenStruct.new(
+      id: virtual_machine_data.dig(:primary_ip4, :id),
+      address: OpenStruct.new(
+        address: virtual_machine_data.dig(:primary_ip4, :address).split('/')[0]
+      )
+    )
+  end
+  let(:primary_ip6) do
+    OpenStruct.new(
+      id: virtual_machine_data.dig(:primary_ip6, :id),
+      address: OpenStruct.new(
+        address: virtual_machine_data.dig(:primary_ip6, :address).split('/')[0]
+      )
+    )
+  end
+  let(:ip_addresses) { ForemanNetbox::API.client.ipam.ip_addresses.filter(virtual_machine_id: virtual_machine.id) }
+  let(:host) do
+    FactoryBot.build_stubbed(
+      :host,
+      hostname: virtual_machine_name,
+      ip: primary_ip4.address.address,
+      ip6: primary_ip6.address.address
+    ).tap do |host|
+      host.stubs(:compute?).returns(true)
+      host.stubs(:compute_object).returns(
+        OpenStruct.new(
+          cpus: virtual_machine_data[:vcpus],
+          memory_mb: virtual_machine_data[:memory],
+          volumes: [
+            OpenStruct.new(size_gb: virtual_machine_data[:disk])
+          ]
+        )
+      )
+    end
+  end
+
+  setup do
+    setup_default_netbox_settings
+    stub_request(:get, "#{Setting[:netbox_url]}/api/ipam/ip-addresses.json").with(
+      query: { limit: 50, virtual_machine_id: virtual_machine.id }
+    ).to_return(
+      status: 200, headers: { 'Content-Type': 'application/json' },
+      body: {
+        count: 2,
+        results: [
+          { id: primary_ip4.id, address: primary_ip4.address.address },
+          { id: primary_ip6.id, address: primary_ip6.address.address }
+        ]
+      }.to_json
+    )
+  end
+
+  context 'if the host has not been updated since the last synchronization' do
+    let(:virtual_machine_tags) { ForemanNetbox::NetboxParameters::DEFAULT_TAGS }
+
+    it 'does not update virtual_machine' do
+      assert_equal virtual_machine, subject.virtual_machine
+    end
+  end
+
+  context 'if the host has been updated since the last synchronization' do
+    let(:cluster) { OpenStruct.new(id: 2) }
+    let(:tenant) { OpenStruct.new(id: 2) }
+    let(:primary_ip4) do
+      OpenStruct.new(
+        id: 3,
+        address: OpenStruct.new(
+          address: '10.0.0.2'
+        )
+      )
+    end
+    let(:primary_ip6) do
+      OpenStruct.new(
+        id: 4,
+        address: OpenStruct.new(
+          address: '1500:0:2d0:201::2'
+        )
+      )
+    end
+    let(:host) do
+      FactoryBot.build_stubbed(
+        :host,
+        ip: primary_ip4.address.address,
+        ip6: primary_ip6.address.address
+      ).tap do |host|
+        host.stubs(:compute?).returns(true)
+        host.stubs(:compute_object).returns(
+          OpenStruct.new(
+            cpus: 4,
+            memory_mb: 256,
+            volumes: [
+              OpenStruct.new(size_gb: 1024)
+            ]
+          )
+        )
+      end
+    end
+
+    it 'updates virtual_machine' do
+      stub_patch = stub_request(:patch, "#{Setting[:netbox_url]}/api/virtualization/virtual-machines/#{virtual_machine.id}.json").with(
+        body: {
+          name: host.name,
+          cluster: cluster.id,
+          disk: host.compute_object.volumes.map(&:size_gb).reduce(&:+),
+          memory: host.compute_object.memory_mb,
+          primary_ip4: primary_ip4.id,
+          primary_ip6: primary_ip6.id,
+          tenant: tenant.id,
+          vcpus: host.compute_object.cpus,
+          tags: virtual_machine_tags | ForemanNetbox::NetboxParameters::DEFAULT_TAGS
+        }.to_json
+      ).to_return(
+        status: 200, headers: { 'Content-Type': 'application/json' },
+        body: { id: 1 }.to_json
+      )
+
+      subject
+      assert_requested(stub_patch)
+    end
+  end
+end

data/test/jobs/foreman_netbox/sync_host_job_test.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class SyncHostJobTest < ActiveJob::TestCase
+  let(:host) { FactoryBot.create(:host) }
+
+  test 'push host to the Netbox' do
+    Host::Managed.expects(:find).with(host.id).returns(host)
+    host.expects(:push_to_netbox)
+
+    ForemanNetbox::SyncHostJob.perform_now(host.id)
+  end
+end

data/test/models/foreman_netbox/location_test.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+module ForemanNetbox
+  class LocationTest < ActiveSupport::TestCase
+    describe '#netbox_site_name' do
+      context 'with netbox_site parameter' do
+        let(:loc) do
+          FactoryBot.create(:location).tap do |location|
+            location.location_parameters.create!(name: 'netbox_site', value: 'My Site')
+          end
+        end
+
+        it { assert_equal loc.parameters['netbox_site'], loc.netbox_site_name }
+      end
+
+      context 'without netbox_site parameter' do
+        let(:loc) { FactoryBot.create(:location) }
+
+        it { assert_equal loc.name, loc.netbox_site_name }
+      end
+    end
+
+    describe '#netbox_site_slug' do
+      context 'with netbox_site parameter' do
+        let(:loc) do
+          FactoryBot.create(:location).tap do |location|
+            location.location_parameters.create!(name: 'netbox_site', value: 'My Site')
+          end
+        end
+
+        it { assert_equal loc.parameters['netbox_site'].parameterize, loc.netbox_site_slug }
+      end
+      context 'without netbox_site parameter' do
+        let(:loc) { FactoryBot.create(:location) }
+
+        it { assert_equal loc.name.parameterize, loc.netbox_site_slug }
+      end
+    end
+  end
+end

data/test/models/foreman_netbox/netbox_facet_test.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+module ForemanNetbox
+  class NetboxFacetTest < ActiveSupport::TestCase
+    describe '#netbox_will_change?' do
+      let(:tenant_name) { raw_data.dig(:tenant, :name) }
+      let(:interfaces) { raw_data.dig(:interfaces, :results) }
+      let(:ip_addresses) { raw_data.dig(:ip_addresses, :results) }
+
+      context 'when the host is a device' do
+        let(:raw_data) { JSON.parse(file_fixture('netbox_device_raw_data.json').read).deep_symbolize_keys }
+        let(:device_name) { raw_data.dig(:device, :name) }
+        let(:site_name) { raw_data.dig(:site, :name) }
+        let(:device_serial) { raw_data.dig(:device, :serial) }
+        let(:manufacturer_name) { raw_data.dig(:manufacturer, :name) }
+        let(:device_type_model) { raw_data.dig(:device_type, :model) }
+        let(:host) do
+          FactoryBot.build_stubbed(
+            :host,
+            :managed,
+            :with_device_netbox_facet,
+            hostname: device_name,
+            owner: FactoryBot.build_stubbed(:usergroup, name: tenant_name),
+            location: FactoryBot.build_stubbed(:location, name: site_name),
+            interfaces: interfaces.map do |interface|
+              ip4 = ip_addresses.find do |ip|
+                ip[:interface][:name] == interface[:name] && ip[:family][:value] == 4
+              end
+              ip6 = ip_addresses.find do |ip|
+                ip[:interface][:name] == interface[:name] && ip[:family][:value] == 6
+              end
+
+              FactoryBot.build_stubbed(
+                :nic_base,
+                identifier: interface[:name],
+                mac: interface[:mac_address],
+                ip: ip4 && ip4[:address].split('/').first,
+                subnet: ip4 && FactoryBot.build_stubbed(
+                  :subnet_ipv4,
+                  cidr: ip4[:address].split('/').second
+                ),
+                ip6: ip6 && ip6[:address].split('/').first,
+                subnet6: ip6 && FactoryBot.build_stubbed(
+                  :subnet_ipv6,
+                  cidr: ip6[:address].split('/').second
+                )
+              )
+            end
+          ).tap do |host|
+            host.stubs(:compute?).returns(false)
+            host.stubs(:facts).returns(
+              serialnumber: device_serial,
+              manufacturer: manufacturer_name,
+              productname: device_type_model
+            )
+          end
+        end
+
+        context 'when no changes detected' do
+          it { assert_not host.netbox_facet.netbox_will_change? }
+        end
+
+        context 'when interfaces are changed' do
+          let(:interfaces) { [] }
+
+          it { assert host.netbox_facet.netbox_will_change? }
+        end
+
+        context 'when ip_addresses are changed' do
+          let(:ip_addresses) { [] }
+
+          it { assert host.netbox_facet.netbox_will_change? }
+        end
+
+        context 'when tenant is changed' do
+          let(:tenant_name) { 'New Tenant Name' }
+
+          it { assert host.netbox_facet.netbox_will_change? }
+        end
+
+        context 'when device is changed' do
+          let(:device_name) { 'new_device_name' }
+
+          it { assert host.netbox_facet.netbox_will_change? }
+        end
+
+        context 'when device type is changed' do
+          let(:device_type_model) { 'New Device Type Model' }
+
+          it { assert host.netbox_facet.netbox_will_change? }
+        end
+
+        context 'when manufacturer is changed' do
+          let(:manufacturer_name) { 'New Manufacturer Name' }
+
+          it { assert host.netbox_facet.netbox_will_change? }
+        end
+
+        context 'when manufacturer is changed' do
+          let(:site_name) { 'New Site Name' }
+
+          it { assert host.netbox_facet.netbox_will_change? }
+        end
+      end
+
+      context 'when the host is a virtual machine' do
+        let(:raw_data) { JSON.parse(file_fixture('netbox_virtual_machine_raw_data.json').read).deep_symbolize_keys }
+        let(:virtual_machine_name) { raw_data.dig(:virtual_machine, :name) }
+        let(:cluster_name) { raw_data.dig(:cluster, :name) }
+        let(:vcpus) { raw_data.dig(:virtual_machine, :vcpus) }
+        let(:memory) { raw_data.dig(:virtual_machine, :memory) }
+        let(:disk) { raw_data.dig(:virtual_machine, :disk) }
+        let(:host) do
+          FactoryBot.build_stubbed(
+            :host,
+            :managed,
+            :with_virtual_machine_netbox_facet,
+            hostname: virtual_machine_name,
+            owner: FactoryBot.build_stubbed(:usergroup, name: tenant_name),
+            interfaces: interfaces.map do |interface|
+              ip4 = ip_addresses.find do |ip|
+                ip[:interface][:name] == interface[:name] && ip[:family][:value] == 4
+              end
+              ip6 = ip_addresses.find do |ip|
+                ip[:interface][:name] == interface[:name] && ip[:family][:value] == 6
+              end
+
+              FactoryBot.build_stubbed(
+                :nic_base,
+                identifier: interface[:name],
+                mac: interface[:mac_address],
+                ip: ip4 && ip4[:address].split('/').first,
+                subnet: ip4 && FactoryBot.build_stubbed(
+                  :subnet_ipv4,
+                  cidr: ip4[:address].split('/').second
+                ),
+                ip6: ip6 && ip6[:address].split('/').first,
+                subnet6: ip6 && FactoryBot.build_stubbed(
+                  :subnet_ipv6,
+                  cidr: ip6[:address].split('/').second
+                )
+              )
+            end
+          ).tap do |host|
+            host.stubs(:compute?).returns(true)
+            host.stubs(:compute_object).returns(
+              OpenStruct.new(
+                cluster: cluster_name,
+                cpus: vcpus,
+                memory_mb: memory,
+                volumes: [
+                  OpenStruct.new(size_gb: disk / 2),
+                  OpenStruct.new(size_gb: disk / 2)
+                ]
+              )
+            )
+            host.stubs(:compute_resource).returns(
+              OpenStruct.new(type: 'Foreman::Model::Vmware')
+            )
+          end
+        end
+
+        context 'when no changes detected' do
+          it { assert_not host.netbox_facet.netbox_will_change? }
+        end
+
+        context 'when interfaces are changed' do
+          let(:interfaces) { [] }
+
+          it { assert host.netbox_facet.netbox_will_change? }
+        end
+
+        context 'when ip_addresses are changed' do
+          let(:ip_addresses) { [] }
+
+          it { assert host.netbox_facet.netbox_will_change? }
+        end
+
+        context 'when tenant is changed' do
+          let(:tenant_name) { 'New Tenant Name' }
+
+          it { assert host.netbox_facet.netbox_will_change? }
+        end
+
+        context 'when virtual machine is changed' do
+          let(:virtual_machine_name) { 'new_virtual_machine' }
+
+          it { assert host.netbox_facet.netbox_will_change? }
+        end
+
+        context 'when cpus is changed' do
+          let(:vcpus) { raw_data.dig(:virtual_machine, :vcpus) * 2 }
+
+          it { assert host.netbox_facet.netbox_will_change? }
+        end
+
+        context 'when memory is changed' do
+          let(:memory) { raw_data.dig(:virtual_machine, :memory) * 2 }
+
+          it { assert host.netbox_facet.netbox_will_change? }
+        end
+
+        context 'when disk is changed' do
+          let(:disk) { raw_data.dig(:virtual_machine, :disk) * 2 }
+
+          it { assert host.netbox_facet.netbox_will_change? }
+        end
+
+        context 'when cluster is changed' do
+          let(:cluster_name) { 'New Cluster Name' }
+
+          it { assert host.netbox_facet.netbox_will_change? }
+        end
+      end
+    end
+  end
+end