foreman_rh_cloud 14.1.1 → 14.1.3

data/webpack/ForemanInventoryUpload/Components/PageHeader/components/CloudConnectorButton/__tests__/CloudConnectorButton.test.js

@@ -1,22 +1,51 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
 import { CloudConnectorButton } from '../CloudConnectorButton';
 import { CONNECTOR_STATUS } from '../CloudConnectorConstants';
 
-const fixtures = {
-  'render no cloud connector': {
-    status: CONNECTOR_STATUS.NOT_RESOLVED,
-    onClick: jest.fn(),
-  },
-  'render resolved cloud connector': {
-    status: CONNECTOR_STATUS.RESOLVED,
-    onClick: jest.fn(),
-  },
-  'render pending connector': {
-    jobLink: '/job-link',
-    status: CONNECTOR_STATUS.PENDING,
-    onClick: jest.fn(),
-  },
-};
+describe('CloudConnectorButton', () => {
+  it('renders "Configure cloud connector" when not resolved', () => {
+    render(
+      <CloudConnectorButton
+        status={CONNECTOR_STATUS.NOT_RESOLVED}
+        onClick={jest.fn()}
+      />
+    );
+    expect(screen.getByRole('button', { name: /Configure cloud connector/ })).toBeTruthy();
+  });
 
-describe('CloudConnectorButton', () =>
-  testComponentSnapshotsWithFixtures(CloudConnectorButton, fixtures));
+  it('renders "Reconfigure cloud connector" when resolved', () => {
+    render(
+      <CloudConnectorButton
+        status={CONNECTOR_STATUS.RESOLVED}
+        onClick={jest.fn()}
+      />
+    );
+    expect(screen.getByRole('button', { name: /Reconfigure cloud connector/ })).toBeTruthy();
+  });
+
+  it('renders in-progress button when pending', () => {
+    render(
+      <CloudConnectorButton
+        status={CONNECTOR_STATUS.PENDING}
+        onClick={jest.fn()}
+        jobLink="/job-link"
+      />
+    );
+    expect(
+      screen.getByText('Cloud Connector is in progress')
+    ).toBeTruthy();
+  });
+
+  it('calls onClick when configure button is clicked', () => {
+    const onClick = jest.fn();
+    render(
+      <CloudConnectorButton
+        status={CONNECTOR_STATUS.NOT_RESOLVED}
+        onClick={onClick}
+      />
+    );
+    fireEvent.click(screen.getByRole('button', { name: /Configure cloud connector/ }));
+    expect(onClick).toHaveBeenCalledTimes(1);
+  });
+});

data/webpack/ForemanInventoryUpload/Components/PageHeader/components/SettingsWarning/SettingsWarning.test.js

@@ -1,18 +1,61 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import React from 'react';
+import { render, screen } from '@testing-library/react';
 import { SettingsWarning } from './SettingsWarning';
 
-const fixtures = {
-  'with 2 alerts': {
-    autoUpload: false,
-    hostObfuscation: true,
-    isCloudConnector: true,
-  },
-  'with isCloudConnector false': {
-    autoUpload: true,
-    hostObfuscation: true,
-    isCloudConnector: false,
-  },
-};
+describe('SettingsWarning', () => {
+  it('renders nothing when isCloudConnector is false', () => {
+    render(
+      <SettingsWarning autoUpload={false} isCloudConnector={false} />
+    );
+    expect(screen.queryByRole('alert')).toBeNull();
+  });
 
-describe('SettingsWarning', () =>
-  testComponentSnapshotsWithFixtures(SettingsWarning, fixtures));
+  it('renders nothing when autoUpload is on and obfuscation is off', () => {
+    render(
+      <SettingsWarning
+        autoUpload
+        hostObfuscation={false}
+        isCloudConnector
+      />
+    );
+    expect(screen.queryByRole('alert')).toBeNull();
+  });
+
+  it('renders upload warning when autoUpload is disabled', () => {
+    render(
+      <SettingsWarning
+        autoUpload={false}
+        hostObfuscation={false}
+        isCloudConnector
+      />
+    );
+    expect(
+      screen.getByText(/inventory auto-upload is disabled/)
+    ).toBeTruthy();
+  });
+
+  it('renders obfuscation warning when hostObfuscation is enabled', () => {
+    render(
+      <SettingsWarning autoUpload hostObfuscation isCloudConnector />
+    );
+    expect(
+      screen.getByText(/obfuscating host names setting is enabled/)
+    ).toBeTruthy();
+  });
+
+  it('renders both warnings when both conditions met', () => {
+    render(
+      <SettingsWarning
+        autoUpload={false}
+        hostObfuscation
+        isCloudConnector
+      />
+    );
+    expect(
+      screen.getByText(/inventory auto-upload is disabled/)
+    ).toBeTruthy();
+    expect(
+      screen.getByText(/obfuscating host names setting is enabled/)
+    ).toBeTruthy();
+  });
+});

