foreman_rh_cloud 13.0.12 → 13.1.0

data/webpack/InsightsVulnerabilityActionsBar/InsightsVulnerabilityActionsBarActions.js

@@ -0,0 +1,169 @@
+import { translate as __, sprintf, ngettext } from 'foremanReact/common/I18n';
+import { addToast } from 'foremanReact/components/ToastsList';
+import store from 'foremanReact/redux';
+import { insightsCloudUrl } from '../InsightsCloudSync/InsightsCloudSyncHelpers';
+import { foremanUrl } from '../ForemanRhCloudHelpers';
+
+const vulnerabilityApiPath = path =>
+  insightsCloudUrl(`api/vulnerability/v1/${path}`);
+
+const getCSRFToken = () =>
+  document.querySelector('meta[name="csrf-token"]')?.content || '';
+
+const fetchHostUuids = async searchQuery => {
+  const response = await fetch(
+    foremanUrl(`/api/hosts?search=${encodeURIComponent(searchQuery)}`),
+    {
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+      },
+    }
+  );
+
+  if (!response.ok) {
+    throw new Error(__('Failed to fetch hosts'));
+  }
+
+  const data = await response.json();
+  const totalHosts = data.results.length;
+  const uuids = data.results
+    .map(host => host.subscription_facet_attributes?.uuid)
+    .filter(Boolean);
+
+  return { uuids, totalHosts, hostsWithoutUuid: totalHosts - uuids.length };
+};
+
+const updateCveCountCache = (uuids, optOutValue) => {
+  const state = store.getState();
+
+  uuids.forEach(uuid => {
+    const apiKey = `HOST_CVE_COUNT_${uuid}`;
+    const cveData = state.API?.[apiKey];
+
+    if (cveData?.response?.data) {
+      store.dispatch({
+        type: `${apiKey}_SUCCESS`,
+        key: apiKey,
+        response: {
+          ...cveData.response,
+          data: cveData.response.data.map(system => ({
+            ...system,
+            attributes: {
+              ...system.attributes,
+              opt_out: optOutValue,
+            },
+          })),
+        },
+      });
+    }
+  });
+};
+
+const callOptOutApi = async (uuids, optOutValue) => {
+  const csrfToken = getCSRFToken();
+
+  const response = await fetch(vulnerabilityApiPath('systems/opt_out'), {
+    method: 'PATCH',
+    headers: {
+      'Content-Type': 'application/vnd.api+json',
+      'X-CSRF-Token': csrfToken,
+    },
+    body: JSON.stringify({
+      inventory_id: uuids,
+      opt_out: optOutValue,
+    }),
+  });
+
+  if (!response.ok) {
+    let errorMessage = __('Failed to update vulnerability analysis status');
+
+    try {
+      const errorBody = await response.json();
+      if (
+        errorBody?.errors?.[0]?.detail &&
+        typeof errorBody.errors[0].detail === 'string' &&
+        errorBody.errors[0].detail.trim() !== ''
+      ) {
+        errorMessage = errorBody.errors[0].detail;
+      }
+    } catch (e) {
+      // JSON parse failed, use generic message
+    }
+
+    throw new Error(errorMessage);
+  }
+
+  return uuids.length;
+};
+
+export const handleBulkOptOut = async (fetchBulkParams, optOutValue) => {
+  try {
+    const searchQuery = fetchBulkParams();
+    const { uuids, hostsWithoutUuid } = await fetchHostUuids(searchQuery);
+
+    if (uuids.length === 0) {
+      store.dispatch(
+        addToast({
+          type: 'warning',
+          message: __('None of the selected hosts are registered'),
+        })
+      );
+      return;
+    }
+
+    const count = await callOptOutApi(uuids, optOutValue);
+
+    updateCveCountCache(uuids, optOutValue);
+
+    const message = optOutValue
+      ? sprintf(
+          ngettext(
+            'Vulnerability analysis disabled for %s host',
+            'Vulnerability analysis disabled for %s hosts',
+            count
+          ),
+          count
+        )
+      : sprintf(
+          ngettext(
+            'Vulnerability analysis enabled for %s host',
+            'Vulnerability analysis enabled for %s hosts',
+            count
+          ),
+          count
+        );
+
+    store.dispatch(
+      addToast({
+        type: 'success',
+        message,
+      })
+    );
+
+    if (hostsWithoutUuid > 0) {
+      store.dispatch(
+        addToast({
+          type: 'warning',
+          message: sprintf(
+            ngettext(
+              '%s host was skipped because it is not registered',
+              '%s hosts were skipped because they are not registered',
+              hostsWithoutUuid
+            ),
+            hostsWithoutUuid
+          ),
+        })
+      );
+    }
+  } catch (error) {
+    const errorMessage =
+      error.message || __('Failed to update vulnerability analysis status');
+    store.dispatch(
+      addToast({
+        type: 'error',
+        message: errorMessage,
+      })
+    );
+  }
+};

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

