foreman_rh_cloud 14.0.3 → 14.1.1

data/test/unit/rh_cloud_host_test.rb

@@ -188,4 +188,218 @@ 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
+
+  test 'scoped search for user_omitted inventory status works' do
+    host1 = FactoryBot.create(:host, :managed)
+    host2 = FactoryBot.create(:host, :managed)
+    host3 = FactoryBot.create(:host, :managed)
+
+    # Create different inventory statuses
+    InventorySync::InventoryStatus.create!(
+      host_id: host1.id,
+      status: InventorySync::InventoryStatus::SYNC,
+      reported_at: Time.zone.now
+    )
+
+    InventorySync::InventoryStatus.create!(
+      host_id: host2.id,
+      status: InventorySync::InventoryStatus::DISCONNECT,
+      reported_at: Time.zone.now
+    )
+
+    InventorySync::InventoryStatus.create!(
+      host_id: host3.id,
+      status: InventorySync::InventoryStatus::USER_OMITTED,
+      reported_at: Time.zone.now
+    )
+
+    # Search for user_omitted status
+    results = Host.search_for('insights_inventory_sync_status = user_omitted')
+    result_ids = results.pluck(:id)
+
+    assert_includes result_ids, host3.id, 'Host with USER_OMITTED status should be in search results'
+    assert_not_includes result_ids, host1.id, 'Host with SYNC status should not be in search results'
+    assert_not_includes result_ids, host2.id, 'Host with DISCONNECT status should not be in search results'
+  end
+
+  test 'scoped search for user_omitted insights client report status works' do
+    host1 = FactoryBot.create(:host, :managed)
+    host2 = FactoryBot.create(:host, :managed)
+    host3 = FactoryBot.create(:host, :managed)
+
+    # Create different insights client report statuses
+    status1 = host1.get_status(InsightsClientReportStatus)
+    status1.status = InsightsClientReportStatus::REPORTING
+    status1.save!
+
+    status2 = host2.get_status(InsightsClientReportStatus)
+    status2.status = InsightsClientReportStatus::NO_REPORT
+    status2.save!
+
+    status3 = host3.get_status(InsightsClientReportStatus)
+    status3.status = InsightsClientReportStatus::USER_OMITTED
+    status3.save!
+
+    # Search for user_omitted status
+    results = Host.search_for('insights_client_report_status = user_omitted')
+    result_ids = results.pluck(:id)
+
+    assert_includes result_ids, host3.id, 'Host with USER_OMITTED status should be in search results'
+    assert_not_includes result_ids, host1.id, 'Host with REPORTING status should not be in search results'
+    assert_not_includes result_ids, host2.id, 'Host with NO_REPORT status should not be in search results'
+  end
 end

data/webpack/CVEsHostDetailsTab/CVEsHostDetailsTab.js

@@ -3,6 +3,10 @@ import PropTypes from 'prop-types';
 import { ScalprumComponent, ScalprumProvider } from '@scalprum/react-core';
 import { createProviderOptions } from '../common/ScalprumModule/ScalprumContext';
 import { useInsightsPermissions } from '../common/Hooks/PermissionsHooks';
+import {
+  vulnerabilityDisabled,
+  useTabRedirect,
+} from '../ForemanRhCloudHelpers';
 import './CVEsHostDetailsTab.scss';
 
 const CVEsHostDetailsTab = ({ systemId }) => {
@@ -10,7 +14,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>
   );
 };
@@ -21,6 +30,15 @@ CVEsHostDetailsTab.propTypes = {
 
 const CVEsHostDetailsTabWrapper = ({ response }) => {
   const permissions = useInsightsPermissions();
+  const isHostDataLoaded = Boolean(response?.id);
+  const shouldHideTab = useTabRedirect(
+    isHostDataLoaded && vulnerabilityDisabled({ hostDetails: response })
+  );
+
+  if (shouldHideTab) {
+    return null;
+  }
+
   return (
     <ScalprumProvider {...createProviderOptions(permissions)}>
       <CVEsHostDetailsTab
@@ -33,10 +51,19 @@ const CVEsHostDetailsTabWrapper = ({ response }) => {
 
 CVEsHostDetailsTabWrapper.propTypes = {
   response: PropTypes.shape({
+    id: PropTypes.number,
+    operatingsystem_name: PropTypes.string,
+    vulnerability: PropTypes.shape({
+      enabled: PropTypes.bool,
+    }),
     subscription_facet_attributes: PropTypes.shape({
-      uuid: PropTypes.string.isRequired,
+      uuid: PropTypes.string,
     }),
-  }).isRequired,
+  }),
+};
+
+CVEsHostDetailsTabWrapper.defaultProps = {
+  response: {},
 };
 
 export default CVEsHostDetailsTabWrapper;

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

@@ -1,6 +1,17 @@
 import React from 'react';
 import { render } from '@testing-library/react';
+import { MemoryRouter } from 'react-router-dom';
 import CVEsHostDetailsTabWrapper from '../CVEsHostDetailsTab';
+import { OVERVIEW_TAB_PATH } from '../../ForemanRhCloudHelpers';
+
+const mockHistoryReplace = jest.fn();
+
+jest.mock('react-router-dom', () => ({
+  ...jest.requireActual('react-router-dom'),
+  useHistory: () => ({
+    replace: mockHistoryReplace,
+  }),
+}));
 
 jest.mock('foremanReact/Root/Context/ForemanContext', () => ({
   useForemanContext: () => ({
@@ -11,24 +22,115 @@ 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>),
+  };
+});
+
+const defaultResponse = {
+  id: 1,
+  operatingsystem_name: 'Red Hat Enterprise Linux 8',
+  vulnerability: { enabled: true },
+  subscription_facet_attributes: { uuid: '1-2-3' },
+};
 
 describe('CVEsHostDetailsTabWrapper', () => {
-  it('renders without crashing', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('renders without crashing and does not redirect for valid host', () => {
     const { container } = render(
-      <CVEsHostDetailsTabWrapper
-        response={{ subscription_facet_attributes: { uuid: '1-2-3' } }}
-      />
+      <MemoryRouter>
+        <CVEsHostDetailsTabWrapper response={defaultResponse} />
+      </MemoryRouter>
     );
     expect(
       container.querySelector(
         '.rh-cloud-insights-vulnerability-host-details-component'
       )
     ).toBeTruthy();
+    expect(mockHistoryReplace).not.toHaveBeenCalled();
+  });
+
+  it('remounts ScalprumComponent when systemId changes', () => {
+    const { ScalprumComponent } = require('@scalprum/react-core');
+
+    const responseHostA = {
+      ...defaultResponse,
+      subscription_facet_attributes: { uuid: 'uuid-host-A' },
+    };
+
+    const { rerender } = render(
+      <MemoryRouter>
+        <CVEsHostDetailsTabWrapper response={responseHostA} />
+      </MemoryRouter>
+    );
+
+    expect(mockUnmountTracker).not.toHaveBeenCalled();
+    expect(ScalprumComponent).toHaveBeenLastCalledWith(
+      expect.objectContaining({ systemId: 'uuid-host-A' }),
+      expect.anything()
+    );
+
+    const responseHostB = {
+      ...defaultResponse,
+      subscription_facet_attributes: { uuid: 'uuid-host-B' },
+    };
+
+    rerender(
+      <MemoryRouter>
+        <CVEsHostDetailsTabWrapper response={responseHostB} />
+      </MemoryRouter>
+    );
+
+    expect(mockUnmountTracker).toHaveBeenCalledTimes(1);
+    expect(ScalprumComponent).toHaveBeenLastCalledWith(
+      expect.objectContaining({ systemId: 'uuid-host-B' }),
+      expect.anything()
+    );
+  });
+
+  it('redirects to Overview when tab should be hidden', () => {
+    const nonRhelResponse = {
+      id: 2,
+      operatingsystem_name: 'Ubuntu 20.04',
+      vulnerability: { enabled: false },
+      subscription_facet_attributes: { uuid: '1-2-3' },
+    };
+
+    const { container } = render(
+      <MemoryRouter>
+        <CVEsHostDetailsTabWrapper response={nonRhelResponse} />
+      </MemoryRouter>
+    );
+
+    expect(mockHistoryReplace).toHaveBeenCalledWith(OVERVIEW_TAB_PATH);
+    expect(
+      container.querySelector(
+        '.rh-cloud-insights-vulnerability-host-details-component'
+      )
+    ).toBeNull();
+  });
+
+  it('does not redirect when host data is not yet loaded', () => {
+    const emptyResponse = { subscription_facet_attributes: { uuid: '1-2-3' } };
+
+    render(
+      <MemoryRouter>
+        <CVEsHostDetailsTabWrapper response={emptyResponse} />
+      </MemoryRouter>
+    );
+
+    expect(mockHistoryReplace).not.toHaveBeenCalled();
   });
 });

data/webpack/ForemanInventoryUpload/Components/PageHeader/components/SyncButton/SyncButtonActions.js

@@ -39,14 +39,20 @@ export const setupInventorySyncTaskPolling = (id, dispatch) =>
     key: INVENTORY_SYNC_TASK_UPDATE,
     onTaskSuccess: ({
       output: {
-        host_statuses: { sync, disconnect },
+        host_statuses: { sync, disconnect, user_omitted: userOmitted },
       },
     }) =>
       dispatch(
         addToast({
           sticky: true,
           type: 'success',
-          message: <Toast syncHosts={sync} disconnectHosts={disconnect} />,
+          message: (
+            <Toast
+              syncHosts={sync}
+              disconnectHosts={disconnect}
+              userOmittedHosts={userOmitted}
+            />
+          ),
         })
       ),
     dispatch,

data/webpack/ForemanInventoryUpload/Components/PageHeader/components/SyncButton/__tests__/__snapshots__/integrations.test.js.snap

@@ -9,6 +9,7 @@ Array [
           "message": <Toast
             disconnectHosts={2}
             syncHosts={0}
+            userOmittedHosts={1}
           />,
           "sticky": true,
           "type": "success",

data/webpack/ForemanInventoryUpload/Components/PageHeader/components/SyncButton/__tests__/integrations.test.js

@@ -30,6 +30,7 @@ describe('SyncButton integration test', () => {
                 host_statuses: {
                   sync: 0,
                   disconnect: 2,
+                  user_omitted: 1,
                 },
               },
               result: 'success',

data/webpack/ForemanInventoryUpload/Components/PageHeader/components/SyncButton/components/Toast.js

@@ -1,33 +1,55 @@
 import React from 'react';
+import { Link } from 'react-router-dom';
 import PropTypes from 'prop-types';
 import { translate as __ } from 'foremanReact/common/I18n';
-import { foremanUrl } from '../../../../../../ForemanRhCloudHelpers';
 
-const Toast = ({ syncHosts, disconnectHosts }) => {
-  const totalHosts = syncHosts + disconnectHosts;
+const statusSearchParams = statusName =>
+  `/new/hosts?search=insights_inventory_sync_status+%3D+${statusName}&page=1`;
+const DISCONNECT = 'disconnect';
+const SYNC = 'sync';
+const USER_OMITTED = 'user_omitted';
+const HostsWithStatusLink = ({ statusName, children }) => (
+  <Link to={statusSearchParams(statusName)}>{children}</Link>
+);
+HostsWithStatusLink.propTypes = {
+  statusName: PropTypes.string.isRequired,
+  children: PropTypes.node.isRequired,
+};
+
+const Toast = ({ syncHosts, disconnectHosts, userOmittedHosts }) => {
+  const totalHosts = syncHosts + disconnectHosts + userOmittedHosts;
   return (
     <span>
       <p>
-        {__('Hosts with subscription in organization: ')}
-        <strong>{totalHosts}</strong>
+        {__('Registered hosts in organization: ')}
+        <Link to="/new/hosts?search=set%3F+subscription_uuid&page=1">
+          {totalHosts}
+        </Link>
       </p>
       <p>
-        {__('Successfully synced hosts: ')}
-        <strong>{syncHosts}</strong>
+        {__('Uploaded and present on console.redhat.com Inventory service: ')}
+        <HostsWithStatusLink statusName={SYNC}>{syncHosts}</HostsWithStatusLink>
       </p>
       <p>
-        {__('Disconnected hosts: ')}
-        <strong>{disconnectHosts}</strong>
+        {__('Not present on console.redhat.com Inventory service: ')}
+        <HostsWithStatusLink statusName={DISCONNECT}>
+          {disconnectHosts}
+        </HostsWithStatusLink>
       </p>
+      {!!userOmittedHosts && (
+        <p>
+          {__(
+            'Excluded from upload to console.redhat.com Inventory service because host_registration_insights_inventory parameter value is false: '
+          )}
+          <HostsWithStatusLink statusName={USER_OMITTED}>
+            {userOmittedHosts}
+          </HostsWithStatusLink>
+        </p>
+      )}
       <p>
-        {__('For more info, please visit the')}{' '}
-        <a
-          href={foremanUrl('/hosts')}
-          target="_blank"
-          rel="noopener noreferrer"
-        >
-          {__('hosts page')}
-        </a>
+        {__(
+          'You can review this information later by looking at the Inventory status of each host.'
+        )}
       </p>
     </span>
   );
@@ -36,6 +58,10 @@ const Toast = ({ syncHosts, disconnectHosts }) => {
 Toast.propTypes = {
   syncHosts: PropTypes.number.isRequired,
   disconnectHosts: PropTypes.number.isRequired,
+  userOmittedHosts: PropTypes.number,
+};
+Toast.defaultProps = {
+  userOmittedHosts: 0,
 };
 
 export default Toast;

data/webpack/ForemanInventoryUpload/Components/PageHeader/components/SyncButton/components/__tests__/Toast.test.js

@@ -0,0 +1,82 @@
+import React from 'react';
+import { shallow } from '@theforeman/test';
+import Toast from '../Toast';
+
+describe('Toast', () => {
+  it('renders with all three status counts including user_omitted', () => {
+    const wrapper = shallow(
+      <Toast syncHosts={5} disconnectHosts={3} userOmittedHosts={2} />
+    );
+
+    const links = wrapper.find('HostsWithStatusLink');
+    expect(links).toHaveLength(3);
+
+    // Check the children (numbers) of each link
+    expect(
+      links
+        .at(0)
+        .children()
+        .text()
+    ).toBe('5');
+    expect(
+      links
+        .at(1)
+        .children()
+        .text()
+    ).toBe('3');
+    expect(
+      links
+        .at(2)
+        .children()
+        .text()
+    ).toBe('2');
+  });
+
+  it('does not render user_omitted section when count is 0', () => {
+    const wrapper = shallow(
+      <Toast syncHosts={5} disconnectHosts={3} userOmittedHosts={0} />
+    );
+
+    // Should have only 2 HostsWithStatusLink components (sync and disconnect)
+    const links = wrapper.find('HostsWithStatusLink');
+    expect(links).toHaveLength(2);
+
+    // Should not contain the user_omitted explanation text
+    expect(wrapper.text()).not.toContain(
+      'host_registration_insights_inventory parameter value is false'
+    );
+  });
+
+  it('renders without crashing when userOmittedHosts is not provided (default)', () => {
+    const wrapper = shallow(<Toast syncHosts={5} disconnectHosts={3} />);
+
+    // Should use default value of 0, so only 2 links
+    const links = wrapper.find('HostsWithStatusLink');
+    expect(links).toHaveLength(2);
+
+    // Verify the count values
+    expect(
+      links
+        .at(0)
+        .children()
+        .text()
+    ).toBe('5');
+    expect(
+      links
+        .at(1)
+        .children()
+        .text()
+    ).toBe('3');
+  });
+
+  it('renders correct status links for each category', () => {
+    const wrapper = shallow(
+      <Toast syncHosts={5} disconnectHosts={3} userOmittedHosts={2} />
+    );
+
+    const links = wrapper.find('HostsWithStatusLink');
+    expect(links.at(0).prop('statusName')).toBe('sync');
+    expect(links.at(1).prop('statusName')).toBe('disconnect');
+    expect(links.at(2).prop('statusName')).toBe('user_omitted');
+  });
+});

data/webpack/ForemanRhCloudHelpers.js

@@ -1,3 +1,6 @@
+import { useEffect } from 'react';
+import { useHistory } from 'react-router-dom';
+
 /**
  * copied from core, since it's not in the ReactApp folder,
  * it's complicated to import it and mock it in tests.
@@ -5,6 +8,25 @@
  */
 export const foremanUrl = path => `${window.URL_PREFIX}${path}`;
 
+export const OVERVIEW_TAB_PATH = '/Overview';
+
+/**
+ * Redirects to Overview tab when the current tab should be hidden
+ * @param {boolean} shouldRedirect - Whether to redirect (e.g., host loaded AND tab should hide)
+ * @returns {boolean} - Returns shouldRedirect for convenience
+ */
+export const useTabRedirect = shouldRedirect => {
+  const history = useHistory();
+
+  useEffect(() => {
+    if (shouldRedirect && history) {
+      history.replace(OVERVIEW_TAB_PATH);
+    }
+  }, [shouldRedirect, history]);
+
+  return shouldRedirect;
+};
+
 export const isNotRhelHost = ({ hostDetails }) =>
   // This regex tries matches sane variations of "RedHat", "RHEL" and "RHCOS"
   !new RegExp('red[\\s\\-]?hat|rh[\\s\\-]?el|rhc[\\s\\-]?os', 'i').test(