foreman_rh_cloud 14.1.1 → 14.1.3

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

@@ -1,18 +1,62 @@
 import React from 'react';
-import { rtlHelpers } from 'foremanReact/common/rtlTestHelpers';
+import { render, screen } from '@testing-library/react';
 import InsightsTable from '../InsightsTable';
 import { tableProps } from './fixtures';
 
 jest.mock('../../../../common/Hooks/ConfigHooks');
+jest.mock('foremanReact/Root/Context/ForemanContext');
+jest.mock('../Pagination', () => () => null);
 
-const { renderWithStore } = rtlHelpers;
+const buildProps = (overrides = {}) => ({
+  ...tableProps,
+  fetchInsights: jest.fn(),
+  onTableSort: jest.fn(),
+  onTableSelect: jest.fn(),
+  selectAll: jest.fn(),
+  clearAllSelection: jest.fn(),
+  ...overrides,
+});
 
 describe('InsightsTable', () => {
   afterEach(() => {
     jest.clearAllMocks();
   });
 
-  it('renders without crashing', () => {
-    renderWithStore(<InsightsTable {...tableProps} />);
+  it('calls fetchInsights on mount', () => {
+    const props = buildProps();
+    render(<InsightsTable {...props} />);
+
+    expect(props.fetchInsights).toHaveBeenCalledTimes(1);
+    expect(props.fetchInsights).toHaveBeenCalledWith(
+      expect.objectContaining({ page: 1, perPage: 5 })
+    );
+  });
+
+  it('renders table with correct aria-label', () => {
+    const props = buildProps();
+    render(<InsightsTable {...props} />);
+
+    expect(
+      screen.getByRole('grid', { name: /Recommendations Table/ })
+    ).toBeTruthy();
+  });
+
+  it('re-fetches when hostname changes', () => {
+    const props = buildProps({ hostname: 'host1.example.com' });
+    const { rerender } = render(<InsightsTable {...props} />);
+
+    props.fetchInsights.mockClear();
+    rerender(
+      <InsightsTable {...props} hostname="host2.example.com" />
+    );
+
+    expect(props.fetchInsights).toHaveBeenCalledTimes(1);
+  });
+
+  it('renders with empty hits', () => {
+    const props = buildProps({ hits: [], status: 'RESOLVED' });
+    const { container } = render(<InsightsTable {...props} />);
+
+    expect(container.querySelector('.rh-cloud-recommendations-table')).toBeTruthy();
   });
 });

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

@@ -1,5 +1,4 @@
-import { testActionSnapshotWithFixtures } from '@theforeman/test';
-import API from 'foremanReact/redux/API';
+import { push } from 'connected-react-router';
 import {
   fetchInsights,
   setSelectAllAlert,
@@ -8,41 +7,133 @@ import {
   selectAll,
   clearAllSelection,
 } from '../InsightsTableActions';
-import { hits } from './fixtures';
+import {
+  INSIGHTS_SET_SELECTED_IDS,
+  INSIGHTS_SET_SELECT_ALL_ALERT,
+  INSIGHTS_SET_SELECT_ALL,
+  INSIGHTS_HITS_API_KEY,
+  INSIGHTS_HITS_PATH,
+} from '../InsightsTableConstants';
 
-jest.mock('foremanReact/redux/API', () => jest.fn());
-API.get = jest.fn(({ handleSuccess, ...action }) => {
-  handleSuccess({ data: { hits } });
-  return { type: 'get', ...action };
-});
+jest.mock('connected-react-router', () => ({
+  push: jest.fn(args => ({ type: '@@router/CALL_HISTORY_METHOD', payload: args })),
+}));
 
-const runWithGetState = (state, action, params) => dispatch => {
-  const getState = () => ({
-    router: {
-      location: {
-        query: {
-          page: '1',
-          per_page: '7',
-          search: '',
-          sort_by: '',
-          sort_order: '',
-          select_all: 'true',
-        },
+const buildGetState = (queryOverrides = {}) => () => ({
+  router: {
+    location: {
+      query: {
+        page: '1',
+        per_page: '7',
+        search: '',
+        sort_by: '',
+        sort_order: '',
+        select_all: 'false',
+        ...queryOverrides,
       },
     },
+  },
+});
+
+describe('InsightsTable actions', () => {
+  let dispatch;
+
+  beforeEach(() => {
+    dispatch = jest.fn();
+    jest.clearAllMocks();
+  });
+
+  describe('plain action creators', () => {
+    it('setSelectAllAlert returns correct action', () => {
+      expect(setSelectAllAlert(true)).toEqual({
+        type: INSIGHTS_SET_SELECT_ALL_ALERT,
+        payload: { showSelectAllAlert: true },
+      });
+    });
+
+    it('selectByIds returns correct action', () => {
+      const ids = { 1: true, 5: true };
+      expect(selectByIds(ids)).toEqual({
+        type: INSIGHTS_SET_SELECTED_IDS,
+        payload: { selectedIds: ids },
+      });
+    });
+  });
+
+  describe('setSelectAll', () => {
+    it('dispatches select all action and url update', () => {
+      setSelectAll(false)(dispatch);
+
+      const dispatched = dispatch.mock.calls.map(c => c[0]);
+      const selectAllAction = dispatched.find(
+        a => a && a.type === INSIGHTS_SET_SELECT_ALL
+      );
+      expect(selectAllAction).toBeTruthy();
+      expect(selectAllAction.payload).toEqual({ isAllSelected: false });
+    });
+  });
+
+  describe('selectAll', () => {
+    it('dispatches setSelectAll with true', () => {
+      selectAll()(dispatch);
+
+      const dispatched = dispatch.mock.calls.map(c => c[0]);
+      const selectAllAction = dispatched.find(
+        a => a && a.type === INSIGHTS_SET_SELECT_ALL
+      );
+      expect(selectAllAction).toBeTruthy();
+      expect(selectAllAction.payload).toEqual({ isAllSelected: true });
+    });
+  });
+
+  describe('clearAllSelection', () => {
+    it('dispatches reset ids, clear alert, and deselect all', () => {
+      clearAllSelection()(dispatch);
+
+      expect(dispatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: INSIGHTS_SET_SELECTED_IDS,
+          payload: { selectedIds: {} },
+        })
+      );
+      expect(dispatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: INSIGHTS_SET_SELECT_ALL_ALERT,
+          payload: { showSelectAllAlert: false },
+        })
+      );
+    });
   });
-  action(params)(dispatch, getState);
-};
-
-const fixtures = {
-  'should fetchInsights': () =>
-    runWithGetState({}, fetchInsights, { page: 2, perPage: 7 }),
-  'should setSelectAllAlert true': () => setSelectAllAlert(true),
-  'should selectByIds': () => selectByIds({ 1: true, 5: true }),
-  'should setSelectAll false': () => setSelectAll(false),
-  'should selectAll': () => selectAll(),
-  'should clearAllSelection': () => clearAllSelection(),
-};
-
-describe('insights table actions', () =>
-  testActionSnapshotWithFixtures(fixtures));
+
+  describe('fetchInsights', () => {
+    it('dispatches url push and API get with correct params', () => {
+      const getState = buildGetState();
+
+      fetchInsights({ page: 2, perPage: 7 })(dispatch, getState);
+
+      expect(push).toHaveBeenCalled();
+
+      const apiAction = dispatch.mock.calls.find(
+        call => call[0] && call[0].key === INSIGHTS_HITS_API_KEY
+      );
+      expect(apiAction).toBeTruthy();
+      const getArg = apiAction[0];
+      expect(getArg.url).toBe(INSIGHTS_HITS_PATH);
+      expect(getArg.params.page).toBe(2);
+      expect(getArg.params.per_page).toBe(7);
+    });
+
+    it('clears select all alert when isSelectAll is false', () => {
+      const getState = buildGetState({ select_all: 'false' });
+
+      fetchInsights({})(dispatch, getState);
+
+      expect(dispatch).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: INSIGHTS_SET_SELECT_ALL_ALERT,
+          payload: { showSelectAllAlert: false },
+        })
+      );
+    });
+  });
+});

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

