foreman_leapp 3.2.1 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dbb9af7bc42545f2e0eecc31e462afef8b356f170e29d1b754281f071b0b2948
-  data.tar.gz: 8f424144f2ef5886a204aa85399fe37d7d8bfbe42249566c3fec8bd5c811ab79
+  metadata.gz: a7e5030bef562d53e8f4212fa76732f0901ec4b827620a5f07028fd11bcf36d4
+  data.tar.gz: eac05d03ce3b746a996751d2b5affb5ea1fabea4d74dd8899f5771b5bc69f8ec
 SHA512:
-  metadata.gz: cada565d0df1f5578f334aa03d5207c91e2f8f89fba58d45a29cf3bf699e89df4aa163068485f6a2e7bd5133c9a36a173fb92445d6bdcefd2301b01d3b772f1c
-  data.tar.gz: 8d8787b1f57a45e88f3f00bec04e9998e71957d37349f54afc883908908d76f9ba20ff2c446db0da82d547d84217c606e28a69392450420e1e05ebf851c661d8
+  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.2.1'
+  VERSION = '3.4.0'
 end

data/webpack/components/PreupgradeReportsTable/PreupgradeReportsTable.scss

@@ -0,0 +1,14 @@
+.leapp-report-details {
+  dd {
+    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/ReportDetails.js

@@ -0,0 +1,134 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import {
+  DescriptionList,
+  DescriptionListGroup,
+  DescriptionListTerm,
+  DescriptionListDescription,
+  Label,
+  LabelGroup,
+} from '@patternfly/react-core';
+import { translate as __ } from 'foremanReact/common/I18n';
+import './PreupgradeReportsTable.scss';
+
+export const renderSeverityLabel = severity => {
+  switch (severity) {
+    case 'high':
+      return <Label color="red">{__('High')}</Label>;
+    case 'medium':
+      return <Label color="orange">{__('Medium')}</Label>;
+    case 'low':
+      return <Label color="blue">{__('Low')}</Label>;
+    case 'info':
+      return <Label color="grey">{__('Info')}</Label>;
+    default:
+      return <Label color="grey">{severity || __('Info')}</Label>;
+  }
+};
+
+const ReportDetails = ({ entry }) => (
+  <DescriptionList isHorizontal isCompact className="leapp-report-details">
+    {entry.title && (
+      <DescriptionListGroup>
+        <DescriptionListTerm>{__('Title')}</DescriptionListTerm>
+        <DescriptionListDescription>{entry.title}</DescriptionListDescription>
+      </DescriptionListGroup>
+    )}
+
+    {entry.severity && (
+      <DescriptionListGroup>
+        <DescriptionListTerm>{__('Risk Factor')}</DescriptionListTerm>
+        <DescriptionListDescription>
+          {renderSeverityLabel(entry.severity)}
+        </DescriptionListDescription>
+      </DescriptionListGroup>
+    )}
+
+    {entry.summary && (
+      <DescriptionListGroup>
+        <DescriptionListTerm>{__('Summary')}</DescriptionListTerm>
+        <DescriptionListDescription>{entry.summary}</DescriptionListDescription>
+      </DescriptionListGroup>
+    )}
+
+    {entry.tags && entry.tags.length > 0 && (
+      <DescriptionListGroup>
+        <DescriptionListTerm>{__('Tags')}</DescriptionListTerm>
+        <DescriptionListDescription>
+          <LabelGroup>
+            {entry.tags.map(tag => (
+              <Label key={tag} color="blue">
+                {tag}
+              </Label>
+            ))}
+          </LabelGroup>
+        </DescriptionListDescription>
+      </DescriptionListGroup>
+    )}
+
+    {entry.detail?.external?.filter(link => link.url).length > 0 && (
+      <DescriptionListGroup>
+        <DescriptionListTerm>{__('Links')}</DescriptionListTerm>
+        <DescriptionListDescription>
+          {entry.detail.external
+            .filter(link => link.url)
+            .map((item, i) => (
+              <div key={item.url || i}>
+                <a href={item.url} target="_blank" rel="noopener noreferrer">
+                  {item.title || item.url}
+                </a>
+              </div>
+            ))}
+        </DescriptionListDescription>
+      </DescriptionListGroup>
+    )}
+
+    {entry.detail?.remediations?.length > 0 &&
+      entry.detail.remediations.map((item, i) => (
+        <DescriptionListGroup key={`remediations-${i}`}>
+          <DescriptionListTerm>
+            {item.type === 'command' ? __('Command') : __('Hint')}
+          </DescriptionListTerm>
+          <DescriptionListDescription>
+            {item.type === 'command' ? (
+              <code>
+                {Array.isArray(item.context)
+                  ? item.context.join(' ')
+                  : item.context}
+              </code>
+            ) : (
+              item.context
+            )}
+          </DescriptionListDescription>
+        </DescriptionListGroup>
+      ))}
+  </DescriptionList>
+);
+
+ReportDetails.propTypes = {
+  entry: PropTypes.shape({
+    title: PropTypes.string,
+    severity: PropTypes.string,
+    summary: PropTypes.string,
+    tags: PropTypes.arrayOf(PropTypes.string),
+    detail: PropTypes.shape({
+      external: PropTypes.arrayOf(
+        PropTypes.shape({
+          url: PropTypes.string,
+          title: PropTypes.string,
+        })
+      ),
+      remediations: PropTypes.arrayOf(
+        PropTypes.shape({
+          type: PropTypes.string,
+          context: PropTypes.oneOfType([
+            PropTypes.string,
+            PropTypes.arrayOf(PropTypes.string),
+          ]),
+        })
+      ),
+    }),
+  }).isRequired,
+};
+
+export default ReportDetails;

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

@@ -1,11 +1,19 @@
-import React from 'react';
-import { render, screen, waitFor, fireEvent } from '@testing-library/react';
 import '@testing-library/jest-dom/extend-expect';
+
+import {
+  fireEvent,
+  render,
+  screen,
+  waitFor,
+  within,
+} from '@testing-library/react';
+
+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');
 
@@ -18,13 +26,28 @@ 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: 'cmd' }] : [] },
+  detail: {
+    remediations:
+      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' }] : [],
+  },
 }));
 
 describe('PreupgradeReportsTable', () => {
@@ -46,57 +69,301 @@ describe('PreupgradeReportsTable', () => {
         return { type: 'MOCK_API_SUCCESS' };
       };
     });
+
+    APIActions.post.mockImplementation(() => () => ({ type: 'MOCK_API_POST' }));
   });
 
