foreman_rh_cloud 13.2.6 → 13.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d11a81329e083956595eae07e1b13a0f337722d2316b73e37eaece51a05ff92
-  data.tar.gz: 925d50c3713f68be27c6290fe67ac5a68b5a5cd7a3f78578ce5acc574469fcd8
+  metadata.gz: 04c6a1daea1675deb081565cf7d9e83e669a3fd01a577a032c9d7d5ba825cbce
+  data.tar.gz: 5172a5c764d0dbcb71cf47e19e423f0eae01db27636be594320dece4c6364719
 SHA512:
-  metadata.gz: 9f0071fcff2a17f1e8d5ac6dacba1b7383a47822a179e6681a7fdb37469be9d4a0b3f3752d044ae64a34b839ded062ebe70db2a572c8b41368fe8b5e630c7d0b
-  data.tar.gz: 26ee66163cb1b8e802b5c52c2cbfef4e3c4cdc25f2094b7de5a68c083bede2d046317b9e965d9df2c9cbecdabb7be0638b599928ceb87b9e6678195914d518e4
+  metadata.gz: 15b24817679825c5e60bc0e0ca0b33c18eadae7277483155c641f3d3d140bd911c0c7ad7dca15c40e3d63f9a8e354acfcd5789048658fd2888a33fa4b9741d0d
+  data.tar.gz: 0cfe77f01b645de55c8e3e41ac4411201c5ec4819e5926d3054bac08b551e12dc923dffa6b1503956cb1075c688a5a3d94e5a63a8c4e332414e10f78054d3954

data/app/models/concerns/rh_cloud_host.rb

@@ -21,7 +21,8 @@ module RhCloudHost
     scoped_search :relation => :inventory_sync_status_object, :on => :status, :rename => :insights_inventory_sync_status,
       :complete_value => { :disconnect => ::InventorySync::InventoryStatus::DISCONNECT,
                            :sync => ::InventorySync::InventoryStatus::SYNC }
-    scoped_search :relation => :insights, :on => :uuid, :only_explicit => true, :rename => :insights_uuid
+    scoped_search :on => :id, :rename => :insights_uuid, :only_explicit => true,
+      :ext_method => :search_by_insights_uuid, :complete_value => false
 
     def insights_facet
       insights
@@ -41,4 +42,33 @@ module RhCloudHost
       insights_facet.update!(uuid: subscription_facet.uuid)
     end
   end
+
+  module ClassMethods
+    def search_by_insights_uuid(_key, operator, value)
+      # Determine which facet table to search based on IoP mode
+      facet_table = ForemanRhCloud.with_iop_smart_proxy? ? Katello::Host::SubscriptionFacet.table_name : InsightsFacet.table_name
+
+      # Build SQL condition
+      if ['IN', 'NOT IN'].include?(operator)
+        # For IN/NOT IN, value may be an array or comma-separated string
+        # Convert to array and build placeholders for each value
+        values = value.is_a?(Array) ? value : value.to_s.split(',').map(&:strip)
+        placeholders = (['?'] * values.size).join(',')
+        condition = sanitize_sql_for_conditions(
+          ["#{facet_table}.uuid #{operator} (#{placeholders})", *values]
+        )
+      else
+        # For other operators (=, !=, LIKE, etc.), use value_to_sql for proper SQL formatting
+        condition = sanitize_sql_for_conditions(
+          ["#{facet_table}.uuid #{operator} ?", value_to_sql(operator, value)]
+        )
+      end
+
+      # Return search parameters with LEFT JOIN to include hosts without facets
+      {
+        joins: "LEFT JOIN #{facet_table} ON #{facet_table}.host_id = #{Host::Managed.table_name}.id",
+        conditions: condition,
+      }
+    end
+  end
 end

data/lib/foreman_inventory_upload/async/create_missing_insights_facets.rb

@@ -7,9 +7,15 @@ module ForemanInventoryUpload
 
       def run
         organization = ::Organization.find(input[:organization_id])
-        hosts_without_facets = ::ForemanInventoryUpload::Generators::Queries.for_org(organization, hosts_query: 'null? insights_uuid')
+        # Find hosts with subscription facets but without insights facets
+        # Note: We can't use scoped_search 'null? insights_uuid' because the null? operator
+        # doesn't work with ext_methods - it would check hosts.id IS NULL instead of the facet
+        hosts_without_facets = ::ForemanInventoryUpload::Generators::Queries.for_org(organization, use_batches: false)
+                                                                            .left_outer_joins(:insights)
+                                                                            .where(insights_facets: { id: nil })
+
         facet_count = 0
-        hosts_without_facets.each do |batch|
+        hosts_without_facets.in_batches(of: ForemanInventoryUpload.slice_size) do |batch|
           facets = batch.pluck(:id, 'katello_subscription_facets.uuid').map do |host_id, uuid|
             {
               host_id: host_id,

data/lib/foreman_rh_cloud/version.rb

@@ -1,3 +1,3 @@
 module ForemanRhCloud
-  VERSION = '13.2.6'.freeze
+  VERSION = '13.2.8'.freeze
 end

data/lib/insights_cloud/async/vmaas_reposcan_sync.rb

@@ -6,6 +6,8 @@ module InsightsCloud
     class VmaasReposcanSync < ::Actions::EntryAction
       include ::ForemanRhCloud::CertAuth
 
+      HTTP_TOO_MANY_REQUESTS = 429
+
       # Subscribe to Katello repository sync hook action, if available
       def self.subscribe
         'Actions::Katello::Repository::SyncHook'.constantize
@@ -49,15 +51,9 @@ module InsightsCloud
 
         response
       rescue RestClient::ExceptionWithResponse => e
-        message = "VMaaS reposcan sync failed: #{e.response&.code} - #{e.response&.body}"
-        logger.error(message)
-        output[:message] = message
-        raise
+        handle_rest_client_error(e)
       rescue StandardError => e
-        message = "Error triggering VMaaS reposcan sync: #{e.message}, response: #{e.respond_to?(:response) ? e.response : nil}"
-        logger.error(message)
-        output[:message] = message
-        raise
+        handle_standard_error(e)
       end
 
       def rescue_strategy_for_self
@@ -70,6 +66,25 @@ module InsightsCloud
 
       private
 
+      def handle_rest_client_error(exception)
+        if exception.response&.code == HTTP_TOO_MANY_REQUESTS
+          message = "VMaaS reposcan sync skipped: another sync already in progress (#{HTTP_TOO_MANY_REQUESTS})"
+          logger.warn(message)
+        else
+          message = "VMaaS reposcan sync failed: #{exception.response&.code} - #{exception.response&.body}"
+          logger.error(message)
+        end
+        output[:message] = message
+        # Do NOT raise - let rescue_strategy_for_self Skip handle this
+      end
+
+      def handle_standard_error(exception)
+        message = "Error triggering VMaaS reposcan sync: #{exception.message}"
+        logger.error(message)
+        output[:message] = message
+        # Do NOT raise - let rescue_strategy_for_self Skip handle this
+      end
+
       def logger
         action_logger
       end

data/package.json

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

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

data/test/unit/rh_cloud_host_test.rb

@@ -188,4 +188,158 @@ class RhCloudHostTest < ActiveSupport::TestCase
       assert_equal local_uuid, @host.insights_uuid
     end
   end
+
+  context 'scoped search on insights_uuid' do
+    setup do
+      @org = FactoryBot.create(:organization)
+    end
+
+    teardown do
+      ForemanRhCloud.unstub(:with_iop_smart_proxy?)
+    end
+
+    test 'searches insights_facet.uuid in non-IoP mode with = operator' do
+      ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(false)
+      host1 = FactoryBot.create(:host, :managed, organization: @org)
+      host1.insights = FactoryBot.create(:insights_facet, host_id: host1.id, uuid: 'insights-uuid-123')
+      host2 = FactoryBot.create(:host, :managed, organization: @org)
+      host2.insights = FactoryBot.create(:insights_facet, host_id: host2.id, uuid: 'insights-uuid-456')
+
+      results = Host::Managed.search_for('insights_uuid = insights-uuid-123')
+
+      assert_includes results, host1
+      assert_not_includes results, host2
+    end
+
+    test 'searches subscription_facet.uuid in IoP mode with = operator' do
+      ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+      host1 = FactoryBot.create(:host, :managed, :with_subscription, organization: @org)
+      host2 = FactoryBot.create(:host, :managed, :with_subscription, organization: @org)
+
+      # Even if insights_facet has different UUID, should use subscription_facet UUID
+      host1.insights = FactoryBot.create(:insights_facet, host_id: host1.id, uuid: 'stale-123')
+
+      results = Host::Managed.search_for("insights_uuid = #{host1.subscription_facet.uuid}")
+
+      assert_includes results, host1
+      assert_not_includes results, host2
+    end
+
+    test 'searches with ^ operator (IN) in non-IoP mode' do
+      ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(false)
+      host1 = FactoryBot.create(:host, :managed, organization: @org)
+      host1.insights = FactoryBot.create(:insights_facet, host_id: host1.id, uuid: 'uuid-1')
+      host2 = FactoryBot.create(:host, :managed, organization: @org)
+      host2.insights = FactoryBot.create(:insights_facet, host_id: host2.id, uuid: 'uuid-2')
+      host3 = FactoryBot.create(:host, :managed, organization: @org)
+      host3.insights = FactoryBot.create(:insights_facet, host_id: host3.id, uuid: 'uuid-3')
+
+      results = Host::Managed.search_for('insights_uuid ^ (uuid-1,uuid-2)')
+
+      assert_includes results, host1
+      assert_includes results, host2
+      assert_not_includes results, host3
+    end
+
+    test 'searches with ^ operator (IN) in IoP mode - THE BUG FIX' do
+      ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+      host1 = FactoryBot.create(:host, :managed, :with_subscription, organization: @org)
+      host2 = FactoryBot.create(:host, :managed, :with_subscription, organization: @org)
+      host3 = FactoryBot.create(:host, :managed, :with_subscription, organization: @org)
+
+      # Create insights facets with stale UUIDs to verify we're using subscription_facet
+      host1.insights = FactoryBot.create(:insights_facet, host_id: host1.id, uuid: 'stale-1')
+      host2.insights = FactoryBot.create(:insights_facet, host_id: host2.id, uuid: 'stale-2')
+      host3.insights = FactoryBot.create(:insights_facet, host_id: host3.id, uuid: 'stale-3')
+
+      uuid1 = host1.subscription_facet.uuid
+      uuid2 = host2.subscription_facet.uuid
+
+      # This is the search query that remediation modal creates
+      results = Host::Managed.search_for("insights_uuid ^ (#{uuid1},#{uuid2})")
+
+      # Should find hosts by subscription_facet UUID, not insights_facet UUID
+      assert_includes results, host1
+      assert_includes results, host2
+      assert_not_includes results, host3
+    end
+
+    test 'searches with !^ operator (NOT IN) in non-IoP mode' do
+      ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(false)
+      host1 = FactoryBot.create(:host, :managed, organization: @org)
+      host1.insights = FactoryBot.create(:insights_facet, host_id: host1.id, uuid: 'uuid-1')
+      host2 = FactoryBot.create(:host, :managed, organization: @org)
+      host2.insights = FactoryBot.create(:insights_facet, host_id: host2.id, uuid: 'uuid-2')
+      host3 = FactoryBot.create(:host, :managed, organization: @org)
+      host3.insights = FactoryBot.create(:insights_facet, host_id: host3.id, uuid: 'uuid-3')
+
+      results = Host::Managed.search_for('insights_uuid !^ (uuid-1,uuid-2)')
+
+      assert_not_includes results, host1
+      assert_not_includes results, host2
+      assert_includes results, host3
+    end
+
+    test 'searches with !^ operator (NOT IN) in IoP mode' do
+      ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+      host1 = FactoryBot.create(:host, :managed, :with_subscription, organization: @org)
+      host2 = FactoryBot.create(:host, :managed, :with_subscription, organization: @org)
+      host3 = FactoryBot.create(:host, :managed, :with_subscription, organization: @org)
+
+      uuid1 = host1.subscription_facet.uuid
+      uuid2 = host2.subscription_facet.uuid
+
+      results = Host::Managed.search_for("insights_uuid !^ (#{uuid1},#{uuid2})")
+
+      assert_not_includes results, host1
+      assert_not_includes results, host2
+      assert_includes results, host3
+    end
+
+    test 'handles hosts without facets in non-IoP mode' do
+      ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(false)
+      host_without_facet = FactoryBot.create(:host, :managed, organization: @org)
+      host_with_facet = FactoryBot.create(:host, :managed, organization: @org)
+      host_with_facet.insights = FactoryBot.create(:insights_facet, host_id: host_with_facet.id, uuid: 'uuid-1')
+
+      results = Host::Managed.search_for('insights_uuid = uuid-1')
+
+      assert_includes results, host_with_facet
+      assert_not_includes results, host_without_facet
+    end
+
+    test 'handles hosts without subscription_facet in IoP mode' do
+      ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+      host_without_sub = FactoryBot.create(:host, :managed, organization: @org)
+      host_with_sub = FactoryBot.create(:host, :managed, :with_subscription, organization: @org)
+
+      uuid = host_with_sub.subscription_facet.uuid
+
+      results = Host::Managed.search_for("insights_uuid = #{uuid}")
+
+      assert_includes results, host_with_sub
+      assert_not_includes results, host_without_sub
+    end
+
+    test 'mode changes are reflected in searches' do
+      host1 = FactoryBot.create(:host, :managed, :with_subscription, organization: @org)
+      host1.insights = FactoryBot.create(:insights_facet, host_id: host1.id, uuid: 'insights-uuid-abc')
+      insights_uuid = 'insights-uuid-abc'
+      subscription_uuid = host1.subscription_facet.uuid
+
+      # Non-IoP mode: should find by insights_facet UUID
+      ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(false)
+      results = Host::Managed.search_for("insights_uuid = #{insights_uuid}")
+      assert_includes results, host1
+
+      # IoP mode: should find by subscription_facet UUID
+      ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+      results = Host::Managed.search_for("insights_uuid = #{subscription_uuid}")
+      assert_includes results, host1
+
+      # Should NOT find by old insights_facet UUID in IoP mode
+      results = Host::Managed.search_for("insights_uuid = #{insights_uuid}")
+      assert_not_includes results, host1
+    end
+  end
 end

data/webpack/CVEsHostDetailsTab/CVEsHostDetailsTab.js

@@ -10,7 +10,12 @@ const CVEsHostDetailsTab = ({ systemId }) => {
   const module = './SystemDetailTable';
   return (
     <div className="rh-cloud-insights-vulnerability-host-details-component vulnerability">
-      <ScalprumComponent scope={scope} module={module} systemId={systemId} />
+      <ScalprumComponent
+        key={systemId}
+        scope={scope}
+        module={module}
+        systemId={systemId}
+      />
     </div>
   );
 };

data/webpack/CVEsHostDetailsTab/__tests__/CVEsHostDetailsTab.test.js

@@ -11,14 +11,25 @@ jest.mock('foremanReact/Root/Context/ForemanContext', () => ({
   useForemanPermissions: () => new Set(['view_vulnerability']),
 }));
 
-jest.mock('@scalprum/react-core', () => ({
-  ScalprumComponent: jest.fn(props => (
-    <div data-testid="mock-scalprum-component">{JSON.stringify(props)}</div>
-  )),
-  ScalprumProvider: jest.fn(({ children }) => <div>{children}</div>),
-}));
+const mockUnmountTracker = jest.fn();
+jest.mock('@scalprum/react-core', () => {
+  const ReactMock = require('react');
+  return {
+    ScalprumComponent: jest.fn(props => {
+      ReactMock.useEffect(() => mockUnmountTracker, []);
+      return (
+        <div data-testid="mock-scalprum-component">{JSON.stringify(props)}</div>
+      );
+    }),
+    ScalprumProvider: jest.fn(({ children }) => <div>{children}</div>),
+  };
+});
 
 describe('CVEsHostDetailsTabWrapper', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
   it('renders without crashing', () => {
     const { container } = render(
       <CVEsHostDetailsTabWrapper
@@ -31,4 +42,32 @@ describe('CVEsHostDetailsTabWrapper', () => {
       )
     ).toBeTruthy();
   });
+
+  it('remounts ScalprumComponent when systemId changes', () => {
+    const { ScalprumComponent } = require('@scalprum/react-core');
+
+    const { rerender } = render(
+      <CVEsHostDetailsTabWrapper
+        response={{ subscription_facet_attributes: { uuid: 'uuid-host-A' } }}
+      />
+    );
+
+    expect(mockUnmountTracker).not.toHaveBeenCalled();
+    expect(ScalprumComponent).toHaveBeenLastCalledWith(
+      expect.objectContaining({ systemId: 'uuid-host-A' }),
+      expect.anything()
+    );
+
+    rerender(
+      <CVEsHostDetailsTabWrapper
+        response={{ subscription_facet_attributes: { uuid: 'uuid-host-B' } }}
+      />
+    );
+
+    expect(mockUnmountTracker).toHaveBeenCalledTimes(1);
+    expect(ScalprumComponent).toHaveBeenLastCalledWith(
+      expect.objectContaining({ systemId: 'uuid-host-B' }),
+      expect.anything()
+    );
+  });
 });

data/webpack/InsightsHostDetailsTab/NewHostDetailsTab.js

@@ -128,17 +128,32 @@ NewHostDetailsTab.defaultProps = {
 const scope = 'advisor';
 const module = './SystemDetailWrapped';
 
-const IopInsightsTab = props => (
-  <div className="advisor">
-    <ScalprumComponent
-      scope={scope}
-      module={module}
-      IopRemediationModal={RemediationModal}
-      generateRuleUrl={generateRuleUrl}
-      {...props}
-    />
-  </div>
-);
+const IopInsightsTab = props => {
+  // eslint-disable-next-line camelcase
+  const systemId = props.response?.subscription_facet_attributes?.uuid;
+  return (
+    <div className="advisor">
+      <ScalprumComponent
+        key={systemId || props.hostName}
+        scope={scope}
+        module={module}
+        IopRemediationModal={RemediationModal}
+        generateRuleUrl={generateRuleUrl}
+        {...props}
+      />
+    </div>
+  );
+};
+
+IopInsightsTab.propTypes = {
+  hostName: PropTypes.string,
+  response: PropTypes.object,
+};
+
+IopInsightsTab.defaultProps = {
+  hostName: '',
+  response: {},
+};
 
 const IopInsightsTabWrapped = props => {
   const permissions = useInsightsPermissions();

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foreman_rh_cloud
 version: !ruby/object:Gem::Version
-  version: 13.2.6
+  version: 13.2.8
 platform: ruby
 authors:
 - Foreman Red Hat Cloud team