foreman_wreckingball 3.1.0 → 3.2.0

data/lib/foreman_wreckingball/engine.rb

@@ -7,6 +7,14 @@ module ForemanWreckingball
   class Engine < ::Rails::Engine
     engine_name 'foreman_wreckingball'
 
+    WRECKINGBALL_STATUSES = [
+      'ForemanWreckingball::ToolsStatus',
+      'ForemanWreckingball::OperatingsystemStatus',
+      'ForemanWreckingball::CpuHotAddStatus',
+      'ForemanWreckingball::SpectreV2Status',
+      'ForemanWreckingball::HardwareVersionStatus'
+    ].freeze
+
     config.autoload_paths += Dir["#{config.root}/app/lib"]
     config.autoload_paths += Dir["#{config.root}/app/services"]
     config.autoload_paths += Dir["#{config.root}/app/models/concerns"]
@@ -47,7 +55,9 @@ module ForemanWreckingball
 
         # Extend built in permissions
         Foreman::AccessControl.permission(:view_hosts).actions.concat [
-          'foreman_wreckingball/hosts/status_dashboard'
+          'foreman_wreckingball/hosts/status_dashboard',
+          'foreman_wreckingball/hosts/status_managed_hosts_dashboard',
+          'foreman_wreckingball/hosts/status_hosts'
         ]
 
         menu :top_menu, :wreckingball_status_dashboard, :url_hash => { :controller => :'foreman_wreckingball/hosts', :action => :status_dashboard },
@@ -55,11 +65,12 @@ module ForemanWreckingball
                                                         :parent => :hosts_menu,
                                                         :after => :hosts
 
-        register_custom_status(ForemanWreckingball::ToolsStatus)
-        register_custom_status(ForemanWreckingball::OperatingsystemStatus)
-        register_custom_status(ForemanWreckingball::CpuHotAddStatus)
-        register_custom_status(ForemanWreckingball::SpectreV2Status)
-        register_custom_status(ForemanWreckingball::HardwareVersionStatus)
+        WRECKINGBALL_STATUSES.each { |status| register_custom_status(status.constantize) }
+
+        menu :top_menu, :wreckingball_status_managed_hosts_dashboard, url_hash: { :controller => :'foreman_wreckingball/hosts', :action => :status_managed_hosts_dashboard },
+                                                                      caption: N_('VMware Managed Status'),
+                                                                      parent: :monitor_menu,
+                                                                      after: :audits
 
         register_facet(ForemanWreckingball::VmwareFacet, :vmware_facet)
 
@@ -87,12 +98,16 @@ module ForemanWreckingball
     # Include concerns in this config.to_prepare block
     config.to_prepare do
       begin
+        ::HostStatus.extend(ForemanWreckingball::HostStatusExtensions)
+
         ::ComputeResource.send(:include, ForemanWreckingball::ComputeResourceExtensions)
         ::Foreman::Model::Vmware.send(:include, ForemanWreckingball::VmwareExtensions)
         ::Host::Managed.send(:include, ForemanWreckingball::HostExtensions)
         ::Host::Managed.send(:include, ForemanWreckingball::VmwareFacetHostExtensions)
         ::Host::Managed.send(:include, ForemanWreckingball::VmwareHypervisorFacetHostExtensions)
         ::HostsHelper.send(:include, ForemanWreckingball::HostsHelperExtensions)
+        ::User.send(:include, ForemanWreckingball::UserExtensions)
+        ::Usergroup.send(:include, ForemanWreckingball::UsergroupExtensions)
 
         if ForemanWreckingball.fog_patches_required?
           Fog::Compute::Vsphere::Host.send(:include, FogExtensions::ForemanWreckingball::Vsphere::Host)

data/lib/foreman_wreckingball/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ForemanWreckingball
-  VERSION = '3.1.0'
+  VERSION = '3.2.0'
 end

