foreman_rh_cloud 13.0.12 → 13.1.0

data/webpack/HostsIndexExtensions/__tests__/VulnerabilityAnalysisActions.test.js

@@ -0,0 +1,567 @@
+/* eslint-disable max-lines */
+// Create mocks
+const mockGetState = jest.fn();
+const mockDispatch = jest.fn();
+const mockPatch = jest.fn();
+const mockGet = jest.fn();
+
+// Mock modules
+jest.mock('../hostVulnerabilityStoreUtils');
+jest.mock(
+  'foremanReact/redux',
+  () => ({
+    __esModule: true,
+    default: {
+      getState: () => mockGetState(),
+      dispatch: action => mockDispatch(action),
+    },
+  }),
+  { virtual: true }
+);
+jest.mock(
+  'foremanReact/redux/API',
+  () => ({
+    patch: (...args) => mockPatch(...args),
+    get: (...args) => mockGet(...args),
+  }),
+  { virtual: true }
+);
+
+// Import after mocking
+// eslint-disable-next-line import/first
+import * as storeUtils from '../hostVulnerabilityStoreUtils';
+// eslint-disable-next-line import/first
+import getVulnerabilityAnalysisActions from '../VulnerabilityAnalysisActions';
+
+describe('VulnerabilityAnalysisActions', () => {
+  beforeEach(() => {
+    mockGetState.mockReturnValue({ API: {} });
+    mockDispatch.mockImplementation(action => action);
+    jest.clearAllMocks();
+  });
+
+  describe('getVulnerabilityAnalysisActions', () => {
+    it('returns empty array when not in IoP mode', () => {
+      const hostDetails = {
+        id: 1,
+        insights_attributes: {
+          use_iop_mode: false,
+        },
+        subscription_facet_attributes: {
+          uuid: 'test-uuid',
+        },
+      };
+
+      const actions = getVulnerabilityAnalysisActions(hostDetails);
+
+      expect(actions).toEqual([]);
+    });
+
+    it('returns empty array when host has no subscription UUID', () => {
+      const hostDetails = {
+        id: 1,
+        insights_attributes: {
+          use_iop_mode: true,
+        },
+        subscription_facet_attributes: {
+          uuid: null,
+        },
+      };
+
+      const actions = getVulnerabilityAnalysisActions(hostDetails);
+
+      expect(actions).toEqual([]);
+    });
+
+    it('returns empty array when API returned empty data (no system record)', () => {
+      mockGetState.mockReturnValue({
+        API: {
+          'HOST_CVE_COUNT_test-uuid': {
+            response: {
+              data: [], // Empty array means no system record exists
+            },
+          },
+        },
+      });
+
+      const hostDetails = {
+        id: 1,
+        insights_attributes: {
+          use_iop_mode: true,
+        },
+        subscription_facet_attributes: {
+          uuid: 'test-uuid',
+        },
+      };
+
+      const actions = getVulnerabilityAnalysisActions(hostDetails);
+
+      expect(actions).toEqual([]);
+    });
+
+    it('returns empty array when opt_out is undefined (data not loaded yet)', () => {
+      mockGetState.mockReturnValue({
+        API: {
+          'HOST_CVE_COUNT_test-uuid': {
+            response: null,
+          },
+        },
+      });
+
+      const hostDetails = {
+        id: 1,
+        insights_attributes: {
+          use_iop_mode: true,
+        },
+        subscription_facet_attributes: {
+          uuid: 'test-uuid',
+        },
+      };
+
+      const actions = getVulnerabilityAnalysisActions(hostDetails);
+
+      expect(actions).toEqual([]);
+    });
+
+    it('returns "Enable vulnerability analysis" action when opt_out is true', () => {
+      const hostDetails = {
+        id: 1,
+        insights_attributes: {
+          use_iop_mode: true,
+          vulnerability_opt_out: true,
+        },
+        subscription_facet_attributes: {
+          uuid: 'test-uuid',
+        },
+      };
+
+      mockPatch.mockReturnValue({ type: 'MOCK_PATCH_ACTION' });
+
+      const actions = getVulnerabilityAnalysisActions(hostDetails);
+
+      expect(actions).toHaveLength(1);
+      expect(actions[0].title).toBe('Enable vulnerability analysis');
+      expect(actions[0].onClick).toBeDefined();
+
+      // Trigger onClick to verify it dispatches correctly
+      actions[0].onClick();
+
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: 'MOCK_PATCH_ACTION',
+      });
+      expect(mockPatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          key: 'HOST_CVE_COUNT_test-uuid',
+          params: {
+            inventory_id: 'test-uuid',
+            opt_out: false, // Should toggle to false
+          },
+        })
+      );
+    });
+
+    it('returns "Disable vulnerability analysis" action when opt_out is false', () => {
+      const hostDetails = {
+        id: 1,
+        insights_attributes: {
+          use_iop_mode: true,
+          vulnerability_opt_out: false,
+        },
+        subscription_facet_attributes: {
+          uuid: 'test-uuid',
+        },
+      };
+
+      mockPatch.mockReturnValue({ type: 'MOCK_PATCH_ACTION' });
+
+      const actions = getVulnerabilityAnalysisActions(hostDetails);
+
+      expect(actions).toHaveLength(1);
+      expect(actions[0].title).toBe('Disable vulnerability analysis');
+      expect(actions[0].onClick).toBeDefined();
+
+      // Trigger onClick to verify it dispatches correctly
+      actions[0].onClick();
+
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: 'MOCK_PATCH_ACTION',
+      });
+      expect(mockPatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          key: 'HOST_CVE_COUNT_test-uuid',
+          params: {
+            inventory_id: 'test-uuid',
+            opt_out: true, // Should toggle to true
+          },
+        })
+      );
+    });
+
+    it('falls back to CVE API cache when opt_out not set on host object', () => {
+      mockGetState.mockReturnValue({
+        API: {
+          'HOST_CVE_COUNT_test-uuid': {
+            response: {
+              data: [
+                {
+                  attributes: {
+                    opt_out: true,
+                  },
+                },
+              ],
+            },
+          },
+        },
+      });
+
+      const hostDetails = {
+        id: 1,
+        insights_attributes: {
+          use_iop_mode: true,
+          // No vulnerability_opt_out set
+        },
+        subscription_facet_attributes: {
+          uuid: 'test-uuid',
+        },
+      };
+
+      mockPatch.mockReturnValue({ type: 'MOCK_PATCH_ACTION' });
+
+      const actions = getVulnerabilityAnalysisActions(hostDetails);
+
+      expect(actions).toHaveLength(1);
+      expect(actions[0].title).toBe('Enable vulnerability analysis');
+    });
+  });
+
+  describe('handleToggle action creator', () => {
+    it('creates patch action with correct parameters', () => {
+      const mockPatchAction = { type: 'MOCK_PATCH_ACTION' };
+      mockPatch.mockReturnValue(mockPatchAction);
+
+      const hostDetails = {
+        id: 123,
+        insights_attributes: {
+          use_iop_mode: true,
+          vulnerability_opt_out: false,
+        },
+        subscription_facet_attributes: {
+          uuid: 'test-uuid-456',
+        },
+      };
+
+      const actions = getVulnerabilityAnalysisActions(hostDetails);
+      actions[0].onClick();
+
+      expect(mockPatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          key: 'HOST_CVE_COUNT_test-uuid-456',
+          url: expect.stringContaining('api/vulnerability/v1/systems/opt_out'),
+          params: {
+            inventory_id: 'test-uuid-456',
+            opt_out: true,
+          },
+          headers: {
+            'Content-Type': 'application/vnd.api+json',
+          },
+        })
+      );
+    });
+
+    it('includes updateData callback when disabling (optimistic update)', () => {
+      mockPatch.mockReturnValue({ type: 'MOCK_PATCH_ACTION' });
+
+      const hostDetails = {
+        id: 1,
+        insights_attributes: {
+          use_iop_mode: true,
+          vulnerability_opt_out: false,
+        },
+        subscription_facet_attributes: {
+          uuid: 'test-uuid',
+        },
+      };
+
+      const actions = getVulnerabilityAnalysisActions(hostDetails);
+      actions[0].onClick(); // Clicking "Disable" action
+
+      const patchCall = mockPatch.mock.calls[0][0];
+      expect(patchCall.updateData).toBeDefined();
+
+      // Test updateData callback
+      const prevState = {
+        data: [
+          {
+            id: 'system-1',
+            attributes: {
+              cve_count: 5,
+              opt_out: false,
+            },
+          },
+        ],
+        meta: { total: 1 },
+      };
+
+      const newState = patchCall.updateData(prevState);
+
+      expect(newState).toEqual({
+        data: [
+          {
+            id: 'system-1',
+            attributes: {
+              cve_count: 5,
+              opt_out: true, // Should be updated to true
+            },
+          },
+        ],
+        meta: { total: 1 },
+      });
+    });
+
+    it('skips updateData when enabling (will refetch instead)', () => {
+      mockPatch.mockReturnValue({ type: 'MOCK_PATCH_ACTION' });
+
+      const hostDetails = {
+        id: 1,
+        insights_attributes: {
+          use_iop_mode: true,
+          vulnerability_opt_out: true, // Currently disabled
+        },
+        subscription_facet_attributes: {
+          uuid: 'test-uuid',
+        },
+      };
+
+      const actions = getVulnerabilityAnalysisActions(hostDetails);
+      actions[0].onClick(); // Clicking "Enable" action
+
+      const patchCall = mockPatch.mock.calls[0][0];
+      // When enabling, updateData should be undefined (no optimistic update)
+      expect(patchCall.updateData).toBeUndefined();
+    });
+
+    it('updateData handles missing data gracefully when disabling', () => {
+      mockPatch.mockReturnValue({ type: 'MOCK_PATCH_ACTION' });
+
+      const hostDetails = {
+        id: 1,
+        insights_attributes: {
+          use_iop_mode: true,
+          vulnerability_opt_out: false,
+        },
+        subscription_facet_attributes: {
+          uuid: 'test-uuid',
+        },
+      };
+
+      const actions = getVulnerabilityAnalysisActions(hostDetails);
+      actions[0].onClick();
+
+      const patchCall = mockPatch.mock.calls[0][0];
+
+      // Test with undefined prevState
+      expect(patchCall.updateData(undefined)).toBeUndefined();
+
+      // Test with missing data
+      expect(patchCall.updateData({})).toEqual({});
+
+      // Test with null data
+      expect(patchCall.updateData({ data: null })).toEqual({ data: null });
+    });
+
+    it('includes successToast callback that returns correct message for disabling', () => {
+      mockPatch.mockReturnValue({ type: 'MOCK_PATCH_ACTION' });
+
+      const hostDetails = {
+        id: 1,
+        insights_attributes: {
+          use_iop_mode: true,
+          vulnerability_opt_out: false,
+        },
+        subscription_facet_attributes: {
+          uuid: 'test-uuid',
+        },
+      };
+
+      const actions = getVulnerabilityAnalysisActions(hostDetails);
+      actions[0].onClick();
+
+      const patchCall = mockPatch.mock.calls[0][0];
+      expect(patchCall.successToast).toBeDefined();
+
+      const message = patchCall.successToast();
+      expect(message).toBe('Vulnerability analysis disabled');
+    });
+
+    it('includes successToast callback that returns correct message for enabling', () => {
+      mockPatch.mockReturnValue({ type: 'MOCK_PATCH_ACTION' });
+
+      const hostDetails = {
+        id: 1,
+        insights_attributes: {
+          use_iop_mode: true,
+          vulnerability_opt_out: true,
+        },
+        subscription_facet_attributes: {
+          uuid: 'test-uuid',
+        },
+      };
+
+      const actions = getVulnerabilityAnalysisActions(hostDetails);
+      actions[0].onClick();
+
+      const patchCall = mockPatch.mock.calls[0][0];
+      const message = patchCall.successToast();
+      expect(message).toBe('Vulnerability analysis enabled');
+    });
+
+    it('includes handleSuccess callback that updates HOSTS Redux data when disabling', () => {
+      mockPatch.mockReturnValue({ type: 'MOCK_PATCH_ACTION' });
+      storeUtils.updateHostVulnerabilityOptOut.mockImplementation(() => {});
+
+      const hostDetails = {
+        id: 123,
+        insights_attributes: {
+          use_iop_mode: true,
+          vulnerability_opt_out: false,
+        },
+        subscription_facet_attributes: {
+          uuid: 'test-uuid',
+        },
+      };
+
+      const actions = getVulnerabilityAnalysisActions(hostDetails);
+
+      // Clear dispatch mock before calling onClick (which dispatches the patch action)
+      mockDispatch.mockClear();
+      mockGet.mockClear();
+
+      actions[0].onClick();
+
+      const patchCall = mockPatch.mock.calls[0][0];
+      expect(patchCall.handleSuccess).toBeDefined();
+
+      // Call handleSuccess
+      patchCall.handleSuccess();
+
+      expect(storeUtils.updateHostVulnerabilityOptOut).toHaveBeenCalledWith(
+        123,
+        true
+      );
+      // When disabling, should NOT dispatch GET (no refetch needed)
+      expect(mockGet).not.toHaveBeenCalled();
+    });
+
+    it('includes handleSuccess callback that refetches data when enabling', () => {
+      mockPatch.mockReturnValue({ type: 'MOCK_PATCH_ACTION' });
+      mockGet.mockReturnValue({ type: 'MOCK_GET_ACTION' });
+      storeUtils.updateHostVulnerabilityOptOut.mockImplementation(() => {});
+
+      const hostDetails = {
+        id: 123,
+        insights_attributes: {
+          use_iop_mode: true,
+          vulnerability_opt_out: true, // Currently disabled
+        },
+        subscription_facet_attributes: {
+          uuid: 'test-uuid-456',
+        },
+      };
+
+      const actions = getVulnerabilityAnalysisActions(hostDetails);
+      actions[0].onClick(); // Click "Enable"
+
+      const patchCall = mockPatch.mock.calls[0][0];
+      expect(patchCall.handleSuccess).toBeDefined();
+
+      // Call handleSuccess
+      patchCall.handleSuccess();
+
+      // Should update HOSTS Redux data
+      expect(storeUtils.updateHostVulnerabilityOptOut).toHaveBeenCalledWith(
+        123,
+        false // Enabling sets to false
+      );
+
+      // Should dispatch GET to refetch CVE data
+      expect(mockDispatch).toHaveBeenCalledWith({ type: 'MOCK_GET_ACTION' });
+      expect(mockGet).toHaveBeenCalledWith(
+        expect.objectContaining({
+          key: 'HOST_CVE_COUNT_test-uuid-456',
+          url: expect.stringContaining(
+            'api/vulnerability/v1/systems?uuid=test-uuid-456'
+          ),
+        })
+      );
+    });
+
+    it('includes errorToast callback that extracts JSON:API error detail', () => {
+      mockPatch.mockReturnValue({ type: 'MOCK_PATCH_ACTION' });
+
+      const hostDetails = {
+        id: 1,
+        insights_attributes: {
+          use_iop_mode: true,
+          vulnerability_opt_out: false,
+        },
+        subscription_facet_attributes: {
+          uuid: 'test-uuid',
+        },
+      };
+
+      const actions = getVulnerabilityAnalysisActions(hostDetails);
+      actions[0].onClick();
+
+      const patchCall = mockPatch.mock.calls[0][0];
+      expect(patchCall.errorToast).toBeDefined();
+
+      // Test with JSON:API error format
+      const errorWithDetail = {
+        response: {
+          data: {
+            errors: [
+              {
+                detail: 'System not found in vulnerability service',
+              },
+            ],
+          },
+        },
+      };
+
+      const errorMessage = patchCall.errorToast(errorWithDetail);
+      expect(errorMessage).toBe('System not found in vulnerability service');
+    });
+
+    it('includes errorToast callback that falls back to generic message', () => {
+      mockPatch.mockReturnValue({ type: 'MOCK_PATCH_ACTION' });
+
+      const hostDetails = {
+        id: 1,
+        insights_attributes: {
+          use_iop_mode: true,
+          vulnerability_opt_out: false,
+        },
+        subscription_facet_attributes: {
+          uuid: 'test-uuid',
+        },
+      };
+
+      const actions = getVulnerabilityAnalysisActions(hostDetails);
+      actions[0].onClick();
+
+      const patchCall = mockPatch.mock.calls[0][0];
+
+      // Test with error that doesn't have JSON:API format
+      const genericError = {
+        response: {
+          data: {},
+        },
+      };
+
+      const errorMessage = patchCall.errorToast(genericError);
+      expect(errorMessage).toBe(
+        'Failed to update vulnerability analysis status'
+      );
+    });
+  });
+});