@@ -1,4 +1,3 @@
-import { testSelectorsSnapshotWithFixtures } from '@theforeman/test';
 import { insightsStateWrapper } from '../../../../ForemanRhCloudTestHelpers';
 import { routerState, APIState, APIErrorState } from './fixtures';
 import {
@@ -24,33 +23,100 @@ const state = {
   ...APIState,
   ...insightsStateWrapper({
     table: {
-      selectedIds: {
-        '51': true,
-      },
+      selectedIds: { '51': true },
       showSelectAllAlert: true,
       isAllSelected: false,
     },
   }),
 };
 
-const fixtures = {
-  'should return router query': () => selectQuery(state),
-  'should return router search': () => selectSearch(state),
-  'should return router page': () => selectPage(state),
-  'should return router perPage': () => selectPerPage(state),
-  'should return router sort by': () => selectSortBy(state),
-  'should return router sort order': () => selectSortOrder(state),
-  'should return queryParams': () => selectQueryParams(state),
-  'should return API status': () => selectStatus(state),
-  'should return API error': () => selectError({ ...state, ...APIErrorState }),
-  'should return API hits': () => selectHits(state),
-  'should return API item count': () => selectItemCount(state),
-  'should return insights table': () => selectInsightsCloudTable(state),
-  'should return insights selectedIds': () => selectSelectedIds(state),
-  'should return insights isAllSelected': () => selectIsAllSelected(state),
-  'should return insights showSelectAllAlert': () =>
-    selectShowSelectAllAlert(state),
-};
+describe('InsightsTable selectors', () => {
+  describe('router query selectors', () => {
+    it('selectQuery returns the query object', () => {
+      expect(selectQuery(state)).toEqual(routerState.router.location.query);
+    });
+
+    it('selectSearch returns URI-decoded search string', () => {
+      expect(selectSearch(state)).toBe('total_risk < 3');
+    });
+
+    it('selectPage returns the page as a number', () => {
+      expect(selectPage(state)).toBe(1);
+    });
+
+    it('selectPerPage returns per_page as a number', () => {
+      expect(selectPerPage(state)).toBe(7);
+    });
+
+    it('selectSortBy returns the sort_by value', () => {
+      expect(selectSortBy(state)).toBe('total_risk');
+    });
+
+    it('selectSortOrder returns the sort_order value', () => {
+      expect(selectSortOrder(state)).toBe('asc');
+    });
+
+    it('selectQueryParams returns aggregated params object', () => {
+      const params = selectQueryParams(state);
+      expect(params.page).toBe(1);
+      expect(params.perPage).toBe(7);
+      expect(params.query).toBe('total_risk < 3');
+      expect(params.sortBy).toBe('total_risk');
+      expect(params.sortOrder).toBe('asc');
+    });
+  });
+
+  describe('API selectors', () => {
+    it('selectStatus returns API status', () => {
+      expect(selectStatus(state)).toBe('RESOLVED');
+    });
+
+    it('selectError returns error message from error state', () => {
+      const errorState = { ...state, ...APIErrorState };
+      expect(selectError(errorState)).toBeTruthy();
+    });
+
+    it('selectHits returns hits when status is RESOLVED', () => {
+      expect(selectHits(state)).toHaveLength(2);
+    });
+
+    it('selectHits returns empty array when status is not RESOLVED', () => {
+      const pendingState = {
+        ...state,
+        API: {
+          INSIGHTS_HITS: {
+            ...state.API.INSIGHTS_HITS,
+            status: 'PENDING',
+          },
+        },
+      };
+      expect(selectHits(pendingState)).toEqual([]);
+    });
+
+    it('selectItemCount returns the item count', () => {
+      expect(selectItemCount(state)).toBe(2);
+    });
+  });
+
+  describe('table state selectors', () => {
+    it('selectInsightsCloudTable returns the table sub-state', () => {
+      expect(selectInsightsCloudTable(state)).toEqual({
+        selectedIds: { '51': true },
+        showSelectAllAlert: true,
+        isAllSelected: false,
+      });
+    });
+
+    it('selectSelectedIds returns selected IDs', () => {
+      expect(selectSelectedIds(state)).toEqual({ '51': true });
+    });
+
+    it('selectIsAllSelected returns false', () => {
+      expect(selectIsAllSelected(state)).toBe(false);
+    });
 
-describe('InsightsTable selectors', () =>
-  testSelectorsSnapshotWithFixtures(fixtures));
+    it('selectShowSelectAllAlert returns true', () => {
+      expect(selectShowSelectAllAlert(state)).toBe(true);
+    });
+  });
+});

data/webpack/InsightsCloudSync/InsightsCloudSync.test.js

@@ -1,25 +1,83 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
-import { noop } from 'foremanReact/common/helpers';
-import InsightsCloudSync from './InsightsCloudSync';
-
-jest.mock('foremanReact/Root/Context/ForemanContext', () => ({
-  useForemanContext: () => ({
-    metadata: {
-      foreman_rh_cloud: {
-        iop: true,
-      },
-    },
-  }),
+import React from 'react';
+import { render } from '@testing-library/react';
+import RecommendationsPage from './InsightsCloudSync';
+
+let mockIsIop = false;
+jest.mock('../common/Hooks/ConfigHooks', () => ({
+  useIopConfig: () => mockIsIop,
+}));
+
+jest.mock('../common/Hooks/PermissionsHooks', () => ({
+  useInsightsPermissions: () => ({}),
 }));
 
-const fixtures = {
-  render: {
-    status: 'RESOLVED',
-    syncInsights: noop,
-    fetchInsights: noop,
-    query: '',
-  },
+jest.mock('./Components/InsightsTable', () => () => null);
+jest.mock('./Components/RemediationModal', () => () => null);
+jest.mock('./Components/InsightsTable/Pagination', () => () => null);
+jest.mock('./Components/InsightsSettings', () => () => null);
+jest.mock('foremanReact/routes/common/PageLayout/PageLayout', () => ({
+  children,
+  header,
+  toolbarButtons,
+}) => (
+  <div data-testid="page-layout" data-header={header}>
+    {toolbarButtons}
+    {children}
+  </div>
+));
+jest.mock('@scalprum/react-core', () => ({
+  ScalprumComponent: () => <div data-testid="scalprum-component" />,
+  ScalprumProvider: ({ children }) => <div>{children}</div>,
+}));
+jest.mock('../common/ScalprumModule/ScalprumContext', () => ({
+  createProviderOptions: () => ({ config: {} }),
+}));
+
+const defaultProps = {
+  syncInsights: jest.fn(),
+  fetchInsights: jest.fn(),
+  query: '',
 };
 
-describe('InsightsCloudSync', () =>
-  testComponentSnapshotsWithFixtures(InsightsCloudSync, fixtures));
+describe('RecommendationsPage', () => {
+  afterEach(() => {
+    mockIsIop = false;
+    jest.clearAllMocks();
+  });
+
+  describe('non-IOP mode', () => {
+    it('renders with rh-cloud-insights class and correct header', () => {
+      const { container } = render(
+        <RecommendationsPage {...defaultProps} />
+      );
+
+      expect(container.querySelector('.rh-cloud-insights')).toBeTruthy();
+      expect(
+        container.querySelector('[data-header="Red Hat Insights"]')
+      ).toBeTruthy();
+    });
+
+    it('does not render IOP advisor view', () => {
+      const { container } = render(
+        <RecommendationsPage {...defaultProps} />
+      );
+
+      expect(container.querySelector('.advisor')).toBeNull();
+    });
+  });
+
+  describe('IOP mode', () => {
+    beforeEach(() => {
+      mockIsIop = true;
+    });
+
+    it('renders advisor view instead of insights page', () => {
+      const { container } = render(
+        <RecommendationsPage {...defaultProps} />
+      );
+
+      expect(container.querySelector('.advisor')).toBeTruthy();
+      expect(container.querySelector('.rh-cloud-insights')).toBeNull();
+    });
+  });
+});

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

@@ -1,9 +1,34 @@
-import { testActionSnapshotWithFixtures } from '@theforeman/test';
 import { syncInsights } from '../InsightsCloudSyncActions';
+import { INSIGHTS_CLOUD_SYNC } from '../InsightsCloudSyncConstants';
 
-const fixtures = {
-  'should syncInsights': () => syncInsights(),
-};
 
-describe('Insights cloud sync actions', () =>
-  testActionSnapshotWithFixtures(fixtures));
+jest.mock('../../common/ForemanTasks');
+
+describe('InsightsCloudSync actions', () => {
+  let dispatch;
+
+  beforeEach(() => {
+    dispatch = jest.fn();
+    jest.clearAllMocks();
+  });
+
+  it('dispatches post with correct key and url', () => {
+    const fetchInsights = jest.fn();
+    syncInsights(fetchInsights, 'test-query')(dispatch);
+
+    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');
+  });
+
+  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');
+    expect(result).toContain('some error');
+  });
+});

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

@@ -1,13 +1,46 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
-
+import React from 'react';
+import { render, screen } from '@testing-library/react';
 import InsightsTab from '../InsightsTab';
-import { props } from './InsightsTab.fixtures';
-
-const fixtures = {
-  'render with props': props,
-};
+import { hits, hostID } from './InsightsTab.fixtures';
 
 describe('InsightsTab', () => {
-  describe('rendering', () =>
-    testComponentSnapshotsWithFixtures(InsightsTab, fixtures));
+  it('renders "No recommendations" message when hits is empty', () => {
+    render(<InsightsTab hostID={hostID} hits={[]} />);
+    expect(
+      screen.getByText('No recommendations were found for this host!')
+    ).toBeTruthy();
+  });
+
+  it('renders Recommendations heading when hits exist', () => {
+    render(<InsightsTab hostID={hostID} hits={hits} />);
+    expect(screen.getByText('Recommendations')).toBeTruthy();
+  });
+
+  it('displays hit titles', () => {
+    render(<InsightsTab hostID={hostID} hits={hits} />);
+    hits.forEach(hit => {
+      expect(screen.getByText(hit.title)).toBeTruthy();
+    });
+  });
+
+  it('calls fetchHits on mount', () => {
+    const fetchHits = jest.fn();
+    render(<InsightsTab hostID={hostID} hits={[]} fetchHits={fetchHits} />);
+    expect(fetchHits).toHaveBeenCalledWith(hostID);
+  });
+
+  it('sorts hits by total_risk descending', () => {
+    const multipleHits = [
+      { ...hits[0], title: 'Low risk', total_risk: 1 },
+      { ...hits[0], title: 'High risk', total_risk: 4 },
+      { ...hits[0], title: 'Medium risk', total_risk: 2 },
+    ];
+    render(<InsightsTab hostID={hostID} hits={multipleHits} />);
+    const titles = screen.getAllByText(/risk/i).map(el => el.textContent);
+    const highRiskIndex = titles.findIndex(t => t === 'High risk');
+    const mediumRiskIndex = titles.findIndex(t => t === 'Medium risk');
+    const lowRiskIndex = titles.findIndex(t => t === 'Low risk');
+    expect(highRiskIndex).toBeLessThan(mediumRiskIndex);
+    expect(mediumRiskIndex).toBeLessThan(lowRiskIndex);
+  });
 });