data/test/actions/foreman_wreckingball/host/remediate_spectre_v2_test.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+module Actions
+  module ForemanWreckingball
+    module Vmware
+      class RemediateSpectreV2Test < ActiveSupport::TestCase
+        include ::Dynflow::Testing
+        setup do
+          ::Fog.mock!
+          # this is not stubbed correctly in fog-vsphere
+          Fog::Compute::Vsphere::Server.any_instance.stubs(:cpuHotAddEnabled).returns(false)
+          Fog::Compute::Vsphere::Server.any_instance.stubs(:hardware_version).returns('vmx-13')
+          ::ForemanWreckingball::SpectreV2Status.any_instance.stubs(:recent_hw_version?).returns(true)
+          ::PowerManager::Virt.any_instance.stubs(:ready?).returns(true)
+          Setting::Wreckingball.load_defaults
+        end
+        teardown { ::Fog.unmock! }
+
+        let(:compute_resource) do
+          cr = FactoryBot.create(:compute_resource, :vmware, :with_taxonomy, :uuid => 'Solutions')
+          ComputeResource.find(cr.id)
+        end
+        let(:uuid) { '5032c8a5-9c5e-ba7a-3804-832a03e16381' }
+        let(:vm) { compute_resource.find_vm_by_uuid(uuid) }
+
+        let(:host) do
+          FactoryBot.create(
+            :host,
+            :managed,
+            :with_vmware_facet,
+            compute_resource: compute_resource,
+            uuid: uuid
+          )
+        end
+
+        let(:action_class) { ::Actions::ForemanWreckingball::Host::RemediateSpectreV2 }
+        let(:action) do
+          create_action(action_class).tap do |action|
+            action.stubs(:action_subject).returns(host)
+            action.input.update(
+              host: {
+                id: host.id
+              }
+            )
+          end
+        end
+        let(:planned_action) do
+          plan_action(action, host)
+        end
+        let(:runned_action) { run_action(planned_action) }
+
+        test "it remediates the host's spectre v2 status" do
+          assert_equal :success, runned_action.state
+          assert_equal true, runned_action.output.fetch('state')
+          assert_equal true, runned_action.output.fetch('initially_powered_on')
+        end
+      end
+    end
+  end
+end

data/test/controllers/foreman_wreckingball/hosts_controller_test.rb

@@ -4,31 +4,152 @@ require 'test_plugin_helper'
 
 module ForemanWreckingball
   class HostsControllerTest < ActionController::TestCase
-    let(:task_id) { 123 }
-    let(:fake_task) do
-      OpenStruct.new(
-        id: task_id
-      )
-    end
+    let(:fake_task) { OpenStruct.new(id: 123) }
 
     setup do
       Setting::Wreckingball.load_defaults
     end
 
     describe '#status_dashboard' do
-      test 'shows an empty status page' do
-        get :status_dashboard, session: set_session_user
-        assert_response :success
+      context 'when there are no hosts with wreckingball statuses' do
+        test 'shows an empty status page' do
+          get :status_dashboard, session: set_session_user
+          assert_response :success
+        end
+      end
+
+      context 'when there are hosts with wreckingball statuses' do
+        context 'for admin user' do
+          setup do
+            FactoryBot.create(:host, :with_wreckingball_statuses, owner: users(:admin))
+            FactoryBot.create(:host, :with_wreckingball_statuses, owner: FactoryBot.create(:usergroup, users: [users(:admin)]))
+            FactoryBot.create(:host, :with_wreckingball_statuses, owner: FactoryBot.create(:user))
+            FactoryBot.create(:host, :with_wreckingball_statuses, owner: FactoryBot.create(:usergroup))
+          end
+
+          test 'shows a status page' do
+            get :status_dashboard, session: set_session_user
+            assert_response :success
+          end
+
+          test 'should count all hosts' do
+            get :status_dashboard, session: set_session_user
+            assert_equal 4, assigns[:data].first[:counter][:ok]
+          end
+
+          test 'should count only owned hosts' do
+            get :status_dashboard, params: { owned_only: true }, session: set_session_user
+            assert_equal 2, assigns[:data].first[:counter][:ok]
+          end
+        end
+
+        context 'for user with custom role' do
+          let(:search) { "owner = current_user or (owner_type = Usergroup and owner_id = #{user.usergroups.first.id}) or hostgroup_id = #{hostgroup.id} or name ~ #{host_name_prefix}" }
+          let(:filter) do
+            FactoryBot.create(:filter,
+                              search: search,
+                              permissions: Permission.where(name: 'view_hosts'))
+          end
+          let(:role) { FactoryBot.create(:role) }
+          let(:user) { FactoryBot.create(:user, :with_mail, :with_usergroup, admin: false, roles: [role]) }
+          let(:hostgroup) { FactoryBot.create(:hostgroup) }
+          let(:host_name_prefix) { 'abc' }
+
+          setup do
+            # hosts that match search query
+            FactoryBot.create(:host, :with_wreckingball_statuses, owner: user)
+            FactoryBot.create(:host, :with_wreckingball_statuses, owner: user.usergroups.first)
+            FactoryBot.create(:host, :with_wreckingball_statuses, hostgroup: hostgroup)
+            FactoryBot.create(:host, :with_wreckingball_statuses, name: "#{host_name_prefix}123", hostname: "#{host_name_prefix}123")
+            # hosts that do not match search query
+            FactoryBot.create(:host, :with_wreckingball_statuses, owner: FactoryBot.create(:user))
+            FactoryBot.create(:host, :with_wreckingball_statuses, owner: FactoryBot.create(:usergroup))
+            FactoryBot.create(:host, :with_wreckingball_statuses, hostgroup: FactoryBot.create(:hostgroup))
+            FactoryBot.create(:host, :with_wreckingball_statuses)
+          end
+
+          setup do
+            role.filters << filter
+          end
+
+          test 'should count only hosts that match search query' do
+            get :status_dashboard, session: set_session_user(user)
+
+            expected_4_ok = { ok: 4, warning: 0, critical: 0 }
+            expected_4_critical = { ok: 0, warning: 0, critical: 4 }
+
+            assert_equal expected_4_ok, assigns[:data][0][:counter]
+            assert_equal expected_4_ok, assigns[:data][1][:counter]
+            assert_equal expected_4_ok, assigns[:data][2][:counter]
+            assert_equal expected_4_critical, assigns[:data][3][:counter]
+          end
+        end
+      end
+    end
+
+    describe '#status_managed_hosts_dashboard' do
+      let(:admin) { users(:admin) }
+      let(:organization) { Organization.find_by(name: 'Organization 1') }
+      let(:tax_location) { Location.find_by(name: 'Location 1') }
+      let(:cr) do
+        FactoryBot.create(
+          :vmware_cr,
+          uuid: 'test',
+          organizations: [organization],
+          locations: [tax_location]
+        )
+      end
+      let(:other_cr) do
+        FactoryBot.create(
+          :vmware_cr,
+          uuid: 'bla',
+          organizations: [organization],
+          locations: [tax_location]
+        )
+      end
+
+      setup do
+        Fog.mock!
+        @managed_host = FactoryBot.create(:host, :managed, :with_vmware_facet, compute_resource: cr, owner: admin, uuid: 1)
+        @missing_host = FactoryBot.create(:host, :managed, :with_vmware_facet, compute_resource: cr, owner: admin, uuid: 2)
+
+        mock_vm = mock('vm')
+        mock_vm.stubs(:uuid).returns(@managed_host.uuid)
+        mock_vm.stubs(:name).returns(@managed_host.name)
+        Foreman::Model::Vmware.any_instance.stubs(:vms).returns(Array(mock_vm))
       end
 
       test 'shows a status page' do
-        FactoryBot.create_list(:host, 5, :with_wreckingball_statuses)
-        get :status_dashboard, session: set_session_user
+        get :status_managed_hosts_dashboard, session: set_session_user
         assert_response :success
       end
+
+      test 'should contain host with missing vm' do
+        get :status_managed_hosts_dashboard, session: set_session_user
+        assert_includes assigns[:missing_hosts], @missing_host
+      end
+
+      test 'should filter host with vm' do
+        get :status_managed_hosts_dashboard, session: set_session_user
+        refute_includes assigns[:missing_hosts], @managed_host
+      end
     end
 
     describe '#status_hosts' do
+      test 'returns correct counts' do
+        FactoryBot.create_list(:vmware_hardware_version_status, 3, :with_ok_status)
+        FactoryBot.create_list(:vmware_hardware_version_status, 4, :with_out_of_date_status)
+
+        get :status_hosts, params: { status: ::ForemanWreckingball::HardwareVersionStatus.host_association },
+                           session: set_session_user, xhr: true
+
+        assert_response :ok
+        json = JSON.parse(response.body)
+        assert_equal 4, json['recordsTotal']
+        assert_equal 4, json['recordsFiltered']
+        assert_equal 4, json['data'].size
+      end
+
       test 'returns hosts for status' do
         ok_status = FactoryBot.create(:vmware_hardware_version_status, :with_ok_status)
         out_of_date_status = FactoryBot.create(:vmware_hardware_version_status, :with_out_of_date_status)
@@ -37,20 +158,67 @@ module ForemanWreckingball
                            session: set_session_user, xhr: true
 
         assert_response :ok