@@ -0,0 +1,91 @@
+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 = {
+  fetchBulkParams: jest.fn(() => 'id ^ (1,2,3)'),
+  selectedCount: 3,
+  setMenuOpen: jest.fn(),
+};
+
+const renderComponent = (contextOverrides = {}, orgId = 1) => {
+  const contextValue = { ...mockContextValue, ...contextOverrides };
+
+  ForemanContext.useForemanOrganization.mockReturnValue({ id: orgId });
+
+  return render(
+    <ForemanHostsIndexActionsBarContext.Provider value={contextValue}>
+      <InsightsVulnerabilityActionsBar />
+    </ForemanHostsIndexActionsBarContext.Provider>
+  );
+};
+
+describe('InsightsVulnerabilityActionsBar', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('when IoP is disabled', () => {
+    beforeEach(() => {
+      ConfigHooks.useIopConfig.mockReturnValue(false);
+    });
+
+    it('renders nothing', () => {
+      const { container } = renderComponent();
+      expect(container.firstChild).toBeNull();
+    });
+  });
+
+  describe('when IoP config returns false (converted system)', () => {
+    beforeEach(() => {
+      ConfigHooks.useIopConfig.mockReturnValue(false);
+    });
+
+    it('renders nothing', () => {
+      const { container } = renderComponent();
+      expect(container.firstChild).toBeNull();
+    });
+  });
+
+  describe('when IoP is enabled', () => {
+    beforeEach(() => {
+      ConfigHooks.useIopConfig.mockReturnValue(true);
+    });
+
+    it('renders the menu item', () => {
+      renderComponent();
+      expect(
+        screen.getByText('Manage vulnerability analysis')
+      ).toBeInTheDocument();
+    });
+
+    it('disables menu when no hosts are selected', () => {
+      renderComponent({ selectedCount: 0 });
+      const menuItem = screen.getByText('Manage vulnerability analysis');
+      expect(menuItem.closest('button')).toBeDisabled();
+    });
+
+    it('enables menu when hosts are selected', () => {
+      renderComponent({ selectedCount: 3 });
+      const menuItem = screen.getByText('Manage vulnerability analysis');
+      expect(menuItem.closest('button')).not.toBeDisabled();
+    });
+
+    it('renders menu item with flyout indicator', () => {
+      renderComponent();
+      const menuItem = screen.getByText('Manage vulnerability analysis');
+      const button = menuItem.closest('button');
+
+      // Button should have aria-haspopup indicating it has a flyout menu
+      expect(button).toHaveAttribute('aria-haspopup', 'menu');
+    });
+  });
+});

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

