foreman_rh_cloud 14.1.2 → 14.1.3

data/webpack/ForemanInventoryUpload/Components/TabFooter/__tests__/TabFooter.test.js

@@ -1,13 +1,15 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
-
+import React from 'react';
+import { render, screen } from '@testing-library/react';
 import TabFooter from '../TabFooter';
 
-const fixtures = {
-  'render without Props': {},
-  /** fixtures, props for the component */
-};
-
 describe('TabFooter', () => {
-  describe('rendering', () =>
-    testComponentSnapshotsWithFixtures(TabFooter, fixtures));
+  it('renders children', () => {
+    render(<TabFooter><span>Footer content</span></TabFooter>);
+    expect(screen.getByText('Footer content')).toBeTruthy();
+  });
+
+  it('renders with the tab-footer class', () => {
+    const { container } = render(<TabFooter />);
+    expect(container.querySelector('.tab-footer')).toBeTruthy();
+  });
 });

data/webpack/ForemanInventoryUpload/SubscriptionsPageExtension/InventoryAutoUpload/__tests__/InventoryAutoUpload.test.js

@@ -1,17 +1,38 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
-import { noop } from 'foremanReact/common/helpers';
-
+import React from 'react';
+import { render, screen } from '@testing-library/react';
 import InventoryAutoUpload from '../InventoryAutoUpload';
 
-const fixtures = {
-  'render with props': {
-    autoUploadEnabled: true,
-    setSetting: noop,
-    getSettings: noop,
-  },
-};
+jest.mock(
+  '../../../Components/InventorySettings/InventorySettings',
+  () => () => <div data-testid="inventory-settings">InventorySettings</div>
+);
 
 describe('InventoryAutoUpload', () => {
-  describe('rendering', () =>
-    testComponentSnapshotsWithFixtures(InventoryAutoUpload, fixtures));
+  const buildProps = (overrides = {}) => ({
+    autoUploadEnabled: true,
+    setSetting: jest.fn(),
+    getSettings: jest.fn(),
+    ...overrides,
+  });
+
+  it('renders the heading', () => {
+    render(<InventoryAutoUpload {...buildProps()} />);
+    expect(screen.getByText('Red Hat Cloud Inventory')).toBeTruthy();
+  });
+
+  it('renders the auto upload switcher', () => {
+    render(<InventoryAutoUpload {...buildProps()} />);
+    expect(screen.getByText('Inventory Auto Upload')).toBeTruthy();
+  });
+
+  it('renders the advanced settings button', () => {
+    render(<InventoryAutoUpload {...buildProps()} />);
+    expect(screen.getByRole('button', { name: /Show Advanced Settings/ })).toBeTruthy();
+  });
+
+  it('calls getSettings on mount', () => {
+    const props = buildProps();
+    render(<InventoryAutoUpload {...props} />);
+    expect(props.getSettings).toHaveBeenCalled();
+  });
 });

data/webpack/ForemanInventoryUpload/__tests__/ForemanInventoryHelpers.test.js

@@ -1,10 +1,23 @@
-import { testSelectorsSnapshotWithFixtures } from '@theforeman/test';
-import { inventoryUrl, getInventoryDocsUrl } from '../ForemanInventoryHelpers';
+import { isExitCodeLoading } from '../ForemanInventoryHelpers';
 
-const fixtures = {
-  'should return inventory Url': () => inventoryUrl('test_path'),
-  'should return inventory docs url': () => getInventoryDocsUrl(),
-};
+describe('ForemanInventoryUpload helpers', () => {
+  describe('isExitCodeLoading', () => {
+    it('returns true when exit code contains "running"', () => {
+      expect(isExitCodeLoading('currently running')).toBe(true);
+    });
 
-describe('ForemanInventoryUpload helpers', () =>
-  testSelectorsSnapshotWithFixtures(fixtures));
+    it('returns true when exit code contains "restarting"', () => {
+      expect(isExitCodeLoading('restarting now')).toBe(true);
+    });
+
+    it('is case-insensitive', () => {
+      expect(isExitCodeLoading('RUNNING')).toBe(true);
+      expect(isExitCodeLoading('Restarting')).toBe(true);
+    });
+
+    it('returns false when exit code contains neither', () => {
+      expect(isExitCodeLoading('exit 0')).toBe(false);
+      expect(isExitCodeLoading('completed')).toBe(false);
+    });
+  });
+});

data/webpack/InsightsCloudSync/Components/InsightsSettings/__tests__/InsightsSettingsActions.test.js

@@ -1,62 +1,76 @@
-import { testActionSnapshotWithFixtures } from '@theforeman/test';
 import { API } from 'foremanReact/redux/API';
 import {
   getInsightsSyncSettings,
   setInsightsSyncEnabled,
 } from '../InsightsSettingsActions';
-import { rhCloudStateWrapper } from '../../../../ForemanRhCloudTestHelpers';
-
-const serverMock = {
-  data: { insightsSyncEnabled: true },
-};
+import {
+  INSIGHTS_SYNC_SETTING_SET,
+  INSIGHTS_SYNC_SETTINGS_GET_SUCCESS,
+} from '../InsightsSettingsConstants';
 
 jest.mock('foremanReact/redux/API');
-API.get.mockImplementation(() => serverMock);
-API.patch.mockImplementation(() => serverMock);
-
-const runWithGetState = (state, action, params) => dispatch => {
-  const getState = () => rhCloudStateWrapper({ InsightsCloudSync: state });
-  action(params)(dispatch, getState);
-};
-
-const fixtures = {
-  'should generate INSIGHTS_SYNC_SETTINGS_GET_SUCCESS action': () =>
-    runWithGetState({ settings: {} }, getInsightsSyncSettings, {}),
-  'should handle getInsightsSyncSettings with error ': () => {
-    API.get.mockImplementationOnce(() =>
-      Promise.reject(new Error('Network error!'))
-    );
-    return runWithGetState({ settings: {} }, getInsightsSyncSettings, {});
-  },
-  'should generate INSIGHTS_SYNC_SETTING_SET action': () =>
-    runWithGetState(
-      { settings: { insightsSyncEnabled: false } },
-      setInsightsSyncEnabled,
-      true
-    ),
-  'should handle setInsightsSyncEnabled with error ': () => {
-    API.patch.mockImplementationOnce(() =>
-      Promise.reject(new Error('Network error!'))
-    );
-    return runWithGetState(
-      { settings: { insightsSyncEnabled: false } },
-      setInsightsSyncEnabled,
-      true
-    );
-  },
-};
 
 describe('InsightsSettings actions', () => {
-  const { location } = window;
+  let dispatch;
 
-  beforeAll(() => {
-    delete window.location;
-    window.location = { href: jest.fn() };
+  beforeEach(() => {
+    dispatch = jest.fn();
+    jest.clearAllMocks();
   });
 
-  afterAll(() => {
-    window.location = location;
+  describe('getInsightsSyncSettings', () => {
+    it('dispatches success action with settings on success', async () => {
+      API.get.mockResolvedValue({ data: { insightsSyncEnabled: true } });
+
+      await getInsightsSyncSettings()(dispatch);
+
+      expect(API.get).toHaveBeenCalledWith('/insights_cloud/settings');
+      expect(dispatch).toHaveBeenCalledWith({
+        type: INSIGHTS_SYNC_SETTINGS_GET_SUCCESS,
+        payload: { settings: { insightsSyncEnabled: true } },
+      });
+    });
+
+    it('dispatches error toast on failure', async () => {
+      API.get.mockRejectedValue(new Error('Network error!'));
+
+      await getInsightsSyncSettings()(dispatch);
+
+      expect(dispatch).toHaveBeenCalledWith({
+        type: 'TOASTS_ADD',
+        payload: {
+          message: { sticky: true, type: 'error', message: 'Network error!' },
+        },
+      });
+    });
   });
 
-  return testActionSnapshotWithFixtures(fixtures);
+  describe('setInsightsSyncEnabled', () => {
+    it('dispatches setting set action on success', async () => {
+      API.patch.mockResolvedValue({ data: { insightsSyncEnabled: true } });
+
+      await setInsightsSyncEnabled(true)(dispatch);
+
+      expect(API.patch).toHaveBeenCalledWith('/insights_cloud/settings', {
+        insightsSyncEnabled: true,
+      });
+      expect(dispatch).toHaveBeenCalledWith({
+        type: INSIGHTS_SYNC_SETTING_SET,
+        payload: { settings: { insightsSyncEnabled: true } },
+      });
+    });
+
+    it('dispatches error toast on failure', async () => {
+      API.patch.mockRejectedValue(new Error('Network error!'));
+
+      await setInsightsSyncEnabled(true)(dispatch);
+
+      expect(dispatch).toHaveBeenCalledWith({
+        type: 'TOASTS_ADD',
+        payload: {
+          message: { sticky: true, type: 'error', message: 'Network error!' },
+        },
+      });
+    });
+  });
 });

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);
+    });
+  });
+});