foreman_rh_cloud 14.4.0 → 14.6.0

data/test/jobs/cloud_connector_announce_task_test.rb

@@ -1,125 +1,135 @@
-require 'json'
 require 'test_plugin_helper'
 require 'foreman_tasks/test_helpers'
-require "#{ForemanTasks::Engine.root}/test/support/dummy_dynflow_action"
 
 class CloudConnectorAnnounceTaskTest < ActiveSupport::TestCase
   include Dynflow::Testing::Factories
 
   setup do
-    RemoteExecutionFeature.register(
-      :ansible_configure_cloud_connector,
-      N_('Configure Cloud Connector on given hosts'),
-      :description => N_('Configure Cloud Connector on given hosts'),
-      :proxy_selector_override => ::RemoteExecutionProxySelector::INTERNAL_PROXY
-    )
+    InsightsCloud::Async::CloudConnectorAnnounceTask.any_instance
+                                                    .stubs(:recent_cloud_remediation?).returns(false)
+  end
+
+  teardown do
+    ForemanRhCloud.unstub(:with_iop_smart_proxy?)
+  end
+
+  test 'announces to sources for all organizations when rhc_instance_id is set' do
+    Setting[:rhc_instance_id] = 'test-rhc-id'
+
+    InsightsCloud::Async::CloudConnectorAnnounceTask.any_instance
+                                                    .stubs(:cert_auth_available?).returns(true)
 
-    @job_invocation = generate_job_invocation(:ansible_configure_cloud_connector)
+    ForemanRhCloud::CloudPresence.any_instance
+                                 .expects(:announce_to_sources)
+                                 .times(Organization.unscoped.count)
 
-    # reset connector feature ID cache
-    InsightsCloud::Async::CloudConnectorAnnounceTask.instance_variable_set(:@connector_feature_id, nil)
+    action = create_and_plan_action(InsightsCloud::Async::CloudConnectorAnnounceTask)
+    action = run_action(action)
+
+    status = action.output[:status].to_s
+    assert_match(/Registered:|Already registered:/, status)
+    refute_match(/Skipped/, status)
+    refute_match(/Failed/, status)
   end
 
-  test 'It executes cloud presence announcer' do
-    ForemanRhCloud::CloudPresence.any_instance.expects(:announce_to_sources).times(Organization.unscoped.count)
+  test 'skips when rhc_instance_id is not set' do
+    Setting[:rhc_instance_id] = nil
+
+    action = create_and_plan_action(InsightsCloud::Async::CloudConnectorAnnounceTask)
 
-    action = create_and_plan_action(InsightsCloud::Async::CloudConnectorAnnounceTask, @job_invocation)
-    finalize_action(action)
+    assert_empty action.execution_plan.planned_run_steps
   end
 
