foreman_rh_cloud 14.1.2 → 14.1.3

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

data/webpack/__tests__/ForemanRhCloudHelpers.test.js

@@ -1,59 +1,97 @@
-import { testSelectorsSnapshotWithFixtures } from '@theforeman/test';
 import {
   foremanUrl,
   vulnerabilityDisabled,
   hasNoInsightsFacet,
 } from '../ForemanRhCloudHelpers';
 
-global.URL_PREFIX = 'MY_TEST_URL_PREFIX.example.com';
-
-const fixtures = {
-  'should return foreman Url': () => foremanUrl('/test_path'),
-  'vulnerabilityDisabled returns false for RHEL host with vulnerability enabled': () =>
-    vulnerabilityDisabled({
-      hostDetails: {
-        operatingsystem_name: 'Red Hat Enterprise Linux',
-        vulnerability: { enabled: true },
-      },
-    }),
-  'vulnerabilityDisabled returns true for non-RHEL host': () =>
-    vulnerabilityDisabled({
-      hostDetails: {
-        operatingsystem_name: 'Ubuntu',
-        vulnerability: { enabled: true },
-      },
-    }),
-  'vulnerabilityDisabled returns true for RHEL host with vulnerability disabled': () =>
-    vulnerabilityDisabled({
-      hostDetails: {
-        operatingsystem_name: 'Red Hat Enterprise Linux',
-        vulnerability: { enabled: false },
-      },
-    }),
-  'vulnerabilityDisabled returns true for missing vulnerability object': () =>
-    vulnerabilityDisabled({
-      hostDetails: {
-        operatingsystem_name: 'Red Hat Enterprise Linux',
-      },
-    }),
-  'vulnerabilityDisabled returns true for missing hostDetails': () =>
-    vulnerabilityDisabled({}),
-  'hasNoInsightsFacet returns false when insights_attributes is present': () =>
-    hasNoInsightsFacet({
-      response: {
-        insights_attributes: {
-          uuid: 'test-uuid',
-          insights_hits_count: 5,
-        },
-      },
-    }),
-  'hasNoInsightsFacet returns true when insights_attributes is missing': () =>
-    hasNoInsightsFacet({
-      response: {},
-    }),
-  'hasNoInsightsFacet returns true when response is missing': () =>
-    hasNoInsightsFacet({}),
-};
-
-describe('ForemanRhCloud helpers', () =>
-  testSelectorsSnapshotWithFixtures(fixtures));
+describe('ForemanRhCloud helpers', () => {
+  describe('foremanUrl', () => {
+    const originalUrlPrefix = global.URL_PREFIX;
+
+    beforeAll(() => {
+      global.URL_PREFIX = 'MY_TEST_URL_PREFIX.example.com';
+    });
+
+    afterAll(() => {
+      global.URL_PREFIX = originalUrlPrefix;
+    });
+
+    it('prepends URL_PREFIX to path', () => {
+      expect(foremanUrl('/test_path')).toBe(
+        'MY_TEST_URL_PREFIX.example.com/test_path'
+      );
+    });
+  });
+
+  describe('vulnerabilityDisabled', () => {
+    it('returns false for RHEL host with vulnerability enabled', () => {
+      expect(
+        vulnerabilityDisabled({
+          hostDetails: {
+            operatingsystem_name: 'Red Hat Enterprise Linux',
+            vulnerability: { enabled: true },
+          },
+        })
+      ).toBe(false);
+    });
+
+    it('returns true for non-RHEL host', () => {
+      expect(
+        vulnerabilityDisabled({
+          hostDetails: {
+            operatingsystem_name: 'Ubuntu',
+            vulnerability: { enabled: true },
+          },
+        })
+      ).toBe(true);
+    });
+
+    it('returns true for RHEL host with vulnerability disabled', () => {
+      expect(
+        vulnerabilityDisabled({
+          hostDetails: {
+            operatingsystem_name: 'Red Hat Enterprise Linux',
+            vulnerability: { enabled: false },
+          },
+        })
+      ).toBe(true);
+    });
+
+    it('returns true when vulnerability object is missing', () => {
+      expect(
+        vulnerabilityDisabled({
+          hostDetails: {
+            operatingsystem_name: 'Red Hat Enterprise Linux',
+          },
+        })
+      ).toBe(true);
+    });
+
+    it('returns true when hostDetails is missing', () => {
+      expect(vulnerabilityDisabled({})).toBe(true);
+    });
+  });
+
+  describe('hasNoInsightsFacet', () => {
+    it('returns false when insights_attributes is present in response', () => {
+      expect(
+        hasNoInsightsFacet({
+          response: {
+            insights_attributes: {
+              uuid: 'test-uuid',
+              insights_hits_count: 5,
+            },
+          },
+        })
+      ).toBe(false);
+    });
+
+    it('returns true when insights_attributes is missing from response', () => {
+      expect(hasNoInsightsFacet({ response: {} })).toBe(true);
+    });
+
+    it('returns true when response is missing', () => {
+      expect(hasNoInsightsFacet({})).toBe(true);
+    });
+  });
+});