-        hosts_names = JSON.parse(response.body)['data'].map { |host| host['name'] }
+
+        data = JSON.parse(response.body)['data']
+
+        hosts_names = data.map { |host| host['name'] }
+        assert_equal 1, data.size
         assert_includes hosts_names, out_of_date_status.host.name
         refute_includes hosts_names, ok_status.host.name
       end
+
+      test 'returns hosts for spectre v2 status' do
+        FactoryBot.create_list(:vmware_spectre_v2_status, 1, :with_enabled)
+        FactoryBot.create_list(:vmware_spectre_v2_status, 2, :with_missing)
+
+        get :status_hosts, params: { status: ::ForemanWreckingball::SpectreV2Status.host_association },
+                           session: set_session_user, xhr: true
+
+        data = JSON.parse(response.body)['data']
+        assert_equal 2, data.size
+      end
+
+      describe 'filtering by owner' do
+        setup do
+          FactoryBot.create(:host, :with_wreckingball_statuses, owner: users(:admin))
+          FactoryBot.create(:host, :with_wreckingball_statuses, owner: FactoryBot.create(:usergroup, users: [users(:admin)]))
+          FactoryBot.create(:host, :with_wreckingball_statuses, owner: FactoryBot.create(:user))
+          FactoryBot.create(:host, :with_wreckingball_statuses, owner: FactoryBot.create(:usergroup))
+        end
+
+        test 'should show all hosts' do
+          get :status_hosts, params: { status: ::ForemanWreckingball::SpectreV2Status.host_association },
+                             session: set_session_user, xhr: true
+          assert_equal 4, JSON.parse(response.body)['data'].count
+        end
+
+        test 'should show only owned hosts' do
+          get :status_hosts, params: { status: ::ForemanWreckingball::SpectreV2Status.host_association, owned_only: true },
+                             session: set_session_user, xhr: true
+          assert_equal 2, JSON.parse(response.body)['data'].count
+        end
+      end
     end
 
     describe '#refresh_status_dashboard' do
       test 'redirects to scheduled task' do
+        FactoryBot.create(:some_task, :vmware_sync, :stopped)
+
         ForemanTasks.expects(:async_task).returns(fake_task)
         put :refresh_status_dashboard, session: set_session_user
         assert_response :redirect
         assert_includes flash[:success], 'successfully scheduled'
         assert_redirected_to foreman_tasks_task_path(123)
       end
+
+      test 'show flash warning message when task is already running' do
+        FactoryBot.create(:some_task, :vmware_sync, :running)
+
+        put :refresh_status_dashboard, session: set_session_user
+        assert_response :redirect
+        assert_includes flash[:warning], 'task is already running'
+        assert_redirected_to status_dashboard_hosts_path
+      end
     end
 
     describe '#schedule_remediate' do

data/test/factories/foreman_wreckingball_factories.rb

@@ -131,6 +131,24 @@ FactoryBot.define do
   factory :vmware_cluster, class: 'ForemanWreckingball::VmwareCluster' do
     sequence(:name) { |n| "Cluster #{n}" }
     association :compute_resource, factory: [:compute_resource, :vmware]
+
+    trait(:with_hosts) do
+      after(:create) do |vmware_cluster|
+        create_list(:vmware_hypervisor_facet, 2, vmware_cluster: vmware_cluster)
+      end
+    end
+
+    trait(:with_vmware_facets) do
+      after(:create) do |vmware_cluster|
+        create_list(:vmware_facet, 2, vmware_cluster: vmware_cluster)
+      end
+    end
+
+    trait(:with_vmware_hypervisor_facets) do
+      after(:create) do |vmware_cluster|
+        create_list(:vmware_hypervisor_facet, 2, vmware_cluster: vmware_cluster)
+      end
+    end
   end
 
   factory :vmware_tools_status, class: 'ForemanWreckingball::ToolsStatus' do
@@ -151,6 +169,20 @@ FactoryBot.define do
     after(:build) { |status| status.status = status.to_status }
   end
 
