foreman_rh_cloud 13.0.6 → 13.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b770b657000088615d19ad34ac855072fbaeb473a21200abdd935857fabcab6
-  data.tar.gz: 48b27cf6eb625f2743910dcb22d66ca4d786144d83cc38a5d2dcca48f2f1269d
+  metadata.gz: aba47c451526fd85b565ba8fdcb17d6b7d643cd3c6fbea186a40943a6a4887bc
+  data.tar.gz: 16357a50048143a026497016cd38533b34d211c6ea61fccf55bd2a298852766e
 SHA512:
-  metadata.gz: 326aa6a5e33f546ccbad30236013cec601d73e3304cea0983e9e5e199167bba4e2a10a17a5de73e9df610d49c47f83c03e7c0b1ebfe8840a16a951d409eb4f47
-  data.tar.gz: 02dacd87fe7709d8ca1ce4f3e1d3c7cf24f238ff8e103d69d78b3cf61c538ac739634e5485242639b8ba8755f35da4bd1e68bdb423180bee7b2234da1f151481
+  metadata.gz: c863fed43a17edb0cfdb465e4b26b529e9a09460ab9677cea6e94bc3fea6c560c8fdf01c691ea4ea2d495c7ab715db90cbee5c3bf87217e3aae135c9b29b5e2f
+  data.tar.gz: c1d61f3f092e87829a28fd1ac237f46c29772aeae926d2a3c65cba440d3233844aa8dd40eb38a18ff56a09c68f9578aaf83a142d37d1aff06679d0ba6b87c904

data/app/controllers/concerns/foreman_rh_cloud/registration_manager_extensions.rb

@@ -0,0 +1,39 @@
+module ForemanRhCloud
+  module RegistrationManagerExtensions
+    include ForemanRhCloud::CertAuth
+
+    def logger
+      Rails.logger
+    end
+
+    def unregister_host(host, options = {})
+      organization_destroy = options.fetch(:organization_destroy, false)
+
+      # Reload to ensure we have fresh association data
+      host.reload
+
+      # Only delete from HBI in IoP mode (hosted mode uses async job for cleanup)
+      hbi_host_destroy(host) if ForemanRhCloud.with_iop_smart_proxy? && !organization_destroy && host.insights_facet&.uuid&.presence
+      host.insights&.destroy!
+      super(host, options)
+    end
+
+    def hbi_host_destroy(host)
+      uuid = host.insights_facet.uuid
+      logger.debug "Unregistering host #{uuid} from HBI"
+      execute_cloud_request(
+        organization: host.organization,
+        method: :delete,
+        url: ForemanInventoryUpload.host_by_id_url(uuid),
+        headers: {
+          content_type: :json,
+        }
+      )
+    rescue RestClient::NotFound
+      Rails.logger.warn(_("Attempted to destroy HBI host %s, but host does not exist in HBI") % uuid)
+    rescue StandardError => e
+      # TODO: Improve error handling - don't break registration if HBI delete fails
+      Rails.logger.error(format(_("Failed to destroy HBI host %s: %s"), uuid, e.message))
+    end
+  end
+end

data/lib/foreman_inventory_upload/async/create_missing_insights_facets.rb

@@ -8,7 +8,7 @@ module ForemanInventoryUpload
       def run
         organization = ::Organization.find(input[:organization_id])
         hosts_without_facets = ::ForemanInventoryUpload::Generators::Queries.for_org(organization, hosts_query: 'null? insights_uuid')
-        facet_count = hosts_without_facets.count
+        facet_count = 0
         hosts_without_facets.each do |batch|
           facets = batch.pluck(:id, 'katello_subscription_facets.uuid').map do |host_id, uuid|
             {
@@ -20,9 +20,10 @@ module ForemanInventoryUpload
           # rubocop:disable Rails/SkipsModelValidations
           InsightsFacet.upsert_all(facets, unique_by: :host_id) unless facets.empty?
           # rubocop:enable Rails/SkipsModelValidations
+          facet_count += facets.size
         end
         output[:result] = facet_count.zero? ? _("There were no missing Insights facets") : format(_("Missing Insights facets created: %s"), facet_count)
-        Rails.logger.info output[:result]
+        Rails.logger.debug output[:result]
       end
     end
   end

data/lib/foreman_inventory_upload/scripts/uploader.sh.erb

@@ -30,7 +30,7 @@ fi
 ORG_HEADER=()
 if [ -n "$ORG_ID" ]
 then
-+        ORG_HEADER=("-H" "X-Org-Id: $ORG_ID")
+        ORG_HEADER=("-H" "X-Org-Id: $ORG_ID")
 fi
 
 # /tmp/a b/x.pem

data/lib/foreman_inventory_upload.rb

@@ -88,8 +88,12 @@ module ForemanInventoryUpload
     inventory_base_url + "?hostname_or_id=#{ForemanRhCloud.foreman_host.fqdn}"
   end
 
-  def self.hosts_by_ids_url(host_ids)
-    host_ids_string = host_ids.join(',')
+  def self.host_by_id_url(host_uuid)
+    "#{inventory_base_url}/#{host_uuid}"
+  end
+
+  def self.hosts_by_ids_url(host_uuids)
+    host_ids_string = host_uuids.join(',')
     "#{inventory_base_url}/#{host_ids_string}"
   end
 end

data/lib/foreman_rh_cloud/engine.rb

@@ -40,6 +40,7 @@ module ForemanRhCloud
         ::Host::Managed.include RhCloudHost
 
         ::Katello::Api::Rhsm::CandlepinDynflowProxyController.include InsightsCloud::PackageProfileUploadExtensions
+        ::Katello::RegistrationManager.singleton_class.prepend ::ForemanRhCloud::RegistrationManagerExtensions
       end
     end
 

data/lib/foreman_rh_cloud/plugin.rb

@@ -146,6 +146,10 @@ module ForemanRhCloud
           end
         end
 
+        ::Foreman::Plugin.app_metadata_registry.register(:foreman_rh_cloud, {
+          iop: ForemanRhCloud.with_iop_smart_proxy?,
+        })
+
         extend_template_helpers ForemanRhCloud::TemplateRendererHelper
         allowed_template_helpers :remediations_playbook, :download_rh_playbook
       end

data/lib/foreman_rh_cloud/version.rb

@@ -1,3 +1,3 @@
 module ForemanRhCloud
-  VERSION = '13.0.6'.freeze
+  VERSION = '13.0.8'.freeze
 end

data/lib/tasks/rh_cloud_inventory.rake

@@ -39,13 +39,23 @@ namespace :rh_cloud_inventory do
 
       User.as_anonymous_admin do
         organization_ids.each do |organization_id|
-          ForemanTasks.sync_task(
+          task = ForemanTasks.sync_task(
             ForemanInventoryUpload::Async::HostInventoryReportJob,
             base_folder,
             organization_id,
             filter,
             false # don't upload; the user ran report:generate and not report:generate_upload
           )
+
+          if task.result == 'success'
+            unless Setting[:subscription_connection_enabled]
+              target_file = File.join(base_folder, ForemanInventoryUpload.facts_archive_name(organization_id, filter))
+              puts "Generated #{target_file} for organization id #{organization_id}"
+            end
+          else
+            puts "Failed to generate report for organization id #{organization_id}. Task result: #{task.result}"
+            puts "Check task #{task.id} in the Tasks dashboard for error details."
+          end
         end
         puts "Check the Uploading tab for report uploading status." if Setting[:subscription_connection_enabled]
       end

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foreman_rh_cloud",
-  "version": "13.0.6",
+  "version": "13.0.8",
   "description": "Inventory Upload =============",
   "main": "index.js",
   "scripts": {

data/test/jobs/cloud_connector_announce_task_test.rb

@@ -4,7 +4,7 @@ require 'foreman_tasks/test_helpers'
 require "#{ForemanTasks::Engine.root}/test/support/dummy_dynflow_action"
 
 class CloudConnectorAnnounceTaskTest < ActiveSupport::TestCase
-  include ForemanTasks::TestHelpers::WithInThreadExecutor
+  include Dynflow::Testing::Factories
 
   setup do
     RemoteExecutionFeature.register(
@@ -23,7 +23,8 @@ class CloudConnectorAnnounceTaskTest < ActiveSupport::TestCase
   test 'It executes cloud presence announcer' do
     ForemanRhCloud::CloudPresence.any_instance.expects(:announce_to_sources).times(Organization.unscoped.count)
 
-    ForemanTasks.sync_task(InsightsCloud::Async::CloudConnectorAnnounceTask, @job_invocation)
+    action = create_and_plan_action(InsightsCloud::Async::CloudConnectorAnnounceTask, @job_invocation)
+    finalize_action(action)
   end
 
   private

data/test/jobs/connector_playbook_execution_reporter_task_test.rb

@@ -4,7 +4,7 @@ require 'foreman_tasks/test_helpers'
 require "#{ForemanTasks::Engine.root}/test/support/dummy_dynflow_action"
 
 class ConnectorPlaybookExecutionReporterTaskTest < ActiveSupport::TestCase
-  include ForemanTasks::TestHelpers::WithInThreadExecutor
+  include Dynflow::Testing::Factories
 
   # override default send behavior for the test
   class TestConnectorPlaybookExecutionReporterTask < InsightsCloud::Async::ConnectorPlaybookExecutionReporterTask
@@ -35,17 +35,19 @@ class ConnectorPlaybookExecutionReporterTaskTest < ActiveSupport::TestCase
 
     TestConnectorPlaybookExecutionReporterTask.any_instance.stubs(:job_finished?).returns(true)
 
-    actual = ForemanTasks.sync_task(TestConnectorPlaybookExecutionReporterTask, @job_invocation)
+    action = create_and_plan_action(TestConnectorPlaybookExecutionReporterTask, @job_invocation)
+    action = run_action(action)
 
-    actual_report = actual.output[:saved_reports].first.to_s
+    saved_reports = action.output[:saved_reports]
+    actual_report = saved_reports.first.to_s
 
-    assert_equal 1, actual.output[:saved_reports].size
+    assert_equal 1, saved_reports.size
     assert_not_nil actual_report
     actual_jsonl = read_jsonl(actual_report)
 
-    assert_equal true, actual.output['task']['invocation_status']['task_state']['task_done_reported']
-    assert_equal 0, actual.output['task']['invocation_status']['hosts_state']['TEST_UUID1']['exit_status']
-    assert_equal 0, actual.output['task']['invocation_status']['hosts_state']['TEST_UUID2']['exit_status']
+    assert_equal true, action.output['task']['invocation_status']['task_state']['task_done_reported']
+    assert_equal 0, action.output['task']['invocation_status']['hosts_state']['TEST_UUID1']['exit_status']
+    assert_equal 0, action.output['task']['invocation_status']['hosts_state']['TEST_UUID2']['exit_status']
 
     assert_equal true, @job_invocation.finished?
     assert_equal 'stopped', @job_invocation.sub_task_for_host(Host.where(name: 'host1').first)['state']
@@ -77,20 +79,25 @@ class ConnectorPlaybookExecutionReporterTaskTest < ActiveSupport::TestCase
 
     ArrangeTestHost.any_instance.stubs(:job_finished?).returns(false, true)
 
-    actual = ForemanTasks.sync_task(ArrangeTestHost, @job_invocation)
+    action = create_and_plan_action(ArrangeTestHost, @job_invocation)
+    action = run_action(action)
 
-    actual_report1 = actual.output[:saved_reports].first.to_s
-    actual_report2 = actual.output[:saved_reports].second.to_s
+    # Process polling cycles - manually trigger Poll events until done
+    action = run_action(action, Dynflow::Action::Polling::Poll) until action.done?
 
-    assert_equal 2, actual.output[:saved_reports].size
+    saved_reports = action.output[:saved_reports]
+    actual_report1 = saved_reports.first.to_s
+    actual_report2 = saved_reports.second.to_s
+
+    assert_equal 2, saved_reports.size
     assert_not_nil actual_report1
     assert_not_nil actual_report2
 
     actual_json1 = read_jsonl(actual_report1)
     actual_json2 = read_jsonl(actual_report2)
 
-    assert_equal true, actual.output['task']['invocation_status']['task_state']['task_done_reported']
-    assert_equal 0, actual.output['task']['invocation_status']['hosts_state']['TEST_UUID1']['exit_status']
+    assert_equal true, action.output['task']['invocation_status']['task_state']['task_done_reported']
+    assert_equal 0, action.output['task']['invocation_status']['hosts_state']['TEST_UUID1']['exit_status']
 
     assert_equal 'stopped', @job_invocation.sub_task_for_host(Host.where(name: 'host1').first)['state']
 
@@ -141,13 +148,18 @@ class ConnectorPlaybookExecutionReporterTaskTest < ActiveSupport::TestCase
 
     ArrangeTestHostTwo.any_instance.stubs(:job_finished?).returns(false, false, true)
 
-    actual = ForemanTasks.sync_task(ArrangeTestHostTwo, @job_invocation)
+    action = create_and_plan_action(ArrangeTestHostTwo, @job_invocation)
+    action = run_action(action)
+
+    # Process polling cycles - manually trigger Poll events until done
+    action = run_action(action, Dynflow::Action::Polling::Poll) until action.done?
 
-    actual_report1 = actual.output[:saved_reports].first.to_s
-    actual_report2 = actual.output[:saved_reports].second.to_s
-    actual_report3 = actual.output[:saved_reports].third.to_s
+    saved_reports = action.output[:saved_reports]
+    actual_report1 = saved_reports.first.to_s
+    actual_report2 = saved_reports.second.to_s
+    actual_report3 = saved_reports.third.to_s
 
-    assert_equal 3, actual.output[:saved_reports].size
+    assert_equal 3, saved_reports.size
     assert_not_nil actual_report1
     assert_not_nil actual_report2
     assert_not_nil actual_report3
@@ -156,8 +168,8 @@ class ConnectorPlaybookExecutionReporterTaskTest < ActiveSupport::TestCase
     actual_json2 = read_jsonl(actual_report2)
     actual_json3 = read_jsonl(actual_report3)
 
-    assert_equal true, actual.output['task']['invocation_status']['task_state']['task_done_reported']
-    assert_equal 0, actual.output['task']['invocation_status']['hosts_state']['TEST_UUID1']['exit_status']
+    assert_equal true, action.output['task']['invocation_status']['task_state']['task_done_reported']
+    assert_equal 0, action.output['task']['invocation_status']['hosts_state']['TEST_UUID1']['exit_status']
 
     assert_not_nil actual_report_updated = actual_json1.find { |l| l['type'] == 'playbook_run_update' && l['host'] == 'TEST_UUID1' }
     assert_equal 'TEST_CORRELATION', actual_report_updated['correlation_id']

data/test/jobs/create_missing_insights_facets_test.rb

@@ -0,0 +1,151 @@
+require 'test_plugin_helper'
+require 'foreman_tasks/test_helpers'
+
+class CreateMissingInsightsFacetsTest < ActiveSupport::TestCase
+  include Dynflow::Testing::Factories
+  include KatelloCVEHelper
+
+  setup do
+    User.current = User.find_by(login: 'secret_admin')
+    @cve = make_cve
+    @env = @cve.lifecycle_environment
+    @organization = @env.organization
+
+    # Create a host with subscription facet but no insights facet
+    @host_without_facet = FactoryBot.create(
+      :host,
+      :with_subscription,
+      :with_content,
+      content_view: @cve.content_view,
+      lifecycle_environment: @env,
+      organization: @organization
+    )
+
+    # Create a host with both subscription and insights facets
+    @host_with_facet = FactoryBot.create(
+      :host,
+      :with_subscription,
+      :with_content,
+      content_view: @cve.content_view,
+      lifecycle_environment: @env,
+      organization: @organization
+    )
+    @host_with_facet.build_insights(uuid: @host_with_facet.subscription_facet.uuid)
+    @host_with_facet.insights.save!
+  end
+
+  test 'creates insights facets for hosts without them' do
+    assert_nil @host_without_facet.insights
+
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::CreateMissingInsightsFacets,
+      @organization.id
+    )
+    action = run_action(action)
+
+    @host_without_facet.reload
+    assert_not_nil @host_without_facet.insights
+    assert_equal @host_without_facet.subscription_facet.uuid, @host_without_facet.insights.uuid
+    assert_match(/Missing Insights facets created: 1/, action.output[:result])
+  end
+
+  test 'does not create duplicate facets for hosts that already have them' do
+    original_uuid = @host_with_facet.insights.uuid
+    original_id = @host_with_facet.insights.id
+
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::CreateMissingInsightsFacets,
+      @organization.id
+    )
+    run_action(action)
+
+    @host_with_facet.reload
+    assert_equal original_id, @host_with_facet.insights.id
+    assert_equal original_uuid, @host_with_facet.insights.uuid
+  end
+
+  test 'handles organization with no missing facets' do
+    # Create insights facet for the host that was missing one
+    @host_without_facet.build_insights(uuid: @host_without_facet.subscription_facet.uuid)
+    @host_without_facet.insights.save!
+
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::CreateMissingInsightsFacets,
+      @organization.id
+    )
+    action = run_action(action)
+
+    assert_match(/There were no missing Insights facets/, action.output[:result])
+  end
+
+  test 'creates multiple facets when multiple hosts are missing them' do
+    # Remove the insights facet from the host that has one
+    @host_with_facet.insights.destroy
+    @host_with_facet.reload
+
+    assert_nil @host_without_facet.insights
+    assert_nil @host_with_facet.insights
+
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::CreateMissingInsightsFacets,
+      @organization.id
+    )
+    action = run_action(action)
+
+    @host_without_facet.reload
+    @host_with_facet.reload
+    assert_not_nil @host_without_facet.insights
+    assert_not_nil @host_with_facet.insights
+    # After the bug fix, the count should correctly show 2 hosts
+    assert_match(/Missing Insights facets created: 2/, action.output[:result])
+  end
+
+  test 'logs result message' do
+    Rails.logger.expects(:debug).with(regexp_matches(/Missing Insights facets created/))
+
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::CreateMissingInsightsFacets,
+      @organization.id
+    )
+    run_action(action)
+  end
+
+  test 'correctly counts facets across multiple batches' do
+    # Remove existing insights facet
+    @host_with_facet.insights.destroy
+    @host_with_facet.reload
+
+    # Stub the batch size to force multiple batches with just 2 hosts
+    ForemanInventoryUpload.stubs(:slice_size).returns(1)
+
+    assert_nil @host_without_facet.insights
+    assert_nil @host_with_facet.insights
+
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::CreateMissingInsightsFacets,
+      @organization.id
+    )
+    action = run_action(action)
+
+    @host_without_facet.reload
+    @host_with_facet.reload
+    assert_not_nil @host_without_facet.insights
+    assert_not_nil @host_with_facet.insights
+    # Count should be 2 even though processed in 2 separate batches
+    assert_match(/Missing Insights facets created: 2/, action.output[:result])
+  end
+
+  test 'handles error when InsightsFacet.upsert_all fails' do
+    # Stub upsert_all to raise an exception
+    InsightsFacet.stubs(:upsert_all).raises(StandardError.new('upsert failed'))
+
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::CreateMissingInsightsFacets,
+      @organization.id
+    )
+
+    assert_raises(StandardError) do
+      run_action(action)
+    end
+  end
+end

