foreman_leapp 3.3.0 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8841245ebb39f45ba92ea5b955a3398434dc103a860c50f2930019c0ee102a4e
-  data.tar.gz: 9a13e0df52eb412eecff7dfa1adff514670ada9dec259a9e349eef1b5ec9e092
+  metadata.gz: a7e5030bef562d53e8f4212fa76732f0901ec4b827620a5f07028fd11bcf36d4
+  data.tar.gz: eac05d03ce3b746a996751d2b5affb5ea1fabea4d74dd8899f5771b5bc69f8ec
 SHA512:
-  metadata.gz: 37b092dbdd94f413763b9301c29c552a55cc44a0a0881462fe228d0f1b3510f750145b20eb55b459bc6acf09212b40381657749eaf0590a49024dbd79c9b097a
-  data.tar.gz: f93aca5a49a5c5f76fc36759310c0372f7e56b418ee2bad597461700ba9055544c9bdcb0b5ffab9561eddf7121dc0ad80af0061ee5557944f2d71b2af2927be2
+  metadata.gz: 77e129433f0175d3951ccc870e66bda4f37930d888a83704142e80d95490e7a9c76b134ab3337c293e03c15bc9c770e8835ba9bec8e11e32d66087ff0a23a5a4
+  data.tar.gz: 29c9135b5faf4f6564c71d24cc989a6adc3d4a67c731a5bfca38d3618ec75745f9f1492295356386a7204971d53853558bf5a6d335f5252f55bc0d557bb42f7d

data/Rakefile

@@ -6,21 +6,6 @@ begin
 rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
-begin
-  require 'rdoc/task'
-rescue LoadError
-  require 'rdoc/rdoc'
-  require 'rake/rdoctask'
-  RDoc::Task = Rake::RDocTask
-end
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'ForemanLeapp'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
 
 APP_RAKEFILE = File.expand_path('test/dummy/Rakefile', __dir__)
 

data/lib/foreman_leapp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ForemanLeapp
-  VERSION = '3.3.0'
+  VERSION = '3.4.0'
 end

data/webpack/components/PreupgradeReportsTable/PreupgradeReportsTable.scss

@@ -3,3 +3,12 @@
     white-space: pre-wrap;
   }
 }
+
+.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);
+  }
+}

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

@@ -1,17 +1,19 @@
-import React from 'react';
+import '@testing-library/jest-dom/extend-expect';
+
 import {
+  fireEvent,
   render,
   screen,
   waitFor,
-  fireEvent,
   within,
 } from '@testing-library/react';
-import '@testing-library/jest-dom/extend-expect';
+
+import { APIActions } from 'foremanReact/redux/API';
+import PreupgradeReportsTable from '../index';
 import { Provider } from 'react-redux';
+import React from 'react';
 import configureMockStore from 'redux-mock-store';
 import thunk from 'redux-thunk';
-import { APIActions } from 'foremanReact/redux/API';
-import PreupgradeReportsTable from '../index';
 
 jest.mock('foremanReact/redux/API');
 
@@ -24,17 +26,25 @@ const mockJobData = {
   template_name: 'Run preupgrade via Leapp',
 };
 
+// Entry 0 (id=1):  command remediation + inhibitor flag → fixable + selectable
+// Entry 1 (id=2):  hint-only remediation                → has_remediation=Yes, NOT selectable
+// Entries 2-11:    no remediations                      → has_remediation=No,  NOT selectable
 const mockEntries = Array.from({ length: 12 }, (_, i) => ({
   id: i + 1,
   title: `Report Entry ${i + 1}`,
   hostname: 'example.com',
+  host_id: 100 + i,
   severity: i === 0 ? 'high' : 'low',
   summary: `Summary for report entry ${i + 1}`,
   tags: i === 0 ? ['security', 'network'] : [],
   flags: i === 0 ? ['inhibitor'] : [],
   detail: {
     remediations:
-      i === 0 ? [{ type: 'command', context: ['echo', 'fix_command'] }] : [],
+      i === 0
+        ? [{ type: 'command', context: ['echo', 'fix_command'] }]
+        : i === 1
+        ? [{ type: 'hint', context: 'Do something manually' }]
+        : null,
     external:
       i === 0 ? [{ url: 'http://example.com', title: 'External Link' }] : [],
   },
@@ -59,6 +69,8 @@ describe('PreupgradeReportsTable', () => {
         return { type: 'MOCK_API_SUCCESS' };
       };
     });
+
+    APIActions.post.mockImplementation(() => () => ({ type: 'MOCK_API_POST' }));
   });
 
   const renderComponent = (data = mockJobData) =>