data/webpack/HostsIndexExtensions/hostVulnerabilityStoreUtils.js

@@ -0,0 +1,41 @@
+import store from 'foremanReact/redux';
+
+/**
+ * Updates a host's vulnerability_opt_out status in the HOSTS Redux cache
+ * @param {number} hostId - The host ID to update
+ * @param {boolean} optOutValue - The new opt_out status
+ * @param {function} dispatch - Redux dispatch function (optional, uses store.dispatch if not provided)
+ */
+export const updateHostVulnerabilityOptOut = (
+  hostId,
+  optOutValue,
+  dispatch = null
+) => {
+  const dispatchFn = dispatch || store.dispatch;
+  const state = store.getState();
+  const hostsData = state.API?.HOSTS;
+
+  if (!hostsData?.response?.results || !hostId) {
+    return;
+  }
+
+  dispatchFn({
+    type: 'HOSTS_SUCCESS',
+    key: 'HOSTS',
+    response: {
+      ...hostsData.response,
+      results: hostsData.response.results.map(host => {
+        if (host.id === hostId) {
+          return {
+            ...host,
+            insights_attributes: {
+              ...host.insights_attributes,
+              vulnerability_opt_out: optOutValue,
+            },
+          };
+        }
+        return host;
+      }),
+    },
+  });
+};

data/webpack/InsightsVulnerabilityActionsBar/InsightsVulnerabilityActionsBar.scss

@@ -0,0 +1,14 @@
+.disabled-menu-item-span {
+  width: 25em;
+  display: flex;
+  flex-direction: row;
+}
+
+.disabled-menu-item-p {
+  margin-left: 0.6em;
+  word-break: normal;
+}
+
+.disabled-menu-item-icon {
+  font-size: small;
+}