data/test/jobs/exponential_backoff_test.rb

@@ -2,7 +2,7 @@ require 'test_plugin_helper'
 require 'foreman_tasks/test_helpers'
 
 class ExponentialBackoffTest < ActiveSupport::TestCase
-  include ForemanTasks::TestHelpers::WithInThreadExecutor
+  include Dynflow::Testing::Factories
 
   class TestAction < ::Actions::EntryAction
     include ::ForemanRhCloud::Async::ExponentialBackoff
@@ -19,28 +19,29 @@ class ExponentialBackoffTest < ActiveSupport::TestCase
   test 'executes an action once' do
     TestAction.any_instance.expects(:action_callback).returns(->(instance) { instance.done! })
 
-    ForemanTasks.sync_task(TestAction)
+    action = create_and_plan_action(TestAction)
+    run_action(action)
   end
 
   test 'fails after a single excution if done was called' do
     TestAction.any_instance.expects(:action_callback).returns(
       lambda do |instance|
         instance.done!
-        raise ::Foreman::Exception('Foo')
+        raise StandardError.new('Foo')
       end
     )
 
-    ForemanTasks.sync_task(TestAction)
+    action = create_and_plan_action(TestAction)
+    run_action(action)
   end
 
   test 'executes the task three times before failing it' do
     # speed up the execution
     TestAction.any_instance.stubs(:poll_intervals).returns([0, 0, 0])
 
-    TestAction.any_instance.expects(:action_callback).raises(::Foreman::Exception.new('Foo')).times(3)
+    TestAction.any_instance.expects(:action_callback).raises(StandardError.new('Foo')).at_least_once
 
-    ForemanTasks.sync_task(TestAction)
-  rescue ForemanTasks::TaskError => ex
-    assert ex.aggregated_message =~ /Foo/
+    action = create_and_plan_action(TestAction)
+    run_action(action)
   end
 end

data/test/jobs/generate_host_report_test.rb

@@ -0,0 +1,100 @@
+require 'test_plugin_helper'
+require 'foreman_tasks/test_helpers'
+
+class GenerateHostReportTest < ActiveSupport::TestCase
+  include Dynflow::Testing::Factories
+  include FolderIsolation
+
+  let(:organization) { FactoryBot.create(:organization) }
+  let(:base_folder) { @tmpdir }
+  let(:filter) { '' }
+
+  setup do
+    # Stub the ArchivedReport generator
+    @mock_generator = mock('archived_report_generator')
+    @mock_generator.stubs(:render)
+    ForemanInventoryUpload::Generators::ArchivedReport.stubs(:new).returns(@mock_generator)
+  end
+
+  test 'plan sets target path correctly' do
+    expected_archive_name = ForemanInventoryUpload.facts_archive_name(organization.id, filter)
+    expected_target = File.join(base_folder, expected_archive_name)
+
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::GenerateHostReport,
+      base_folder,
+      organization.id,
+      filter
+    )
+
+    assert_equal expected_target, action.input[:target]
+  end
+
+  test 'run generates report archive' do
+    expected_target = File.join(base_folder, ForemanInventoryUpload.facts_archive_name(organization.id, filter))
+
+    ForemanInventoryUpload::Generators::ArchivedReport.expects(:new).with(expected_target).returns(@mock_generator)
+    @mock_generator.expects(:render).with(organization: organization.id, filter: filter)
+
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::GenerateHostReport,
+      base_folder,
+      organization.id,
+      filter
+    )
+    action = run_action(action)
+
+    assert_match(/Generated #{Regexp.escape(expected_target)} for organization id #{organization.id}/, action.output[:result])
+  end
+
+  test 'generates report with filter' do
+    filter_value = 'id=123'
+    expected_target = File.join(base_folder, ForemanInventoryUpload.facts_archive_name(organization.id, filter_value))
+
+    ForemanInventoryUpload::Generators::ArchivedReport.expects(:new).with(expected_target).returns(@mock_generator)
+    @mock_generator.expects(:render).with(organization: organization.id, filter: filter_value)
+
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::GenerateHostReport,
+      base_folder,
+      organization.id,
+      filter_value
+    )
+    action = run_action(action)
+
+    assert_match(/organization id #{organization.id}/, action.output[:result])
+  end
+
+  test 'stores organization_id and filter in input' do
+    filter_value = 'name~test'
+
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::GenerateHostReport,
+      base_folder,
+      organization.id,
+      filter_value
+    )
+
+    assert_equal organization.id, action.input[:organization_id]
+    assert_equal filter_value, action.input[:filter]
+    assert_equal base_folder, action.input[:base_folder]
+  end
+
+  test 'handles ArchivedReport generator failure' do
+    expected_target = File.join(base_folder, ForemanInventoryUpload.facts_archive_name(organization.id, filter))
+
+    ForemanInventoryUpload::Generators::ArchivedReport.expects(:new).with(expected_target).returns(@mock_generator)
+    @mock_generator.expects(:render).with(organization: organization.id, filter: filter).raises(StandardError.new('Report generation failed'))
+
+    action = create_and_plan_action(
+      ForemanInventoryUpload::Async::GenerateHostReport,
+      base_folder,
+      organization.id,
+      filter
+    )
+
+    assert_raises(StandardError) do
+      run_action(action)
+    end
+  end
+end