+  factory :vmware_spectre_v2_status, class: 'ForemanWreckingball::SpectreV2Status' do
+    association :host, factory: [:host, :with_vmware_facet]
+    reported_at { Time.now.utc }
+    after(:build) { |status| status.status = status.to_status }
+
+    trait(:with_enabled) do
+      after(:build) { |status| status.status = ForemanWreckingball::SpectreV2Status::ENABLED }
+    end
+
+    trait(:with_missing) do
+      after(:build) { |status| status.status = ForemanWreckingball::SpectreV2Status::MISSING }
+    end
+  end
+
   factory :vmware_hardware_version_status, class: 'ForemanWreckingball::HardwareVersionStatus' do
     association :host, factory: [:host, :with_vmware_facet]
     reported_at { Time.now.utc }

data/test/factories/host.rb

@@ -38,10 +38,18 @@ FactoryBot.modify do
       end
     end
 
+    trait :with_vmware_spectrev2_status do
+      with_vmware_facet
+      after(:create) do |host, _evaluator|
+        create :vmware_spectre_v2_status, host: host
+      end
+    end
+
     trait :with_wreckingball_statuses do
       with_vmware_tools_status
       with_vmware_operatingsystem_status
       with_vmware_cpu_hot_add_status
+      with_vmware_spectrev2_status
       with_vmware_hardware_version_status
     end
   end

data/test/factories/task.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+FactoryBot.modify do
+  factory :some_task do
+    trait :running do
+      state 'running'
+    end
+
+    trait :stopped do
+      state 'stopped'
+    end
+
+    trait :vmware_sync do
+      label ::Actions::ForemanWreckingball::Vmware::ScheduleVmwareSync.to_s
+    end
+  end
+end

data/test/integration/hosts_status_dashboard_test.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'integration_test_plugin_helper'
+
+class HostsStatusDashboardTest < ActionDispatch::IntegrationTest
+  setup do
+    Setting::Wreckingball.load_defaults
+  end
+
+  test 'shows different vmware host statuses' do
+    FactoryBot.create_list(:host, 10)
+    FactoryBot.create_list(:vmware_tools_status, 1)
+    FactoryBot.create_list(:vmware_operatingsystem_status, 2)
+    FactoryBot.create_list(:vmware_cpu_hot_add_status, 3)
+    FactoryBot.create_list(:vmware_spectre_v2_status, 4, :with_enabled)
+    FactoryBot.create_list(:vmware_spectre_v2_status, 5, :with_missing)
+    FactoryBot.create_list(:vmware_hardware_version_status, 6, :with_ok_status)
+    FactoryBot.create_list(:vmware_hardware_version_status, 7, :with_out_of_date_status)
+
+    User.current = users(:admin)
+    visit status_dashboard_hosts_path
+
+    lists = find_all('div.list-view-pf-main-info')
+
+    # VMWare Tools
+    assert_text lists[0].text, '1 OK'
+    assert_text lists[0].text, '0 Warning'
+    assert_text lists[0].text, '0 Critical'
+
+    # VMWare Operating System
+    assert_text lists[1].text, '2 OK'
+    assert_text lists[1].text, '0 Warning'
+    assert_text lists[1].text, '0 Critical'
+
+    # VMWare CPU Hot Plug
+    assert_text lists[2].text, '3 OK'
+    assert_text lists[2].text, '0 Warning'
+    assert_text lists[2].text, '0 Critical'
+
+    # VMWare Spectre V2
+    assert_text lists[3].text, '4 OK'
+    assert_text lists[3].text, '0 Warning'
+    assert_text lists[3].text, '5 Critical'
+
+    # VMWare Hardware Version
+    assert_text lists[4].text, '6 OK'
+    assert_text lists[4].text, '7 Warning'
+    assert_text lists[4].text, '0 Critical'
+  end
+end

data/test/integration/hosts_status_managed_hosts_test.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'integration_test_plugin_helper'
+
+class HostsStatusManagedHostsTest < ActionDispatch::IntegrationTest
+  setup do
+    Setting::Wreckingball.load_defaults
+    Fog.mock!
+  end
+
+  let(:organization) { Organization.find_by(name: 'Organization 1') }
+  let(:tax_location) { Location.find_by(name: 'Location 1') }
+  let(:admin) { users(:admin) }
+  let(:cr) do
+    FactoryBot.create(
+      :vmware_cr,
+      uuid: 'test',
+      organizations: [organization],
+      locations: [tax_location]
+    )
+  end
+
+  test 'shows missing host without VMware vm' do
+    managed_host = FactoryBot.create(:host, :managed, compute_resource: cr, owner: admin, uuid: 1)
+    missing_host = FactoryBot.create(:host, :managed, compute_resource: cr, owner: admin, uuid: 2)
+
+    mock_vm = mock('vm')
+    mock_vm.stubs(:uuid).returns(managed_host.uuid)
+    mock_vm.stubs(:name).returns(managed_host.name)
+    Foreman::Model::Vmware.any_instance.stubs(:vms).returns(Array(mock_vm))
+
+    visit status_managed_hosts_dashboard_hosts_path
+
+    list = page.find('#missing_vms')
+    assert_includes list.text, missing_host.name
+    refute_includes list.text, managed_host.name
+  end
+
+  test 'shows duplicate vms with same uuid for a host' do
+    managed_host = FactoryBot.create(:host, :managed, compute_resource: cr, owner: admin, uuid: 1)
+
+    mock1_vm = mock('vm1')
+    mock1_vm.stubs(:uuid).returns(managed_host.uuid)
+    mock1_vm.stubs(:name).returns('foo01.example.com')
+    mock2_vm = mock('vm2')
+    mock2_vm.stubs(:uuid).returns(managed_host.uuid)
+    mock2_vm.stubs(:name).returns('foo02.example.com')
+    Foreman::Model::Vmware.any_instance.stubs(:vms).returns([mock1_vm, mock2_vm])
+
+    visit status_managed_hosts_dashboard_hosts_path
+
+    list = page.find('#duplicate_vms')
+    assert_includes list.text, 'foo01.example.com'
+    assert_includes list.text, 'foo02.example.com'
+  end
+
+  test 'shows hosts with vm associated with a different compute resource' do
+    other_cr = FactoryBot.create(
+      :vmware_cr,
+      uuid: 'bla',
+      organizations: [organization],
+      locations: [tax_location]
+    )
+
+    # Host 2 is associated to other_cr, but shows up on cr
+    # Host 1 and 3 are correctly associated.
+    managed1_host = FactoryBot.create(:host, :managed, compute_resource: cr, owner: admin, uuid: 1)
+    managed2_host = FactoryBot.create(:host, :managed, compute_resource: other_cr, owner: admin, uuid: 2)
+    managed3_host = FactoryBot.create(:host, :managed, compute_resource: other_cr, owner: admin, uuid: 3)
+
+    mock1_vm = mock('vm1')
+    mock1_vm.stubs(:uuid).returns(managed1_host.uuid)
+    mock1_vm.stubs(:name).returns(managed1_host.name)
+    mock2_vm = mock('vm2')
+    mock2_vm.stubs(:uuid).returns(managed2_host.uuid)
+    mock2_vm.stubs(:name).returns(managed2_host.name)
+    mock3_vm = mock('vm3')
+    mock3_vm.stubs(:uuid).returns(managed3_host.uuid)
+    mock3_vm.stubs(:name).returns(managed3_host.name)
+
+    cr.stubs(:vms).returns([mock1_vm, mock2_vm])
+    other_cr.stubs(:vms).returns([mock3_vm])
+
+    ComputeResource.stubs(:where).returns([cr, other_cr])
+
+    visit status_managed_hosts_dashboard_hosts_path
+
+    list = page.find('#different_vms')
+    refute_includes list.text, managed1_host.name
+    assert_includes list.text, managed2_host.name
+    refute_includes list.text, managed3_host.name
+  end
+end

data/test/integration_test_plugin_helper.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'integration_test_helper'
+
+require 'webmock/minitest'
+require 'webmock'
+
+# Add plugin to FactoryBot's paths
+FactoryBot.definition_file_paths << File.join(File.dirname(__FILE__), 'factories')
+FactoryBot.reload
+
+WebMock.disable_net_connect!(allow_localhost: true)

data/test/models/host_status_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class HostStatusTest < ActiveSupport::TestCase
+  describe '#wreckingball_statuses' do
+    test 'returns wreckingball statuses' do
+      expected = ForemanWreckingball::Engine::WRECKINGBALL_STATUSES.sort.map(&:constantize)
+      actual = HostStatus.wreckingball_statuses.sort_by(&:to_s)
+      assert_equal expected, actual
+    end
+  end
+
+  describe '#find_wreckingball_status_by_host_association' do
+    test 'returns expected wreckingball status' do
+      expected = ForemanWreckingball::Engine::WRECKINGBALL_STATUSES.first.constantize
+      actual = HostStatus.find_wreckingball_status_by_host_association(expected.host_association)
+
+      assert_equal expected, actual
+    end
+  end
+end