@@ -0,0 +1,299 @@
+import store from 'foremanReact/redux';
+import { handleBulkOptOut } from '../InsightsVulnerabilityActionsBarActions';
+
+jest.mock('../../InsightsCloudSync/InsightsCloudSyncHelpers', () => ({
+  insightsCloudUrl: jest.fn(path => `/foreman_rh_cloud/${path}`),
+}));
+jest.mock('../../ForemanRhCloudHelpers', () => ({
+  foremanUrl: jest.fn(path => path),
+}));
+
+global.fetch = jest.fn();
+Object.defineProperty(document, 'querySelector', {
+  value: jest.fn(() => ({ content: 'test-csrf-token' })),
+  writable: true,
+});
+
+const hostWithUuid = id => ({
+  id,
+  subscription_facet_attributes: { uuid: `uuid${id}` },
+});
+const successResponse = () => ({ ok: true, json: async () => ({}) });
+
+describe('InsightsVulnerabilityActionsBarActions', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    store.getState.mockReturnValue({ API: {} });
+  });
+
+  describe('handleBulkOptOut', () => {
+    const mockFetchBulkParams = jest.fn(() => 'id ^ (1,2,3)');
+
+    it('shows warning toast when no hosts are registered', async () => {
+      global.fetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          results: [
+            { id: 1, name: 'host1' },
+            { id: 2, name: 'host2' },
+          ],
+        }),
+      });
+
+      await handleBulkOptOut(mockFetchBulkParams, true);
+
+      expect(store.dispatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'TOASTS_ADD',
+          payload: expect.objectContaining({
+            message: expect.objectContaining({
+              type: 'warning',
+              message: 'None of the selected hosts are registered',
+            }),
+          }),
+        })
+      );
+    });
+
+    it('calls opt_out API with correct parameters for disable', async () => {
+      global.fetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({ results: [hostWithUuid(1), hostWithUuid(2)] }),
+        })
+        .mockResolvedValueOnce(successResponse());
+
+      await handleBulkOptOut(mockFetchBulkParams, true);
+
+      expect(global.fetch).toHaveBeenCalledTimes(2);
+      expect(global.fetch).toHaveBeenLastCalledWith(
+        '/foreman_rh_cloud/api/vulnerability/v1/systems/opt_out',
+        expect.objectContaining({
+          method: 'PATCH',
+          headers: expect.objectContaining({
+            'Content-Type': 'application/vnd.api+json',
+            'X-CSRF-Token': 'test-csrf-token',
+          }),
+          body: JSON.stringify({
+            inventory_id: ['uuid1', 'uuid2'],
+            opt_out: true,
+          }),
+        })
+      );
+    });
+
+    it('calls opt_out API with correct parameters for enable', async () => {
+      global.fetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({ results: [hostWithUuid(1)] }),
+        })
+        .mockResolvedValueOnce(successResponse());
+
+      await handleBulkOptOut(mockFetchBulkParams, false);
+
+      expect(global.fetch).toHaveBeenLastCalledWith(
+        '/foreman_rh_cloud/api/vulnerability/v1/systems/opt_out',
+        expect.objectContaining({
+          body: JSON.stringify({
+            inventory_id: ['uuid1'],
+            opt_out: false,
+          }),
+        })
+      );
+    });
+
+    it('shows success toast with singular message for 1 host', async () => {
+      global.fetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({ results: [hostWithUuid(1)] }),
+        })
+        .mockResolvedValueOnce(successResponse());
+
+      await handleBulkOptOut(mockFetchBulkParams, true);
+
+      expect(store.dispatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'TOASTS_ADD',
+          payload: expect.objectContaining({
+            message: expect.objectContaining({
+              type: 'success',
+              message: 'Vulnerability analysis disabled for 1 host',
+            }),
+          }),
+        })
+      );
+    });
+
+    it('shows success toast with plural message for multiple hosts', async () => {
+      global.fetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({ results: [hostWithUuid(1), hostWithUuid(2)] }),
+        })
+        .mockResolvedValueOnce(successResponse());
+
+      await handleBulkOptOut(mockFetchBulkParams, false);
+
+      expect(store.dispatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'TOASTS_ADD',
+          payload: expect.objectContaining({
+            message: expect.objectContaining({
+              type: 'success',
+              message: 'Vulnerability analysis enabled for 2 hosts',
+            }),
+          }),
+        })
+      );
+    });
+
+    it('shows warning toast for unregistered hosts', async () => {
+      global.fetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({
+            results: [
+              hostWithUuid(1),
+              { id: 2, name: 'host-without-uuid' },
+              { id: 3, subscription_facet_attributes: {} },
+            ],
+          }),
+        })
+        .mockResolvedValueOnce(successResponse());
+
+      await handleBulkOptOut(mockFetchBulkParams, true);
+
+      expect(store.dispatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'TOASTS_ADD',
+          payload: expect.objectContaining({
+            message: expect.objectContaining({
+              type: 'success',
+            }),
+          }),
+        })
+      );
+      expect(store.dispatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'TOASTS_ADD',
+          payload: expect.objectContaining({
+            message: expect.objectContaining({
+              type: 'warning',
+              message: '2 hosts were skipped because they are not registered',
+            }),
+          }),
+        })
+      );
+    });
+
+    it('shows error toast when fetch hosts fails', async () => {
+      global.fetch.mockResolvedValueOnce({
+        ok: false,
+      });
+
+      await handleBulkOptOut(mockFetchBulkParams, true);
+
+      expect(store.dispatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'TOASTS_ADD',
+          payload: expect.objectContaining({
+            message: expect.objectContaining({
+              type: 'error',
+              message: 'Failed to fetch hosts',
+            }),
+          }),
+        })
+      );
+    });
+
+    it('shows error toast when opt_out API fails', async () => {
+      global.fetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({ results: [hostWithUuid(1)] }),
+        })
+        .mockResolvedValueOnce({
+          ok: false,
+          json: async () => ({
+            errors: [{ detail: 'Custom API error message' }],
+          }),
+        });
+
+      await handleBulkOptOut(mockFetchBulkParams, true);
+
+      expect(store.dispatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'TOASTS_ADD',
+          payload: expect.objectContaining({
+            message: expect.objectContaining({
+              type: 'error',
+              message: 'Custom API error message',
+            }),
+          }),
+        })
+      );
+    });
+
+    it('shows generic error message when API error has no detail', async () => {
+      global.fetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({ results: [hostWithUuid(1)] }),
+        })
+        .mockResolvedValueOnce({
+          ok: false,
+          json: async () => ({}),
+        });
+
+      await handleBulkOptOut(mockFetchBulkParams, true);
+
+      expect(store.dispatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'TOASTS_ADD',
+          payload: expect.objectContaining({
+            message: expect.objectContaining({
+              type: 'error',
+              message: 'Failed to update vulnerability analysis status',
+            }),
+          }),
+        })
+      );
+    });
+
+    it('updates CVE count cache after successful API call', async () => {
+      store.getState.mockReturnValue({
+        API: {
+          HOST_CVE_COUNT_uuid1: {
+            response: { data: [{ attributes: { opt_out: false } }] },
+          },
+        },
+      });
+      global.fetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: async () => ({ results: [hostWithUuid(1)] }),
+        })
+        .mockResolvedValueOnce(successResponse());
+
+      await handleBulkOptOut(mockFetchBulkParams, true);
+
+      expect(store.dispatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'HOST_CVE_COUNT_uuid1_SUCCESS',
+          key: 'HOST_CVE_COUNT_uuid1',
+          response: expect.objectContaining({
+            data: [
+              expect.objectContaining({
+                attributes: expect.objectContaining({
+                  opt_out: true,
+                }),
+              }),
+            ],
+          }),
+        })
+      );
+    });
+  });
+});

