foreman_leapp 3.4.0 → 4.1.0

data/webpack/components/PreupgradeReports/__tests__/PreupgradeReports.fixtures.js

@@ -60,6 +60,49 @@ export const preupgradeReports = [
   },
 ];
 
+export const preupgradeReportsWithFixableEntries = [
+  {
+    hostId: 5,
+    entries: [
+      {
+        title: 'Fixable entry',
+        severity: 'high',
+        id: 100,
+        hostId: 5,
+        hostname: 'host.example.com',
+        flags: [],
+        detail: {
+          remediations: [{ type: 'command', context: ['echo', 'fix'] }],
+        },
+      },
+      {
+        title: 'Not fixable entry',
+        severity: 'low',
+        id: 101,
+        hostId: 5,
+        hostname: 'host.example.com',
+        flags: [],
+      },
+    ],
+  },
+  {
+    hostId: 6,
+    entries: [
+      {
+        title: 'Another fixable entry',
+        severity: 'medium',
+        id: 102,
+        hostId: 6,
+        hostname: 'foo.example.com',
+        flags: [],
+        detail: {
+          remediations: [{ type: 'command', context: ['echo', 'fix2'] }],
+        },
+      },
+    ],
+  },
+];
+
 export const reportsWithRemediations = [
   {
     hostId: 5,

data/webpack/components/PreupgradeReports/__tests__/PreupgradeReports.test.js

@@ -1,54 +1,159 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import React from 'react';
+import { Provider } from 'react-redux';
+import configureMockStore from 'redux-mock-store';
+import { fireEvent, render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
 
 import PreupgradeReports from '../PreupgradeReports';
+import {
+  preupgradeReports,
+  preupgradeReportsWithFixableEntries,
+} from './PreupgradeReports.fixtures';
 
-import { preupgradeReports } from './PreupgradeReports.fixtures';
+jest.mock('foremanReact/components/Pagination', () => {
+  const MockPagination = () => <div data-testid="pagination">Pagination</div>;
+  return MockPagination;
+});
+
+jest.mock('../../PreupgradeReportsList/components/images/i_severity-high.svg', () => 'severity-high.svg');
+jest.mock('../../PreupgradeReportsList/components/images/i_severity-med.svg', () => 'severity-med.svg');
+jest.mock('../../PreupgradeReportsList/components/images/i_severity-low.svg', () => 'severity-low.svg');
+
+const mockStore = configureMockStore([]);
 
 const csrfToken = 'xyz';
 const newJobInvocationUrl = '/job_invocations/new';
-const getPreupgradeReports = () => {};
-
-const fixtures = {
-  'should render when loaded with reports': {
-    loading: false,
-    error: {},
-    preupgradeReports,
-    csrfToken,
-    newJobInvocationUrl,
-    getPreupgradeReports,
-    reportsExpected: true,
-  },
-  'should render when loaded without reports': {
-    loading: false,
-    error: {},
-    preupgradeReports: [],
-    csrfToken,
-    newJobInvocationUrl,
-    getPreupgradeReports,
-    reportsExpected: true,
-  },
-  'should render when loading': {
-    loading: true,
-    error: {},
-    preupgradeReports: [],
-    csrfToken,
-    newJobInvocationUrl,
-    getPreupgradeReports,
-    reportsExpected: false,
-  },
-  'should render error': {
-    loading: false,
-    error: {
-      statusText: 'Internal server error',
-      errorMsg: 'Well, this is embarassing',
-    },
-    preupgradeReports: [],
-    csrfToken,
-    newJobInvocationUrl,
-    getPreupgradeReports,
-    reportsExpected: false,
-  },
+
+const defaultProps = {
+  loading: false,
+  error: {},
+  preupgradeReports,
+  csrfToken,
+  newJobInvocationUrl,
+  reportsExpected: true,
 };
 
-describe('PreupgradeReports', () =>
-  testComponentSnapshotsWithFixtures(PreupgradeReports, fixtures));
+const renderComponent = (props = {}) =>
+  render(
+    <Provider store={mockStore({})}>
+      <PreupgradeReports {...defaultProps} {...props} />
+    </Provider>
+  );
+
+const getFixSelectedForm = () =>
+  screen.getByRole('button', { name: 'Fix Selected' }).closest('form');
+
+describe('PreupgradeReports', () => {
+  // withLoadingState wraps content in patternfly-react LoadingState, which
+  // delays showing the spinner by 300ms and always schedules that timeout on
+  // mount — even when loading=false. Without fake timers the timeout fires
+  // after the test unmounts and React logs a setState-on-unmounted warning.
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.runOnlyPendingTimers();
+    jest.useRealTimers();
+  });
+
+  it('renders report entries when loaded with reports', () => {
+    renderComponent();
+
+    expect(screen.getByText('Fix me!')).toBeInTheDocument();
+    expect(screen.getByText('I am broken too')).toBeInTheDocument();
+    expect(screen.getByText('Octocat is not happy')).toBeInTheDocument();
+  });
+
+  it('renders empty state when loaded without reports', () => {
+    renderComponent({ preupgradeReports: [] });
+
+    expect(
+      screen.getByRole('heading', {
+        name: 'No Preupgrade Report Available',
+        level: 5,
+      })
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText(
+        'The preupgrade report could not be generated, check the job details for the reason'
+      )
+    ).toBeInTheDocument();
+  });
+
+  it('renders loading state while data is being fetched', () => {
+    renderComponent({
+      loading: true,
+      preupgradeReports: [],
+      reportsExpected: false,
+    });
+
+    // LoadingState renders nothing until its 300ms timeout elapses.
+    jest.advanceTimersByTime(300);
+
+    expect(screen.getByText('Loading')).toBeInTheDocument();
+    expect(
+      screen.queryByRole('heading', {
+        name: 'No Preupgrade Report Available',
+      })
+    ).not.toBeInTheDocument();
+  });
+
+  it('renders error empty state when data retrieval fails', () => {
+    renderComponent({
+      error: {
+        statusText: 'Internal server error',
+        errorMsg: 'Unexpected error',
+      },
+      preupgradeReports: [],
+      reportsExpected: false,
+    });
+
+    expect(
+      screen.getByRole('heading', {
+        name: 'Could not retrieve data: Internal server error - Unexpected error',
+        level: 5,
+      })
+    ).toBeInTheDocument();
+  });
+
+  it('disables Fix Selected when no fixable entries are selected', () => {
+    renderComponent({ preupgradeReports: preupgradeReportsWithFixableEntries });
+
+    expect(screen.getByRole('button', { name: 'Fix Selected' })).toBeDisabled();
+  });
+
+  it('enables Fix Selected and passes selected entry ids when a fixable entry is selected', () => {
+    renderComponent({ preupgradeReports: preupgradeReportsWithFixableEntries });
+
+    const [, fixableEntryCheckbox] = screen.getAllByRole('checkbox');
+
+    fireEvent.click(fixableEntryCheckbox);
+
+    expect(screen.getByRole('button', { name: 'Fix Selected' })).toBeEnabled();
+    expect(
+      getFixSelectedForm().querySelector('input[name="inputs[remediation_ids]"]')
+    ).toHaveValue('100');
+  });
+
+  it('selects all fixable entries when header checkbox is clicked', () => {
+    renderComponent({ preupgradeReports: preupgradeReportsWithFixableEntries });
+
+    const [selectAllCheckbox] = screen.getAllByRole('checkbox');
+
+    fireEvent.click(selectAllCheckbox);
+
+    expect(screen.getByRole('button', { name: 'Fix Selected' })).toBeEnabled();
+
+    const form = getFixSelectedForm();
+
+    expect(
+      form.querySelector('input[name="inputs[remediation_ids]"]')
+    ).toHaveValue('100,102');
+    expect(
+      [...form.querySelectorAll('input[name="host_ids[]"]')].map(
+        input => input.value
+      )
+    ).toEqual(['5', '6']);
+  });
+});

data/webpack/components/PreupgradeReports/components/NoReports.test.js

@@ -1,15 +1,29 @@
-import { testComponentSnapshotsWithFixtures } from '@theforeman/test';
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
 
 import NoReports from './NoReports';
 
-const fixtures = {
-  'should render when reports expected': {
-    reportsExpected: true,
-  },
-  'should render when reports not expected': {
-    reportsExpected: false,
-  },
-};
-
-describe('NoReports', () =>
-  testComponentSnapshotsWithFixtures(NoReports, fixtures));
+describe('NoReports', () => {
+  it('should render when reports expected', () => {
+    render(<NoReports reportsExpected />);
+
+    expect(screen.getByText('No Preupgrade Report Available')).toBeInTheDocument();
+    expect(
+      screen.getByText(
+        'The preupgrade report could not be generated, check the job details for the reason'
+      )
+    ).toBeInTheDocument();
+  });
+
+  it('should render when reports not expected', () => {
+    render(<NoReports reportsExpected={false} />);
+
+    expect(screen.getByText('No Preupgrade Report Available')).toBeInTheDocument();
+    expect(
+      screen.getByText(
+        'The preupgrade report will be available after the job finishes'
+      )
+    ).toBeInTheDocument();
+  });
+});

data/webpack/components/PreupgradeReportsTable/PreupgradeReportsTable.scss

@@ -4,11 +4,19 @@
   }
 }
 
