foreman_rh_cloud 13.0.12 → 13.1.0

data/webpack/InsightsVulnerabilityHostIndexExtensions/CVECountCell.js

@@ -1,19 +1,24 @@
-import React from 'react';
+import React, { useEffect } from 'react';
 import PropTypes from 'prop-types';
-import { UnknownIcon } from '@patternfly/react-icons';
+import { useDispatch } from 'react-redux';
+import { translate as __ } from 'foremanReact/common/I18n';
 import { Link } from 'react-router-dom';
 import { useAPI } from 'foremanReact/common/hooks/API/APIHooks';
+import { propsToCamelCase } from 'foremanReact/common/helpers';
 import { insightsCloudUrl } from '../InsightsCloudSync/InsightsCloudSyncHelpers';
 import { useIopConfig } from '../common/Hooks/ConfigHooks';
+import { updateHostVulnerabilityOptOut } from '../HostsIndexExtensions/hostVulnerabilityStoreUtils';
 
 const vulnerabilityApiPath = path =>
   insightsCloudUrl(`api/vulnerability/v1/${path}`);
 
 export const CVECountCell = ({ hostDetails }) => {
   const isIopEnabled = useIopConfig();
+  const dispatch = useDispatch();
 
   // eslint-disable-next-line camelcase
   const uuid = hostDetails?.subscription_facet_attributes?.uuid;
+  const hostId = hostDetails?.id;
 
   const key = `HOST_CVE_COUNT_${uuid}`;
   const response = useAPI(
@@ -24,24 +29,31 @@ export const CVECountCell = ({ hostDetails }) => {
     }
   );
 
-  if (!isIopEnabled) {
-    return <UnknownIcon />;
-  }
+  const { cveCount, optOut } = propsToCamelCase(
+    (response.response?.data || [])[0]?.attributes || {}
+  );
+
+  // Update HOSTS Redux data when CVE data loads
+  // This triggers table re-render so kebab actions recompute with correct opt_out value
+  useEffect(() => {
+    if (optOut !== undefined && hostId) {
+      updateHostVulnerabilityOptOut(hostId, optOut, dispatch);
+    }
+  }, [optOut, hostId, dispatch]);
 
-  if (uuid === undefined) {
-    return <UnknownIcon />;
+  if (!isIopEnabled || uuid === undefined) {
+    return '—';
   }
 
-  // eslint-disable-next-line camelcase
-  const { cve_count } = (response.response?.data || [])[0]?.attributes || {};
+  if (optOut === true) {
+    return __('Analysis disabled');
+  }
 
   const cveLink = (
-    // eslint-disable-next-line camelcase
-    <Link to={`hosts/${hostDetails.name}#/Vulnerabilities`}>{cve_count}</Link>
+    <Link to={`hosts/${hostDetails.name}#/Vulnerabilities`}>{cveCount}</Link>
   );
 
-  // eslint-disable-next-line camelcase
-  return cve_count === undefined ? <UnknownIcon /> : cveLink;
+  return cveCount == null ? '—' : cveLink;
 };
 
 CVECountCell.propTypes = {

data/webpack/InsightsVulnerabilityHostIndexExtensions/__tests__/CVECountCell.test.js

@@ -1,129 +1,198 @@
 import React from 'react';
-import { screen } from '@testing-library/react';
-import { rtlHelpers } from 'foremanReact/common/rtlTestHelpers';
-import { API } from 'foremanReact/redux/API';
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import { Provider } from 'react-redux';
+import { ConnectedRouter } from 'connected-react-router';
+import { createMemoryHistory } from 'history';
+import configureMockStore from 'redux-mock-store';
+import { STATUS } from 'foremanReact/constants';
+import * as APIHooks from 'foremanReact/common/hooks/API/APIHooks';
+import * as ConfigHooks from '../../common/Hooks/ConfigHooks';
 import { CVECountCell } from '../CVECountCell';
 
-jest.mock('foremanReact/redux/API');
+jest.mock('foremanReact/common/hooks/API/APIHooks');
 jest.mock('../../common/Hooks/ConfigHooks');
 
-const { renderWithStore } = rtlHelpers;
-
-API.get.mockImplementation(async () => ({
-  data: [
-    {
-      attributes: {
-        cve_count: 1,
-      },
+const mockStore = configureMockStore();
+const history = createMemoryHistory();
+const store = mockStore({
+  router: {
+    location: {
+      pathname: '/',
+      search: '',
+      hash: '',
+      state: null,
     },
-  ],
-}));
+    action: 'POP',
+  },
+});
 
 const hostDetailsMock = {
+  id: 1,
   name: 'test-host.example.com',
   subscription_facet_attributes: {
     uuid: 'test-uuid-123',
   },
 };
 
+const renderComponent = (props = {}) => {
+  const allProps = {
+    hostDetails: hostDetailsMock,
+    ...props,
+  };
+
+  return render(
+    <Provider store={store}>
+      <ConnectedRouter history={history}>
+        <CVECountCell {...allProps} />
+      </ConnectedRouter>
+    </Provider>
+  );
+};
+
 describe('CVECountCell', () => {
-  afterEach(() => {
+  beforeEach(() => {
+    store.clearActions();
     jest.clearAllMocks();
   });
 
   it('renders an empty cves count column when no subscription UUID', () => {
-    const hostDetailsMockIoP = {
+    ConfigHooks.useIopConfig.mockReturnValue(true);
+    APIHooks.useAPI.mockReturnValue({
+      status: STATUS.RESOLVED,
+      response: null,
+    });
+
+    const hostDetailsMockNoUuid = {
       name: 'test-host.example.com',
       subscription_facet_attributes: {
         uuid: null, // no subscription
       },
     };
-    renderWithStore(<CVECountCell hostDetails={hostDetailsMockIoP} />, {
-      router: {
-        location: {
-          pathname: '/',
-          search: '',
-          hash: '',
-          query: {},
-        },
-      },
-      API: {
-        ADVISOR_ENGINE_CONFIG: {
-          response: { use_iop_mode: true },
-          status: 'RESOLVED',
-        },
-      },
+
+    renderComponent({ hostDetails: hostDetailsMockNoUuid });
+    expect(screen.getByText('—')).toBeInTheDocument();
+  });
+
+  it('renders — when IoP is not enabled', () => {
+    ConfigHooks.useIopConfig.mockReturnValue(false);
+    APIHooks.useAPI.mockReturnValue({
+      status: STATUS.RESOLVED,
+      response: null,
     });
-    expect(screen.getByRole('img', { hidden: true })).toBeTruthy();
+
+    renderComponent();
+    expect(screen.getByText('—')).toBeInTheDocument();
   });
 
-  it('renders UnknownIcon when IoP is not enabled', () => {
-    renderWithStore(<CVECountCell hostDetails={hostDetailsMock} />, {
-      router: {
-        location: {
-          pathname: '/',
-          search: '',
-          hash: '',
-          query: {},
-        },
-      },
-      API: {
-        ADVISOR_ENGINE_CONFIG: {
-          response: { use_iop_mode: false },
-          status: 'RESOLVED',
-        },
-      },
+  it('renders — when IoP is enabled but CVE API call fails', () => {
+    ConfigHooks.useIopConfig.mockReturnValue(true);
+    APIHooks.useAPI.mockReturnValue({
+      status: STATUS.ERROR,
+      response: null,
     });
-    expect(screen.getByRole('img', { hidden: true })).toBeTruthy();
+
+    renderComponent();
+    expect(screen.getByText('—')).toBeInTheDocument();
   });
 
-  it('renders UnknownIcon when IoP is enabled but CVE API call fails', () => {
-    // Mock CVE API failure - override the global mock for this test
-    API.get.mockImplementationOnce(async () => {
-      throw new Error('CVE API call failed');
+  it('renders — when IoP is undefined (API call pending)', () => {
+    ConfigHooks.useIopConfig.mockReturnValue(undefined);
+    APIHooks.useAPI.mockReturnValue({
+      status: STATUS.PENDING,
+      response: null,
     });
 
-    renderWithStore(<CVECountCell hostDetails={hostDetailsMock} />, {
-      router: {
-        location: {
-          pathname: '/',
-          search: '',
-          hash: '',
-          query: {},
-        },
+    renderComponent();
+    expect(screen.getByText('—')).toBeInTheDocument();
+  });
+
+  it('renders "Analysis disabled" when opt_out is true', () => {
+    ConfigHooks.useIopConfig.mockReturnValue(true);
+    APIHooks.useAPI.mockReturnValue({
+      status: STATUS.RESOLVED,
+      response: {
+        data: [
+          {
+            attributes: {
+              opt_out: true,
+            },
+          },
+        ],
       },
-      API: {
-        ADVISOR_ENGINE_CONFIG: {
-          response: { use_iop_mode: true },
-          status: 'RESOLVED',
-        },
-        // Mock the API failure state for the CVE endpoint
-        [`HOST_CVE_COUNT_${hostDetailsMock.subscription_facet_attributes.uuid}`]: {
-          status: 'ERROR',
-          error: 'CVE API call failed',
-        },
+    });
+
+    renderComponent();
+    expect(screen.getByText('Analysis disabled')).toBeInTheDocument();
+  });
+
+  it('renders CVE count link when valid count is returned', () => {
+    ConfigHooks.useIopConfig.mockReturnValue(true);
+    APIHooks.useAPI.mockReturnValue({
+      status: STATUS.RESOLVED,
+      response: {
+        data: [
+          {
+            attributes: {
+              cve_count: 1,
+            },
+          },
+        ],
       },
     });
-    // Should render UnknownIcon when CVE API fails
-    expect(screen.getByRole('img', { hidden: true })).toBeTruthy();
+
+    renderComponent();
+
+    // Should render a link with the CVE count
+    const link = screen.getByRole('link');
+    expect(link).toBeInTheDocument();
+    expect(link).toHaveTextContent('1');
+    expect(link).toHaveAttribute(
+      'href',
+      `/hosts/${hostDetailsMock.name}#/Vulnerabilities`
+    );
   });
 
-  it('renders UnknownIcon when IoP is undefined (API call pending)', () => {
-    renderWithStore(<CVECountCell hostDetails={hostDetailsMock} />, {
-      router: {
-        location: {
-          pathname: '/',
-          search: '',
-          hash: '',
-          query: {},
-        },
+  it('renders — when cve_count is null (analysis enabled but not scanned yet)', () => {
+    ConfigHooks.useIopConfig.mockReturnValue(true);
+    APIHooks.useAPI.mockReturnValue({
+      status: STATUS.RESOLVED,
+      response: {
+        data: [
+          {
+            attributes: {
+              cve_count: null, // null when enabled but not scanned
+              opt_out: false,
+            },
+          },
+        ],
       },
-      API: {
-        ADVISOR_ENGINE_CONFIG: {
-          status: 'PENDING',
-        },
+    });
+
+    renderComponent();
+    expect(screen.getByText('—')).toBeInTheDocument();
+  });
+
+  it('renders 0 CVE count link when count is 0', () => {
+    ConfigHooks.useIopConfig.mockReturnValue(true);
+    APIHooks.useAPI.mockReturnValue({
+      status: STATUS.RESOLVED,
+      response: {
+        data: [
+          {
+            attributes: {
+              cve_count: 0,
+            },
+          },
+        ],
       },
     });
-    expect(screen.getByRole('img', { hidden: true })).toBeTruthy();
+
+    renderComponent();
+
+    // Should render a link with 0
+    const link = screen.getByRole('link');
+    expect(link).toBeInTheDocument();
+    expect(link).toHaveTextContent('0');
   });
 });

data/webpack/__mocks__/foremanReact/Root/Context/ForemanContext.js

@@ -1,2 +1,6 @@
-export const useForemanSettings = () => ({ perPage: 20 });
-export const useForemanOrganization = () => ({ title: 'some-org' });
+export const useForemanSettings = jest.fn(() => ({ perPage: 20 }));
+export const useForemanOrganization = jest.fn(() => ({
+  id: 1,
+  title: 'some-org',
+}));
+export const useForemanContext = jest.fn(() => ({ metadata: {} }));

data/webpack/__mocks__/foremanReact/common/I18n.js

@@ -2,4 +2,5 @@ export { sprintf } from 'jed';
 
 export const translate = s => s;
 
-export const ngettext = s => s;
+export const ngettext = (singular, plural, count) =>
+  count === 1 ? singular : plural;

data/webpack/__mocks__/foremanReact/common/helpers.js

@@ -1,3 +1,14 @@
+import camelCase from 'lodash/camelCase';
+
 export const getURIQuery = jest.fn(() => ({}));
 
 export const noop = Function.prototype;
+
+export const propsToCamelCase = ob => {
+  if (typeof ob !== 'object' || ob === null) return ob;
+
+  return Object.keys(ob).reduce((memo, key) => {
+    memo[camelCase(key)] = ob[key];
+    return memo;
+  }, {});
+};

data/webpack/__mocks__/foremanReact/components/HostsIndex/index.js

@@ -0,0 +1,8 @@
+import React from 'react';
+
+export const ForemanHostsIndexActionsBarContext = React.createContext({
+  fetchBulkParams: jest.fn(() => ''),
+  selectedCount: 0,
+  selectAllMode: false,
+  setMenuOpen: jest.fn(),
+});

data/webpack/__mocks__/foremanReact/redux.js

@@ -0,0 +1,10 @@
+const mockStore = {
+  dispatch: jest.fn(),
+  getState: jest.fn(() => ({
+    API: {},
+  })),
+  subscribe: jest.fn(),
+  replaceReducer: jest.fn(),
+};
+
+export default mockStore;

data/webpack/common/Hooks/ConfigHooks.js

@@ -2,4 +2,4 @@ import { useForemanContext } from 'foremanReact/Root/Context/ForemanContext';
 
 export const useIopConfig = () =>
   // eslint-disable-next-line camelcase
-  useForemanContext().metadata?.foreman_rh_cloud?.iop;
+  useForemanContext().metadata?.foreman_rh_cloud?.iop === true;

data/webpack/global_index.js

@@ -1,10 +1,17 @@
 import { registerColumns } from 'foremanReact/components/HostsIndex/Columns/core';
+import { registerGetActions } from 'foremanReact/components/HostsIndex/TableRowActions/core';
 import { registerReducers } from './ForemanRhCloudReducers';
 import { registerFills } from './ForemanRhCloudFills';
 import { registerRoutes } from './ForemanRhCloudPages';
 import hostsIndexColumnExtensions from './ForemanColumnExtensions/index';
+import getVulnerabilityAnalysisActions from './HostsIndexExtensions/VulnerabilityAnalysisActions';
 
 registerReducers();
 registerFills();
 registerRoutes();
 registerColumns(hostsIndexColumnExtensions);
+registerGetActions({
+  pluginName: 'foreman_rh_cloud',
+  getActionsFunc: getVulnerabilityAnalysisActions,
+  tableName: 'hosts',
+});

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foreman_rh_cloud
 version: !ruby/object:Gem::Version
-  version: 13.0.12
+  version: 13.1.0
 platform: ruby
 authors:
 - Foreman Red Hat Cloud team
@@ -513,6 +513,9 @@ files:
 - webpack/ForemanRhCloudReducers.js
 - webpack/ForemanRhCloudSelectors.js
 - webpack/ForemanRhCloudTestHelpers.js
+- webpack/HostsIndexExtensions/VulnerabilityAnalysisActions.js
+- webpack/HostsIndexExtensions/__tests__/VulnerabilityAnalysisActions.test.js
+- webpack/HostsIndexExtensions/hostVulnerabilityStoreUtils.js
 - webpack/InsightsCloudSync/Components/InsightsSettings/InsightsSettings.js
 - webpack/InsightsCloudSync/Components/InsightsSettings/InsightsSettingsActions.js
 - webpack/InsightsCloudSync/Components/InsightsSettings/InsightsSettingsConstants.js
@@ -592,6 +595,11 @@ files:
 - webpack/InsightsHostDetailsTab/index.js
 - webpack/InsightsVulnerability/InsightsVulnerabilityListPage.js
 - webpack/InsightsVulnerability/InsightsVulnerabilityListPage.test.js
+- webpack/InsightsVulnerabilityActionsBar/InsightsVulnerabilityActionsBar.scss
+- webpack/InsightsVulnerabilityActionsBar/InsightsVulnerabilityActionsBarActions.js
+- webpack/InsightsVulnerabilityActionsBar/__tests__/InsightsVulnerabilityActionsBar.test.js
+- webpack/InsightsVulnerabilityActionsBar/__tests__/InsightsVulnerabilityActionsBarActions.test.js
+- webpack/InsightsVulnerabilityActionsBar/index.js
 - webpack/InsightsVulnerabilityHostIndexExtensions/CVECountCell.js
 - webpack/InsightsVulnerabilityHostIndexExtensions/__tests__/CVECountCell.test.js
 - webpack/IopRecommendationDetails/IopRecommendationDetails.js
@@ -601,10 +609,12 @@ files:
 - webpack/__mocks__/foremanReact/common/helpers.js
 - webpack/__mocks__/foremanReact/components/ConfirmModal/index.js
 - webpack/__mocks__/foremanReact/components/Head.js
+- webpack/__mocks__/foremanReact/components/HostsIndex/index.js
 - webpack/__mocks__/foremanReact/components/Layout/LayoutConstants.js
 - webpack/__mocks__/foremanReact/components/ToastsList/index.js
 - webpack/__mocks__/foremanReact/components/common/dates/RelativeDateTime.js
 - webpack/__mocks__/foremanReact/constants.js
+- webpack/__mocks__/foremanReact/redux.js
 - webpack/__mocks__/foremanReact/redux/API/APISelectors.js
 - webpack/__mocks__/foremanReact/redux/API/index.js
 - webpack/__mocks__/foremanReact/redux/middlewares/IntervalMiddleware.js