data/webpack/common/Switcher/__tests__/HelpLabel.test.js

@@ -1,13 +1,28 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import React from 'react';
+import { render, screen } from '@testing-library/react';
 import { HelpLabel } from '../HelpLabel';
 
-const fixtures = {
-  'should return insights cloud Url': {
-    id: 'some-id',
-    text: 'some-text',
-    className: 'some-class',
-  },
-};
+describe('HelpLabel', () => {
+  it('renders nothing when text is empty', () => {
+    const { container } = render(<HelpLabel id="test-id" text="" />);
+    expect(container.firstChild).toBeNull();
+  });
 
-describe('InsightsCloudSync helpers', () =>
-  testComponentSnapshotsWithFixtures(HelpLabel, fixtures));
+  it('renders nothing when text is not provided', () => {
+    const { container } = render(<HelpLabel id="test-id" />);
+    expect(container.firstChild).toBeNull();
+  });
+
+  it('renders a button when text is provided', () => {
+    render(<HelpLabel id="test-id" text="Help text" />);
+    expect(screen.getByRole('button')).toBeTruthy();
+  });
+
+  it('applies the provided className', () => {
+    render(
+      <HelpLabel id="test-id" text="Help text" className="custom-class" />
+    );
+    const button = screen.getByRole('button');
+    expect(button.className).toContain('custom-class');
+  });
+});

data/webpack/common/Switcher/__tests__/SwitcherPF4.test.js

@@ -1,14 +1,45 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
 import SwitcherPF4 from '../SwitcherPF4';
 
-const fixtures = {
-  'should return insights cloud Url': {
-    id: 'some-id',
-    tooltip: 'some-text',
-    label: 'some-label',
+describe('SwitcherPF4', () => {
+  const buildProps = (overrides = {}) => ({
+    id: 'test-id',
+    label: 'Test Label',
+    tooltip: 'Test tooltip',
     onChange: jest.fn(),
-  },
-};
+    ...overrides,
+  });
 
-describe('InsightsCloudSync helpers', () =>
-  testComponentSnapshotsWithFixtures(SwitcherPF4, fixtures));
+  it('renders the switch', () => {
+    render(<SwitcherPF4 {...buildProps()} />);
+    expect(screen.getByRole('checkbox')).toBeTruthy();
+  });
+
+  it('renders the label text', () => {
+    render(<SwitcherPF4 {...buildProps()} />);
+    expect(screen.getAllByText('Test Label').length).toBeGreaterThan(0);
+  });
+
+  it('is checked by default', () => {
+    render(<SwitcherPF4 {...buildProps()} />);
+    expect(screen.getByRole('checkbox').checked).toBe(true);
+  });
+
+  it('respects isChecked prop', () => {
+    render(<SwitcherPF4 {...buildProps({ isChecked: false })} />);
+    expect(screen.getByRole('checkbox').checked).toBe(false);
+  });
+
+  it('respects isDisabled prop', () => {
+    render(<SwitcherPF4 {...buildProps({ isDisabled: true })} />);
+    expect(screen.getByRole('checkbox').disabled).toBe(true);
+  });
+
+  it('calls onChange when toggled', () => {
+    const onChange = jest.fn();
+    render(<SwitcherPF4 {...buildProps({ onChange })} />);
+    fireEvent.click(screen.getByRole('checkbox'));
+    expect(onChange).toHaveBeenCalledTimes(1);
+  });
+});