data/webpack/InsightsVulnerabilityActionsBar/index.js

@@ -0,0 +1,93 @@
+import React, { useContext } from 'react';
+import PropTypes from 'prop-types';
+import { Menu, MenuItem, MenuContent, MenuList } from '@patternfly/react-core';
+import { BanIcon } from '@patternfly/react-icons';
+import { translate as __ } from 'foremanReact/common/I18n';
+import { ForemanHostsIndexActionsBarContext } from 'foremanReact/components/HostsIndex';
+import { useForemanOrganization } from 'foremanReact/Root/Context/ForemanContext';
+import { useIopConfig } from '../common/Hooks/ConfigHooks';
+import { handleBulkOptOut } from './InsightsVulnerabilityActionsBarActions';
+import './InsightsVulnerabilityActionsBar.scss';
+
+const DisabledMenuItemDescription = ({ disabledReason }) => (
+  <span className="disabled-menu-item-span">
+    <span className="disabled-menu-item-icon">
+      <BanIcon />
+    </span>
+    <p className="disabled-menu-item-p">{disabledReason}</p>
+  </span>
+);
+
+DisabledMenuItemDescription.propTypes = {
+  disabledReason: PropTypes.string.isRequired,
+};
+
+const InsightsVulnerabilityActionsBar = () => {
+  const isIopEnabled = useIopConfig();
+  const { fetchBulkParams, selectedCount, setMenuOpen } = useContext(
+    ForemanHostsIndexActionsBarContext
+  );
+  const orgId = useForemanOrganization()?.id;
+  const isDisabled = selectedCount === 0 || !orgId;
+
+  const handleEnable = () => handleBulkOptOut(fetchBulkParams, false);
+  const handleDisable = () => handleBulkOptOut(fetchBulkParams, true);
+
+  if (!isIopEnabled) {
+    return null;
+  }
+
+  const orgRequiredDescription = __(
+    'A specific organization must be selected from the organization context.'
+  );
+
+  return (
+    <MenuItem
+      itemId="vulnerability-flyout-item"
+      isDisabled={selectedCount === 0}
+      flyoutMenu={
+        <Menu
+          ouiaId="vulnerability-flyout-menu"
+          onSelect={() => setMenuOpen(false)}
+        >
+          <MenuContent>
+            <MenuList>
+              <MenuItem
+                itemId="enable-vulnerability-management-item"
+                isDisabled={isDisabled}
+                onClick={handleEnable}
+                description={
+                  !orgId && (
+                    <DisabledMenuItemDescription
+                      disabledReason={orgRequiredDescription}
+                    />
+                  )
+                }
+              >
+                {__('Enable')}
+              </MenuItem>
+              <MenuItem
+                itemId="disable-vulnerability-management-item"
+                isDisabled={isDisabled}
+                onClick={handleDisable}
+                description={
+                  !orgId && (
+                    <DisabledMenuItemDescription
+                      disabledReason={orgRequiredDescription}
+                    />
+                  )
+                }
+              >
+                {__('Disable')}
+              </MenuItem>
+            </MenuList>
+          </MenuContent>
+        </Menu>
+      }
+    >
+      {__('Manage vulnerability analysis')}
+    </MenuItem>
+  );
+};
+
+export default InsightsVulnerabilityActionsBar;