-  const renderComponent = () =>
+  const renderComponent = (data = mockJobData) =>
     render(
       <Provider store={store}>
-        <PreupgradeReportsTable data={mockJobData} />
+        <PreupgradeReportsTable data={data} />
       </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 waitForTable();
+    expect(
+      screen.getByText('Report Entry 1', { selector: 'td' })
+    ).toBeInTheDocument();
+  });
+
+  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 waitForTable();
+
+    const callCountAfterFirstFetch = APIActions.get.mock.calls.length;
 
-    await waitFor(() => screen.getByText('Report Entry 1'));
+    rerender(
+      <Provider store={store}>
+        <PreupgradeReportsTable
+          data={{ ...mockJobData, status_label: 'Succeeded' }}
+        />
+      </Provider>
+    );
 
-    expect(screen.getByText('Report Entry 1')).toBeInTheDocument();
-    expect(screen.getByText('Report Entry 5')).toBeInTheDocument();
-    expect(screen.queryByText('Report Entry 6')).not.toBeInTheDocument();
+    await waitFor(() =>
+      expect(APIActions.get.mock.calls.length).toBeGreaterThan(
+        callCountAfterFirstFetch
+      )
+    );
+    expect(
+      screen.getByText('Report Entry 1', { selector: 'td' })
+    ).toBeInTheDocument();
   });
 
-  it('paginates to the next page', 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'));
+    await waitFor(() =>
+      expect(
+        screen.getByText('The preupgrade report shows no issues.')
+      ).toBeInTheDocument()
+    );
+  });
 
-    fireEvent.click(screen.getAllByLabelText('Go to next page')[0]);
+  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();
+  });
 
-    await waitFor(() => screen.getByText('Report Entry 6'));
-    expect(screen.getByText('Report Entry 10')).toBeInTheDocument();
-    expect(screen.queryByText('Report Entry 1')).not.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();
+    expect(
+      await screen.findByText('Summary for report entry 5')
+    ).toBeInTheDocument();
   });
 
-  it('changes perPage limit to 10', async () => {
+  it('paginates to the next page', async () => {
     renderComponent();
     expandSection();
-    await waitFor(() => screen.getByText('Report Entry 1'));
+    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();
+  });
 
+  it('changes perPage limit to 10', async () => {
+    renderComponent();
+    expandSection();
+    await waitForTable();
     fireEvent.click(screen.getAllByLabelText('Items per page')[0]);
     fireEvent.click(screen.getAllByText('10 per page')[0]);
+    await waitFor(() =>
+      expect(
+        screen.getByText('Report Entry 10', { selector: 'td' })
+      ).toBeInTheDocument()
+    );
+  });
 
-    await waitFor(() => {
-      expect(screen.getByText('Report Entry 10')).toBeInTheDocument();
-      expect(screen.queryByText('Report Entry 11')).not.toBeInTheDocument();
-    });
+  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('renders empty state message when no issues found', async () => {
+  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'))
@@ -106,12 +373,37 @@ describe('PreupgradeReportsTable', () => {
         return { type: 'EMPTY' };
       };
     });
+    renderComponent();
+    expandSection();
+    await waitFor(() =>
+      screen.getByText('The preupgrade report shows no issues.')
+    );
+    expect(
+      screen.queryByRole('button', { name: 'Fix Selected' })
+    ).not.toBeInTheDocument();
+    expect(
+      screen.queryByRole('button', { name: 'Run Upgrade' })
+    ).not.toBeInTheDocument();
+  });
 
+  it('renders the SelectAll checkbox', async () => {
     renderComponent();
     expandSection();
+    await waitForTable();
+    expect(screen.getAllByRole('checkbox').length).toBeGreaterThan(0);
+  });
 
-    await waitFor(() => {
-      expect(screen.getByText('The preupgrade report shows no issues.')).toBeInTheDocument();
-    });
+  it('selecting all fixable rows enables Fix Selected', async () => {
+    renderComponent();
+    expandSection();
+    await waitForTable();
+
+    fireEvent.click(screen.getByLabelText('Select all'));
+
+    await waitFor(() =>
+      expect(
+        screen.getByRole('button', { name: 'Fix Selected' })
+      ).not.toBeDisabled()
+    );
   });
 });

data/webpack/components/PreupgradeReportsTable/index.js

@@ -1,145 +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, Label, 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,
+  entryFixable,
+} from '../PreupgradeReports/PreupgradeReportsHelpers';
+import ReportDetails, { renderSeverityLabel } from './ReportDetails';
+import './PreupgradeReportsTable.scss';
 
-import { entriesPage } from '../PreupgradeReports/PreupgradeReportsHelpers';
-
-const renderSeverityLabel = severity => {
-  switch (severity) {
-    case 'high':
-      return <Label color="red">{__('High')}</Label>;
-    case 'medium':
-      return <Label color="orange">{__('Medium')}</Label>;
-    case 'low':
-      return <Label color="blue">{__('Low')}</Label>;
-    case 'info':
-      return <Label color="grey">{__('Info')}</Label>;
-    default:
-      return <Label color="grey">{severity || __('Info')}</Label>;
-  }
+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 [isExpanded, setIsExpanded] = useState(false);
+  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());
+
   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 || !isExpanded || 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;
     };
-  }, [isExpanded, 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 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 = newParams => {
+  const handleParamsChange = useCallback(newParams => {
     setPagination(prev => ({
       ...prev,
       page: newParams.page || prev.page,
       perPage: newParams.per_page || prev.perPage,
     }));
-  };
+    setExpandedRowIds(new Set());
+  }, []);
+
+  const toggleRowExpansion = useCallback((id, isExpanding) => {
+    setExpandedRowIds(prev => {
+      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 = 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 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={isExpanded}
-      onToggle={(_event, val) => setIsExpanded(val)}
+      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}
@@ -156,20 +385,75 @@ 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}
+        areAllRowsExpanded={!areAllRowsExpanded}
+      >
+        {pagedEntries.map((entry, rowIndex) => {
+          const isRowExpanded = expandedRowIds.has(entry.id);
+
+          return (
+            <Tbody
+              key={entry.id}
+              isExpanded={isRowExpanded}
+              className={isRowExpanded ? 'leapp-expanded-tbody' : ''}
+            >
+              <Tr ouiaId={`table-row-${rowIndex}`}>
+                <Td
+                  expand={{
+                    rowIndex,
+                    isExpanded: isRowExpanded,
+                    onToggle: (_event, _rowIndex, isOpen) =>
+                      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
+                      ? columns[key].wrapper(entry)
+                      : entry[key]}
+                  </Td>
+                ))}
+              </Tr>
+              <Tr
+                isExpanded={isRowExpanded}
+                ouiaId={`table-row-details-${rowIndex}`}
+              >
+                <Td colSpan={columnKeys.length + 2}>
+                  <ExpandableRowContent>
+                    {isRowExpanded && <ReportDetails entry={entry} />}
+                  </ExpandableRowContent>
+                </Td>
+              </Tr>
+            </Tbody>
+          );
+        })}
+      </Table>
     </ExpandableSection>
   );
 };
 
 PreupgradeReportsTable.propTypes = {
   data: PropTypes.shape({
-    id: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+    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.2.1
+  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
@@ -186,6 +172,8 @@ files:
 - webpack/components/PreupgradeReportsList/components/images/i_severity-low.svg
 - webpack/components/PreupgradeReportsList/components/images/i_severity-med.svg
 - webpack/components/PreupgradeReportsList/index.js
+- webpack/components/PreupgradeReportsTable/PreupgradeReportsTable.scss
+- webpack/components/PreupgradeReportsTable/ReportDetails.js
 - webpack/components/PreupgradeReportsTable/__tests__/PreupgradeReportsTable.test.js
 - webpack/components/PreupgradeReportsTable/index.js
 - webpack/consts.js
@@ -212,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: