foreman_cve_scanner 0.6.0 → 0.7.0

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

@@ -23,82 +23,117 @@ jest.mock('../CveCompareModal', () => ({ isOpen, scanIds }) =>
 const { useAPI } = require('foremanReact/common/hooks/API/APIHooks');
 
 describe('CveScansTab', () => {
+  const historyResponse = {
+    results: [
+      {
+        id: 1,
+        scanned_at: '2026-02-20',
+        scanner: 'trivy',
+        source: 'rex',
+        total: 10,
+        critical: 1,
+        high: 2,
+        medium: 3,
+        low: 4,
+      },
+      {
+        id: 2,
+        scanned_at: '2026-02-21',
+        scanner: 'grype',
+        source: 'external',
+        total: 5,
+        critical: 0,
+        high: 1,
+        medium: 1,
+        low: 3,
+      },
+    ],
+    total: 2,
+  };
+  const latestResponse = {
+    id: 2,
+    scanned_at: '2026-02-21',
+    scanner: 'grype',
+    source: 'external',
+    total: 5,
+    findings: [
+      {
+        id: 'CVE-2026-0001',
+        name: 'openssl',
+        version: '1.0',
+        fixed: '1.1',
+        status: 'open',
+        severity: 'HIGH',
+        title: 'OpenSSL issue',
+        published: '2026-02-11T00:00:00Z',
+        url: 'https://example.test/CVE-2026-0001',
+      },
+    ],
+  };
+
+  const mockScanApis = ({
+    latest = latestResponse,
+    history = historyResponse,
+    latestStatus = 'RESOLVED',
+    historyStatus = 'RESOLVED',
+  } = {}) => {
+    useAPI.mockImplementation((_method, url) => {
+      if (url && url.includes('/cve_scans/latest')) {
+        return { response: latest, status: latestStatus };
+      }
+      return { response: history, status: historyStatus };
+    });
+  };
+
   beforeEach(() => {
     useAPI.mockReset();
   });
 
-  it('renders overview and reports sub-tabs', () => {
-    const scansResponse = {
-      results: [
-        {
-          id: 1,
-          scanned_at: '2026-02-20',
-          scanner: 'trivy',
-          source: 'rex',
-          total: 10,
-          critical: 1,
-          high: 2,
-          medium: 3,
-          low: 4,
-        },
-        {
-          id: 2,
-          scanned_at: '2026-02-21',
-          scanner: 'grype',
-          source: 'external',
-          total: 5,
-          critical: 0,
-          high: 1,
-          medium: 1,
-          low: 3,
-        },
-      ],
-      total: 2,
-    };
-
-    useAPI.mockReturnValue({ response: scansResponse, status: 'RESOLVED' });
+  it('renders latest scan, trends and history tabs', () => {
+    mockScanApis();
 
     const wrapper = mount(<CveScansTab response={{ id: 1 }} />);
 
-    expect(wrapper.text()).toContain('Overview');
-    expect(wrapper.text()).toContain('Reports');
-    expect(wrapper.text()).toContain('Trend');
-    expect(wrapper.text()).toContain('Latest total');
+    expect(wrapper.text()).toContain('Latest Scan');
+    expect(wrapper.text()).toContain('Trends');
+    expect(wrapper.text()).toContain('History');
+    expect(wrapper.text()).toContain('Report from');
+    expect(wrapper.text()).toContain('grype / external');
+    expect(wrapper.text()).toContain('openssl');
   });
 
-  it('opens compare modal from overview trend selection', () => {
-    const scansResponse = {
-      results: [
-        {
-          id: 1,
-          scanned_at: '2026-02-20',
-          scanner: 'trivy',
-          source: 'rex',
-          total: 10,
-          critical: 1,
-          high: 2,
-          medium: 3,
-          low: 4,
-        },
-        {
-          id: 2,
-          scanned_at: '2026-02-21',
-          scanner: 'grype',
-          source: 'external',
-          total: 5,
-          critical: 0,
-          high: 1,
-          medium: 1,
-          low: 3,
-        },
-      ],
-      total: 2,
-    };
-
-    useAPI.mockReturnValue({ response: scansResponse, status: 'RESOLVED' });
+  it('renders a success state when the latest scan has no findings', () => {
+    mockScanApis({
+      latest: {
+        id: 2,
+        scanned_at: '2026-02-21',
+        scanner: 'grype',
+        source: 'external',
+        total: 0,
+        findings: [],
+      },
+    });
+
+    const wrapper = mount(<CveScansTab response={{ id: 1 }} />);
+
+    expect(wrapper.text()).toContain('No CVEs found');
+    expect(wrapper.text()).toContain(
+      'The latest CVE scan found no vulnerabilities for this host.'
+    );
+  });
+
+  it('opens compare modal from trends selection', () => {
+    mockScanApis();
 
     const wrapper = mount(<CveScansTab response={{ id: 1 }} />);
 
+    wrapper
+      .find('[role="tab"]')
+      .filterWhere(node => node.text() === 'Trends')
+      .first()
+      .simulate('click');
+    wrapper.update();
+
     wrapper
       .find('button')
       .filterWhere(node => node.text() === 'Compare 2 reports')
@@ -113,42 +148,14 @@ describe('CveScansTab', () => {
     expect(wrapper.find('[data-test="compare-modal"]').text()).toBe('1,2');
   });
 
-  it('renders scan rows in the reports sub-tab', () => {
-    const scansResponse = {
-      results: [
-        {
-          id: 1,
-          scanned_at: '2026-02-20',
-          scanner: 'trivy',
-          source: 'rex',
-          total: 10,
-          critical: 1,
-          high: 2,
-          medium: 3,
-          low: 4,
-        },
-        {
-          id: 2,
-          scanned_at: '2026-02-21',
-          scanner: 'grype',
-          source: 'external',
-          total: 5,
-          critical: 0,
-          high: 1,
-          medium: 1,
-          low: 3,
-        },
-      ],
-      total: 2,
-    };
-
-    useAPI.mockReturnValue({ response: scansResponse, status: 'RESOLVED' });
+  it('renders scan rows in the history tab', () => {
+    mockScanApis();
 
     const wrapper = mount(<CveScansTab response={{ id: 1 }} />);
 
     wrapper
       .find('[role="tab"]')
-      .filterWhere(node => node.text() === 'Reports')
+      .filterWhere(node => node.text() === 'History')
       .first()
       .simulate('click');
     wrapper.update();
@@ -161,41 +168,13 @@ describe('CveScansTab', () => {
   });
 
   it('opens compare modal when two scans are selected', () => {
-    const scansResponse = {
-      results: [
-        {
-          id: 1,
-          scanned_at: '2026-02-20',
-          scanner: 'trivy',
-          source: 'rex',
-          total: 10,
-          critical: 1,
-          high: 2,
-          medium: 3,
-          low: 4,
-        },
-        {
-          id: 2,
-          scanned_at: '2026-02-21',
-          scanner: 'grype',
-          source: 'external',
-          total: 5,
-          critical: 0,
-          high: 1,
-          medium: 1,
-          low: 3,
-        },
-      ],
-      total: 2,
-    };
-
-    useAPI.mockReturnValue({ response: scansResponse, status: 'RESOLVED' });
+    mockScanApis();
 
     const wrapper = mount(<CveScansTab response={{ id: 1 }} />);
 
     wrapper
       .find('[role="tab"]')
-      .filterWhere(node => node.text() === 'Reports')
+      .filterWhere(node => node.text() === 'History')
       .first()
       .simulate('click');
     wrapper.update();
@@ -215,40 +194,55 @@ describe('CveScansTab', () => {
   });
 
   it('renders empty state with no scans', () => {
-    useAPI.mockReturnValue({ response: { results: [] }, status: 'RESOLVED' });
+    mockScanApis({ latest: null, history: { results: [] } });
 
     const wrapper = mount(<CveScansTab response={{ id: 1 }} />);
     expect(wrapper.text()).toContain('No CVE reports for this host');
   });
 
-  it('renders trend overview when recent scans have no cves', () => {
-    const scansResponse = {
-      results: [
-        {
-          id: 1,
-          scanned_at: '2026-02-20',
-          scanner: 'trivy',
-          source: 'rex',
-          total: 0,
-          critical: 0,
-          high: 0,
-          medium: 0,
-          low: 0,
-        },
-      ],
-      total: 1,
-    };
-
-    useAPI.mockReturnValue({ response: scansResponse, status: 'RESOLVED' });
+  it('renders trend content in the trends tab when recent scans have no cves', () => {
+    mockScanApis({
+      latest: {
+        id: 1,
+        scanned_at: '2026-02-20',
+        scanner: 'trivy',
+        source: 'rex',
+        total: 0,
+        findings: [],
+      },
+      history: {
+        results: [
+          {
+            id: 1,
+            scanned_at: '2026-02-20',
+            scanner: 'trivy',
+            source: 'rex',
+            total: 0,
+            critical: 0,
+            high: 0,
+            medium: 0,
+            low: 0,
+          },
+        ],
+        total: 1,
+      },
+    });
 
     const wrapper = mount(<CveScansTab response={{ id: 1 }} />);
-    expect(wrapper.text()).toContain('Trend');
+
+    wrapper
+      .find('[role="tab"]')
+      .filterWhere(node => node.text() === 'Trends')
+      .first()
+      .simulate('click');
+    wrapper.update();
+
     expect(wrapper.text()).toContain('Latest total');
     expect(wrapper.text()).toContain('0');
   });
 
   it('does not render when host id is missing', () => {
-    useAPI.mockReturnValue({ response: { results: [] }, status: 'RESOLVED' });
+    mockScanApis({ latest: null, history: { results: [] } });
 
     const wrapper = mount(<CveScansTab response={{}} />);
     expect(wrapper.isEmptyRender()).toBe(true);

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

@@ -0,0 +1,68 @@
+/* eslint-disable import/no-unresolved */
+import React from 'react';
+import { mount } from 'enzyme';
+import { act } from 'react-dom/test-utils';
+import CveSummaryCell from '../CveSummaryCell';
+import { resetCveSummaryStore } from '../cve_summary_store';
+
+jest.mock('../CveFindingsModal', () => () => null);
+
+const flushBatch = () =>
+  new Promise(resolve => {
+    setTimeout(resolve, 0);
+  });
+
+describe('CveSummaryCell', () => {
+  beforeEach(() => {
+    resetCveSummaryStore();
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        results: [
+          {
+            id: 11,
+            host_id: 1,
+            total: 2,
+            summary: { worst: 'high' },
+          },
+          {
+            id: 22,
+            host_id: 2,
+            total: 0,
+            summary: { worst: 'none' },
+          },
+        ],
+      }),
+    });
+  });
+
+  afterEach(() => {
+    resetCveSummaryStore();
+    delete global.fetch;
+  });
+
+  it('batches host summary requests across cells', async () => {
+    let wrapper;
+
+    await act(async () => {
+      wrapper = mount(
+        <div>
+          <CveSummaryCell hostId={1} hostName="alpha" />
+          <CveSummaryCell hostId={2} hostName="beta" />
+        </div>
+      );
+      await flushBatch();
+      await flushBatch();
+    });
+    wrapper.update();
+
+    expect(global.fetch).toHaveBeenCalledTimes(1);
+    expect(global.fetch.mock.calls[0][0]).toContain(
+      '/api/v2/cve_scans/latest_by_hosts?'
+    );
+    expect(global.fetch.mock.calls[0][0]).toContain('host_ids%5B%5D=1');
+    expect(global.fetch.mock.calls[0][0]).toContain('host_ids%5B%5D=2');
+    expect(wrapper.text()).toContain('2');
+    expect(wrapper.text()).toContain('0');
+  });
+});

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

@@ -4,7 +4,7 @@ import { mount } from 'enzyme';
 import CveTrendChart from '../CveTrendChart';
 
 describe('CveTrendChart', () => {
-  it('renders the last scan summary and legend', () => {
+  it('renders the scan summary and legend', () => {
     const wrapper = mount(
       <CveTrendChart
         scans={[
@@ -30,8 +30,6 @@ describe('CveTrendChart', () => {
       />
     );
 
-    expect(wrapper.text()).toContain('Trend');
-    expect(wrapper.text()).toContain('Last 2 scans');
     expect(wrapper.text()).toContain('Latest total');
     expect(wrapper.text()).toContain('18');
     expect(wrapper.text()).toContain('Critical');

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

@@ -1,5 +1,6 @@
 /* eslint-disable import/no-unresolved */
 import {
+  findingIdentity,
   severityRank,
   riskLevelFromWorst,
   formatDateTime,
@@ -7,6 +8,12 @@ import {
   formatScannedAt,
   compareStrings,
   visibleScanSource,
+  katelloFixLabel,
+  katelloFixTitle,
+  katelloFixCounts,
+  katelloFixErrataSearch,
+  katelloFixInstallUrl,
+  shouldShowKatelloFixColumn,
 } from '../cve_helpers';
 
 describe('cve_helpers', () => {
@@ -57,4 +64,81 @@ describe('cve_helpers', () => {
     expect(visibleScanSource('rex')).toBe('');
     expect(visibleScanSource('external')).toBe('external');
   });
+
+  it('builds finding identity from cve and package', () => {
+    expect(findingIdentity({ id: 'CVE-2026-0001', name: 'openssl' })).toBe(
+      'CVE-2026-0001::openssl'
+    );
+  });
+
+  it('formats fix availability status labels and titles', () => {
+    const fix = {
+      status: 'installable',
+      errata: [{ errata_id: 'RHSA-2026:0001' }],
+    };
+
+    expect(katelloFixLabel(fix)).toBe('Installable');
+    expect(katelloFixTitle(fix)).toContain('RHSA-2026:0001');
+  });
+
+  it('hides fix availability column when findings are not enriched', () => {
+    expect(
+      shouldShowKatelloFixColumn([
+        {
+          id: 'CVE-2026-0001',
+        },
+      ])
+    ).toBe(false);
+
+    expect(
+      shouldShowKatelloFixColumn([
+        {
+          katello_fix: {
+            status: 'applicable',
+            reason: null,
+          },
+        },
+      ])
+    ).toBe(true);
+  });
+
+  it('counts fix availability statuses', () => {
+    expect(
+      katelloFixCounts([
+        { katello_fix: { status: 'installable' } },
+        { katello_fix: { status: 'installable' } },
+        { katello_fix: { status: 'applicable' } },
+        { katello_fix: { status: 'unavailable' } },
+      ])
+    ).toEqual({ installable: 2, applicable: 1 });
+  });
+
+  it('builds errata install remote execution urls for installable fixes', () => {
+    const fix = {
+      status: 'installable',
+      errata: [{ errata_id: 'RHSA-2026:0001' }],
+    };
+    const url = katelloFixInstallUrl({ hostName: 'host.example.com', fix });
+    const params = new URL(url, 'http://example.test').searchParams;
+
+    expect(katelloFixErrataSearch(fix)).toBe('errata_id = RHSA-2026:0001');
+    expect(url).toContain('/job_invocations/new?');
+    expect(params.get('feature')).toBe('katello_errata_install_by_search');
+    expect(params.get('search')).toBe('name ^ (host.example.com)');
+    expect(params.get('inputs[Errata search query]')).toBe(
+      'errata_id = RHSA-2026:0001'
+    );
+  });
+
+  it('does not build install urls for non-installable fixes', () => {
+    expect(
+      katelloFixInstallUrl({
+        hostName: 'host.example.com',
+        fix: {
+          status: 'applicable',
+          errata: [{ errata_id: 'RHSA-2026:0001' }],
+        },
+      })
+    ).toBe('');
+  });
 });

data/webpack/components/cve_helpers.js

@@ -13,6 +13,14 @@ const COMPARE_STATUS_RANK = {
   updated: 2,
   unchanged: 1,
 };
+const KATELLO_FIX_RANK = {
+  installable: 3,
+  applicable: 2,
+  unavailable: 1,
+  unknown: 0,
+};
+const KATELLO_ERRATA_INSTALL_FEATURE = 'katello_errata_install_by_search';
+const ERRATA_SEARCH_INPUT = 'Errata search query';
 const COMPARISON_DIFF_LABELS = {
   severity: __('Severity'),
   version: __('Version'),
@@ -88,6 +96,8 @@ export const findingMatchesSearch = (finding, query) =>
     finding.title,
     finding.url,
     finding.severity,
+    katelloFixLabel(finding.katello_fix),
+    katelloFixTitle(finding.katello_fix),
   ].some(value =>
     (value || '')
       .toString()
@@ -95,11 +105,16 @@ export const findingMatchesSearch = (finding, query) =>
       .includes(query)
   );
 
+export const findingIdentity = finding =>
+  [finding.id, finding.name].map(value => value || '').join('::');
+
 export const findingSorters = {
   published: (a, b) => new Date(a.published || 0) - new Date(b.published || 0),
   name: (a, b) => compareStrings(a.name, b.name),
   version: (a, b) => compareStrings(a.version, b.version),
   fixed: (a, b) => compareStrings(a.fixed, b.fixed),
+  katello_fix: (a, b) =>
+    katelloFixRank(a.katello_fix) - katelloFixRank(b.katello_fix),
   id: (a, b) => compareStrings(a.id, b.id),
   status: (a, b) => compareStrings(a.status, b.status),
   title: (a, b) => compareStrings(a.title, b.title),
@@ -172,3 +187,102 @@ export const formatScanOrigin = (scanner, source, fallback = __('Unknown')) => {
 };
 export const formatScannedAt = value =>
   formatDateTime(value) || __('Unknown time');
+
+export const katelloFixRank = fix =>
+  KATELLO_FIX_RANK[(fix?.status || '').toLowerCase()] ?? 0;
+
+export const katelloFixLabel = fix => {
+  switch ((fix?.status || '').toLowerCase()) {
+    case 'installable':
+      return __('Installable');
+    case 'applicable':
+      return __('Applicable');
+    case 'unavailable':
+      return __('No managed fix');
+    case 'unknown':
+      return __('Unknown');
+    default:
+      return '';
+  }
+};
+
+export const katelloFixTitle = fix => {
+  const errataIds = (fix?.errata || [])
+    .map(erratum => erratum.errata_id)
+    .filter(Boolean)
+    .join(', ');
+
+  switch ((fix?.status || '').toLowerCase()) {
+    case 'installable':
+      return errataIds
+        ? `${__(
+            'A matching erratum is installable for this host'
+          )}: ${errataIds}`
+        : __('A matching erratum is installable for this host');
+    case 'applicable':
+      return errataIds
+        ? `${__(
+            'A matching erratum applies to this host, but is not installable in the current content'
+          )}: ${errataIds}`
+        : __(
+            'A matching erratum applies to this host, but is not installable in the current content'
+          );
+    case 'unavailable':
+      return __(
+        'No matching managed erratum was found for this CVE and package'
+      );
+    case 'unknown':
+      if (fix?.reason === 'missing_cve') {
+        return __('This finding has no CVE identifier');
+      }
+      if (fix?.reason === 'query_failed') {
+        return __('Fix availability could not be calculated');
+      }
+      return __('Fix availability is unknown');
+    default:
+      return '';
+  }
+};
+
+export const shouldShowKatelloFixColumn = findings =>
+  (findings || []).some(finding => finding.katello_fix);
+
+export const katelloFixCounts = findings =>
+  (findings || []).reduce(
+    (counts, finding) => {
+      const status = (finding.katello_fix?.status || '').toLowerCase();
+      if (status === 'installable') counts.installable += 1;
+      if (status === 'applicable') counts.applicable += 1;
+      return counts;
+    },
+    { installable: 0, applicable: 0 }
+  );
+
+export const katelloFixErrataIds = fix =>
+  (fix?.errata || []).map(erratum => erratum.errata_id).filter(Boolean);
+
+export const katelloFixErrataSearch = fix => {
+  const errataIds = katelloFixErrataIds(fix);
+  if (errataIds.length === 0) return '';
+  if (errataIds.length === 1) return `errata_id = ${errataIds[0]}`;
+  return `errata_id ^ (${errataIds.join(',')})`;
+};
+
+export const katelloFixInstallUrl = ({ hostName, fix }) => {
+  if ((fix?.status || '').toLowerCase() !== 'installable') return '';
+  const errataSearch = katelloFixErrataSearch(fix);
+  if (!hostName || !errataSearch) return '';
+
+  const params = new URLSearchParams();
+  params.set('feature', KATELLO_ERRATA_INSTALL_FEATURE);
+  params.set('search', `name ^ (${hostName})`);
+  params.set(`inputs[${ERRATA_SEARCH_INPUT}]`, errataSearch);
+  return `/job_invocations/new?${params.toString()}`;
+};
+
+export const katelloFixDetailsUrl = fix => {
+  const erratumId = (fix?.errata || [])
+    .map(erratum => erratum.id)
+    .find(Boolean);
+  return erratumId ? `/errata/${erratumId}` : '';
+};