foreman_rh_cloud 14.0.3 → 14.1.1

data/test/jobs/inventory_full_sync_test.rb

@@ -5,6 +5,7 @@ class InventoryFullSyncTest < ActiveSupport::TestCase
   include Dynflow::Testing::Factories
   include MockCerts
   include KatelloCVEHelper
+  include CandlepinIsolation
 
   setup do
     User.current = User.find_by(login: 'secret_admin')
@@ -310,4 +311,215 @@ class InventoryFullSyncTest < ActiveSupport::TestCase
 
     assert_nil InventorySync::InventoryStatus.where(host_id: @host3.id).first
   end
+
+  test 'user-omitted hosts get USER_OMITTED status' do
+    # Add parameter to exclude host1
+    @host1.host_parameters << HostParameter.create(
+      name: 'host_registration_insights_inventory',
+      value: 'false',
+      parameter_type: 'boolean'
+    )
+    @host1.save!
+
+    setup_certs_expectation do
+      InventorySync::Async::InventoryFullSync.any_instance.stubs(:candlepin_id_cert)
+    end
+    InventorySync::Async::InventoryFullSync.any_instance.expects(:query_inventory).returns(@inventory)
+    FactoryBot.create(:fact_value, fact_name: fact_names['virt::uuid'], value: '1234', host: @host2)
+
+    action = create_and_plan_action(InventorySync::Async::InventoryFullSync, @host1.organization)
+    run_action(action)
+
+    @host1.reload
+    @host2.reload
+
+    # Host1 should be USER_OMITTED
+    assert_equal InventorySync::InventoryStatus::USER_OMITTED,
+      InventorySync::InventoryStatus.where(host_id: @host1.id).first.status,
+      'Host with host_registration_insights_inventory=false should have USER_OMITTED status'
+
+    # Host2 should be SYNC
+    assert_equal InventorySync::InventoryStatus::SYNC,
+      InventorySync::InventoryStatus.where(host_id: @host2.id).first.status,
+      'Normal host should have SYNC status'
+  end
+
+  test 'user-omitted hosts are not marked as disconnected' do
+    # Add parameter to exclude host1
+    @host1.host_parameters << HostParameter.create(
+      name: 'host_registration_insights_inventory',
+      value: 'false',
+      parameter_type: 'boolean'
+    )
+    @host1.save!
+
+    # Host1 is not in the cloud inventory response
+    setup_certs_expectation do
+      InventorySync::Async::InventoryFullSync.any_instance.stubs(:candlepin_id_cert)
+    end
+    InventorySync::Async::InventoryFullSync.any_instance.expects(:query_inventory).returns(@inventory)
+    InventorySync::Async::InventoryFullSync.any_instance.expects(:affected_host_ids).returns([@host1.id, @host2.id])
+    FactoryBot.create(:fact_value, fact_name: fact_names['virt::uuid'], value: '1234', host: @host2)
+
+    action = create_and_plan_action(InventorySync::Async::InventoryFullSync, @host1.organization)
+    run_action(action)
+
+    @host1.reload
+
+    # Host1 should be USER_OMITTED, not DISCONNECT
+    assert_equal InventorySync::InventoryStatus::USER_OMITTED,
+      InventorySync::InventoryStatus.where(host_id: @host1.id).first.status,
+      'User-omitted host should have USER_OMITTED status even if not in cloud inventory'
+  end
+
+  test 'host_statuses output includes all three counts' do
+    # Create a mix of hosts with different statuses
+    # Host1: will be user-omitted
+    @host1.host_parameters << HostParameter.create(
+      name: 'host_registration_insights_inventory',
+      value: 'false',
+      parameter_type: 'boolean'
+    )
+    @host1.save!
+
+    # Host2: will be synced (in cloud inventory)
+    # Host3: will be disconnected (not in cloud inventory)
+
+    # Create inventory response with only host2 (exclude host1 and host3)
+    inventory_with_host2_only = @inventory.dup
+    inventory_with_host2_only['results'] = [@inventory['results'][0]] # Only host2
+    inventory_with_host2_only['total'] = 1
+    inventory_with_host2_only['count'] = 1
+
+    setup_certs_expectation do
+      InventorySync::Async::InventoryFullSync.any_instance.stubs(:candlepin_id_cert)
+    end
+    InventorySync::Async::InventoryFullSync.any_instance.expects(:query_inventory).returns(inventory_with_host2_only)
+    InventorySync::Async::InventoryFullSync.any_instance.expects(:affected_host_ids).returns([@host1.id, @host2.id, @host3.id])
+    FactoryBot.create(:fact_value, fact_name: fact_names['virt::uuid'], value: '1234', host: @host2)
+
+    action = create_and_plan_action(InventorySync::Async::InventoryFullSync, @host1.organization)
+    run_action(action)
+
+    # Verify the statuses were actually set correctly
+    @host1.reload
+    @host2.reload
+    @host3.reload
+
+    assert_equal InventorySync::InventoryStatus::USER_OMITTED,
+      InventorySync::InventoryStatus.where(host_id: @host1.id).first.status,
+      'Host with host_registration_insights_inventory=false should have USER_OMITTED status'
+    assert_equal InventorySync::InventoryStatus::SYNC,
+      InventorySync::InventoryStatus.where(host_id: @host2.id).first.status,
+      'Host in cloud inventory should have SYNC status'
+    assert_equal InventorySync::InventoryStatus::DISCONNECT,
+      InventorySync::InventoryStatus.where(host_id: @host3.id).first.status,
+      'Host not in cloud inventory and not user-omitted should have DISCONNECT status'
+  end
+
+  test 'user-omitted status respects parameter inheritance from hostgroup' do
+    # Create a hostgroup and assign it to host1
+    hostgroup = FactoryBot.create(:hostgroup)
+    hostgroup.organizations << @host1.organization
+    @host1.hostgroup = hostgroup
+    @host1.save!
+
+    # Set parameter at hostgroup level, not directly on host
+    # This verifies the fix that uses search_for instead of querying HostParameter directly
+    hostgroup.group_parameters << GroupParameter.create(
+      name: 'host_registration_insights_inventory',
+      value: 'false',
+      key_type: 'boolean'
+    )
+    hostgroup.save!
+
+    # Verify parameter is inherited (not set directly on host)
+    assert_nil @host1.parameters.find_by(name: 'host_registration_insights_inventory'),
+      'Test setup: parameter should not be set directly on host'
+    refute ::Foreman::Cast.to_bool(@host1.host_param('host_registration_insights_inventory')),
+      'Test setup: parameter should be inherited from hostgroup'
+
+    # Host2 remains normal (no parameter)
+    setup_certs_expectation do
+      InventorySync::Async::InventoryFullSync.any_instance.stubs(:candlepin_id_cert)
+    end
+    InventorySync::Async::InventoryFullSync.any_instance.expects(:query_inventory).returns(@inventory)
+    InventorySync::Async::InventoryFullSync.any_instance.expects(:affected_host_ids).returns([@host1.id, @host2.id])
+    FactoryBot.create(:fact_value, fact_name: fact_names['virt::uuid'], value: '1234', host: @host2)
+
+    action = create_and_plan_action(InventorySync::Async::InventoryFullSync, @host1.organization)
+    run_action(action)
+
+    @host1.reload
+    @host2.reload
+
+    # Host1 should be USER_OMITTED (inherited parameter from hostgroup)
+    host1_status = InventorySync::InventoryStatus.where(host_id: @host1.id).first
+    assert_not_nil host1_status, 'Host1 should have an inventory status'
+    assert_equal InventorySync::InventoryStatus::USER_OMITTED, host1_status.status,
+      'Host with inherited host_registration_insights_inventory=false should have USER_OMITTED status'
+
+    # Host2 should be SYNC
+    assert_equal InventorySync::InventoryStatus::SYNC,
+      InventorySync::InventoryStatus.where(host_id: @host2.id).first.status,
+      'Normal host should have SYNC status'
+  end
+
+  test 'user-omitted statuses are cleared before re-creating them to avoid silent create failures' do
+    # First sync: host1 is user-omitted
+    @host1.host_parameters << HostParameter.create(
+      name: 'host_registration_insights_inventory',
+      value: 'false',
+      parameter_type: 'boolean'
+    )
+    @host1.save!
+
+    setup_certs_expectation do
+      InventorySync::Async::InventoryFullSync.any_instance.stubs(:candlepin_id_cert)
+    end
+    InventorySync::Async::InventoryFullSync.any_instance.expects(:query_inventory).returns(@inventory).twice
+    InventorySync::Async::InventoryFullSync.any_instance.expects(:affected_host_ids).returns([@host1.id, @host2.id]).twice
+    FactoryBot.create(:fact_value, fact_name: fact_names['virt::uuid'], value: '1234', host: @host2)
+
+    # Run first sync
+    action = create_and_plan_action(InventorySync::Async::InventoryFullSync, @host1.organization)
+    run_action(action)
+
+    @host1.reload
+    initial_status = InventorySync::InventoryStatus.where(host_id: @host1.id).first
+    assert_equal InventorySync::InventoryStatus::USER_OMITTED, initial_status.status,
+      'Initial sync: host should be USER_OMITTED'
+    initial_status_id = initial_status.id
+
+    # Verify there's only one status record for host1
+    assert_equal 1, InventorySync::InventoryStatus.where(host_id: @host1.id).count,
+      'Should have exactly one status record after first sync'
+
+    # Run second sync (parameter still false)
+    # Without clearing old user_omitted statuses, the .create would silently fail
+    # with 'Host has already been taken' due to uniqueness constraint
+    setup_certs_expectation do
+      InventorySync::Async::InventoryFullSync.any_instance.stubs(:candlepin_id_cert)
+    end
+
+    action2 = create_and_plan_action(InventorySync::Async::InventoryFullSync, @host1.organization)
+    run_action(action2)
+
+    @host1.reload
+    final_status = InventorySync::InventoryStatus.where(host_id: @host1.id).first
+
+    # Verify status is still USER_OMITTED (not stale from first sync)
+    assert_equal InventorySync::InventoryStatus::USER_OMITTED, final_status.status,
+      'Status should be USER_OMITTED after second sync'
+
+    # Verify there's still only one status record (old one was deleted before creating new one)
+    assert_equal 1, InventorySync::InventoryStatus.where(host_id: @host1.id).count,
+      'Should have exactly one status record (old cleared before new created)'
+
+    # Verify the old status record was actually deleted and replaced with a new one
+    refute InventorySync::InventoryStatus.exists?(initial_status_id),
+      'Old status record should have been deleted before creating new one'
+    assert_not_equal initial_status_id, final_status.id,
+      'New status record should have different ID, proving old was deleted'
+  end
 end

data/test/models/insights_client_report_status_test.rb

@@ -72,4 +72,113 @@ class InsightsClientReportStatusTest < ActiveSupport::TestCase
 
     assert_equal HostStatus::Global::ERROR, @host.global_status
   end
+
+  test 'host with host_registration_insights parameter set to false gets USER_OMITTED status' do
+    @host.host_parameters << HostParameter.create(
+      name: 'host_registration_insights',
+      value: 'false',
+      parameter_type: 'boolean'
+    )
+    @host.save!
+
+    insights_status = @host.get_status(InsightsClientReportStatus)
+    insights_status.refresh!
+
+    assert_equal InsightsClientReportStatus::USER_OMITTED, insights_status.status
+    assert_equal HostStatus::Global::OK, insights_status.to_global
+  end
+
+  test 'USER_OMITTED status has correct label' do
+    insights_status = @host.get_status(InsightsClientReportStatus)
+    insights_status.status = InsightsClientReportStatus::USER_OMITTED
+    insights_status.save!
+
+    label = insights_status.to_label
+    assert_match(/host_registration_insights/, label)
+    assert_match(/false/, label)
+  end
+
+  test 'stale scope excludes USER_OMITTED hosts' do
+    host1 = FactoryBot.create(:host, :managed)
+    host2 = FactoryBot.create(:host, :managed)
+    host3 = FactoryBot.create(:host, :managed)
+
+    # Host 1: USER_OMITTED with old reported_at (should NOT be in stale scope)
+    status1 = host1.get_status(InsightsClientReportStatus)
+    status1.status = InsightsClientReportStatus::USER_OMITTED
+    status1.reported_at = Time.zone.now - InsightsClientReportStatus::REPORT_INTERVAL - 1.day
+    status1.save!
+
+    # Host 2: REPORTING with old reported_at (should be in stale scope)
+    status2 = host2.get_status(InsightsClientReportStatus)
+    status2.status = InsightsClientReportStatus::REPORTING
+    status2.reported_at = Time.zone.now - InsightsClientReportStatus::REPORT_INTERVAL - 1.day
+    status2.save!
+
+    # Host 3: NO_REPORT with old reported_at (should be in stale scope)
+    status3 = host3.get_status(InsightsClientReportStatus)
+    status3.status = InsightsClientReportStatus::NO_REPORT
+    status3.reported_at = Time.zone.now - InsightsClientReportStatus::REPORT_INTERVAL - 1.day
+    status3.save!
+
+    stale_statuses = InsightsClientReportStatus.stale
+    stale_host_ids = stale_statuses.pluck(:host_id)
+
+    assert_not_includes stale_host_ids, host1.id, 'USER_OMITTED host should not be in stale scope'
+    assert_includes stale_host_ids, host2.id, 'REPORTING host with old report should be in stale scope'
+    assert_includes stale_host_ids, host3.id, 'NO_REPORT host with old report should be in stale scope'
+  end
+
+  test 'USER_OMITTED status respects parameter inheritance from hostgroup' do
+    # Create a hostgroup with parameter = false
+    hostgroup = FactoryBot.create(:hostgroup)
+    hostgroup.group_parameters << GroupParameter.create(
+      name: 'host_registration_insights',
+      value: 'false',
+      key_type: 'boolean'
+    )
+    hostgroup.save!
+
+    @host.hostgroup = hostgroup
+    @host.save!
+
+    # Verify parameter is inherited (not set directly on host)
+    assert_nil @host.parameters.find_by(name: 'host_registration_insights'),
+      'Test setup: parameter should not be set directly on host'
+
+    insights_status = @host.get_status(InsightsClientReportStatus)
+    insights_status.refresh!
+
+    assert_equal InsightsClientReportStatus::USER_OMITTED, insights_status.status,
+      'Status should be USER_OMITTED when host_registration_insights=false is inherited from hostgroup'
+    assert_equal HostStatus::Global::OK, insights_status.to_global,
+      'USER_OMITTED status should not affect global status'
+  end
+
+  test 'host parameter overrides inherited parameter from hostgroup' do
+    # Create a hostgroup with parameter = false
+    hostgroup = FactoryBot.create(:hostgroup)
+    hostgroup.group_parameters << GroupParameter.create(
+      name: 'host_registration_insights',
+      value: 'false',
+      key_type: 'boolean'
+    )
+    hostgroup.save!
+
+    @host.hostgroup = hostgroup
+
+    # Override with host parameter = true
+    @host.host_parameters << HostParameter.create(
+      name: 'host_registration_insights',
+      value: 'true',
+      parameter_type: 'boolean'
+    )
+    @host.save!
+
+    insights_status = @host.get_status(InsightsClientReportStatus)
+    insights_status.refresh!
+
+    assert_not_equal InsightsClientReportStatus::USER_OMITTED, insights_status.status,
+      'Status should not be USER_OMITTED when host parameter overrides hostgroup parameter with true'
+  end
 end

data/test/models/inventory_sync/inventory_status_test.rb

@@ -0,0 +1,85 @@
+require 'test_plugin_helper'
+
+module InventorySync
+  class InventoryStatusTest < ActiveSupport::TestCase
+    setup do
+      @host = FactoryBot.create(:host, :managed)
+    end
+
+    test 'status constants are defined correctly' do
+      assert_equal 0, InventorySync::InventoryStatus::DISCONNECT
+      assert_equal 1, InventorySync::InventoryStatus::SYNC
+      assert_equal 2, InventorySync::InventoryStatus::USER_OMITTED
+    end
+
+    test 'to_global returns OK for USER_OMITTED status' do
+      status = @host.get_status(InventorySync::InventoryStatus)
+      status.status = InventorySync::InventoryStatus::USER_OMITTED
+      status.save!
+
+      assert_equal HostStatus::Global::OK, status.to_global
+    end
+
+    test 'to_global returns WARN for DISCONNECT status' do
+      status = @host.get_status(InventorySync::InventoryStatus)
+      status.status = InventorySync::InventoryStatus::DISCONNECT
+      status.save!
+
+      assert_equal HostStatus::Global::WARN, status.to_global
+    end
+
+    test 'to_global returns OK for SYNC status' do
+      status = @host.get_status(InventorySync::InventoryStatus)
+      status.status = InventorySync::InventoryStatus::SYNC
+      status.save!
+
+      assert_equal HostStatus::Global::OK, status.to_global
+    end
+
+    test 'to_label returns appropriate messages for each status' do
+      status = @host.get_status(InventorySync::InventoryStatus)
+
+      # Test DISCONNECT label
+      status.status = InventorySync::InventoryStatus::DISCONNECT
+      status.save!
+      label = status.to_label
+      assert_match(/not present/, label.downcase)
+      assert_match(/console\.redhat\.com/, label)
+
+      # Test SYNC label
+      status.status = InventorySync::InventoryStatus::SYNC
+      status.save!
+      label = status.to_label
+      assert_match(/uploaded.*present/, label.downcase)
+      assert_match(/console\.redhat\.com/, label)
+
+      # Test USER_OMITTED label
+      status.status = InventorySync::InventoryStatus::USER_OMITTED
+      status.save!
+      label = status.to_label
+      assert_match(/excluded/, label.downcase)
+      assert_match(/host parameter/, label.downcase)
+      assert_match(/console\.redhat\.com/, label)
+    end
+
+    test 'relevant? returns true in regular (non-IoP) mode' do
+      ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(false)
+
+      status = @host.get_status(InventorySync::InventoryStatus)
+      status.status = InventorySync::InventoryStatus::SYNC
+      status.save!
+
+      assert status.relevant?, 'Inventory status should be relevant in regular mode'
+    end
+
+    test 'relevant? returns false in IoP mode' do
+      ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+
+      status = @host.get_status(InventorySync::InventoryStatus)
+      status.status = InventorySync::InventoryStatus::SYNC
+      status.save!
+
+      refute status.relevant?, 'Inventory status should NOT be relevant in IoP mode'
+    end
+  end
+end

data/test/unit/lib/insights_cloud/async/vmaas_reposcan_sync_test.rb

@@ -5,19 +5,17 @@ class VmaasReposcanSyncTest < ActiveSupport::TestCase
   include ForemanTasks::TestHelpers::WithInThreadExecutor
 
   setup do
-    @root = FactoryBot.build(:katello_root_repository, :fedora_17_x86_64_dev_root)
-    @root.save(validate: false)
-    @repo = FactoryBot.create(
-      :katello_repository,
-      :with_product,
-      distribution_family: 'Red Hat',
-      distribution_version: '7.5',
-      root: @root
-    )
+    @organization = FactoryBot.create(:organization)
+    # Create a simple repository - we only need id and organization_id for the action
+    @repo = ::Katello::Repository.new(id: 1)
+    @repo.stubs(:organization_id).returns(@organization.id)
+    ::Katello::Repository.stubs(:find).with(1).returns(@repo)
+
     @repo_payload = { id: @repo.id }
     @expected_url = 'https://example.com/api/v1/vmaas/reposcan/sync'
     InsightsCloud.stubs(:vmaas_reposcan_sync_url).returns(@expected_url)
     ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+    Organization.stubs(:find).with(@organization.id).returns(@organization)
   end
 
   teardown do
@@ -83,7 +81,7 @@ class VmaasReposcanSyncTest < ActiveSupport::TestCase
         params[:url] == @expected_url &&
         params[:headers].is_a?(Hash) &&
         params[:headers]['Content-Type'] == 'application/json' &&