+.leapp-searchbar-item {
+  min-width: 200px;
+  flex-grow: 1;
+}
+
 .leapp-expanded-tbody {
   border: 1px solid var(--pf-v5-global--BorderColor--100);
   box-shadow: var(--pf-v5-global--BoxShadow--sm);
 
   tr:first-child > td {
-    background-color: var(--pf-v5-global--primary-color--light-background, #e7f1fa);
+    background-color: var(
+      --pf-v5-global--primary-color--light-background,
+      #e7f1fa
+    );
   }
 }

data/webpack/components/PreupgradeReportsTable/PreupgradeReportsTableHelpers.js

@@ -0,0 +1,164 @@
+import { useState, useEffect, useRef } from 'react';
+import { useDispatch } from 'react-redux';
+import { APIActions } from 'foremanReact/redux/API';
+import { STATUS } from 'foremanReact/constants';
+import { useForemanSettings } from 'foremanReact/Root/Context/ForemanContext';
+
+export const usePreupgradeTableState = (data, isExpanded) => {
+  const dispatch = useDispatch();
+  const lastFetchedKeyRef = useRef(null);
+  const lastEntriesFetchKeyRef = useRef(null);
+  const { perPage: foremanPerPage } = useForemanSettings();
+
+  const [status, setStatus] = useState(STATUS.RESOLVED);
+  const [error, setError] = useState(null);
+  const [reportId, setReportId] = useState(null);
+  const [rows, setRows] = useState([]);
+  const [totalCount, setTotalCount] = useState(0);
+  const [searchValue, setSearchValue] = useState('');
+  const [pagination, setPagination] = useState({
+    page: 1,
+    perPage: foremanPerPage,
+  });
+  const [sortBy, setSortBy] = useState({ index: '', direction: 'asc' });
+  const [expandedRowIds, setExpandedRowIds] = useState(new Set());
+
+  // eslint-disable-next-line camelcase
+  const isLeappJob = data?.template_name?.includes('Run preupgrade via Leapp');
+  // eslint-disable-next-line camelcase
+  const jobStatusLabel = data?.status_label;
+
+  useEffect(() => {
+    const fetchKey = `${data.id}:${jobStatusLabel}`;
+    if (!isLeappJob || !isExpanded || lastFetchedKeyRef.current === fetchKey)
+      return undefined;
+
+    let ignore = false;
+    setStatus(STATUS.PENDING);
+
+    dispatch(
+      APIActions.get({
+        key: `GET_LEAPP_REPORT_LIST_${data.id}`,
+        url: `/api/v2/job_invocations/${data.id}/preupgrade_reports`,
+        handleSuccess: res => {
+          if (ignore) return;
+          lastFetchedKeyRef.current = fetchKey;
+          const payload = res.data || res;
+          const rawResults = payload.results;
+          const resultsArray = rawResults ? [].concat(rawResults) : [];
+
+          if (resultsArray[0]?.id) {
+            setReportId(resultsArray[0].id);
+          } else {
+            setRows([]);
+            setTotalCount(0);
+            setStatus(STATUS.RESOLVED);
+          }
+        },
+        handleError: err => {
+          if (ignore) return;
+          setError(err);
+          setStatus(STATUS.ERROR);
+        },
+      })
+    );
+
+    return () => {
+      ignore = true;
+    };
+  }, [isExpanded, data.id, isLeappJob, dispatch, jobStatusLabel]);
+
+  useEffect(() => {
+    if (!isLeappJob || !isExpanded || !reportId) return undefined;
+
+    const entriesFetchKey = `${reportId}_P${pagination.page}_PP${pagination.perPage}_S${searchValue}_O${sortBy.index}${sortBy.direction}_J${jobStatusLabel}`;
+    if (lastEntriesFetchKeyRef.current === entriesFetchKey) return undefined;
+
+    let ignore = false;
+    setStatus(STATUS.PENDING);
+
+    const orderParam = sortBy.index
+      ? `${sortBy.index} ${sortBy.direction.toUpperCase()}`
+      : undefined;
+
+    dispatch(
+      APIActions.get({
+        key: `GET_LEAPP_REPORT_ENTRIES_${entriesFetchKey}`,
+        url: `/api/v2/preupgrade_reports/${reportId}/preupgrade_report_entries`,
+        params: {
+          page: pagination.page,
+          per_page: pagination.perPage,
+          ...(searchValue && { search: searchValue }),
+          ...(orderParam && { order: orderParam }),
+        },
+        handleSuccess: res => {
+          if (ignore) return;
+          lastEntriesFetchKeyRef.current = entriesFetchKey;
+          const payload = res.data || res;
+          const fetchedResults = payload.results;
+          setRows(fetchedResults ? [].concat(fetchedResults) : []);
+          setTotalCount(payload.subtotal ?? 0);
+          setStatus(STATUS.RESOLVED);
+          setExpandedRowIds(new Set());
+        },
+        handleError: err => {
+          if (ignore) return;
+          setError(err);
+          setStatus(STATUS.ERROR);
+        },
+      })
+    );
+
+    return () => {
+      ignore = true;
+    };
+  }, [
+    isExpanded,
+    isLeappJob,
+    reportId,
+    searchValue,
+    pagination.page,
+    pagination.perPage,
+    sortBy.index,
+    sortBy.direction,
+    dispatch,
+    jobStatusLabel,
+  ]);
+
+  const areAllRowsExpanded =
+    rows.length > 0 && rows.every(row => expandedRowIds.has(row.id));
+
+  const onExpandAll = () => {
+    setExpandedRowIds(
+      areAllRowsExpanded ? new Set() : new Set(rows.map(r => r.id))
+    );
+  };
+
+  const toggleRowExpansion = (id, isOpen) => {
+    setExpandedRowIds(prev => {
+      const next = new Set(prev);
+      if (isOpen) next.add(id);
+      else next.delete(id);
+      return next;
+    });
+  };
+
+  return {
+    isLeappJob,
+    status,
+    error,
+    reportId,
+    rows,
+    totalCount,
+    pagination,
+    sortBy,
+    searchValue,
+    setSearchValue,
+    setPagination,
+    setSortBy,
+    expandedRowIds,
+    toggleRowExpansion,
+    areAllRowsExpanded,
+    onExpandAll,
+  };
+};