-  private
-
-  def generate_job_invocation(feature_name)
-    job_template = FactoryBot.build(
-      :job_template,
-      :template => 'BLEH'
-    )
-    feature = RemoteExecutionFeature.feature!(feature_name).id
-
-    job_invocation = FactoryBot.create(
-      :job_invocation,
-      remote_execution_feature_id: feature,
-      task_id: FactoryBot.create(:dynflow_task).id
-    )
-
-    job_template.template_inputs << playbook_url_input = FactoryBot.build(:template_input,
-      :name => 'playbook_url',
-      :input_type => 'user',
-      :required => true)
-    job_template.template_inputs << report_url_input = FactoryBot.build(:template_input,
-      :name => 'report_url',
-      :input_type => 'user',
-      :required => true)
-    job_template.template_inputs << correlation_id_input = FactoryBot.build(:template_input,
-      :name => 'correlation_id',
-      :input_type => 'user',
-      :required => true)
-    job_template.template_inputs << report_interval_input = FactoryBot.build(:template_input,
-      :name => 'report_interval',
-      :input_type => 'user',
-      :required => true)
-
-    template_invocation = FactoryBot.build(:template_invocation,
-      :template => job_template,
-      :job_invocation => job_invocation)
-
-    template_invocation.input_values << FactoryBot.create(
-      :template_invocation_input_value,
-      :template_invocation => template_invocation,
-      :template_input => playbook_url_input,
-      :value => 'http://example.com/TEST_PLAYBOOK'
-    )
-    template_invocation.input_values << FactoryBot.create(
-      :template_invocation_input_value,
-      :template_invocation => template_invocation,
-      :template_input => report_url_input,
-      :value => 'http://example.com/TEST_REPORT'
-    )
-    template_invocation.input_values << FactoryBot.create(
-      :template_invocation_input_value,
-      :template_invocation => template_invocation,
-      :template_input => correlation_id_input,
-      :value => 'TEST_CORRELATION'
-    )
-    template_invocation.input_values << FactoryBot.create(
-      :template_invocation_input_value,
-      :template_invocation => template_invocation,
-      :template_input => report_interval_input,
-      :value => '1'
-    )
-
-    @host1 = FactoryBot.create(:host, :with_insights_hits, name: 'host1')
-    @host1.insights.uuid = 'TEST_UUID1'
-    @host1.insights.save!
-    @host2 = FactoryBot.create(:host, :with_insights_hits, name: 'host2')
-    @host2.insights.uuid = 'TEST_UUID2'
-    @host2.insights.save!
-
-    targeting = FactoryBot.create(:targeting, hosts: [@host1, @host2])
-    job_invocation.targeting = targeting
-    job_invocation.save!
-
-    job_invocation.template_invocations << FactoryBot.create(
-      :template_invocation,
-      run_host_job_task: FactoryBot.create(:dynflow_task),
-      host_id: @host1.id
-    )
-    job_invocation.template_invocations << FactoryBot.create(
-      :template_invocation,
-      run_host_job_task: FactoryBot.create(:dynflow_task),
-      host_id: @host2.id
-    )
-
-    fake_output = (1..5).map do |i|
-      { 'timestamp' => (Time.now - (5 - i)).to_f, 'output' => "#{i}\n" }
-    end
-    Support::DummyDynflowAction.any_instance.stubs(:live_output).returns(fake_output)
-    Support::DummyDynflowAction.any_instance.stubs(:exit_status).returns(0)
+  test 'skips when rhc_instance_id is empty string' do
+    Setting[:rhc_instance_id] = ''
+
+    action = create_and_plan_action(InsightsCloud::Async::CloudConnectorAnnounceTask)
+
+    assert_empty action.execution_plan.planned_run_steps
+  end
+
+  test 'skips when in IoP mode' do
+    Setting[:rhc_instance_id] = 'test-rhc-id'
+    ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+
+    action = create_and_plan_action(InsightsCloud::Async::CloudConnectorAnnounceTask)
+
+    assert_empty action.execution_plan.planned_run_steps
+  end
+
+  test 'skips organizations without a manifest' do
+    Setting[:rhc_instance_id] = 'test-rhc-id'
+
+    InsightsCloud::Async::CloudConnectorAnnounceTask.any_instance
+                                                    .stubs(:cert_auth_available?).returns(false)
+
+    ForemanRhCloud::CloudPresence.any_instance
+                                 .expects(:announce_to_sources)
+                                 .never
 
-    job_invocation
+    action = create_and_plan_action(InsightsCloud::Async::CloudConnectorAnnounceTask)
+    action = run_action(action)
+
+    status = action.output[:status].to_s
+    assert_match(/Skipped \(no manifest\):/, status)
+    refute_match(/Registered/, status)
+    refute_match(/Failed/, status)
+  end
+
+  test 'still runs when allow_auto_inventory_upload is disabled' do
+    Setting[:rhc_instance_id] = 'test-rhc-id'
+    Setting[:allow_auto_inventory_upload] = false
+
+    InsightsCloud::Async::CloudConnectorAnnounceTask.any_instance
+                                                    .stubs(:cert_auth_available?).returns(true)
+
+    ForemanRhCloud::CloudPresence.any_instance
+                                 .expects(:announce_to_sources)
+                                 .times(Organization.unscoped.count)
+
+    action = create_and_plan_action(InsightsCloud::Async::CloudConnectorAnnounceTask)
+    action = run_action(action)
+
+    assert_match(/Registered:|Already registered:/, action.output[:status].to_s)
+  end
+
+  test 'skips orgs with recent cloud remediation jobs' do
+    Setting[:rhc_instance_id] = 'test-rhc-id'
+
+    InsightsCloud::Async::CloudConnectorAnnounceTask.any_instance
+                                                    .stubs(:cert_auth_available?).returns(true)
+    InsightsCloud::Async::CloudConnectorAnnounceTask.any_instance
+                                                    .stubs(:recent_cloud_remediation?).returns(true)
+
+    ForemanRhCloud::CloudPresence.any_instance
+                                 .expects(:announce_to_sources)
+                                 .never
+
+    action = create_and_plan_action(InsightsCloud::Async::CloudConnectorAnnounceTask)
+    action = run_action(action)
+
+    status = action.output[:status].to_s
+    assert_match(/Already registered \(recent cloud remediation\):/, status)
+    refute_match(/\bRegistered:/, status)
   end
 
-  def read_jsonl(jsonl)
-    jsonl.lines.map { |l| JSON.parse(l) }
+  test 'continues processing other orgs when one fails and task errors' do
+    Setting[:rhc_instance_id] = 'test-rhc-id'
+
+    InsightsCloud::Async::CloudConnectorAnnounceTask.any_instance
+                                                    .stubs(:cert_auth_available?).returns(true)
+
+    call_count = 0
+    ForemanRhCloud::CloudPresence.any_instance.stubs(:announce_to_sources).with do
+      call_count += 1
+      raise(StandardError.new('API error')) if call_count == 1
+      true
+    end
+
+    action = create_and_plan_action(InsightsCloud::Async::CloudConnectorAnnounceTask)
+
+    error = assert_raises(StandardError) { run_action(action) }
+    assert_match(/Sources announcement failed for:/, error.message)
+    assert_equal Organization.unscoped.count, call_count
   end
 end

data/test/unit/foreman_rh_cloud_iop_metadata_test.rb

@@ -101,6 +101,22 @@ class ForemanRhCloudIopMetadataTest < ActiveSupport::TestCase
       assert_equal 'https://iop.example.com', ForemanRhCloud.cert_base_url
     end
 
+    test 'cloud_cert_base_url returns IoP URL when IoP exists and force_cla_connection is off' do
+      create_iop_proxy
+      Setting[:force_cla_connection] = false
+
+      assert_equal 'https://iop.example.com', ForemanRhCloud.cloud_cert_base_url
+    end
+
+    test 'cloud_cert_base_url returns cloud URL when IoP exists and force_cla_connection is on' do
+      create_iop_proxy
+      Setting[:force_cla_connection] = true
+
+      assert_equal 'https://cert.cloud.redhat.com', ForemanRhCloud.cloud_cert_base_url
+    ensure
+      Setting[:force_cla_connection] = false
+    end
+
     test 'legacy_insights_url returns IoP URL when IoP smart proxy exists' do
       create_iop_proxy
 
@@ -153,6 +169,17 @@ class ForemanRhCloudIopMetadataTest < ActiveSupport::TestCase
       ENV.delete('SATELLITE_CERT_RH_CLOUD_URL')
     end
 
+    test 'cloud_cert_base_url uses ENV var when force_cla_connection is on' do
+      ENV['SATELLITE_CERT_RH_CLOUD_URL'] = 'https://env-cert.cloud.test'
+      Setting[:force_cla_connection] = true
+      create_iop_proxy
+
+      assert_equal 'https://env-cert.cloud.test', ForemanRhCloud.cloud_cert_base_url
+    ensure
+      ENV.delete('SATELLITE_CERT_RH_CLOUD_URL')
+      Setting[:force_cla_connection] = false
+    end
+
     test 'legacy_insights_url prefers IoP URL over ENV var' do
       ENV['SATELLITE_LEGACY_INSIGHTS_URL'] = 'https://env-legacy.insights.test'
 

data/test/unit/services/foreman_rh_cloud/cloud_request_forwarder_test.rb

@@ -10,7 +10,9 @@ class CloudRequestForwarderTest < ActiveSupport::TestCase
 
     ForemanRhCloud.stubs(:base_url).returns('https://cloud.example.com')
     ForemanRhCloud.stubs(:cert_base_url).returns('https://cert.cloud.example.com')
+    ForemanRhCloud.stubs(:cloud_cert_base_url).returns('https://cert.cloud.example.com')
     ForemanRhCloud.stubs(:legacy_insights_url).returns('https://cert-api.access.example.com')
+    ForemanRhCloud.stubs(:transformed_cloud_http_proxy_string).returns(nil)
 
     UpstreamOnlySettingsTestHelper.set_if_available('allow_multiple_content_views')
     env = FactoryBot.create(:katello_k_t_environment)
@@ -34,6 +36,7 @@ class CloudRequestForwarderTest < ActiveSupport::TestCase
 
   test 'should prepare correct cloud url' do
     paths = {
+      "/api/lightspeed/v1/query" => "https://cert.cloud.example.com/api/lightspeed/v1/query",
       "/redhat_access/r/insights/platform/module-update-router/v1/channel?module=insights-core" => "https://cert.cloud.example.com/api/module-update-router/v1/channel?module=insights-core",
       "/redhat_access/r/insights/v1/static/release/insights-core.egg" => "https://cert-api.access.example.com/r/insights/v1/static/release/insights-core.egg",
       "/redhat_access/r/insights/v1/static/uploader.v2.json" => "https://cert-api.access.example.com/r/insights/v1/static/uploader.v2.json",
@@ -50,6 +53,31 @@ class CloudRequestForwarderTest < ActiveSupport::TestCase
     end
   end
 
+  test 'does not force CLA to cloud when IoP is enabled and setting is off' do
+    ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+    ForemanRhCloud.stubs(:cert_base_url).returns('https://iop.example.com')
+    ForemanRhCloud.stubs(:cloud_cert_base_url).returns('https://iop.example.com')
+    Setting.stubs(:[]).with(:force_cla_connection).returns(false)
+
+    actual = @forwarder.path_params('/api/lightspeed/v1/query')
+
+    assert_equal 'https://iop.example.com/api/lightspeed/v1/query', actual[:url]
+    refute actual[:force_cloud]
+  end
+
+  test 'forwards CLA to cloud when IoP is enabled and force_cla_connection is on' do
+    ForemanRhCloud.stubs(:with_iop_smart_proxy?).returns(true)
+    ForemanRhCloud.stubs(:cert_base_url).returns('https://iop.example.com')
+    ForemanRhCloud.stubs(:cloud_cert_base_url).returns('https://cert.cloud.example.com')
+    ForemanRhCloud.stubs(:transformed_cloud_http_proxy_string).returns(nil)
+    Setting.stubs(:[]).with(:force_cla_connection).returns(true)
+
+    actual = @forwarder.path_params('/api/lightspeed/v1/query')
+
+    assert_equal 'https://cert.cloud.example.com/api/lightspeed/v1/query', actual[:url]
+    assert actual[:force_cloud]
+  end
+
   test 'should forward payload from request parameters' do
     params = { 'pumpkin' => 'pie' }
     req = ActionDispatch::Request.new(

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

@@ -3,24 +3,16 @@ import { render, screen, fireEvent } from '@testing-library/react';
 import { Provider } from 'react-redux';
 import configureMockStore from 'redux-mock-store';
 import thunk from 'redux-thunk';
-import * as API from 'foremanReact/redux/API';
 import ConnectedSyncButton from '../index';
-import { successResponse } from './SyncButtonFixtures';
-import { INVENTORY_SYNC } from '../SyncButtonConstants';
-
-jest.spyOn(API, 'post');
 
 const mockStore = configureMockStore([thunk]);
 
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
 describe('SyncButton integration test', () => {
   it('dispatches sync action when button is clicked', () => {
-    API.post.mockImplementation(({ handleSuccess, key, ...action }) => {
-      if (key === INVENTORY_SYNC && handleSuccess) {
-        handleSuccess(successResponse);
-      }
-      return { type: 'API_POST', ...action };
-    });
-
     const store = mockStore({
       API: {},
     });

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

@@ -1,82 +1,83 @@
 import React from 'react';
-import { shallow } from '@theforeman/test';
+import { render, screen } from '@testing-library/react';
+import { MemoryRouter } from 'react-router-dom';
+import '@testing-library/jest-dom';
 import Toast from '../Toast';
 
+jest.mock('foremanReact/common/I18n', () => ({
+  translate: jest.fn(str => str),
+}));
+
+const renderToast = (props = {}) =>
+  render(
+    <MemoryRouter>
+      <Toast syncHosts={5} disconnectHosts={3} {...props} />
+    </MemoryRouter>
+  );
+
+const omittedText =
+  'Excluded from upload to console.redhat.com Inventory service because host_registration_insights_inventory parameter value is false:';
+
 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);
+    renderToast({ userOmittedHosts: 2 });
 
-    // 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');
+    expect(screen.getByRole('link', { name: '10' })).toHaveAttribute(
+      'href',
+      '/new/hosts?search=set%3F+subscription_uuid&page=1'
+    );
+    expect(screen.getByRole('link', { name: '5' })).toHaveAttribute(
+      'href',
+      '/new/hosts?search=insights_inventory_sync_status+%3D+sync&page=1'
+    );
+    expect(screen.getByRole('link', { name: '3' })).toHaveAttribute(
+      'href',
+      '/new/hosts?search=insights_inventory_sync_status+%3D+disconnect&page=1'
+    );
+    expect(screen.getByRole('link', { name: '2' })).toHaveAttribute(
+      'href',
+      '/new/hosts?search=insights_inventory_sync_status+%3D+user_omitted&page=1'
+    );
+    expect(screen.getByText(omittedText, { exact: false })).toBeInTheDocument();
   });
 
   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);
+    renderToast({ userOmittedHosts: 0 });
 
-    // Should not contain the user_omitted explanation text
-    expect(wrapper.text()).not.toContain(
-      'host_registration_insights_inventory parameter value is false'
-    );
+    expect(screen.getByRole('link', { name: '8' })).toBeInTheDocument();
+    expect(screen.getByRole('link', { name: '5' })).toBeInTheDocument();
+    expect(screen.getByRole('link', { name: '3' })).toBeInTheDocument();
+    expect(screen.queryByRole('link', { name: '2' })).not.toBeInTheDocument();
+    expect(
+      screen.queryByText(omittedText, { exact: false })
+    ).not.toBeInTheDocument();
   });
 
   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);
+    renderToast();
 
-    // Verify the count values
+    expect(screen.getByRole('link', { name: '8' })).toBeInTheDocument();
+    expect(screen.getByRole('link', { name: '5' })).toBeInTheDocument();
+    expect(screen.getByRole('link', { name: '3' })).toBeInTheDocument();
     expect(
-      links
-        .at(0)
-        .children()
-        .text()
-    ).toBe('5');
-    expect(
-      links
-        .at(1)
-        .children()
-        .text()
-    ).toBe('3');
+      screen.queryByText(omittedText, { exact: false })
+    ).not.toBeInTheDocument();
   });
 
   it('renders correct status links for each category', () => {
-    const wrapper = shallow(
-      <Toast syncHosts={5} disconnectHosts={3} userOmittedHosts={2} />
-    );
+    renderToast({ 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');
+    expect(screen.getByRole('link', { name: '5' })).toHaveAttribute(
+      'href',
+      expect.stringContaining('sync')
+    );
+    expect(screen.getByRole('link', { name: '3' })).toHaveAttribute(
+      'href',
+      expect.stringContaining('disconnect')
+    );
+    expect(screen.getByRole('link', { name: '2' })).toHaveAttribute(
+      'href',
+      expect.stringContaining('user_omitted')
+    );
   });
 });

data/webpack/InsightsCloudSync/Components/InsightsTable/__tests__/InsightsTableActions.test.js

@@ -117,10 +117,10 @@ describe('InsightsTable actions', () => {
       expect(push).toHaveBeenCalled();
 
       const apiAction = dispatch.mock.calls.find(
-        call => call[0] && call[0].key === INSIGHTS_HITS_API_KEY
+        call => call[0] && call[0].payload?.key === INSIGHTS_HITS_API_KEY
       );
       expect(apiAction).toBeTruthy();
-      const getArg = apiAction[0];
+      const getArg = apiAction[0].payload;
       expect(getArg.url).toBe(INSIGHTS_HITS_PATH);
       expect(getArg.params.page).toBe(2);
       expect(getArg.params.per_page).toBe(7);

data/webpack/InsightsCloudSync/__tests__/InsightsCloudSyncActions.test.js

@@ -1,3 +1,4 @@
+import { API_OPERATIONS } from 'foremanReact/redux/API';
 import { syncInsights } from '../InsightsCloudSyncActions';
 import { INSIGHTS_CLOUD_SYNC } from '../InsightsCloudSyncConstants';
 
@@ -17,17 +18,18 @@ describe('InsightsCloudSync actions', () => {
 
     expect(dispatch).toHaveBeenCalledTimes(1);
     const dispatched = dispatch.mock.calls[0][0];
-    expect(dispatched.key).toBe(INSIGHTS_CLOUD_SYNC);
-    expect(dispatched.url).toBe('/insights_cloud/tasks');
-    expect(typeof dispatched.handleSuccess).toBe('function');
-    expect(typeof dispatched.errorToast).toBe('function');
+    expect(dispatched.type).toBe(API_OPERATIONS.POST);
+    expect(dispatched.payload.key).toBe(INSIGHTS_CLOUD_SYNC);
+    expect(dispatched.payload.url).toBe('/insights_cloud/tasks');
+    expect(typeof dispatched.payload.handleSuccess).toBe('function');
+    expect(typeof dispatched.payload.errorToast).toBe('function');
   });
 
   it('errorToast returns failure message with error details', () => {
     syncInsights(jest.fn(), '')(dispatch);
     const dispatched = dispatch.mock.calls[0][0];
 
-    const result = dispatched.errorToast('some error');
+    const result = dispatched.payload.errorToast('some error');
     expect(result).toContain('some error');
   });
 });

data/webpack/InsightsHostDetailsTab/__tests__/InsightsTabIntegration.test.js

@@ -1,17 +1,78 @@
 import React from 'react';
-import { IntegrationTestHelper } from '@theforeman/test';
+import { screen, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { Provider } from 'react-redux';
+import { applyMiddleware, combineReducers, createStore } from 'redux';
+import thunk from 'redux-thunk';
+import { rtlHelpers } from 'foremanReact/common/rtlTestHelpers';
+import { API } from 'foremanReact/redux/API';
 
 import InsightsTab from '../index';
 import reducers from '../../ForemanRhCloudReducers';
-import { hostID } from './InsightsTab.fixtures';
+import { INSIGHTS_HITS_SUCCESS } from '../InsightsTabConstants';
+import { hostID, hits } from './InsightsTab.fixtures';
 
-describe('InsightsTab integration test', () => {
-  it('should flow', async () => {
-    const integrationTestHelper = new IntegrationTestHelper(reducers);
-    const component = integrationTestHelper.mount(
+const { renderWithI18n } = rtlHelpers;
+
+jest.mock('foremanReact/redux/API');
+
+const recommendationTitle =
+  'New Ansible Engine packages are inaccessible when dedicated Ansible repo is not enabled';
+
+const createTabStore = () =>
+  createStore(combineReducers({ ...reducers }), applyMiddleware(thunk));
+
+const renderConnectedTab = (store = createTabStore()) =>
+  renderWithI18n(
+    <Provider store={store}>
       <InsightsTab hostID={hostID} />
+    </Provider>
+  );
+
+describe('InsightsTab integration test', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('requests hits for the host and shows empty state when there are none', async () => {
+    let resolveHits;
+    API.get.mockReturnValue(
+      new Promise(resolve => {
+        resolveHits = resolve;
+      })
     );
-    component.update();
-    /** Create a Flow test */
+
+    const store = createTabStore();
+    store.dispatch({
+      type: INSIGHTS_HITS_SUCCESS,
+      payload: { hits },
+    });
+
+    renderConnectedTab(store);
+
+    expect(await screen.findByText(recommendationTitle)).toBeInTheDocument();
+
+    await waitFor(() => {
+      expect(API.get).toHaveBeenCalledWith(`/insights_cloud/hits/${hostID}`);
+    });
+
+    resolveHits({ data: { hits: [] } });
+
+    expect(
+      await screen.findByRole('heading', {
+        name: 'No recommendations were found for this host!',
+      })
+    ).toBeInTheDocument();
+    expect(screen.queryByText(recommendationTitle)).not.toBeInTheDocument();
+  });
+
+  it('shows recommendation titles from the hits API response', async () => {
+    API.get.mockResolvedValue({ data: { hits } });
+
+    renderConnectedTab();
+
+    expect(await screen.findByText(recommendationTitle)).toBeInTheDocument();
+
+    expect(API.get).toHaveBeenCalledWith(`/insights_cloud/hits/${hostID}`);
   });
 });

data/webpack/InsightsVulnerabilityActionsBar/__tests__/InsightsVulnerabilityActionsBar.test.js

@@ -1,13 +1,11 @@
 import React from 'react';
 import { render, screen } from '@testing-library/react';
 import '@testing-library/jest-dom';
-import * as ForemanContext from 'foremanReact/Root/Context/ForemanContext';
 import { ForemanHostsIndexActionsBarContext } from 'foremanReact/components/HostsIndex';
 import * as ConfigHooks from '../../common/Hooks/ConfigHooks';
 import InsightsVulnerabilityActionsBar from '../index';
 
 jest.mock('../../common/Hooks/ConfigHooks');
-jest.mock('foremanReact/Root/Context/ForemanContext');
 jest.mock('../InsightsVulnerabilityActionsBarActions');
 
 const mockContextValue = {
@@ -16,11 +14,9 @@ const mockContextValue = {
   setMenuOpen: jest.fn(),
 };
 
-const renderComponent = (contextOverrides = {}, orgId = 1) => {
+const renderComponent = (contextOverrides = {}) => {
   const contextValue = { ...mockContextValue, ...contextOverrides };
 
-  ForemanContext.useForemanOrganization.mockReturnValue({ id: orgId });
-
   return render(
     <ForemanHostsIndexActionsBarContext.Provider value={contextValue}>
       <InsightsVulnerabilityActionsBar />