data/webpack/ForemanInventoryUpload/Components/PageHeader/components/SyncButton/__tests__/SyncButton.test.js

@@ -1,13 +1,27 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
-import { noop } from 'foremanReact/common/helpers';
-
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
 import SyncButton from '../SyncButton';
 
-const fixtures = {
-  'render with Props': { handleSync: noop },
-};
-
 describe('SyncButton', () => {
-  describe('rendering', () =>
-    testComponentSnapshotsWithFixtures(SyncButton, fixtures));
+  it('renders the sync button text', () => {
+    render(<SyncButton handleSync={jest.fn()} />);
+    expect(screen.getByRole('button', { name: /Sync all inventory status/ })).toBeTruthy();
+  });
+
+  it('calls handleSync on click', () => {
+    const handleSync = jest.fn();
+    render(<SyncButton handleSync={handleSync} />);
+    fireEvent.click(screen.getByRole('button'));
+    expect(handleSync).toHaveBeenCalledTimes(1);
+  });
+
+  it('disables button when status is PENDING', () => {
+    render(<SyncButton handleSync={jest.fn()} status="PENDING" />);
+    expect(screen.getByRole('button').disabled).toBe(true);
+  });
+
+  it('enables button when status is not PENDING', () => {
+    render(<SyncButton handleSync={jest.fn()} status="RESOLVED" />);
+    expect(screen.getByRole('button').disabled).toBe(false);
+  });
 });

data/webpack/ForemanInventoryUpload/Components/PageHeader/components/SyncButton/__tests__/SyncButtonSelectors.test.js

@@ -1,27 +1,29 @@
-import { testSelectorsSnapshotWithFixtures } from '@theforeman/test';
 import { selectTaskStatus } from '../SyncButtonSelectors';
 
-const state = {
+const buildState = result => ({
   API: {
     INVENTORY_SYNC_TASK_UPDATE: {
       response: {
-        endedAt: '2021-03-08T14:27:30.718+02:00',
-        output: {
-          host_statuses: {
-            sync: 0,
-            disconnect: 2,
-          },
-        },
-        result: 'pending',
+        result,
       },
-      status: 'RESOLVED',
     },
   },
-};
+});
 
-const fixtures = {
-  'should return InventorySync status': () => selectTaskStatus(state),
-};
+describe('SyncButton selectors', () => {
+  it('uppercases the result string', () => {
+    expect(selectTaskStatus(buildState('pending'))).toBe('PENDING');
+  });
 
-describe('SyncButton selectors', () =>
-  testSelectorsSnapshotWithFixtures(fixtures));
+  it('handles other result strings', () => {
+    expect(selectTaskStatus(buildState('success'))).toBe('SUCCESS');
+  });
+
+  it('returns null when result is not a string', () => {
+    expect(selectTaskStatus(buildState(null))).toBeNull();
+  });
+
+  it('returns null when result is undefined', () => {
+    expect(selectTaskStatus(buildState(undefined))).toBeNull();
+  });
+});

data/webpack/ForemanInventoryUpload/Components/PageHeader/components/SyncButton/__tests__/integrations.test.js

@@ -1,52 +1,40 @@
 import React from 'react';
-import { IntegrationTestHelper } from '@theforeman/test';
+import { render, screen, fireEvent } from '@testing-library/react';
+import { Provider } from 'react-redux';
+import configureMockStore from 'redux-mock-store';
+import thunk from 'redux-thunk';
 import * as API from 'foremanReact/redux/API';
-import { noop } from 'foremanReact/common/helpers';
-import SyncButton from '../index';
+import ConnectedSyncButton from '../index';
 import { successResponse } from './SyncButtonFixtures';
-import {
-  INVENTORY_SYNC,
-  INVENTORY_SYNC_TASK_UPDATE,
-} from '../SyncButtonConstants';
+import { INVENTORY_SYNC } from '../SyncButtonConstants';
 
 jest.spyOn(API, 'post');
-jest.spyOn(API, 'get');
+
+const mockStore = configureMockStore([thunk]);
 
 describe('SyncButton integration test', () => {
-  it('Successful task was triggered on the server resulting in an info toast and polling on the task', async () => {
-    API.post.mockImplementation(({ handleSuccess = noop, key, ...action }) => {
-      if (key === INVENTORY_SYNC) {
+  it('dispatches sync action when button is clicked', () => {
+    API.post.mockImplementation(({ handleSuccess, key, ...action }) => {
+      if (key === INVENTORY_SYNC && handleSuccess) {
         handleSuccess(successResponse);
       }
       return { type: 'API_POST', ...action };
     });
-    API.get.mockImplementation(({ handleSuccess = noop, key, ...action }) => {
-      if (key === INVENTORY_SYNC_TASK_UPDATE) {
-        handleSuccess(
-          {
-            data: {
-              endedAt: '2021-03-22T15:59:02.468+02:00',
-              output: {
-                host_statuses: {
-                  sync: 0,
-                  disconnect: 2,
-                  user_omitted: 1,
-                },
-              },
-              result: 'success',
-            },
-          },
-          jest.fn
-        );
-      }
-      return { type: 'API_GET', ...action };
+
+    const store = mockStore({
+      API: {},
     });
 
-    const integrationTestHelper = new IntegrationTestHelper();
-    const wrapper = integrationTestHelper.mount(<SyncButton />);
-    const instance = wrapper.find('SyncButton').instance();
-    instance.props.handleSync();
-    await IntegrationTestHelper.flushAllPromises();
-    integrationTestHelper.takeActionsSnapshot('handleSync was called');
+    render(
+      <Provider store={store}>
+        <ConnectedSyncButton />
+      </Provider>
+    );
+
+    fireEvent.click(screen.getByRole('button'));
+
+    const actions = store.getActions();
+    const syncAction = actions.find(a => a.type === 'API_POST');
+    expect(syncAction).toBeTruthy();
   });
 });

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

@@ -1,13 +1,33 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
-
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import { IntlProvider } from 'react-intl';
 import ScheduledRun from '../ScheduledRun';
-import { props } from '../ScheduledRun.fixtures';
 
-const fixtures = {
-  'render with Props': props,
-};
+const renderWithIntl = ui =>
+  render(<IntlProvider locale="en">{ui}</IntlProvider>);
 
 describe('ScheduledRun', () => {
-  describe('rendering', () =>
-    testComponentSnapshotsWithFixtures(ScheduledRun, fixtures));
+  it('renders next run info when autoUploadEnabled and date are set', () => {
+    renderWithIntl(
+      <ScheduledRun date="2019-08-21T16:14:16.520+03:00" autoUploadEnabled />
+    );
+    expect(screen.getByText(/Next run:/)).toBeTruthy();
+  });
+
+  it('renders nothing when autoUploadEnabled is false', () => {
+    renderWithIntl(
+      <ScheduledRun
+        date="2019-08-21T16:14:16.520+03:00"
+        autoUploadEnabled={false}
+      />
+    );
+    expect(screen.queryByText(/Next run:/)).toBeNull();
+  });
+
+  it('renders nothing when date is null', () => {
+    renderWithIntl(
+      <ScheduledRun date={null} autoUploadEnabled />
+    );
+    expect(screen.queryByText(/Next run:/)).toBeNull();
+  });
 });

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

@@ -1,13 +1,30 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
-
+import React from 'react';
+import { render } from '@testing-library/react';
 import StatusChart from '../StatusChart';
 
-const fixtures = {
-  'render without Props': {},
-  /** fixtures, props for the component */
-};
+jest.mock('patternfly-react', () => ({
+  Grid: { Col: ({ children }) => <div>{children}</div> },
+  DonutChart: ({ title }) => (
+    <div data-testid="donut-chart">
+      <span>{title?.primary}</span>
+      <span>{title?.secondary}</span>
+    </div>
+  ),
+}));
 
 describe('StatusChart', () => {
-  describe('rendering', () =>
-    testComponentSnapshotsWithFixtures(StatusChart, fixtures));
+  it('renders the status chart container', () => {
+    const { container } = render(<StatusChart />);
+    expect(container.querySelector('.status-chart')).toBeTruthy();
+  });
+
+  it('passes the completed percentage to the chart', () => {
+    const { getByText } = render(<StatusChart completed={75} />);
+    expect(getByText('75%')).toBeTruthy();
+  });
+
+  it('shows Completed label', () => {
+    const { getByText } = render(<StatusChart completed={50} />);
+    expect(getByText('Completed')).toBeTruthy();
+  });
 });

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

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

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