-        params[:organization] == @repo.organization
+        params[:organization] == @organization
     end
                                            .returns(mock_response)
 
@@ -116,37 +114,94 @@ class VmaasReposcanSyncTest < ActiveSupport::TestCase
                                            .stubs(:execute_cloud_request)
                                            .raises(exception)
 
-    error = assert_raises(ForemanTasks::TaskError) do
-      ForemanTasks.sync_task(InsightsCloud::Async::VmaasReposcanSync, @repo_payload)
-    end
+    task = ForemanTasks.sync_task(InsightsCloud::Async::VmaasReposcanSync, @repo_payload)
 
-    assert_equal 'VMaaS reposcan sync failed: 500 - Server Error', error.task.output[:message]
+    assert_equal 'VMaaS reposcan sync failed: 500 - Server Error', task.output[:message]
   end
 
   test 'run sets error message in task output for StandardError exception' do
+    mock_logger = mock('logger')
+    mock_logger.expects(:error).with('Error triggering VMaaS reposcan sync: Network timeout')
+    InsightsCloud::Async::VmaasReposcanSync.any_instance.stubs(:logger).returns(mock_logger)
+
     InsightsCloud::Async::VmaasReposcanSync.any_instance
                                            .stubs(:execute_cloud_request)
                                            .raises(StandardError.new('Network timeout'))
 
-    error = assert_raises(ForemanTasks::TaskError) do
-      ForemanTasks.sync_task(InsightsCloud::Async::VmaasReposcanSync, @repo_payload)
-    end
+    task = ForemanTasks.sync_task(InsightsCloud::Async::VmaasReposcanSync, @repo_payload)
 
-    # The task is available via main_action
-    assert_match(/Error triggering VMaaS reposcan sync: Network timeout, response: /,
-      error.task.main_action.output[:message])
+    assert_equal 'Error triggering VMaaS reposcan sync: Network timeout', task.output[:message]
   end
 
-  test 'run logs and re-raises when cloud request returns error response' do
-    error_response = mock('error_response', code: 500, body: 'error')
+  test 'run logs and handles error response without raising' do
+    error_response = mock('error_response')
+    error_response.stubs(:code).returns(500)
+    error_response.stubs(:body).returns('error')
     exception = RestClient::ExceptionWithResponse.new(error_response)
 
     InsightsCloud::Async::VmaasReposcanSync.any_instance
                                            .stubs(:execute_cloud_request)
                                            .raises(exception)
 
-    assert_raises(ForemanTasks::TaskError) do
-      ForemanTasks.sync_task(InsightsCloud::Async::VmaasReposcanSync, @repo_payload)
-    end
+    task = ForemanTasks.sync_task(InsightsCloud::Async::VmaasReposcanSync, @repo_payload)
+
+    assert_equal 'VMaaS reposcan sync failed: 500 - error', task.output[:message]
+  end
+
+  test 'run handles 429 error with warning log level' do
+    error_response = mock('error_response')
+    error_response.stubs(:code).returns(429)
+    error_response.stubs(:body).returns('{"msg": "Another task already in progress"}')
+    exception = RestClient::ExceptionWithResponse.new(error_response)
+
+    mock_logger = mock('logger')
+    mock_logger.expects(:warn).with('VMaaS reposcan sync skipped: another sync already in progress (429)')
+    InsightsCloud::Async::VmaasReposcanSync.any_instance.stubs(:logger).returns(mock_logger)
+
+    InsightsCloud::Async::VmaasReposcanSync.any_instance
+                                           .stubs(:execute_cloud_request)
+                                           .raises(exception)
+
+    task = ForemanTasks.sync_task(InsightsCloud::Async::VmaasReposcanSync, @repo_payload)
+
+    assert_equal 'VMaaS reposcan sync skipped: another sync already in progress (429)',
+      task.output[:message]
+  end
+
+  test 'run handles non-429 errors with error log level' do
+    error_response = mock('error_response')
+    error_response.stubs(:code).returns(500)
+    error_response.stubs(:body).returns('Internal Server Error')
+    exception = RestClient::ExceptionWithResponse.new(error_response)
+
+    mock_logger = mock('logger')
+    mock_logger.expects(:error).with('VMaaS reposcan sync failed: 500 - Internal Server Error')
+    InsightsCloud::Async::VmaasReposcanSync.any_instance.stubs(:logger).returns(mock_logger)
+
+    InsightsCloud::Async::VmaasReposcanSync.any_instance
+                                           .stubs(:execute_cloud_request)
+                                           .raises(exception)
+
+    task = ForemanTasks.sync_task(InsightsCloud::Async::VmaasReposcanSync, @repo_payload)
+
+    assert_equal 'VMaaS reposcan sync failed: 500 - Internal Server Error',
+      task.output[:message]
+  end
+
+  test 'run handles RestClient::ExceptionWithResponse with nil response' do
+    exception = RestClient::ExceptionWithResponse.new(nil)
+
+    mock_logger = mock('logger')
+    mock_logger.expects(:error).with('VMaaS reposcan sync failed:  - ')
+    InsightsCloud::Async::VmaasReposcanSync.any_instance.stubs(:logger).returns(mock_logger)
+
+    InsightsCloud::Async::VmaasReposcanSync.any_instance
+                                           .stubs(:execute_cloud_request)
+                                           .raises(exception)
+
+    task = ForemanTasks.sync_task(InsightsCloud::Async::VmaasReposcanSync, @repo_payload)
+
+    refute_nil task.output[:message]
+    assert_equal 'VMaaS reposcan sync failed:  - ', task.output[:message]
   end
 end