@@ -68,41 +80,106 @@ describe('PreupgradeReportsTable', () => {
       </Provider>
     );
 
-  const expandSection = () => {
+  const expandSection = () =>
     fireEvent.click(screen.getByText('Leapp preupgrade report'));
-  };
+
+  const waitForTable = () =>
+    waitFor(() => screen.getByText('Report Entry 1', { selector: 'td' }));
 
   it('renders data', async () => {
     renderComponent();
     expandSection();
-    await waitFor(() => screen.getByText('Report Entry 1', { selector: 'td' }));
+    await waitForTable();
     expect(
       screen.getByText('Report Entry 1', { selector: 'td' })
     ).toBeInTheDocument();
   });
 
-  it('expands a row and shows details', async () => {
-    renderComponent();
+  it('does not render anything for non-Leapp jobs', () => {
+    renderComponent({ id: 55, template_name: 'Standard RHEL Update' });
+    expect(
+      screen.queryByText('Leapp preupgrade report')
+    ).not.toBeInTheDocument();
+  });
+
+  it('refetches when status_label transitions (e.g. Running → Succeeded)', async () => {
+    const { rerender } = render(
+      <Provider store={store}>
+        <PreupgradeReportsTable
+          data={{ ...mockJobData, status_label: 'Running' }}
+        />
+      </Provider>
+    );
     expandSection();
-    await waitFor(() => screen.getByText('Report Entry 1', { selector: 'td' }));
+    await waitForTable();
 
-    const rowExpandButtons = screen.getAllByLabelText('Details');
-    fireEvent.click(rowExpandButtons[0]);
+    const callCountAfterFirstFetch = APIActions.get.mock.calls.length;
 
-    expect(await screen.findByText('Summary')).toBeInTheDocument();
+    rerender(
+      <Provider store={store}>
+        <PreupgradeReportsTable
+          data={{ ...mockJobData, status_label: 'Succeeded' }}
+        />
+      </Provider>
+    );
+
+    await waitFor(() =>
+      expect(APIActions.get.mock.calls.length).toBeGreaterThan(
+        callCountAfterFirstFetch
+      )
+    );
     expect(
-      await screen.findByText('Summary for report entry 1')
+      screen.getByText('Report Entry 1', { selector: 'td' })
     ).toBeInTheDocument();
   });
 
-  it('expands all rows', async () => {
+  it('does not refetch on collapse/re-expand when status_label is unchanged', async () => {
+    renderComponent({ ...mockJobData, status_label: 'Succeeded' });
+    expandSection();
+    await waitForTable();
+
+    const callCountAfterFirstFetch = APIActions.get.mock.calls.length;
+
+    fireEvent.click(screen.getByText('Leapp preupgrade report')); // collapse
+    fireEvent.click(screen.getByText('Leapp preupgrade report')); // re-expand
+
+    expect(APIActions.get.mock.calls.length).toBe(callCountAfterFirstFetch);
+  });
+
+  it('renders empty state message when no issues found', async () => {
+    APIActions.get.mockImplementation(({ key, handleSuccess }) => {
+      return () => {
+        if (key.includes('GET_LEAPP_REPORT_LIST'))
+          handleSuccess({ results: [{ id: mockReportId }] });
+        if (key.includes('GET_LEAPP_REPORT_DETAIL'))
+          handleSuccess({ id: mockReportId, preupgrade_report_entries: [] });
+        return { type: 'EMPTY' };
+      };
+    });
     renderComponent();
     expandSection();
-    await waitFor(() => screen.getByText('Report Entry 1', { selector: 'td' }));
+    await waitFor(() =>
+      expect(
+        screen.getByText('The preupgrade report shows no issues.')
+      ).toBeInTheDocument()
+    );
+  });
 
-    const expandAllButton = screen.getByLabelText('Expand all rows');
-    fireEvent.click(expandAllButton);
+  it('expands a row and shows details', async () => {
+    renderComponent();
+    expandSection();
+    await waitForTable();
+    fireEvent.click(screen.getAllByLabelText('Details')[0]);
+    expect(
+      await screen.findByText('Summary for report entry 1')
+    ).toBeInTheDocument();
+  });
 
+  it('expands all rows', async () => {
+    renderComponent();
+    expandSection();
+    await waitForTable();
+    fireEvent.click(screen.getByLabelText('Expand all rows'));
     expect(
       await screen.findByText('Summary for report entry 1')
     ).toBeInTheDocument();
@@ -114,11 +191,9 @@ describe('PreupgradeReportsTable', () => {
   it('paginates to the next page', async () => {
     renderComponent();
     expandSection();
-    await waitFor(() => screen.getByText('Report Entry 1', { selector: 'td' }));
-
+    await waitForTable();
     fireEvent.click(screen.getAllByLabelText('Go to next page')[0]);
     await waitFor(() => screen.getByText('Report Entry 6', { selector: 'td' }));
-
     expect(
       screen.getByText('Report Entry 10', { selector: 'td' })
     ).toBeInTheDocument();
@@ -127,19 +202,168 @@ describe('PreupgradeReportsTable', () => {
   it('changes perPage limit to 10', async () => {
     renderComponent();
     expandSection();
-    await waitFor(() => screen.getByText('Report Entry 1', { selector: 'td' }));
-
+    await waitForTable();
     fireEvent.click(screen.getAllByLabelText('Items per page')[0]);
     fireEvent.click(screen.getAllByText('10 per page')[0]);
-
-    await waitFor(() => {
+    await waitFor(() =>
       expect(
         screen.getByText('Report Entry 10', { selector: 'td' })
-      ).toBeInTheDocument();
-    });
+      ).toBeInTheDocument()
+    );
   });
 
-  it('renders empty state message when no issues found', async () => {
+  it('displays correct inhibitor status based on flags', async () => {
+    renderComponent();
+    expandSection();
+    await waitForTable();
+
+    const row1 = screen
+      .getByText('Report Entry 1', { selector: 'td' })
+      .closest('tr');
+    expect(
+      within(row1.querySelector('td[data-label="Inhibitor?"]')).getByText('Yes')
+    ).toBeInTheDocument();
+
+    const row2 = screen
+      .getByText('Report Entry 2', { selector: 'td' })
+      .closest('tr');
+    expect(
+      within(row2.querySelector('td[data-label="Inhibitor?"]')).getByText('No')
+    ).toBeInTheDocument();
+  });
+
+  it('shows Has Remediation? Yes for any remediation type, not only command', async () => {
+    renderComponent();
+    expandSection();
+    await waitForTable();
+
+    // id=1: command → Yes
+    const row1 = screen
+      .getByText('Report Entry 1', { selector: 'td' })
+      .closest('tr');
+    expect(
+      within(row1.querySelector('td[data-label="Has Remediation?"]')).getByText(
+        'Yes'
+      )
+    ).toBeInTheDocument();
+
+    // id=2: hint-only → still Yes (display column shows any remediations)
+    const row2 = screen
+      .getByText('Report Entry 2', { selector: 'td' })
+      .closest('tr');
+    expect(
+      within(row2.querySelector('td[data-label="Has Remediation?"]')).getByText(
+        'Yes'
+      )
+    ).toBeInTheDocument();
+
+    // id=3: no remediations → No
+    const row3 = screen
+      .getByText('Report Entry 3', { selector: 'td' })
+      .closest('tr');
+    expect(
+      within(row3.querySelector('td[data-label="Has Remediation?"]')).getByText(
+        'No'
+      )
+    ).toBeInTheDocument();
+  });
+
+  it('renders Fix Selected button disabled initially', async () => {
+    renderComponent();
+    expandSection();
+    await waitForTable();
+    expect(screen.getByRole('button', { name: 'Fix Selected' })).toBeDisabled();
+  });
+
+  it('enables Fix Selected after selecting a fixable (command) row', async () => {
+    renderComponent();
+    expandSection();
+    await waitForTable();
+
+    // checkboxes[0] = SelectAll, checkboxes[1] = entry id=1 (command remediation)
+    fireEvent.click(screen.getAllByRole('checkbox')[1]);
+
+    await waitFor(() =>
+      expect(
+        screen.getByRole('button', { name: 'Fix Selected' })
+      ).not.toBeDisabled()
+    );
+  });
+
+  it('Fix Selected dispatches APIActions.post with correct feature, host_ids and remediation_ids', async () => {
+    renderComponent();
+    expandSection();
+    await waitForTable();
+
+    fireEvent.click(screen.getAllByRole('checkbox')[1]); // select entry id=1 (host_id=100)
+
+    await waitFor(() =>
+      expect(
+        screen.getByRole('button', { name: 'Fix Selected' })
+      ).not.toBeDisabled()
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: 'Fix Selected' }));
+
+    expect(APIActions.post).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: expect.stringContaining('/api/job_invocations'),
+        params: {
+          job_invocation: {
+            feature: 'leapp_remediation_plan',
+            host_ids: [100],
+            inputs: { remediation_ids: '1' },
+          },
+        },
+      })
+    );
+  });
+
+  it('hint-only row checkbox is disabled and does not enable Fix Selected', async () => {
+    renderComponent();
+    expandSection();
+    await waitForTable();
+
+    // checkboxes[2] = entry id=2, which has hint-only remediation — must be disabled
+    const hintCheckbox = screen.getAllByRole('checkbox')[2];
+    expect(hintCheckbox).toBeDisabled();
+
+    fireEvent.click(hintCheckbox);
+    expect(screen.getByRole('button', { name: 'Fix Selected' })).toBeDisabled();
+  });
+
+  it('renders Run Upgrade button enabled when entries are present', async () => {
+    renderComponent();
+    expandSection();
+    await waitForTable();
+    expect(
+      screen.getByRole('button', { name: 'Run Upgrade' })
+    ).not.toBeDisabled();
+  });
+
+  it('Run Upgrade dispatches APIActions.post with correct feature and all host_ids', async () => {
+    renderComponent();
+    expandSection();
+    await waitForTable();
+
+    fireEvent.click(screen.getByRole('button', { name: 'Run Upgrade' }));
+
+    expect(APIActions.post).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: expect.stringContaining('/api/job_invocations'),
+        params: {
+          job_invocation: {
+            feature: 'leapp_upgrade',
+            host_ids: expect.arrayContaining([100, 101, 102]),
+          },
+        },
+      })
+    );
+    const callParams = APIActions.post.mock.calls[0][0].params.job_invocation;
+    expect(callParams.inputs).toBeUndefined();
+  });
+
+  it('does not render toolbar buttons when report has no entries', async () => {
     APIActions.get.mockImplementation(({ key, handleSuccess }) => {
       return () => {
         if (key.includes('GET_LEAPP_REPORT_LIST'))
@@ -151,36 +375,35 @@ describe('PreupgradeReportsTable', () => {
     });
     renderComponent();
     expandSection();
-    await waitFor(() => {
-      expect(
-        screen.getByText('The preupgrade report shows no issues.')
-      ).toBeInTheDocument();
-    });
-  });
-
-  it('does not render anything for non-Leapp jobs', () => {
-    const nonLeappData = { id: 55, template_name: 'Standard RHEL Update' };
-    renderComponent(nonLeappData);
+    await waitFor(() =>
+      screen.getByText('The preupgrade report shows no issues.')
+    );
     expect(
-      screen.queryByText('Leapp preupgrade report')
+      screen.queryByRole('button', { name: 'Fix Selected' })
+    ).not.toBeInTheDocument();
+    expect(
+      screen.queryByRole('button', { name: 'Run Upgrade' })
     ).not.toBeInTheDocument();
   });
 
-  it('displays correct inhibitor status based on flags', async () => {
+  it('renders the SelectAll checkbox', async () => {
     renderComponent();
     expandSection();
-    await waitFor(() => screen.getByText('Report Entry 1', { selector: 'td' }));
+    await waitForTable();
+    expect(screen.getAllByRole('checkbox').length).toBeGreaterThan(0);
+  });
 
-    const row1 = screen
-      .getByText('Report Entry 1', { selector: 'td' })
-      .closest('tr');
-    const inhibitorCell1 = row1.querySelector('td[data-label="Inhibitor?"]');
-    expect(within(inhibitorCell1).getByText('Yes')).toBeInTheDocument();
+  it('selecting all fixable rows enables Fix Selected', async () => {
+    renderComponent();
+    expandSection();
+    await waitForTable();
 
-    const row2 = screen
-      .getByText('Report Entry 2', { selector: 'td' })
-      .closest('tr');
-    const inhibitorCell2 = row2.querySelector('td[data-label="Inhibitor?"]');
-    expect(within(inhibitorCell2).getByText('No')).toBeInTheDocument();
+    fireEvent.click(screen.getByLabelText('Select all'));
+
+    await waitFor(() =>
+      expect(
+        screen.getByRole('button', { name: 'Fix Selected' })
+      ).not.toBeDisabled()
+    );
   });
 });

data/webpack/components/PreupgradeReportsTable/index.js

@@ -1,163 +1,374 @@
+/* eslint-disable max-lines */
 import PropTypes from 'prop-types';
-import React, { useEffect, useState } from 'react';
+import React, {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
 import { useDispatch } from 'react-redux';
-import { ExpandableSection, Tooltip } from '@patternfly/react-core';
+import {
+  Button,
+  ExpandableSection,
+  Toolbar,
+  ToolbarContent,
+  ToolbarGroup,
+  ToolbarItem,
+  Tooltip,
+} from '@patternfly/react-core';
 import { ExpandableRowContent, Tbody, Td, Tr } from '@patternfly/react-table';
 import { translate as __ } from 'foremanReact/common/I18n';
+import { foremanUrl } from 'foremanReact/common/helpers';
 import { Table } from 'foremanReact/components/PF4/TableIndexPage/Table/Table';
+import SelectAllCheckbox from 'foremanReact/components/PF4/TableIndexPage/Table/SelectAllCheckbox';
+import { useBulkSelect } from 'foremanReact/components/PF4/TableIndexPage/Table/TableHooks';
+import { RowSelectTd } from 'foremanReact/components/PF4/TableIndexPage/RowSelectTd';
 import { getColumnHelpers } from 'foremanReact/components/PF4/TableIndexPage/Table/helpers';
 import { APIActions } from 'foremanReact/redux/API';
 import { STATUS } from 'foremanReact/constants';
-import { entriesPage } from '../PreupgradeReports/PreupgradeReportsHelpers';
+import {
+  entriesPage,
+  entryFixable,
+} from '../PreupgradeReports/PreupgradeReportsHelpers';
 import ReportDetails, { renderSeverityLabel } from './ReportDetails';
+import './PreupgradeReportsTable.scss';
+
+const LEAPP_TEMPLATE_NAME = 'Run preupgrade via Leapp';
+
+const isRowFixable = entryFixable;
+
+const submitJobInvocation = (
+  dispatch,
+  setError,
+  feature,
+  hostIds,
+  remediationIds
+) => {
+  const payload = {
+    job_invocation: {
+      feature,
+      host_ids: hostIds,
+      ...(remediationIds != null
+        ? { inputs: { remediation_ids: remediationIds } }
+        : {}),
+    },
+  };
+
+  dispatch(
+    APIActions.post({
+      key: `CREATE_JOB_INVOCATION_${feature}`,
+      url: foremanUrl('/api/job_invocations'),
+      params: payload,
+      handleSuccess: response => {
+        const result = response.data || response;
+        if (result?.id) {
+          window.location.assign(foremanUrl(`/job_invocations/${result.id}`));
+        }
+      },
+      handleError: err => setError(err),
+    })
+  );
+};
 
 const PreupgradeReportsTable = ({ data = {} }) => {
   const [error, setError] = useState(null);
-
-  const [isReportExpanded, setIsReportExpanded] = useState(false); // Outer expansion state (Leapp Report Section)
+  const [isReportExpanded, setIsReportExpanded] = useState(false);
   const [pagination, setPagination] = useState({ page: 1, perPage: 5 });
   const [reportData, setReportData] = useState(null);
   const [status, setStatus] = useState(STATUS.RESOLVED);
-  const [expandedRowIds, setExpandedRowIds] = useState(new Set()); // Inner table expansion state (Rows)
+  const [expandedRowIds, setExpandedRowIds] = useState(new Set());
 
   const dispatch = useDispatch();
   // eslint-disable-next-line camelcase
-  const isLeappJob = data?.template_name?.includes('Run preupgrade via Leapp');
+  const isLeappJob = data?.template_name?.includes(LEAPP_TEMPLATE_NAME);
 
-  const columns = {
-    title: {
-      title: __('Title'),
-    },
-    host: {
-      title: __('Host'),
-      wrapper: entry =>
-        entry.hostname || (reportData && reportData.hostname) || '-',
-    },
-    risk_factor: {
-      title: __('Risk Factor'),
-      wrapper: ({ severity }) => renderSeverityLabel(severity),
-    },
-    has_remediation: {
-      title: __('Has Remediation?'),
-      wrapper: entry =>
-        entry.detail && entry.detail.remediations ? __('Yes') : __('No'),
-    },
-    inhibitor: {
-      title: __('Inhibitor?'),
-      wrapper: entry =>
-        entry.flags && entry.flags.some(flag => flag === 'inhibitor') ? (
-          <Tooltip content={__('This issue inhibits the upgrade.')}>
-            <span>{__('Yes')}</span>
-          </Tooltip>
-        ) : (
-          __('No')
-        ),
-    },
-  };
+  // eslint-disable-next-line camelcase
+  const jobStatusLabel = data?.status_label;
+
+  const lastFetchedKeyRef = useRef(null);
+
+  const columns = useMemo(
+    () => ({
+      title: { title: __('Title') },
+      host: {
+        title: __('Host'),
+        wrapper: entry => entry.hostname || reportData?.hostname || '-',
+      },
+      risk_factor: {
+        title: __('Risk Factor'),
+        wrapper: ({ severity }) => renderSeverityLabel(severity),
+      },
+      has_remediation: {
+        title: __('Has Remediation?'),
+        wrapper: entry => (entry.detail?.remediations ? __('Yes') : __('No')),
+      },
+      inhibitor: {
+        title: __('Inhibitor?'),
+        wrapper: entry =>
+          entry.flags?.some(flag => flag === 'inhibitor') ? (
+            <Tooltip content={__('This issue inhibits the upgrade.')}>
+              <span>{__('Yes')}</span>
+            </Tooltip>
+          ) : (
+            __('No')
+          ),
+      },
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [reportData?.hostname]
+  );
 
   useEffect(() => {
     let isMounted = true;
-    if (!isLeappJob || !isReportExpanded || reportData) {
+    const fetchKey = `${data.id}:${jobStatusLabel}`;
+
+    if (
+      !isLeappJob ||
+      !isReportExpanded ||
+      lastFetchedKeyRef.current === fetchKey
+    )
       return undefined;
-    }
-    setStatus(STATUS.PENDING);
 
+    const fail = err => {
+      if (!isMounted) return;
+      setError(err);
+      setStatus(STATUS.ERROR);
+    };
+
+    const succeed = response => {
+      if (!isMounted) return;
+      lastFetchedKeyRef.current = fetchKey;
+      setReportData(response?.data || response || null);
+      setStatus(STATUS.RESOLVED);
+    };
+
+    setStatus(STATUS.PENDING);
     dispatch(
       APIActions.get({
         key: `GET_LEAPP_REPORT_LIST_${data.id}`,
         url: `/api/job_invocations/${data.id}/preupgrade_reports`,
         handleSuccess: listResponse => {
           if (!isMounted) return;
-          const listPayload = listResponse.data || listResponse;
-          const summary = listPayload.results?.[0];
+          const summary = (listResponse.data || listResponse).results?.[0];
           if (summary?.id) {
             dispatch(
               APIActions.get({
                 key: `GET_LEAPP_REPORT_DETAIL_${summary.id}`,
                 url: `/api/preupgrade_reports/${summary.id}`,
-                handleSuccess: detailResponse => {
-                  if (isMounted) {
-                    const detailPayload = detailResponse.data || detailResponse;
-                    setReportData(detailPayload);
-                    setStatus(STATUS.RESOLVED);
-                  }
-                },
-                handleError: err => {
-                  if (isMounted) {
-                    setError(err);
-                    setStatus(STATUS.ERROR);
-                  }
-                },
+                handleSuccess: detailResponse => succeed(detailResponse),
+                handleError: err => fail(err),
               })
             );
-          } else if (isMounted) {
-            setReportData({});
-            setStatus(STATUS.RESOLVED);
-          }
-        },
-        handleError: err => {
-          if (isMounted) {
-            setError(err);
-            setStatus(STATUS.ERROR);
+            return;
           }
+          succeed(null);
         },
+        handleError: err => fail(err),
       })
     );
 
     return () => {
       isMounted = false;
     };
-  }, [isReportExpanded, data.id, isLeappJob, reportData, dispatch]);
+  }, [isReportExpanded, data.id, isLeappJob, dispatch, jobStatusLabel]);
 
   // eslint-disable-next-line camelcase
-  const entries = reportData?.preupgrade_report_entries || [];
-  const pagedEntries = entriesPage(entries, pagination);
+  const entries = useMemo(() => reportData?.preupgrade_report_entries || [], [
+    reportData,
+  ]);
 
-  const handleParamsChange = newParams => {
+  const pagedEntries = useMemo(
+    () => entriesPage(entries, pagination),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [entries, pagination.page, pagination.perPage]
+  );
+
+  const getHostId = useCallback(
+    entry =>
+      entry.host_id ||
+      entry.hostId ||
+      // eslint-disable-next-line camelcase
+      reportData?.host_id ||
+      reportData?.host?.id ||
+      // eslint-disable-next-line camelcase
+      data?.targeting?.host_id,
+    [reportData, data]
+  );
+
+  const handleParamsChange = useCallback(newParams => {
     setPagination(prev => ({
       ...prev,
       page: newParams.page || prev.page,
       perPage: newParams.per_page || prev.perPage,
     }));
     setExpandedRowIds(new Set());
-  };
+  }, []);
 
-  const toggleRowExpansion = (id, isExpanding) => {
+  const toggleRowExpansion = useCallback((id, isExpanding) => {
     setExpandedRowIds(prev => {
-      const newSet = new Set(prev);
-      if (isExpanding) {
-        newSet.add(id);
-      } else {
-        newSet.delete(id);
-      }
-      return newSet;
+      const next = new Set(prev);
+      if (isExpanding) next.add(id);
+      else next.delete(id);
+      return next;
     });
-  };
+  }, []);
+
+  const { inclusionSet, exclusionSet, ...selectAllOptions } = useBulkSelect({
+    results: pagedEntries,
+    metadata: {
+      total: entries.length,
+      page: pagination.page,
+      selectable: entries.length,
+    },
+    initialSearchQuery: '',
+  });
+
+  const {
+    selectAll,
+    selectPage,
+    selectNone,
+    selectOne,
+    areAllRowsSelected,
+    isSelected,
+  } = selectAllOptions;
+
+  const rawSelectedIds =
+    areAllRowsSelected() || exclusionSet.size > 0
+      ? entries.map(e => e.id).filter(id => !exclusionSet.has(id))
+      : Array.from(inclusionSet);
+
+  const validFixableIds = useMemo(
+    () => entries.filter(isRowFixable).map(e => e.id),
+    [entries]
+  );
+
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  const selectedIds = useMemo(
+    () => rawSelectedIds.filter(id => validFixableIds.includes(id)),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [rawSelectedIds.join(','), validFixableIds]
+  );
+
+  const pagedFixableEntries = useMemo(() => pagedEntries.filter(isRowFixable), [
+    pagedEntries,
+  ]);
+
+  const areAllPageFixableSelected =
+    pagedFixableEntries.length > 0 &&
+    pagedFixableEntries.every(e => selectedIds.includes(e.id));
+
+  const areAllFixableSelected =
+    validFixableIds.length > 0 &&
+    validFixableIds.every(id => selectedIds.includes(id));
 
   const areAllRowsExpanded =
     pagedEntries.length > 0 &&
     pagedEntries.every(entry => expandedRowIds.has(entry.id));
 
-  const onExpandAll = () => {
-    setExpandedRowIds(() => {
-      if (areAllRowsExpanded) {
-        return new Set();
-      }
-      return new Set(pagedEntries.map(e => e.id));
-    });
-  };
+  const onExpandAll = useCallback(() => {
+    setExpandedRowIds(
+      areAllRowsExpanded ? new Set() : new Set(pagedEntries.map(e => e.id))
+    );
+  }, [areAllRowsExpanded, pagedEntries]);
+
+  const [columnKeys, keysToColumnNames] = useMemo(
+    () => getColumnHelpers(columns),
+    [columns]
+  );
+
+  const hostIdsForSelected = useMemo(
+    () =>
+      Array.from(
+        new Set(
+          entries
+            .filter(e => selectedIds.includes(e.id))
+            .map(getHostId)
+            .filter(Boolean)
+        )
+      ),
+    [entries, selectedIds, getHostId]
+  );
 
-  const [columnKeys, keysToColumnNames] = getColumnHelpers(columns);
+  const allHostIds = useMemo(
+    () => Array.from(new Set(entries.map(getHostId).filter(Boolean))),
+    [entries, getHostId]
+  );
 
   if (!isLeappJob) return null;
 
+  const isFixSelectedDisabled =
+    validFixableIds.length === 0 ||
+    selectedIds.length === 0 ||
+    hostIdsForSelected.length === 0;
+
   return (
     <ExpandableSection
-      className="leapp-report-section"
       isExpanded={isReportExpanded}
       onToggle={(_event, val) => setIsReportExpanded(val)}
       toggleText={__('Leapp preupgrade report')}
     >
+      {entries.length > 0 && status === STATUS.RESOLVED && (
+        <Toolbar ouiaId="leapp-report-toolbar">
+          <ToolbarContent>
+            <ToolbarGroup variant="filter-group">
+              <ToolbarItem>
+                <SelectAllCheckbox
+                  selectAll={selectAll}
+                  selectPage={selectPage}
+                  selectNone={selectNone}
+                  selectedCount={selectedIds.length}
+                  pageRowCount={pagedFixableEntries.length}
+                  totalCount={validFixableIds.length}
+                  areAllRowsOnPageSelected={areAllPageFixableSelected}
+                  areAllRowsSelected={areAllFixableSelected}
+                />
+              </ToolbarItem>
+            </ToolbarGroup>
+            <ToolbarGroup
+              align={{ default: 'alignRight' }}
+              variant="button-group"
+            >
+              <ToolbarItem>
+                <Button
+                  variant="secondary"
+                  isDisabled={isFixSelectedDisabled}
+                  onClick={() =>
+                    submitJobInvocation(
+                      dispatch,
+                      setError,
+                      'leapp_remediation_plan',
+                      hostIdsForSelected,
+                      selectedIds.join(',')
+                    )
+                  }
+                  ouiaId="fix-selected-button"
+                >
+                  {__('Fix Selected')}
+                </Button>
+              </ToolbarItem>
+              <ToolbarItem>
+                <Button
+                  variant="primary"
+                  isDisabled={allHostIds.length === 0}
+                  onClick={() =>
+                    submitJobInvocation(
+                      dispatch,
+                      setError,
+                      'leapp_upgrade',
+                      allHostIds
+                    )
+                  }
+                  ouiaId="run-upgrade-button"
+                >
+                  {__('Run Upgrade')}
+                </Button>
+              </ToolbarItem>
+            </ToolbarGroup>
+          </ToolbarContent>
+        </Toolbar>
+      )}
+
       <Table
         ouiaId="leapp-report-table"
         columns={columns}
@@ -174,20 +385,24 @@ const PreupgradeReportsTable = ({ data = {} }) => {
         errorMessage={
           status === STATUS.ERROR && error?.message ? error.message : null
         }
-        showCheckboxes={false}
+        showCheckboxes
         refreshData={() => {}}
         isDeleteable={false}
         emptyMessage={__('The preupgrade report shows no issues.')}
         setParams={handleParamsChange}
         childrenOutsideTbody
         onExpandAll={onExpandAll}
-        // Inverted per PatternFly implementation to ensure correct toggle icon state
         areAllRowsExpanded={!areAllRowsExpanded}
       >
         {pagedEntries.map((entry, rowIndex) => {
           const isRowExpanded = expandedRowIds.has(entry.id);
+
           return (
-            <Tbody key={entry.id} isExpanded={isRowExpanded}>
+            <Tbody
+              key={entry.id}
+              isExpanded={isRowExpanded}
+              className={isRowExpanded ? 'leapp-expanded-tbody' : ''}
+            >
               <Tr ouiaId={`table-row-${rowIndex}`}>
                 <Td
                   expand={{
@@ -197,6 +412,12 @@ const PreupgradeReportsTable = ({ data = {} }) => {
                       toggleRowExpansion(entry.id, isOpen),
                   }}
                 />
+                <RowSelectTd
+                  rowData={entry}
+                  selectOne={selectOne}
+                  isSelected={id => isRowFixable(entry) && isSelected(id)}
+                  isSelectable={isRowFixable}
+                />
                 {columnKeys.map(key => (
                   <Td key={key} dataLabel={keysToColumnNames[key]}>
                     {columns[key].wrapper
@@ -209,7 +430,7 @@ const PreupgradeReportsTable = ({ data = {} }) => {
                 isExpanded={isRowExpanded}
                 ouiaId={`table-row-details-${rowIndex}`}
               >
-                <Td colSpan={columnKeys.length + 1}>
+                <Td colSpan={columnKeys.length + 2}>
                   <ExpandableRowContent>
                     {isRowExpanded && <ReportDetails entry={entry} />}
                   </ExpandableRowContent>
@@ -226,7 +447,13 @@ const PreupgradeReportsTable = ({ data = {} }) => {
 PreupgradeReportsTable.propTypes = {
   data: PropTypes.shape({
     id: PropTypes.number,
+    // eslint-disable-next-line camelcase
     template_name: PropTypes.string,
+    // eslint-disable-next-line camelcase
+    status_label: PropTypes.string,
+    targeting: PropTypes.shape({
+      host_id: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+    }),
   }),
 };
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: foreman_leapp
 version: !ruby/object:Gem::Version
-  version: 3.3.0
+  version: 3.4.0
 platform: ruby
 authors:
 - Foreman Leapp team
 bindir: bin
 cert_chain: []
-date: 2026-03-10 00:00:00.000000000 Z
+date: 2026-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: foreman_remote_execution
@@ -37,20 +37,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
-- !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6.2'
 description: A Foreman plugin to support inplace RHEL upgrades with Leapp utility.
 email:
 - foreman-dev@googlegroups.com
@@ -214,7 +200,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.10
 specification_version: 4
 summary: A Foreman plugin for Leapp utility.
 test_files: